LU-2675 llapi: find_param cleanup part I

Add fp_ prefixes to several (dev,type,{u,g}id,{a,c,m}time,...,depth)
members of struct find_param. Remove the unused print_fmt
member. Remove the llapi internal arrays llapi_dir_filetype_table[]
and llapi_filetype_dir_table[] replacing their uses with IFTODT() and
DTTOIF().

Signed-off-by: John L. Hammond <john.hammond@intel.com>
Change-Id: I0c24d8075493b814f3d3824f48b64d4b088928c5
Reviewed-on: http://review.whamcloud.com/10103
Tested-by: Jenkins
Tested-by: Maloo <hpdd-maloo@intel.com>
Reviewed-by: Bob Glossman <bob.glossman@intel.com>
Reviewed-by: Andreas Dilger <andreas.dilger@intel.com>

diff --git a/lustre/include/lustre/lustreapi.h b/lustre/include/lustre/lustreapi.h
index ff8d9ba..bc4abda 100644 (file)
--- a/lustre/include/lustre/lustreapi.h
+++ b/lustre/include/lustre/lustreapi.h
@@ -128,42 +128,43 @@ extern int llapi_file_lookup(int dirfd, const char *name);
                                 VERBOSE_LAYOUT)
 
 struct find_param {
-       unsigned int             maxdepth;
-       time_t                   atime;
-       time_t                   mtime;
-       time_t                   ctime;
-       /* cannot be bitfields due to using pointers to */
-       int                      asign;
-       /* access them during argument parsing. */
-       int                      csign;
-       int                      msign;
-       int                      type;
+       unsigned int             fp_max_depth;
+       dev_t                    fp_dev;
+       mode_t                   fp_type; /* S_IFIFO,... */
+       uid_t                    fp_uid;
+       gid_t                    fp_gid;
+       time_t                   fp_atime;
+       time_t                   fp_mtime;
+       time_t                   fp_ctime;
+       /* {a,m,c}sign cannot be bitfields due to using pointers to
+        * access them during argument parsing. */
+       int                      fp_asign;
+       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;
-       uid_t                    uid;
-       gid_t                    gid;
 
        unsigned long            zeroend:1,
                                 recursive:1,
                                 exclude_pattern:1,
-                                exclude_type:1,
+                                fp_exclude_type:1,
                                 exclude_obd:1,
                                 exclude_mdt:1,
-                                exclude_gid:1,
-                                exclude_uid:1,
-                                check_gid:1,           /* group ID */
-                                check_uid:1,           /* user ID */
+                                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,
-                                exclude_atime:1,
-                                exclude_mtime:1,
-                                exclude_ctime: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 */
@@ -181,8 +182,6 @@ struct find_param {
        /* regular expression */
        char                    *pattern;
 
-       char                    *print_fmt;
-
        struct  obd_uuid        *obduuid;
        int                      num_obds;
        int                      num_alloc_obds;
@@ -213,12 +212,7 @@ struct find_param {
        unsigned long            got_uuids:1,
                                 obds_printed:1,
                                 have_fileinfo:1; /* file attrs and LOV xattr */
-       unsigned int             depth;
-       dev_t                    st_dev;
-       __u64                    padding1;
-       __u64                    padding2;
-       __u64                    padding3;
-       __u64                    padding4;
+       unsigned int             fp_depth;
 };
 
 extern int llapi_ostlist(char *path, struct find_param *param);

diff --git a/lustre/utils/lfs.c b/lustre/utils/lfs.c
index 0001b8e..59f82e6 100644 (file)
--- a/lustre/utils/lfs.c
+++ b/lustre/utils/lfs.c
@@ -885,7 +885,10 @@ static int lfs_find(int argc, char **argv)
 {
         int c, ret;
         time_t t;
-        struct find_param param = { .maxdepth = -1, .quiet = 1 };
+       struct find_param param = {
+               .fp_max_depth = -1,
+               .quiet = 1,
+       };
         struct option long_opts[] = {
                 {"atime",        required_argument, 0, 'A'},
                 {"stripe-count", required_argument, 0, 'c'},
@@ -964,24 +967,24 @@ static int lfs_find(int argc, char **argv)
                         if (strcmp(optarg, "!") == 0)
                                 neg_opt = 2;
                         break;
-                case 'A':
-                        xtime = &param.atime;
-                        xsign = &param.asign;
-                        param.exclude_atime = !!neg_opt;
-                        /* no break, this falls through to 'C' for ctime */
-                case 'C':
-                        if (c == 'C') {
-                                xtime = &param.ctime;
-                                xsign = &param.csign;
-                                param.exclude_ctime = !!neg_opt;
-                        }
-                        /* no break, this falls through to 'M' for mtime */
-                case 'M':
-                        if (c == 'M') {
-                                xtime = &param.mtime;
-                                xsign = &param.msign;
-                                param.exclude_mtime = !!neg_opt;
-                        }
+               case 'A':
+                       xtime = &param.fp_atime;
+                       xsign = &param.fp_asign;
+                       param.fp_exclude_atime = !!neg_opt;
+                       /* no break, this falls through to 'C' for ctime */
+               case 'C':
+                       if (c == 'C') {
+                               xtime = &param.fp_ctime;
+                               xsign = &param.fp_csign;
+                               param.fp_exclude_ctime = !!neg_opt;
+                       }
+                       /* no break, this falls through to 'M' for mtime */
+               case 'M':
+                       if (c == 'M') {
+                               xtime = &param.fp_mtime;
+                               xsign = &param.fp_msign;
+                               param.fp_exclude_mtime = !!neg_opt;
+                       }
                         ret = set_time(&t, xtime, optarg);
                         if (ret == INT_MAX) {
                                 ret = -1;
@@ -1009,14 +1012,14 @@ static int lfs_find(int argc, char **argv)
                         param.check_stripecount = 1;
                         param.exclude_stripecount = !!neg_opt;
                         break;
-                case 'D':
-                        param.maxdepth = strtol(optarg, 0, 0);
-                        break;
-                case 'g':
-                case 'G':
-                        ret = name2id(&param.gid, optarg, GROUP);
-                        if (ret) {
-                                param.gid = strtoul(optarg, &endptr, 10);
+               case 'D':
+                       param.fp_max_depth = strtol(optarg, 0, 0);
+                       break;
+               case 'g':
+               case 'G':
+                       ret = name2id(&param.fp_gid, optarg, GROUP);
+                       if (ret) {
+                               param.fp_gid = strtoul(optarg, &endptr, 10);
                                 if (*endptr != '\0') {
                                         fprintf(stderr, "Group/GID: %s cannot "
                                                 "be found.\n", optarg);
@@ -1024,8 +1027,8 @@ static int lfs_find(int argc, char **argv)
                                         goto err;
                                 }
                         }
-                        param.exclude_gid = !!neg_opt;
-                        param.check_gid = 1;
+                       param.fp_exclude_gid = !!neg_opt;
+                       param.fp_check_gid = 1;
                         break;
                case 'L':
                        ret = name2layout(&param.layout, optarg);
@@ -1036,9 +1039,9 @@ static int lfs_find(int argc, char **argv)
                        break;
                 case 'u':
                 case 'U':
-                        ret = name2id(&param.uid, optarg, USER);
-                        if (ret) {
-                                param.uid = strtoul(optarg, &endptr, 10);
+                       ret = name2id(&param.fp_uid, optarg, USER);
+                       if (ret) {
+                               param.fp_uid = strtoul(optarg, &endptr, 10);
                                 if (*endptr != '\0') {
                                         fprintf(stderr, "User/UID: %s cannot "
                                                 "be found.\n", optarg);
@@ -1046,8 +1049,8 @@ static int lfs_find(int argc, char **argv)
                                         goto err;
                                 }
                         }
-                        param.exclude_uid = !!neg_opt;
-                        param.check_uid = 1;
+                       param.fp_exclude_uid = !!neg_opt;
+                       param.fp_check_uid = 1;
                         break;
                 case FIND_POOL_OPT:
                         if (strlen(optarg) > LOV_MAXPOOLNAME) {
@@ -1179,25 +1182,37 @@ err_free:
                        param.check_stripesize = 1;
                        param.exclude_stripesize = !!neg_opt;
                        break;
-                case 't':
-                        param.exclude_type = !!neg_opt;
-                        switch(optarg[0]) {
-                        case 'b': param.type = S_IFBLK; break;
-                        case 'c': param.type = S_IFCHR; break;
-                        case 'd': param.type = S_IFDIR; break;
-                        case 'f': param.type = S_IFREG; break;
-                        case 'l': param.type = S_IFLNK; break;
-                        case 'p': param.type = S_IFIFO; break;
-                        case 's': param.type = S_IFSOCK; break;
-#ifdef S_IFDOOR /* Solaris only */
-                        case 'D': param.type = S_IFDOOR; break;
-#endif
-                        default: fprintf(stderr, "error: %s: bad type '%s'\n",
-                                         argv[0], optarg);
-                                 ret = CMD_HELP;
-                                 goto err;
-                        };
-                        break;
+               case 't':
+                       param.fp_exclude_type = !!neg_opt;
+                       switch (optarg[0]) {
+                       case 'b':
+                               param.fp_type = S_IFBLK;
+                               break;
+                       case 'c':
+                               param.fp_type = S_IFCHR;
+                               break;
+                       case 'd':
+                               param.fp_type = S_IFDIR;
+                               break;
+                       case 'f':
+                               param.fp_type = S_IFREG;
+                               break;
+                       case 'l':
+                               param.fp_type = S_IFLNK;
+                               break;
+                       case 'p':
+                               param.fp_type = S_IFIFO;
+                               break;
+                       case 's':
+                               param.fp_type = S_IFSOCK;
+                               break;
+                       default:
+                               fprintf(stderr, "error: %s: bad type '%s'\n",
+                                       argv[0], optarg);
+                               ret = CMD_HELP;
+                               goto err;
+                       };
+                       break;
                 default:
                         ret = CMD_HELP;
                         goto err;
@@ -1282,7 +1297,7 @@ static int lfs_getstripe_internal(int argc, char **argv,
        };
        int c, rc;
 
-       param->maxdepth = 1;
+       param->fp_max_depth = 1;
        optind = 0;
        while ((c = getopt_long(argc, argv, "cdDghiLMoO:pqrRsSv",
                                long_opts, NULL)) != -1) {
@@ -1300,7 +1315,7 @@ static int lfs_getstripe_internal(int argc, char **argv,
                        param->quiet++;
                        break;
                case 'd':
-                       param->maxdepth = 0;
+                       param->fp_max_depth = 0;
                        break;
                case 'D':
                        param->get_default_lmv = 1;
@@ -1319,7 +1334,7 @@ static int lfs_getstripe_internal(int argc, char **argv,
 #endif
                        if (!(param->verbose & VERBOSE_DETAIL)) {
                                param->verbose |= VERBOSE_COUNT;
-                               param->maxdepth = 0;
+                               param->fp_max_depth = 0;
                        }
                        break;
 #if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(2, 9, 53, 0)
@@ -1332,7 +1347,7 @@ static int lfs_getstripe_internal(int argc, char **argv,
                case 'S':
                        if (!(param->verbose & VERBOSE_DETAIL)) {
                                param->verbose |= VERBOSE_SIZE;
-                               param->maxdepth = 0;
+                               param->fp_max_depth = 0;
                        }
                        break;
 #if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(2, 9, 53, 0)
@@ -1348,30 +1363,30 @@ static int lfs_getstripe_internal(int argc, char **argv,
 #endif
                        if (!(param->verbose & VERBOSE_DETAIL)) {
                                param->verbose |= VERBOSE_OFFSET;
-                               param->maxdepth = 0;
+                               param->fp_max_depth = 0;
                        }
                        break;
                case 'p':
                        if (!(param->verbose & VERBOSE_DETAIL)) {
                                param->verbose |= VERBOSE_POOL;
-                               param->maxdepth = 0;
+                               param->fp_max_depth = 0;
                        }
                        break;
                case 'g':
                        if (!(param->verbose & VERBOSE_DETAIL)) {
                                param->verbose |= VERBOSE_GENERATION;
-                               param->maxdepth = 0;
+                               param->fp_max_depth = 0;
                        }
                        break;
                case 'L':
                        if (!(param->verbose & VERBOSE_DETAIL)) {
                                param->verbose |= VERBOSE_LAYOUT;
-                               param->maxdepth = 0;
+                               param->fp_max_depth = 0;
                        }
                        break;
                case 'M':
                        if (!(param->verbose & VERBOSE_DETAIL))
-                               param->maxdepth = 0;
+                               param->fp_max_depth = 0;
                        param->verbose |= VERBOSE_MDTINDEX;
                        break;
                case 'R':
@@ -1386,7 +1401,7 @@ static int lfs_getstripe_internal(int argc, char **argv,
                return CMD_HELP;
 
        if (param->recursive)
-               param->maxdepth = -1;
+               param->fp_max_depth = -1;
 
        if (!param->verbose)
                param->verbose = VERBOSE_ALL;
@@ -1601,7 +1616,10 @@ static int lfs_rmentry(int argc, char **argv)
 
 static int lfs_mv(int argc, char **argv)
 {
-       struct  find_param param = { .maxdepth = -1, .mdtindex = -1};
+       struct  find_param param = {
+               .fp_max_depth = -1,
+               .mdtindex = -1,
+       };
        char   *end;
        int     c;
        int     rc = 0;

diff --git a/lustre/utils/liblustreapi.c b/lustre/utils/liblustreapi.c
index 479a445..203dff3 100644 (file)
--- a/lustre/utils/liblustreapi.c
+++ b/lustre/utils/liblustreapi.c
@@ -75,47 +75,6 @@
 #include <lustre_ioctl.h>
 #include "lustreapi_internal.h"
 
-static unsigned llapi_dir_filetype_table[] = {
-        [DT_UNKNOWN]= 0,
-        [DT_FIFO]= S_IFIFO,
-        [DT_CHR] = S_IFCHR,
-        [DT_DIR] = S_IFDIR,
-        [DT_BLK] = S_IFBLK,
-        [DT_REG] = S_IFREG,
-        [DT_LNK] = S_IFLNK,
-        [DT_SOCK]= S_IFSOCK,
-#if defined(DT_DOOR) && defined(S_IFDOOR)
-        [DT_DOOR]= S_IFDOOR,
-#endif
-};
-
-#if defined(DT_DOOR) && defined(S_IFDOOR)
-static const int DT_MAX = DT_DOOR;
-#else
-static const int DT_MAX = DT_SOCK;
-#endif
-
-static unsigned llapi_filetype_dir_table[] = {
-        [0]= DT_UNKNOWN,
-        [S_IFIFO]= DT_FIFO,
-        [S_IFCHR] = DT_CHR,
-        [S_IFDIR] = DT_DIR,
-        [S_IFBLK] = DT_BLK,
-        [S_IFREG] = DT_REG,
-        [S_IFLNK] = DT_LNK,
-        [S_IFSOCK]= DT_SOCK,
-#if defined(DT_DOOR) && defined(S_IFDOOR)
-        [S_IFDOOR]= DT_DOOR,
-#endif
-};
-
-#if defined(DT_DOOR) && defined(S_IFDOOR)
-static const int S_IFMAX = DT_DOOR;
-#else
-static const int S_IFMAX = DT_SOCK;
-#endif
-
-/* liblustreapi message level */
 static int llapi_msg_level = LLAPI_MSG_MAX;
 
 void llapi_msg_set_level(int level)
@@ -1498,9 +1457,10 @@ static void find_param_fini(struct find_param *param)
 static int cb_common_fini(char *path, DIR *parent, DIR **dirp, void *data,
                          struct dirent64 *de)
 {
-        struct find_param *param = (struct find_param *)data;
-        param->depth--;
-        return 0;
+       struct find_param *param = data;
+       param->fp_depth--;
+
+       return 0;
 }
 
 /* set errno upon failure */
@@ -1649,11 +1609,9 @@ static int llapi_semantic_traverse(char *path, int size, DIR *parent,
 
                        ret = get_lmd_info(path, d, NULL, param->lmd,
                                           param->lumlen);
-                        if (ret == 0) {
-                               dent->d_type =
-                                       llapi_filetype_dir_table[st->st_mode &
-                                                                S_IFMT];
-                       }
+                       if (ret == 0)
+                               dent->d_type = IFTODT(st->st_mode);
+
                         if (ret == -ENOENT)
                                 continue;
                }
@@ -1715,7 +1673,8 @@ static int param_callback(char *path, semantic_func_t sem_init,
         ret = common_param_init(param, buf);
         if (ret)
                 goto out;
-        param->depth = 0;
+
+       param->fp_depth = 0;
 
         ret = llapi_semantic_traverse(buf, PATH_MAX + 1, NULL, sem_init,
                                       sem_fini, param, NULL);
@@ -2506,7 +2465,7 @@ void llapi_lov_dump_user_lmm(struct find_param *param, char *path, int is_dir)
                 lov_dump_user_lmm_v1v3(&param->lmd->lmd_lmm, NULL,
                                        param->lmd->lmd_lmm.lmm_objects,
                                        path, is_dir,
-                                       param->obdindex, param->maxdepth,
+                                      param->obdindex, param->fp_max_depth,
                                        param->verbose, param->raw);
                 break;
         case LOV_USER_MAGIC_V3: {
@@ -2519,7 +2478,7 @@ void llapi_lov_dump_user_lmm(struct find_param *param, char *path, int is_dir)
                 objects = lmmv3->lmm_objects;
                 lov_dump_user_lmm_v1v3(&param->lmd->lmd_lmm, pool_name,
                                        objects, path, is_dir,
-                                       param->obdindex, param->maxdepth,
+                                      param->obdindex, param->fp_max_depth,
                                        param->verbose, param->raw);
                 break;
         }
@@ -2531,7 +2490,7 @@ void llapi_lov_dump_user_lmm(struct find_param *param, char *path, int is_dir)
                lum = (struct lmv_user_md *)param->fp_lmv_md;
                strncpy(pool_name, lum->lum_pool_name, LOV_MAXPOOLNAME);
                lmv_dump_user_lmm(lum, pool_name, path,
-                                 param->obdindex, param->maxdepth,
+                                 param->obdindex, param->fp_max_depth,
                                  param->verbose);
                break;
        }
@@ -2669,46 +2628,46 @@ static int find_value_cmp(unsigned long long file, unsigned long long limit,
  * updated timestamps. */
 static int find_time_check(lstat_t *st, struct find_param *param, int mds)
 {
-        int ret;
-        int rc = 1;
-
-        /* Check if file is accepted. */
-        if (param->atime) {
-                ret = find_value_cmp(st->st_atime, param->atime,
-                                     param->asign, param->exclude_atime,
-                                     24 * 60 * 60, mds);
-                if (ret < 0)
-                        return ret;
-                rc = ret;
-        }
-
-        if (param->mtime) {
-                ret = find_value_cmp(st->st_mtime, param->mtime,
-                                     param->msign, param->exclude_mtime,
-                                     24 * 60 * 60, mds);
-                if (ret < 0)
-                        return ret;
-
-                /* If the previous check matches, but this one is not yet clear,
-                 * we should return 0 to do an RPC on OSTs. */
-                if (rc == 1)
-                        rc = ret;
-        }
+       int rc = 1;
+       int rc2;
+
+       /* Check if file is accepted. */
+       if (param->fp_atime) {
+               rc2 = find_value_cmp(st->st_atime, param->fp_atime,
+                                    param->fp_asign, param->fp_exclude_atime,
+                                    24 * 60 * 60, mds);
+               if (rc2 < 0)
+                       return rc2;
+               rc = rc2;
+       }
 
-        if (param->ctime) {
-                ret = find_value_cmp(st->st_ctime, param->ctime,
-                                     param->csign, param->exclude_ctime,
-                                     24 * 60 * 60, mds);
-                if (ret < 0)
-                        return ret;
+       if (param->fp_mtime) {
+               rc2 = find_value_cmp(st->st_mtime, param->fp_mtime,
+                                    param->fp_msign, param->fp_exclude_mtime,
+                                    24 * 60 * 60, mds);
+               if (rc2 < 0)
+                       return rc2;
+
+               /* If the previous check matches, but this one is not yet clear,
+                * we should return 0 to do an RPC on OSTs. */
+               if (rc == 1)
+                       rc = rc2;
+       }
 
-                /* If the previous check matches, but this one is not yet clear,
-                 * we should return 0 to do an RPC on OSTs. */
-                if (rc == 1)
-                        rc = ret;
-        }
+       if (param->fp_ctime) {
+               rc2 = find_value_cmp(st->st_ctime, param->fp_ctime,
+                                    param->fp_csign, param->fp_exclude_ctime,
+                                    24 * 60 * 60, mds);
+               if (rc2 < 0)
+                       return rc2;
+
+               /* If the previous check matches, but this one is not yet clear,
+                * we should return 0 to do an RPC on OSTs. */
+               if (rc == 1)
+                       rc = rc2;
+       }
 
-        return rc;
+       return rc;
 }
 
 /**
@@ -2833,31 +2792,32 @@ static int cb_find_init(char *path, DIR *parent, DIR **dirp,
                         goto decided;
         }
 
-        /* See if we can check the file type from the dirent. */
-        if (param->type && de != NULL && de->d_type != DT_UNKNOWN &&
-            de->d_type < DT_MAX) {
-                checked_type = 1;
-                if (llapi_dir_filetype_table[de->d_type] == param->type) {
-                        if (param->exclude_type)
-                                goto decided;
-                } else {
-                        if (!param->exclude_type)
-                                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) {
+               checked_type = 1;
+
+               if (DTTOIF(de->d_type) == param->fp_type) {
+                       if (param->fp_exclude_type)
+                               goto decided;
+               } else {
+                       if (!param->fp_exclude_type)
+                               goto decided;
+               }
+       }
 
         ret = 0;
 
         /* Request MDS for the stat info if some of these parameters need
          * to be compared. */
-       if (param->obduuid   || param->mdtuuid || param->check_uid ||
-           param->check_gid || param->check_pool || param->atime   ||
-           param->ctime     || param->mtime || param->check_size ||
+       if (param->obduuid || param->mdtuuid ||
+           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)
                decision = 0;
 
-        if (param->type && checked_type == 0)
+       if (param->fp_type != 0 && checked_type == 0)
                 decision = 0;
 
         if (param->have_fileinfo == 0 && decision == 0) {
@@ -2907,20 +2867,20 @@ static int cb_find_init(char *path, DIR *parent, DIR **dirp,
                 }
         }
 
-        if (param->type && !checked_type) {
-                if ((st->st_mode & S_IFMT) == param->type) {
-                        if (param->exclude_type)
-                                goto decided;
-                } else {
-                        if (!param->exclude_type)
-                                goto decided;
-                }
-        }
+       if (param->fp_type && !checked_type) {
+               if ((st->st_mode & S_IFMT) == param->fp_type) {
+                       if (param->fp_exclude_type)
+                               goto decided;
+               } else {
+                       if (!param->fp_exclude_type)
+                               goto decided;
+               }
+       }
 
         /* Prepare odb. */
         if (param->obduuid || param->mdtuuid) {
                 if (lustre_fs && param->got_uuids &&
-                    param->st_dev != st->st_dev) {
+                   param->fp_dev != st->st_dev) {
                         /* A lustre/lustre mount point is crossed. */
                         param->got_uuids = 0;
                         param->obds_printed = 0;
@@ -2933,7 +2893,7 @@ static int cb_find_init(char *path, DIR *parent, DIR **dirp,
                         if (ret)
                                 return ret;
 
-                        param->st_dev = st->st_dev;
+                       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;
@@ -2999,25 +2959,25 @@ static int cb_find_init(char *path, DIR *parent, DIR **dirp,
                 }
         }
 obd_matches:
-        if (param->check_uid) {
-                if (st->st_uid == param->uid) {
-                        if (param->exclude_uid)
-                                goto decided;
-                } else {
-                        if (!param->exclude_uid)
-                                goto decided;
+       if (param->fp_check_uid) {
+               if (st->st_uid == param->fp_uid) {
+                       if (param->fp_exclude_uid)
+                               goto decided;
+       } else {
+                       if (!param->fp_exclude_uid)
+                               goto decided;
                 }
         }
 
-        if (param->check_gid) {
-                if (st->st_gid == param->gid) {
-                        if (param->exclude_gid)
-                                goto decided;
-                } else {
-                        if (!param->exclude_gid)
-                                goto decided;
-                }
-        }
+       if (param->fp_check_gid) {
+               if (st->st_gid == param->fp_gid) {
+                       if (param->fp_exclude_gid)
+                               goto decided;
+               } else {
+                       if (!param->fp_exclude_gid)
+                               goto decided;
+               }
+       }
 
         if (param->check_pool) {
                 struct lov_user_md_v3 *lmmv3 = (void *)&param->lmd->lmd_lmm;
@@ -3038,9 +2998,9 @@ obd_matches:
                 }
         }
 
-        /* Check the time on mds. */
-        decision = 1;
-        if (param->atime || param->ctime || param->mtime) {
+       /* 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) &&
@@ -3118,11 +3078,12 @@ obd_matches:
 
 decided:
         /* Do not get down anymore? */
-        if (param->depth == param->maxdepth)
-                return 1;
+       if (param->fp_depth == param->fp_max_depth)
+               return 1;
 
-        param->depth++;
-        return 0;
+       param->fp_depth++;
+
+       return 0;
 }
 
 static int cb_mv_init(char *path, DIR *parent, DIR **dirp,
@@ -3279,12 +3240,13 @@ static int cb_get_mdt_index(char *path, DIR *parent, DIR **dirp, void *data,
                              path, mdtidx);
 
 out:
-        /* Do not get down anymore? */
-        if (param->depth == param->maxdepth)
-                return 1;
+       /* Do not get down anymore? */
+       if (param->fp_depth == param->fp_max_depth)
+               return 1;
 
-        param->depth++;
-        return 0;
+       param->fp_depth++;
+
+       return 0;
 }
 
 static int cb_getstripe(char *path, DIR *parent, DIR **dirp, void *data,
@@ -3385,12 +3347,13 @@ dump:
                 llapi_lov_dump_user_lmm(param, path, d ? 1 : 0);
 
 out:
-        /* Do not get down anymore? */
-        if (param->depth == param->maxdepth)
-                return 1;
+       /* Do not get down anymore? */
+       if (param->fp_depth == param->fp_max_depth)
+               return 1;
 
-        param->depth++;
-        return 0;
+       param->fp_depth++;
+
+       return 0;
 }
 
 int llapi_getstripe(char *path, struct find_param *param)