From 530763d717189fd57c48b352ba4d13a751a2ba64 Mon Sep 17 00:00:00 2001 From: "John L. Hammond" Date: Mon, 27 Oct 2014 14:40:29 -0500 Subject: [PATCH] LU-2675 llapi: find_param cleanup part II Add fp_ prefixes to the remaining members of struct find_param. Also add underscores between words in several member names: obduuid -> fp_obd_uuid stripesize_units -> fp_stripe_size_units ... Signed-off-by: John L. Hammond Change-Id: Iaa62a6b44e2929f3925525a97fec0434243dec1b Reviewed-on: http://review.whamcloud.com/12851 Tested-by: Jenkins Tested-by: Maloo Reviewed-by: Andreas Dilger Reviewed-by: Dmitry Eremin --- lustre/include/lustre/lustreapi.h | 101 ++++--- lustre/utils/lfs.c | 162 +++++----- lustre/utils/liblustreapi.c | 616 ++++++++++++++++++++------------------ 3 files changed, 449 insertions(+), 430 deletions(-) diff --git a/lustre/include/lustre/lustreapi.h b/lustre/include/lustre/lustreapi.h index 52b352d..48f2f8a 100644 --- a/lustre/include/lustre/lustreapi.h +++ b/lustre/include/lustre/lustreapi.h @@ -157,76 +157,75 @@ struct find_param { int fp_msign; int fp_csign; /* these need to be signed values */ - int size_sign:2, - stripesize_sign:2, - stripecount_sign:2; - unsigned long long size; - unsigned long long size_units; - - unsigned long zeroend:1, - recursive:1, - exclude_pattern:1, + int fp_size_sign:2, + fp_stripe_size_sign:2, + fp_stripe_count_sign:2; + unsigned long long fp_size; + unsigned long long fp_size_units; + + unsigned long fp_zero_end:1, + fp_recursive:1, + fp_exclude_pattern:1, fp_exclude_type:1, - exclude_obd:1, - exclude_mdt:1, + fp_exclude_obd:1, + fp_exclude_mdt:1, fp_exclude_gid:1, fp_exclude_uid:1, fp_check_gid:1, fp_check_uid:1, - check_pool:1, /* LOV pool name */ - check_size:1, /* file size */ - exclude_pool:1, - exclude_size:1, + fp_check_pool:1, /* LOV pool name */ + fp_check_size:1, /* file size */ + fp_exclude_pool:1, + fp_exclude_size:1, fp_exclude_atime:1, fp_exclude_mtime:1, fp_exclude_ctime:1, - get_lmv:1, /* get MDT list from LMV */ - raw:1, /* do not fill in defaults */ - check_stripesize:1, /* LOV stripe size */ - exclude_stripesize:1, - check_stripecount:1, /* LOV stripe count */ - exclude_stripecount:1, - check_layout:1, - exclude_layout:1, - get_default_lmv:1, /* Get default LMV */ - migrate:1; - - int verbose; - int quiet; + fp_get_lmv:1, /* get MDT list from LMV */ + fp_raw:1, /* do not fill in defaults */ + fp_check_stripe_size:1, /* LOV stripe size */ + fp_exclude_stripe_size:1, + fp_check_stripe_count:1, /* LOV stripe count */ + fp_exclude_stripe_count:1, + fp_check_layout:1, + fp_exclude_layout:1, + fp_get_default_lmv:1, /* Get default LMV */ + fp_migrate:1; + + int fp_verbose; + int fp_quiet; /* regular expression */ - char *pattern; + char *fp_pattern; - struct obd_uuid *obduuid; - int num_obds; - int num_alloc_obds; - int obdindex; - int *obdindexes; + struct obd_uuid *fp_obd_uuid; + int fp_num_obds; + int fp_num_alloc_obds; + int fp_obd_index; + int *fp_obd_indexes; - struct obd_uuid *mdtuuid; - int num_mdts; - int num_alloc_mdts; - int mdtindex; - int *mdtindexes; - int file_mdtindex; + struct obd_uuid *fp_mdt_uuid; + int fp_num_mdts; + int fp_num_alloc_mdts; + int fp_mdt_index; + int *fp_mdt_indexes; + int fp_file_mdt_index; - int lumlen; - struct lov_user_mds_data *lmd; + size_t fp_lum_size; + struct lov_user_mds_data *fp_lmd; - char poolname[LOV_MAXPOOLNAME + 1]; + char fp_poolname[LOV_MAXPOOLNAME + 1]; - int fp_lmv_count; + __u32 fp_lmv_stripe_count; struct lmv_user_md *fp_lmv_md; - unsigned long long stripesize; - unsigned long long stripesize_units; - unsigned long long stripecount; - __u32 layout; + unsigned long long fp_stripe_size; + unsigned long long fp_stripe_size_units; + unsigned long long fp_stripe_count; + __u32 fp_layout; /* In-process parameters. */ - unsigned long got_uuids:1, - obds_printed:1, - have_fileinfo:1; /* file attrs and LOV xattr */ + unsigned long fp_got_uuids:1, + fp_obds_printed:1; unsigned int fp_depth; }; diff --git a/lustre/utils/lfs.c b/lustre/utils/lfs.c index 47860f7..a047513 100644 --- a/lustre/utils/lfs.c +++ b/lustre/utils/lfs.c @@ -1055,7 +1055,7 @@ static int lfs_find(int argc, char **argv) time_t t; struct find_param param = { .fp_max_depth = -1, - .quiet = 1, + .fp_quiet = 1, }; struct option long_opts[] = { {"atime", required_argument, 0, 'A'}, @@ -1163,22 +1163,22 @@ static int lfs_find(int argc, char **argv) break; case 'c': if (optarg[0] == '+') { - param.stripecount_sign = -1; + param.fp_stripe_count_sign = -1; optarg++; } else if (optarg[0] == '-') { - param.stripecount_sign = 1; + param.fp_stripe_count_sign = 1; optarg++; } - param.stripecount = strtoul(optarg, &endptr, 0); + param.fp_stripe_count = strtoul(optarg, &endptr, 0); if (*endptr != '\0') { fprintf(stderr,"error: bad stripe_count '%s'\n", optarg); ret = -1; goto err; } - param.check_stripecount = 1; - param.exclude_stripecount = !!neg_opt; + param.fp_check_stripe_count = 1; + param.fp_exclude_stripe_count = !!neg_opt; break; case 'D': param.fp_max_depth = strtol(optarg, 0, 0); @@ -1199,11 +1199,11 @@ static int lfs_find(int argc, char **argv) param.fp_check_gid = 1; break; case 'L': - ret = name2layout(¶m.layout, optarg); + ret = name2layout(¶m.fp_layout, optarg); if (ret) goto err; - param.exclude_layout = !!neg_opt; - param.check_layout = 1; + param.fp_exclude_layout = !!neg_opt; + param.fp_check_layout = 1; break; case 'u': case 'U': @@ -1231,14 +1231,14 @@ static int lfs_find(int argc, char **argv) } /* we do check for empty pool because empty pool * is used to find V1 lov attributes */ - strncpy(param.poolname, optarg, LOV_MAXPOOLNAME); - param.poolname[LOV_MAXPOOLNAME] = '\0'; - param.exclude_pool = !!neg_opt; - param.check_pool = 1; + strncpy(param.fp_poolname, optarg, LOV_MAXPOOLNAME); + param.fp_poolname[LOV_MAXPOOLNAME] = '\0'; + param.fp_exclude_pool = !!neg_opt; + param.fp_check_pool = 1; break; case 'n': - param.pattern = (char *)optarg; - param.exclude_pattern = !!neg_opt; + param.fp_pattern = (char *)optarg; + param.fp_exclude_pattern = !!neg_opt; break; case 'm': case 'i': @@ -1253,7 +1253,7 @@ static int lfs_find(int argc, char **argv) goto err; } - param.exclude_obd = !!neg_opt; + param.fp_exclude_obd = !!neg_opt; token = buf; while (token && *token) { @@ -1264,38 +1264,38 @@ static int lfs_find(int argc, char **argv) } } if (c == 'm') { - param.exclude_mdt = !!neg_opt; - param.num_alloc_mdts += len; - tmp = realloc(param.mdtuuid, - param.num_alloc_mdts * - sizeof(*param.mdtuuid)); + param.fp_exclude_mdt = !!neg_opt; + param.fp_num_alloc_mdts += len; + tmp = realloc(param.fp_mdt_uuid, + param.fp_num_alloc_mdts * + sizeof(*param.fp_mdt_uuid)); if (tmp == NULL) { ret = -ENOMEM; goto err_free; } - param.mdtuuid = tmp; + param.fp_mdt_uuid = tmp; } else { - param.exclude_obd = !!neg_opt; - param.num_alloc_obds += len; - tmp = realloc(param.obduuid, - param.num_alloc_obds * - sizeof(*param.obduuid)); + param.fp_exclude_obd = !!neg_opt; + param.fp_num_alloc_obds += len; + tmp = realloc(param.fp_obd_uuid, + param.fp_num_alloc_obds * + sizeof(*param.fp_obd_uuid)); if (tmp == NULL) { ret = -ENOMEM; goto err_free; } - param.obduuid = tmp; + param.fp_obd_uuid = tmp; } for (token = buf; token && *token; token = next) { struct obd_uuid *puuid; if (c == 'm') { puuid = - ¶m.mdtuuid[param.num_mdts++]; + ¶m.fp_mdt_uuid[param.fp_num_mdts++]; } else { puuid = - ¶m.obduuid[param.num_obds++]; + ¶m.fp_obd_uuid[param.fp_num_obds++]; } p = strchr(token, ','); next = 0; @@ -1318,47 +1318,47 @@ err_free: break; } case 'p': - param.zeroend = 1; + param.fp_zero_end = 1; break; case 'P': break; case 's': if (optarg[0] == '+') { - param.size_sign = -1; + param.fp_size_sign = -1; optarg++; } else if (optarg[0] == '-') { - param.size_sign = 1; + param.fp_size_sign = 1; optarg++; } - ret = llapi_parse_size(optarg, ¶m.size, - ¶m.size_units, 0); + ret = llapi_parse_size(optarg, ¶m.fp_size, + ¶m.fp_size_units, 0); if (ret) { fprintf(stderr, "error: bad file size '%s'\n", optarg); goto err; } - param.check_size = 1; - param.exclude_size = !!neg_opt; + param.fp_check_size = 1; + param.fp_exclude_size = !!neg_opt; break; case 'S': if (optarg[0] == '+') { - param.stripesize_sign = -1; + param.fp_stripe_size_sign = -1; optarg++; } else if (optarg[0] == '-') { - param.stripesize_sign = 1; + param.fp_stripe_size_sign = 1; optarg++; } - ret = llapi_parse_size(optarg, ¶m.stripesize, - ¶m.stripesize_units, 0); + ret = llapi_parse_size(optarg, ¶m.fp_stripe_size, + ¶m.fp_stripe_size_units, 0); if (ret) { fprintf(stderr, "error: bad stripe_size '%s'\n", optarg); goto err; } - param.check_stripesize = 1; - param.exclude_stripesize = !!neg_opt; + param.fp_check_stripe_size = 1; + param.fp_exclude_stripe_size = !!neg_opt; break; case 't': param.fp_exclude_type = !!neg_opt; @@ -1417,11 +1417,11 @@ err_free: fprintf(stderr, "error: %s failed for %s.\n", argv[0], argv[optind - 1]); err: - if (param.obduuid && param.num_alloc_obds) - free(param.obduuid); + if (param.fp_obd_uuid && param.fp_num_alloc_obds) + free(param.fp_obd_uuid); - if (param.mdtuuid && param.num_alloc_mdts) - free(param.mdtuuid); + if (param.fp_mdt_uuid && param.fp_num_alloc_mdts) + free(param.fp_mdt_uuid); return ret; } @@ -1483,28 +1483,28 @@ static int lfs_getstripe_internal(int argc, char **argv, long_opts, NULL)) != -1) { switch (c) { case 'O': - if (param->obduuid) { + if (param->fp_obd_uuid) { fprintf(stderr, "error: %s: only one obduuid allowed", argv[0]); return CMD_HELP; } - param->obduuid = (struct obd_uuid *)optarg; + param->fp_obd_uuid = (struct obd_uuid *)optarg; break; case 'q': - param->quiet++; + param->fp_quiet++; break; case 'd': param->fp_max_depth = 0; break; case 'D': - param->get_default_lmv = 1; + param->fp_get_default_lmv = 1; break; case 'r': - param->recursive = 1; + param->fp_recursive = 1; break; case 'v': - param->verbose = VERBOSE_ALL | VERBOSE_DETAIL; + param->fp_verbose = VERBOSE_ALL | VERBOSE_DETAIL; break; case 'c': #if LUSTRE_VERSION_CODE >= OBD_OCD_VERSION(2, 6, 53, 0) @@ -1512,8 +1512,8 @@ static int lfs_getstripe_internal(int argc, char **argv, fprintf(stderr, "warning: '--count' deprecated," " use '--stripe-count' instead\n"); #endif - if (!(param->verbose & VERBOSE_DETAIL)) { - param->verbose |= VERBOSE_COUNT; + if (!(param->fp_verbose & VERBOSE_DETAIL)) { + param->fp_verbose |= VERBOSE_COUNT; param->fp_max_depth = 0; } break; @@ -1525,8 +1525,8 @@ static int lfs_getstripe_internal(int argc, char **argv, #endif #endif /* LUSTRE_VERSION_CODE < OBD_OCD_VERSION(2, 9, 53, 0) */ case 'S': - if (!(param->verbose & VERBOSE_DETAIL)) { - param->verbose |= VERBOSE_SIZE; + if (!(param->fp_verbose & VERBOSE_DETAIL)) { + param->fp_verbose |= VERBOSE_SIZE; param->fp_max_depth = 0; } break; @@ -1541,36 +1541,36 @@ static int lfs_getstripe_internal(int argc, char **argv, fprintf(stderr, "warning: '--index' deprecated" ", use '--stripe-index' instead\n"); #endif - if (!(param->verbose & VERBOSE_DETAIL)) { - param->verbose |= VERBOSE_OFFSET; + if (!(param->fp_verbose & VERBOSE_DETAIL)) { + param->fp_verbose |= VERBOSE_OFFSET; param->fp_max_depth = 0; } break; case 'p': - if (!(param->verbose & VERBOSE_DETAIL)) { - param->verbose |= VERBOSE_POOL; + if (!(param->fp_verbose & VERBOSE_DETAIL)) { + param->fp_verbose |= VERBOSE_POOL; param->fp_max_depth = 0; } break; case 'g': - if (!(param->verbose & VERBOSE_DETAIL)) { - param->verbose |= VERBOSE_GENERATION; + if (!(param->fp_verbose & VERBOSE_DETAIL)) { + param->fp_verbose |= VERBOSE_GENERATION; param->fp_max_depth = 0; } break; case 'L': - if (!(param->verbose & VERBOSE_DETAIL)) { - param->verbose |= VERBOSE_LAYOUT; + if (!(param->fp_verbose & VERBOSE_DETAIL)) { + param->fp_verbose |= VERBOSE_LAYOUT; param->fp_max_depth = 0; } break; case 'M': - if (!(param->verbose & VERBOSE_DETAIL)) + if (!(param->fp_verbose & VERBOSE_DETAIL)) param->fp_max_depth = 0; - param->verbose |= VERBOSE_MDTINDEX; + param->fp_verbose |= VERBOSE_MDTINDEX; break; case 'R': - param->raw = 1; + param->fp_raw = 1; break; default: return CMD_HELP; @@ -1580,13 +1580,13 @@ static int lfs_getstripe_internal(int argc, char **argv, if (optind >= argc) return CMD_HELP; - if (param->recursive) + if (param->fp_recursive) param->fp_max_depth = -1; - if (!param->verbose) - param->verbose = VERBOSE_ALL; - if (param->quiet) - param->verbose = VERBOSE_OBJID; + if (!param->fp_verbose) + param->fp_verbose = VERBOSE_ALL; + if (param->fp_quiet) + param->fp_verbose = VERBOSE_OBJID; do { rc = llapi_getstripe(argv[optind], param); @@ -1621,7 +1621,7 @@ static int lfs_tgts(int argc, char **argv) memset(¶m, 0, sizeof(param)); if (!strcmp(argv[0], "mdts")) - param.get_lmv = 1; + param.fp_get_lmv = 1; rc = llapi_ostlist(mntdir, ¶m); if (rc) { @@ -1647,7 +1647,7 @@ static int lfs_getdirstripe(int argc, char **argv) { struct find_param param = { 0 }; - param.get_lmv = 1; + param.fp_get_lmv = 1; return lfs_getstripe_internal(argc, argv, ¶m); } @@ -1820,7 +1820,7 @@ static int lfs_mv(int argc, char **argv) { struct find_param param = { .fp_max_depth = -1, - .mdtindex = -1, + .fp_mdt_index = -1, }; char *end; int c; @@ -1834,7 +1834,7 @@ static int lfs_mv(int argc, char **argv) while ((c = getopt_long(argc, argv, "M:v", long_opts, NULL)) != -1) { switch (c) { case 'M': { - param.mdtindex = strtoul(optarg, &end, 0); + param.fp_mdt_index = strtoul(optarg, &end, 0); if (*end != '\0') { fprintf(stderr, "%s: invalid MDT index'%s'\n", argv[0], optarg); @@ -1843,7 +1843,7 @@ static int lfs_mv(int argc, char **argv) break; } case 'v': { - param.verbose = VERBOSE_DETAIL; + param.fp_verbose = VERBOSE_DETAIL; break; } default: @@ -1853,7 +1853,7 @@ static int lfs_mv(int argc, char **argv) } } - if (param.mdtindex == -1) { + if (param.fp_mdt_index == -1) { fprintf(stderr, "%s MDT index must be indicated\n", argv[0]); return CMD_HELP; } @@ -1863,11 +1863,11 @@ static int lfs_mv(int argc, char **argv) return CMD_HELP; } - param.migrate = 1; + param.fp_migrate = 1; rc = llapi_mv(argv[optind], ¶m); if (rc != 0) fprintf(stderr, "cannot migrate '%s' to MDT%04x: %s\n", - argv[optind], param.mdtindex, strerror(-rc)); + argv[optind], param.fp_mdt_index, strerror(-rc)); return rc; } diff --git a/lustre/utils/liblustreapi.c b/lustre/utils/liblustreapi.c index 3f4e370..00465f9 100644 --- a/lustre/utils/liblustreapi.c +++ b/lustre/utils/liblustreapi.c @@ -1542,44 +1542,46 @@ typedef int (semantic_func_t)(char *path, DIR *parent, DIR **d, static int common_param_init(struct find_param *param, char *path) { - int lumlen = get_mds_md_size(path); + int lum_size = get_mds_md_size(path); - if (lumlen < PATH_MAX + 1) - lumlen = PATH_MAX + 1; + if (lum_size < PATH_MAX + 1) + lum_size = PATH_MAX + 1; - param->lumlen = lumlen; - param->lmd = malloc(sizeof(lstat_t) + param->lumlen); - if (param->lmd == NULL) { + param->fp_lum_size = lum_size; + param->fp_lmd = malloc(sizeof(lstat_t) + param->fp_lum_size); + if (param->fp_lmd == NULL) { llapi_error(LLAPI_MSG_ERROR, -ENOMEM, "error: allocation of %zu bytes for ioctl", - sizeof(lstat_t) + param->lumlen); + sizeof(lstat_t) + param->fp_lum_size); return -ENOMEM; } - param->fp_lmv_count = 256; - param->fp_lmv_md = malloc(lmv_user_md_size(256, LMV_MAGIC_V1)); + param->fp_lmv_stripe_count = 256; + param->fp_lmv_md = malloc(lmv_user_md_size(param->fp_lmv_stripe_count, + LMV_MAGIC_V1)); if (param->fp_lmv_md == NULL) { llapi_error(LLAPI_MSG_ERROR, -ENOMEM, "error: allocation of %d bytes for ioctl", - lmv_user_md_size(256, LMV_MAGIC_V1)); + lmv_user_md_size(param->fp_lmv_stripe_count, + LMV_MAGIC_V1)); return -ENOMEM; } - param->got_uuids = 0; - param->obdindexes = NULL; - param->obdindex = OBD_NOT_FOUND; - if (!param->migrate) - param->mdtindex = OBD_NOT_FOUND; + param->fp_got_uuids = 0; + param->fp_obd_indexes = NULL; + param->fp_obd_index = OBD_NOT_FOUND; + if (!param->fp_migrate) + param->fp_mdt_index = OBD_NOT_FOUND; return 0; } static void find_param_fini(struct find_param *param) { - if (param->obdindexes) - free(param->obdindexes); + if (param->fp_obd_indexes) + free(param->fp_obd_indexes); - if (param->lmd) - free(param->lmd); + if (param->fp_lmd) + free(param->fp_lmd); if (param->fp_lmv_md) free(param->fp_lmv_md); @@ -1617,8 +1619,8 @@ static int cb_get_dirstripe(char *path, DIR *d, struct find_param *param) struct lmv_user_md *lmv = (struct lmv_user_md *)param->fp_lmv_md; int ret = 0; - lmv->lum_stripe_count = param->fp_lmv_count; - if (param->get_default_lmv) + lmv->lum_stripe_count = param->fp_lmv_stripe_count; + if (param->fp_get_default_lmv) lmv->lum_magic = LMV_USER_MAGIC; else lmv->lum_magic = LMV_MAGIC_V1; @@ -1716,8 +1718,6 @@ static int llapi_semantic_traverse(char *path, int size, DIR *parent, while ((dent = readdir64(d)) != NULL) { int rc; - param->have_fileinfo = 0; - if (!strcmp(dent->d_name, ".") || !strcmp(dent->d_name, "..")) continue; @@ -1736,10 +1736,10 @@ static int llapi_semantic_traverse(char *path, int size, DIR *parent, strcat(path, dent->d_name); if (dent->d_type == DT_UNKNOWN) { - lstat_t *st = ¶m->lmd->lmd_st; + lstat_t *st = ¶m->fp_lmd->lmd_st; - rc = get_lmd_info(path, d, NULL, param->lmd, - param->lumlen); + rc = get_lmd_info(path, d, NULL, param->fp_lmd, + param->fp_lum_size); if (rc == 0) dent->d_type = IFTODT(st->st_mode); else if (ret == 0) @@ -1979,8 +1979,8 @@ int llapi_uuid_match(char *real_uuid, char *search_uuid) return (strncmp(search_uuid, real_uuid, cmplen) == 0); } -/* Here, param->obduuid points to a single obduuid, the index of which is - * returned in param->obdindex */ +/* Here, param->fp_obd_uuid points to a single obduuid, the index of which is + * returned in param->fp_obd_index */ static int setup_obd_uuid(DIR *dir, char *dname, struct find_param *param) { struct obd_uuid obd_uuid; @@ -1989,11 +1989,11 @@ static int setup_obd_uuid(DIR *dir, char *dname, struct find_param *param) FILE *fp; int rc = 0; - if (param->got_uuids) + if (param->fp_got_uuids) return rc; /* Get the lov/lmv name */ - if (param->get_lmv) + if (param->fp_get_lmv) rc = llapi_file_fget_lmv_uuid(dirfd(dir), &obd_uuid); else rc = llapi_file_fget_lov_uuid(dirfd(dir), &obd_uuid); @@ -2007,11 +2007,11 @@ static int setup_obd_uuid(DIR *dir, char *dname, struct find_param *param) return rc; } - param->got_uuids = 1; + param->fp_got_uuids = 1; - /* Now get the ost uuids from /proc */ - snprintf(buf, sizeof(buf), "/proc/fs/lustre/%s/%s/target_obd", - param->get_lmv ? "lmv" : "lov", obd_uuid.uuid); + /* Now get the ost uuids from /proc */ + snprintf(buf, sizeof(buf), "/proc/fs/lustre/%s/%s/target_obd", + param->fp_get_lmv ? "lmv" : "lov", obd_uuid.uuid); fp = fopen(buf, "r"); if (fp == NULL) { rc = -errno; @@ -2019,9 +2019,9 @@ static int setup_obd_uuid(DIR *dir, char *dname, struct find_param *param) return rc; } - if (!param->obduuid && !param->quiet && !param->obds_printed) - llapi_printf(LLAPI_MSG_NORMAL, "%s:\n", - param->get_lmv ? "MDTS" : "OBDS:"); + if (!param->fp_obd_uuid && !param->fp_quiet && !param->fp_obds_printed) + llapi_printf(LLAPI_MSG_NORMAL, "%s:\n", + param->fp_get_lmv ? "MDTS" : "OBDS:"); snprintf(format, sizeof(format), "%%d: %%%zus", sizeof(obd_uuid.uuid) - 1); @@ -2031,34 +2031,34 @@ static int setup_obd_uuid(DIR *dir, char *dname, struct find_param *param) if (sscanf(buf, format, &index, obd_uuid.uuid) < 2) break; - if (param->obduuid) { + if (param->fp_obd_uuid) { if (llapi_uuid_match(obd_uuid.uuid, - param->obduuid->uuid)) { - param->obdindex = index; - break; - } - } else if (!param->quiet && !param->obds_printed) { - /* Print everything */ - llapi_printf(LLAPI_MSG_NORMAL, "%s", buf); - } - } - param->obds_printed = 1; + param->fp_obd_uuid->uuid)) { + param->fp_obd_index = index; + break; + } + } else if (!param->fp_quiet && !param->fp_obds_printed) { + /* Print everything */ + llapi_printf(LLAPI_MSG_NORMAL, "%s", buf); + } + } + param->fp_obds_printed = 1; fclose(fp); - if (param->obduuid && (param->obdindex == OBD_NOT_FOUND)) { - llapi_err_noerrno(LLAPI_MSG_ERROR, - "error: %s: unknown obduuid: %s", - __func__, param->obduuid->uuid); - rc = -EINVAL; - } + if (param->fp_obd_uuid && (param->fp_obd_index == OBD_NOT_FOUND)) { + llapi_err_noerrno(LLAPI_MSG_ERROR, + "error: %s: unknown obduuid: %s", + __func__, param->fp_obd_uuid->uuid); + rc = -EINVAL; + } return (rc); } -/* In this case, param->obduuid will be an array of obduuids and +/* In this case, param->fp_obd_uuid will be an array of obduuids and * obd index for all these obduuids will be returned in - * param->obdindexes */ + * param->fp_obd_indexes */ static int setup_indexes(DIR *dir, char *path, struct obd_uuid *obduuids, int num_obds, int **obdindexes, int *obdindex, enum tgt_type type) @@ -2152,20 +2152,27 @@ static int setup_target_indexes(DIR *dir, char *path, struct find_param *param) { int ret = 0; - if (param->mdtuuid) { - ret = setup_indexes(dir, path, param->mdtuuid, param->num_mdts, - ¶m->mdtindexes, ¶m->mdtindex, LMV_TYPE); - if (ret) - return ret; - } - if (param->obduuid) { - ret = setup_indexes(dir, path, param->obduuid, param->num_obds, - ¶m->obdindexes, ¶m->obdindex, LOV_TYPE); - if (ret) - return ret; - } - param->got_uuids = 1; - return ret; + if (param->fp_mdt_uuid) { + ret = setup_indexes(dir, path, param->fp_mdt_uuid, + param->fp_num_mdts, + ¶m->fp_mdt_indexes, + ¶m->fp_mdt_index, LMV_TYPE); + if (ret) + return ret; + } + + if (param->fp_obd_uuid) { + ret = setup_indexes(dir, path, param->fp_obd_uuid, + param->fp_num_obds, + ¶m->fp_obd_indexes, + ¶m->fp_obd_index, LOV_TYPE); + if (ret) + return ret; + } + + param->fp_got_uuids = 1; + + return ret; } int llapi_ostlist(char *path, struct find_param *param) @@ -2618,30 +2625,30 @@ void llapi_lov_dump_user_lmm(struct find_param *param, char *path, int is_dir) { __u32 magic; - if (param->get_lmv || param->get_default_lmv) + if (param->fp_get_lmv || param->fp_get_default_lmv) magic = (__u32)param->fp_lmv_md->lum_magic; else - magic = *(__u32 *)¶m->lmd->lmd_lmm; /* lum->lmm_magic */ + magic = *(__u32 *)¶m->fp_lmd->lmd_lmm; /* lum->lmm_magic */ switch (magic) { case LOV_USER_MAGIC_V1: - lov_dump_user_lmm_v1v3(¶m->lmd->lmd_lmm, NULL, - param->lmd->lmd_lmm.lmm_objects, - path, is_dir, - param->obdindex, param->fp_max_depth, - param->verbose, param->raw); + lov_dump_user_lmm_v1v3(¶m->fp_lmd->lmd_lmm, NULL, + param->fp_lmd->lmd_lmm.lmm_objects, + path, is_dir, + param->fp_obd_index, param->fp_max_depth, + param->fp_verbose, param->fp_raw); break; case LOV_USER_MAGIC_V3: { char pool_name[LOV_MAXPOOLNAME + 1]; struct lov_user_ost_data_v1 *objects; - struct lov_user_md_v3 *lmmv3 = (void *)¶m->lmd->lmd_lmm; + struct lov_user_md_v3 *lmmv3 = (void *)¶m->fp_lmd->lmd_lmm; strlcpy(pool_name, lmmv3->lmm_pool_name, sizeof(pool_name)); - objects = lmmv3->lmm_objects; - lov_dump_user_lmm_v1v3(¶m->lmd->lmd_lmm, pool_name, - objects, path, is_dir, - param->obdindex, param->fp_max_depth, - param->verbose, param->raw); + objects = lmmv3->lmm_objects; + lov_dump_user_lmm_v1v3(¶m->fp_lmd->lmd_lmm, pool_name, + objects, path, is_dir, + param->fp_obd_index, param->fp_max_depth, + param->fp_verbose, param->fp_raw); break; } case LMV_MAGIC_V1: @@ -2652,14 +2659,14 @@ void llapi_lov_dump_user_lmm(struct find_param *param, char *path, int is_dir) lum = (struct lmv_user_md *)param->fp_lmv_md; strlcpy(pool_name, lum->lum_pool_name, sizeof(pool_name)); lmv_dump_user_lmm(lum, pool_name, path, - param->obdindex, param->fp_max_depth, - param->verbose); + param->fp_obd_index, param->fp_max_depth, + param->fp_verbose); break; } default: llapi_printf(LLAPI_MSG_NORMAL, "unknown lmm_magic: %#x " "(expecting one of %#x %#x %#x %#x)\n", - *(__u32 *)¶m->lmd->lmd_lmm, + *(__u32 *)¶m->fp_lmd->lmd_lmm, LOV_USER_MAGIC_V1, LOV_USER_MAGIC_V3, LMV_USER_MAGIC, LMV_MAGIC_V1); return; @@ -2839,66 +2846,68 @@ static int find_time_check(lstat_t *st, struct find_param *param, int mds) */ static int check_obd_match(struct find_param *param) { - lstat_t *st = ¶m->lmd->lmd_st; - struct lov_user_ost_data_v1 *lmm_objects; - int i, j; + lstat_t *st = ¶m->fp_lmd->lmd_st; + struct lov_user_ost_data_v1 *lmm_objects; + int i, j; - if (param->obduuid && param->obdindex == OBD_NOT_FOUND) - return 0; + if (param->fp_obd_uuid && param->fp_obd_index == OBD_NOT_FOUND) + return 0; - if (!S_ISREG(st->st_mode)) - return 0; + if (!S_ISREG(st->st_mode)) + return 0; - /* Only those files should be accepted, which have a - * stripe on the specified OST. */ - if (!param->lmd->lmd_lmm.lmm_stripe_count) - return 0; + /* Only those files should be accepted, which have a + * stripe on the specified OST. */ + if (!param->fp_lmd->lmd_lmm.lmm_stripe_count) + return 0; - if (param->lmd->lmd_lmm.lmm_magic == - LOV_USER_MAGIC_V3) { - struct lov_user_md_v3 *lmmv3 = (void *)¶m->lmd->lmd_lmm; + if (param->fp_lmd->lmd_lmm.lmm_magic == + LOV_USER_MAGIC_V3) { + struct lov_user_md_v3 *lmmv3 = (void *)¶m->fp_lmd->lmd_lmm; - lmm_objects = lmmv3->lmm_objects; - } else if (param->lmd->lmd_lmm.lmm_magic == LOV_USER_MAGIC_V1) { - lmm_objects = param->lmd->lmd_lmm.lmm_objects; - } else { - llapi_err_noerrno(LLAPI_MSG_ERROR, "%s:Unknown magic: 0x%08X\n", - __func__, param->lmd->lmd_lmm.lmm_magic); - return -EINVAL; - } + lmm_objects = lmmv3->lmm_objects; + } else if (param->fp_lmd->lmd_lmm.lmm_magic == LOV_USER_MAGIC_V1) { + lmm_objects = param->fp_lmd->lmd_lmm.lmm_objects; + } else { + llapi_err_noerrno(LLAPI_MSG_ERROR, "%s:Unknown magic: 0x%08X\n", + __func__, param->fp_lmd->lmd_lmm.lmm_magic); + return -EINVAL; + } - for (i = 0; i < param->lmd->lmd_lmm.lmm_stripe_count; i++) { - for (j = 0; j < param->num_obds; j++) { - if (param->obdindexes[j] == - lmm_objects[i].l_ost_idx) { - if (param->exclude_obd) - return 0; - return 1; - } - } - } + for (i = 0; i < param->fp_lmd->lmd_lmm.lmm_stripe_count; i++) { + for (j = 0; j < param->fp_num_obds; j++) { + if (param->fp_obd_indexes[j] == + lmm_objects[i].l_ost_idx) { + if (param->fp_exclude_obd) + return 0; + return 1; + } + } + } - if (param->exclude_obd) + if (param->fp_exclude_obd) return 1; - return 0; + + return 0; } static int check_mdt_match(struct find_param *param) { - int i; + int i; - if (param->mdtuuid && param->mdtindex == OBD_NOT_FOUND) - return 0; + if (param->fp_mdt_uuid && param->fp_mdt_index == OBD_NOT_FOUND) + return 0; - /* FIXME: For striped dir, we should get stripe information and check */ - for (i = 0; i < param->num_mdts; i++) { - if (param->mdtindexes[i] == param->file_mdtindex) - return !param->exclude_mdt; + /* FIXME: For striped dir, we should get stripe information and check */ + for (i = 0; i < param->fp_num_mdts; i++) { + if (param->fp_mdt_indexes[i] == param->fp_file_mdt_index) + return !param->fp_exclude_mdt; } - if (param->exclude_mdt) - return 1; - return 0; + if (param->fp_exclude_mdt) + return 1; + + return 0; } /** @@ -2916,16 +2925,17 @@ static int print_failed_tgt(struct find_param *param, char *path, int type) memset(&stat_buf, 0, sizeof(struct obd_statfs)); memset(&uuid_buf, 0, sizeof(struct obd_uuid)); - ret = llapi_obd_statfs(path, type, - param->obdindex, &stat_buf, - &uuid_buf); - if (ret) { - llapi_printf(LLAPI_MSG_NORMAL, - "obd_uuid: %s failed %s ", - param->obduuid->uuid, - strerror(errno)); - } - return ret; + ret = llapi_obd_statfs(path, type, + param->fp_obd_index, &stat_buf, + &uuid_buf); + if (ret) { + llapi_printf(LLAPI_MSG_NORMAL, + "obd_uuid: %s failed %s ", + param->fp_obd_uuid->uuid, + strerror(errno)); + } + + return ret; } static int cb_find_init(char *path, DIR *parent, DIR **dirp, @@ -2934,25 +2944,24 @@ static int cb_find_init(char *path, DIR *parent, DIR **dirp, struct find_param *param = (struct find_param *)data; DIR *dir = dirp == NULL ? NULL : *dirp; int decision = 1; /* 1 is accepted; -1 is rejected. */ - lstat_t *st = ¶m->lmd->lmd_st; + lstat_t *st = ¶m->fp_lmd->lmd_st; int lustre_fs = 1; int checked_type = 0; int ret = 0; LASSERT(parent != NULL || dir != NULL); - if (param->have_fileinfo == 0) - param->lmd->lmd_lmm.lmm_stripe_count = 0; + param->fp_lmd->lmd_lmm.lmm_stripe_count = 0; - /* If a regular expression is presented, make the initial decision */ - if (param->pattern != NULL) { - char *fname = strrchr(path, '/'); - fname = (fname == NULL ? path : fname + 1); - ret = fnmatch(param->pattern, fname, 0); - if ((ret == FNM_NOMATCH && !param->exclude_pattern) || - (ret == 0 && param->exclude_pattern)) - goto decided; - } + /* If a regular expression is presented, make the initial decision */ + if (param->fp_pattern != NULL) { + char *fname = strrchr(path, '/'); + fname = (fname == NULL ? path : fname + 1); + ret = fnmatch(param->fp_pattern, fname, 0); + if ((ret == FNM_NOMATCH && !param->fp_exclude_pattern) || + (ret == 0 && param->fp_exclude_pattern)) + goto decided; + } /* See if we can check the file type from the dirent. */ if (param->fp_type != 0 && de != NULL && de->d_type != DT_UNKNOWN) { @@ -2967,28 +2976,28 @@ static int cb_find_init(char *path, DIR *parent, DIR **dirp, } } - ret = 0; + ret = 0; - /* Request MDS for the stat info if some of these parameters need - * to be compared. */ - if (param->obduuid || param->mdtuuid || + /* Request MDS for the stat info if some of these parameters need + * to be compared. */ + if (param->fp_obd_uuid || param->fp_mdt_uuid || param->fp_check_uid || param->fp_check_gid || param->fp_atime || param->fp_mtime || param->fp_ctime || - param->check_pool || param->check_size || - param->check_stripecount || param->check_stripesize || - param->check_layout) + param->fp_check_pool || param->fp_check_size || + param->fp_check_stripe_count || param->fp_check_stripe_size || + param->fp_check_layout) decision = 0; if (param->fp_type != 0 && checked_type == 0) decision = 0; - if (param->have_fileinfo == 0 && decision == 0) { - ret = get_lmd_info(path, parent, dir, param->lmd, - param->lumlen); + if (decision == 0) { + ret = get_lmd_info(path, parent, dir, param->fp_lmd, + param->fp_lum_size); if (ret == 0) { if (dir) { - ret = llapi_file_fget_mdtidx(dirfd(dir), - ¶m->file_mdtindex); + ret = llapi_file_fget_mdtidx(dirfd(dir), + ¶m->fp_file_mdt_index); } else { int fd; lstat_t tmp_st; @@ -3005,7 +3014,7 @@ static int cb_find_init(char *path, DIR *parent, DIR **dirp, fd = open(path, O_RDONLY); if (fd > 0) { ret = llapi_file_fget_mdtidx(fd, - ¶m->file_mdtindex); + ¶m->fp_file_mdt_index); close(fd); } else { ret = fd; @@ -3015,8 +3024,8 @@ static int cb_find_init(char *path, DIR *parent, DIR **dirp, * reside on the same MDT with the * parent */ fd = dirfd(parent); - ret = llapi_file_fget_mdtidx(fd, - ¶m->file_mdtindex); + ret = llapi_file_fget_mdtidx(fd, + ¶m->fp_file_mdt_index); } } } @@ -3040,96 +3049,102 @@ static int cb_find_init(char *path, DIR *parent, DIR **dirp, } /* Prepare odb. */ - if (param->obduuid || param->mdtuuid) { - if (lustre_fs && param->got_uuids && + if (param->fp_obd_uuid || param->fp_mdt_uuid) { + if (lustre_fs && param->fp_got_uuids && param->fp_dev != st->st_dev) { - /* A lustre/lustre mount point is crossed. */ - param->got_uuids = 0; - param->obds_printed = 0; - param->obdindex = param->mdtindex = OBD_NOT_FOUND; - } + /* A lustre/lustre mount point is crossed. */ + param->fp_got_uuids = 0; + param->fp_obds_printed = 0; + param->fp_mdt_index = OBD_NOT_FOUND; + param->fp_obd_index = OBD_NOT_FOUND; + } - if (lustre_fs && !param->got_uuids) { - ret = setup_target_indexes(dir ? dir : parent, path, - param); - if (ret) - return ret; + if (lustre_fs && !param->fp_got_uuids) { + ret = setup_target_indexes(dir ? dir : parent, path, + param); + if (ret) + return ret; param->fp_dev = st->st_dev; - } else if (!lustre_fs && param->got_uuids) { - /* A lustre/non-lustre mount point is crossed. */ - param->got_uuids = 0; - param->obdindex = param->mdtindex = OBD_NOT_FOUND; + } else if (!lustre_fs && param->fp_got_uuids) { + /* A lustre/non-lustre mount point is crossed. */ + param->fp_got_uuids = 0; + param->fp_mdt_index = OBD_NOT_FOUND; + param->fp_obd_index = OBD_NOT_FOUND; } } - if (param->check_stripesize) { - decision = find_value_cmp(param->lmd->lmd_lmm.lmm_stripe_size, - param->stripesize, - param->stripesize_sign, - param->exclude_stripesize, - param->stripesize_units, 0); - if (decision == -1) - goto decided; - } + if (param->fp_check_stripe_size) { + decision = find_value_cmp( + param->fp_lmd->lmd_lmm.lmm_stripe_size, + param->fp_stripe_size, + param->fp_stripe_size_sign, + param->fp_exclude_stripe_size, + param->fp_stripe_size_units, 0); + if (decision == -1) + goto decided; + } - if (param->check_stripecount) { - decision = find_value_cmp(param->lmd->lmd_lmm.lmm_stripe_count, - param->stripecount, - param->stripecount_sign, - param->exclude_stripecount, 1, 0); - if (decision == -1) - goto decided; + if (param->fp_check_stripe_count) { + decision = find_value_cmp( + param->fp_lmd->lmd_lmm.lmm_stripe_count, + param->fp_stripe_count, + param->fp_stripe_count_sign, + param->fp_exclude_stripe_count, 1, 0); + if (decision == -1) + goto decided; } - if (param->check_layout) { + if (param->fp_check_layout) { __u32 found; - found = (param->lmd->lmd_lmm.lmm_pattern & param->layout); - if ((param->lmd->lmd_lmm.lmm_pattern == 0xFFFFFFFF) || - (found && param->exclude_layout) || - (!found && !param->exclude_layout)) { + found = (param->fp_lmd->lmd_lmm.lmm_pattern & param->fp_layout); + if ((param->fp_lmd->lmd_lmm.lmm_pattern == 0xFFFFFFFF) || + (found && param->fp_exclude_layout) || + (!found && !param->fp_exclude_layout)) { decision = -1; goto decided; } } - /* If an OBD UUID is specified but none matches, skip this file. */ - if ((param->obduuid && param->obdindex == OBD_NOT_FOUND) || - (param->mdtuuid && param->mdtindex == OBD_NOT_FOUND)) - goto decided; - - /* If a OST or MDT UUID is given, and some OST matches, - * check it here. */ - if (param->obdindex != OBD_NOT_FOUND || - param->mdtindex != OBD_NOT_FOUND) { - if (param->obduuid) { - if (check_obd_match(param)) { - /* If no mdtuuid is given, we are done. - * Otherwise, fall through to the mdtuuid - * check below. */ - if (!param->mdtuuid) - goto obd_matches; - } else { - goto decided; - } - } - if (param->mdtuuid) { - if (check_mdt_match(param)) - goto obd_matches; - goto decided; - } - } + /* If an OBD UUID is specified but none matches, skip this file. */ + if ((param->fp_obd_uuid && param->fp_obd_index == OBD_NOT_FOUND) || + (param->fp_mdt_uuid && param->fp_mdt_index == OBD_NOT_FOUND)) + goto decided; + + /* If a OST or MDT UUID is given, and some OST matches, + * check it here. */ + if (param->fp_obd_index != OBD_NOT_FOUND || + param->fp_mdt_index != OBD_NOT_FOUND) { + if (param->fp_obd_uuid) { + if (check_obd_match(param)) { + /* If no mdtuuid is given, we are done. + * Otherwise, fall through to the mdtuuid + * check below. */ + if (!param->fp_mdt_uuid) + goto obd_matches; + } else { + goto decided; + } + } + + if (param->fp_mdt_uuid) { + if (check_mdt_match(param)) + goto obd_matches; + goto decided; + } + } + obd_matches: if (param->fp_check_uid) { if (st->st_uid == param->fp_uid) { if (param->fp_exclude_uid) goto decided; - } else { + } else { if (!param->fp_exclude_uid) goto decided; - } - } + } + } if (param->fp_check_gid) { if (st->st_gid == param->fp_gid) { @@ -3141,33 +3156,33 @@ obd_matches: } } - if (param->check_pool) { - struct lov_user_md_v3 *lmmv3 = (void *)¶m->lmd->lmd_lmm; - - /* empty requested pool is taken as no pool search => V1 */ - if (((param->lmd->lmd_lmm.lmm_magic == LOV_USER_MAGIC_V1) && - (param->poolname[0] == '\0')) || - ((param->lmd->lmd_lmm.lmm_magic == LOV_USER_MAGIC_V3) && - (strncmp(lmmv3->lmm_pool_name, - param->poolname, LOV_MAXPOOLNAME) == 0)) || - ((param->lmd->lmd_lmm.lmm_magic == LOV_USER_MAGIC_V3) && - (strcmp(param->poolname, "*") == 0))) { - if (param->exclude_pool) - goto decided; - } else { - if (!param->exclude_pool) - goto decided; - } - } + if (param->fp_check_pool) { + struct lov_user_md_v3 *lmmv3 = (void *)¶m->fp_lmd->lmd_lmm; + + /* empty requested pool is taken as no pool search => V1 */ + if (((param->fp_lmd->lmd_lmm.lmm_magic == LOV_USER_MAGIC_V1) && + (param->fp_poolname[0] == '\0')) || + ((param->fp_lmd->lmd_lmm.lmm_magic == LOV_USER_MAGIC_V3) && + (strncmp(lmmv3->lmm_pool_name, + param->fp_poolname, LOV_MAXPOOLNAME) == 0)) || + ((param->fp_lmd->lmd_lmm.lmm_magic == LOV_USER_MAGIC_V3) && + (strcmp(param->fp_poolname, "*") == 0))) { + if (param->fp_exclude_pool) + goto decided; + } else { + if (!param->fp_exclude_pool) + goto decided; + } + } /* Check the time on mds. */ decision = 1; if (param->fp_atime || param->fp_mtime || param->fp_ctime) { int for_mds; - for_mds = lustre_fs ? (S_ISREG(st->st_mode) && - param->lmd->lmd_lmm.lmm_stripe_count) - : 0; + for_mds = lustre_fs ? (S_ISREG(st->st_mode) && + param->fp_lmd->lmd_lmm.lmm_stripe_count) + : 0; decision = find_time_check(st, param, for_mds); if (decision == -1) goto decided; @@ -3177,30 +3192,30 @@ obd_matches: The regular stat is almost of the same speed as some new 'glimpse-size-ioctl'. */ - if (param->check_size && S_ISREG(st->st_mode) && - param->lmd->lmd_lmm.lmm_stripe_count) + if (param->fp_check_size && S_ISREG(st->st_mode) && + param->fp_lmd->lmd_lmm.lmm_stripe_count) decision = 0; while (!decision) { /* For regular files with the stripe the decision may have not * been taken yet if *time or size is to be checked. */ LASSERT((S_ISREG(st->st_mode) && - param->lmd->lmd_lmm.lmm_stripe_count) || - param->mdtindex != OBD_NOT_FOUND); + param->fp_lmd->lmd_lmm.lmm_stripe_count) || + param->fp_mdt_index != OBD_NOT_FOUND); - if (param->obdindex != OBD_NOT_FOUND) + if (param->fp_obd_index != OBD_NOT_FOUND) print_failed_tgt(param, path, LL_STATFS_LOV); - if (param->mdtindex != OBD_NOT_FOUND) + if (param->fp_mdt_index != OBD_NOT_FOUND) print_failed_tgt(param, path, LL_STATFS_LMV); - if (dir) { - ret = ioctl(dirfd(dir), IOC_LOV_GETINFO, - (void *)param->lmd); - } else if (parent) { - ret = ioctl(dirfd(parent), IOC_LOV_GETINFO, - (void *)param->lmd); - } + if (dir) { + ret = ioctl(dirfd(dir), IOC_LOV_GETINFO, + (void *)param->fp_lmd); + } else if (parent) { + ret = ioctl(dirfd(parent), IOC_LOV_GETINFO, + (void *)param->fp_lmd); + } if (ret) { if (errno == ENOENT) { @@ -3225,14 +3240,15 @@ obd_matches: break; } - if (param->check_size) - decision = find_value_cmp(st->st_size, param->size, - param->size_sign, param->exclude_size, - param->size_units, 0); + if (param->fp_check_size) + decision = find_value_cmp(st->st_size, param->fp_size, + param->fp_size_sign, + param->fp_exclude_size, + param->fp_size_units, 0); if (decision != -1) { llapi_printf(LLAPI_MSG_NORMAL, "%s", path); - if (param->zeroend) + if (param->fp_zero_end) llapi_printf(LLAPI_MSG_NORMAL, "%c", '\0'); else llapi_printf(LLAPI_MSG_NORMAL, "\n"); @@ -3280,8 +3296,8 @@ static int cb_mv_init(char *path, DIR *parent, DIR **dirp, filename = basename(path); data.ioc_inlbuf1 = (char *)filename; data.ioc_inllen1 = strlen(filename) + 1; - data.ioc_inlbuf2 = (char *)¶m->mdtindex; - data.ioc_inllen2 = sizeof(param->mdtindex); + data.ioc_inlbuf2 = (char *)¶m->fp_mdt_index; + data.ioc_inllen2 = sizeof(param->fp_mdt_index); ret = obd_ioctl_pack(&data, &rawbuf, sizeof(raw)); if (ret != 0) { llapi_error(LLAPI_MSG_ERROR, ret, @@ -3294,8 +3310,9 @@ static int cb_mv_init(char *path, DIR *parent, DIR **dirp, ret = -errno; fprintf(stderr, "%s migrate failed %d\n", path, ret); goto out; - } else if (param->verbose & VERBOSE_DETAIL) { - fprintf(stdout, "migrate %s to MDT%d\n", path, param->mdtindex); + } else if (param->fp_verbose & VERBOSE_DETAIL) { + fprintf(stdout, "migrate %s to MDT%d\n", + path, param->fp_mdt_index); } out: @@ -3368,7 +3385,7 @@ static int cb_get_mdt_index(char *path, DIR *parent, DIR **dirp, void *data, if (ret) { if (ret == -ENODATA) { - if (!param->obduuid) + if (!param->fp_obd_uuid) llapi_printf(LLAPI_MSG_NORMAL, "%s has no stripe info\n", path); goto out; @@ -3393,7 +3410,7 @@ static int cb_get_mdt_index(char *path, DIR *parent, DIR **dirp, void *data, * that either 'd' or 'parent' is not null. * So in all cases llapi_file_fget_mdtidx() is called, * thus initializing 'mdtidx'. */ - if (param->quiet || !(param->verbose & VERBOSE_DETAIL)) + if (param->fp_quiet || !(param->fp_verbose & VERBOSE_DETAIL)) /* coverity[uninit_use_in_call] */ llapi_printf(LLAPI_MSG_NORMAL, "%d\n", mdtidx); else @@ -3420,29 +3437,30 @@ static int cb_getstripe(char *path, DIR *parent, DIR **dirp, void *data, LASSERT(parent != NULL || d != NULL); - if (param->obduuid) { - param->quiet = 1; + if (param->fp_obd_uuid) { + param->fp_quiet = 1; ret = setup_obd_uuid(d ? d : parent, path, param); if (ret) return ret; } if (d) { - if (param->get_lmv || param->get_default_lmv) { + if (param->fp_get_lmv || param->fp_get_default_lmv) { ret = cb_get_dirstripe(path, d, param); } else { ret = ioctl(dirfd(d), LL_IOC_LOV_GETSTRIPE, - (void *)¶m->lmd->lmd_lmm); + (void *)¶m->fp_lmd->lmd_lmm); } - } else if (parent && !param->get_lmv && !param->get_default_lmv) { + } else if (parent && !param->fp_get_lmv && !param->fp_get_default_lmv) { char *fname = strrchr(path, '/'); fname = (fname == NULL ? path : fname + 1); - strlcpy((char *)¶m->lmd->lmd_lmm, fname, param->lumlen); + strlcpy((char *)¶m->fp_lmd->lmd_lmm, fname, + param->fp_lum_size); ret = ioctl(dirfd(parent), IOC_MDC_GETFILESTRIPE, - (void *)¶m->lmd->lmd_lmm); + (void *)¶m->fp_lmd->lmd_lmm); } else { return 0; } @@ -3455,14 +3473,14 @@ static int cb_getstripe(char *path, DIR *parent, DIR **dirp, void *data, * a check later on in the code path. * The object_seq needs to be set for the "(Default)" * prefix to be displayed. */ - if (param->get_default_lmv) { + if (param->fp_get_default_lmv) { struct lmv_user_md *lum = param->fp_lmv_md; lum->lum_magic = LMV_USER_MAGIC; lum->lum_stripe_count = 0; lum->lum_stripe_offset = -1; goto dump; - } else if (param->get_lmv) { + } else if (param->fp_get_lmv) { struct lmv_user_md *lum = param->fp_lmv_md; int mdtidx; @@ -3474,9 +3492,11 @@ static int cb_getstripe(char *path, DIR *parent, DIR **dirp, void *data, lum->lum_stripe_offset = mdtidx; goto dump; } else { - struct lov_user_md *lmm = ¶m->lmd->lmd_lmm; + struct lov_user_md *lmm = + ¶m->fp_lmd->lmd_lmm; + lmm->lmm_magic = LOV_USER_MAGIC_V1; - if (!param->raw) + if (!param->fp_raw) ostid_set_seq(&lmm->lmm_oi, FID_SEQ_LOV_DEFAULT); lmm->lmm_stripe_count = 0; @@ -3485,7 +3505,7 @@ static int cb_getstripe(char *path, DIR *parent, DIR **dirp, void *data, goto dump; } } else if (errno == ENODATA && parent != NULL) { - if (!param->obduuid && !param->mdtuuid) + if (!param->fp_obd_uuid && !param->fp_mdt_uuid) llapi_printf(LLAPI_MSG_NORMAL, "%s has no stripe info\n", path); goto out; @@ -3512,7 +3532,7 @@ err_out: } dump: - if (!(param->verbose & VERBOSE_MDTINDEX)) + if (!(param->fp_verbose & VERBOSE_MDTINDEX)) llapi_lov_dump_user_lmm(param, path, d ? 1 : 0); out: @@ -3527,7 +3547,7 @@ out: int llapi_getstripe(char *path, struct find_param *param) { - return param_callback(path, (param->verbose & VERBOSE_MDTINDEX) ? + return param_callback(path, (param->fp_verbose & VERBOSE_MDTINDEX) ? cb_get_mdt_index : cb_getstripe, cb_common_fini, param); } @@ -3761,10 +3781,10 @@ static int cb_quotachown(char *path, DIR *parent, DIR **dirp, void *data, LASSERT(parent != NULL || d != NULL); - rc = get_lmd_info(path, parent, d, param->lmd, param->lumlen); + rc = get_lmd_info(path, parent, d, param->fp_lmd, param->fp_lum_size); if (rc) { if (rc == -ENODATA) { - if (!param->obduuid && !param->quiet) + if (!param->fp_obd_uuid && !param->fp_quiet) llapi_error(LLAPI_MSG_ERROR, -ENODATA, "%s has no stripe info", path); rc = 0; @@ -3774,7 +3794,7 @@ static int cb_quotachown(char *path, DIR *parent, DIR **dirp, void *data, return rc; } - st = ¶m->lmd->lmd_st; + st = ¶m->fp_lmd->lmd_st; /* libc chown() will do extra check, and if the real owner is * the same as the ones to set, it won't fall into kernel, so @@ -3799,9 +3819,9 @@ int llapi_quotachown(char *path, int flag) struct find_param param; memset(¶m, 0, sizeof(param)); - param.recursive = 1; - param.verbose = 0; - param.quiet = 1; + param.fp_recursive = 1; + param.fp_verbose = 0; + param.fp_quiet = 1; return param_callback(path, cb_quotachown, NULL, ¶m); } -- 1.8.3.1