LU-4961 lustre: remove liblustre.h and obd.h from userspace

[fs/lustre-release.git] / lustre / utils / lfs.c

diff --git a/lustre/utils/lfs.c b/lustre/utils/lfs.c
index a51ba82..1c0b2fe 100644 (file)
--- a/lustre/utils/lfs.c
+++ b/lustre/utils/lfs.c
@@ -69,12 +69,11 @@
 
 #include <lnet/lnetctl.h>
 
-#include <liblustre.h>
+#include <libcfs/libcfs.h>
+#include <lustre/lustre_idl.h>
 #include <lustre/lustreapi.h>
 
 #include <libcfs/libcfsutil.h>
-#include <obd.h>
-#include <obd_lov.h>
 #include "obdctl.h"
 
 /* all functions */
@@ -120,6 +119,7 @@ static int lfs_hsm_release(int argc, char **argv);
 static int lfs_hsm_remove(int argc, char **argv);
 static int lfs_hsm_cancel(int argc, char **argv);
 static int lfs_swap_layouts(int argc, char **argv);
+static int lfs_mv(int argc, char **argv);
 
 #define SETSTRIPE_USAGE(_cmd, _tgt) \
        "usage: "_cmd" [--stripe-count|-c <stripe_count>]\n"\
@@ -324,13 +324,17 @@ command_t cmdlist[] = {
         "usage: hsm_cancel [--filelist FILELIST] [--data DATA] <file> ..."},
        {"swap_layouts", lfs_swap_layouts, 0, "Swap layouts between 2 files.\n"
         "usage: swap_layouts <path1> <path2>"},
-       {"migrate", lfs_setstripe, 0, "migrate file from one layout to "
+       {"migrate", lfs_setstripe, 0, "migrate file from one OST layout to "
         "another (may be not safe with concurent writes).\n"
         SETSTRIPE_USAGE("migrate  ", "<filename>")},
-        {"help", Parser_help, 0, "help"},
-        {"exit", Parser_quit, 0, "quit"},
-        {"quit", Parser_quit, 0, "quit"},
-        { 0, 0, 0, NULL }
+       {"mv", lfs_mv, 0,
+        "To move directories between MDTs.\n"
+        "usage: mv <directory|filename> [--mdt-index|-M] <mdt_index> "
+        "[--verbose|-v]\n"},
+       {"help", Parser_help, 0, "help"},
+       {"exit", Parser_quit, 0, "quit"},
+       {"quit", Parser_quit, 0, "quit"},
+       { 0, 0, 0, NULL }
 };
 
 #define MIGRATION_BLOCKS 1
@@ -882,7 +886,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'},
@@ -961,24 +968,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;
@@ -1006,14 +1013,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);
@@ -1021,8 +1028,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);
@@ -1033,9 +1040,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);
@@ -1043,8 +1050,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) {
@@ -1176,25 +1183,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;
@@ -1279,7 +1298,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) {
@@ -1297,7 +1316,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;
@@ -1316,7 +1335,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)
@@ -1329,7 +1348,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)
@@ -1345,30 +1364,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':
@@ -1383,7 +1402,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;
@@ -1596,6 +1615,61 @@ static int lfs_rmentry(int argc, char **argv)
        return result;
 }
 
+static int lfs_mv(int argc, char **argv)
+{
+       struct  find_param param = {
+               .fp_max_depth = -1,
+               .mdtindex = -1,
+       };
+       char   *end;
+       int     c;
+       int     rc = 0;
+       struct option long_opts[] = {
+               {"--mdt-index", required_argument, 0, 'M'},
+               {"verbose",     no_argument,       0, 'v'},
+               {0, 0, 0, 0}
+       };
+
+       while ((c = getopt_long(argc, argv, "M:v", long_opts, NULL)) != -1) {
+               switch (c) {
+               case 'M': {
+                       param.mdtindex = strtoul(optarg, &end, 0);
+                       if (*end != '\0') {
+                               fprintf(stderr, "%s: invalid MDT index'%s'\n",
+                                       argv[0], optarg);
+                               return CMD_HELP;
+                       }
+                       break;
+               }
+               case 'v': {
+                       param.verbose = VERBOSE_DETAIL;
+                       break;
+               }
+               default:
+                       fprintf(stderr, "error: %s: unrecognized option '%s'\n",
+                               argv[0], argv[optind - 1]);
+                       return CMD_HELP;
+               }
+       }
+
+       if (param.mdtindex == -1) {
+               fprintf(stderr, "%s MDT index must be indicated\n", argv[0]);
+               return CMD_HELP;
+       }
+
+       if (optind >= argc) {
+               fprintf(stderr, "%s missing operand path\n", argv[0]);
+               return CMD_HELP;
+       }
+
+       param.migrate = 1;
+       rc = llapi_mv(argv[optind], &param);
+       if (rc != 0)
+               fprintf(stderr, "cannot migrate '%s' to MDT%04x: %s\n",
+                       argv[optind], param.mdtindex, strerror(-rc));
+       return rc;
+}
+
 static int lfs_osts(int argc, char **argv)
 {
         return lfs_tgts(argc, argv);
@@ -2577,13 +2651,13 @@ static void kbytes2str(__u64 num, char *buf, bool h)
                sprintf(buf, LPU64, num);
        } else {
                if (num >> 30)
-                       sprintf(buf, LPU64"%s", num >> 30, "T");
+                       sprintf(buf, "%5.4gT", (double)num / (1 << 30));
                else if (num >> 20)
-                       sprintf(buf, LPU64"%s", num >> 20, "G");
+                       sprintf(buf, "%5.4gG", (double)num / (1 << 20));
                else if (num >> 10)
-                       sprintf(buf, LPU64"%s", num >> 10, "M");
+                       sprintf(buf, "%5.4gM", (double)num / (1 << 10));
                else
-                       sprintf(buf, LPU64"%s", num, "K");
+                       sprintf(buf, LPU64"%s", num, "k");
        }
 }
 
@@ -2874,11 +2948,11 @@ ug_output:
            verbose) {
                char strbuf[32];
 
-               kbytes2str(total_balloc, strbuf, human_readable);
                rc2 = print_obd_quota(mnt, &qctl, 1, human_readable,
                                      &total_ialloc);
                rc3 = print_obd_quota(mnt, &qctl, 0, human_readable,
                                      &total_balloc);
+               kbytes2str(total_balloc, strbuf, human_readable);
                printf("Total allocated inode limit: "LPU64", total "
                       "allocated block limit: %s\n", total_ialloc, strbuf);
        }
@@ -3656,6 +3730,7 @@ static int lfs_hsm_request(int argc, char **argv, int action)
                                                strerror(errno));
                                        hur = oldhur;
                                        rc = -errno;
+                                       fclose(fp);
                                        goto out_free;
                                }
                                memcpy(hur, oldhur, hur_len(oldhur));
@@ -3672,8 +3747,10 @@ static int lfs_hsm_request(int argc, char **argv, int action)
                        rc = lfs_hsm_prepare_file(line, &hui->hui_fid,
                                                  &last_dev);
                        hur->hur_request.hr_itemcount++;
-                       if (rc)
+                       if (rc) {
+                               fclose(fp);
                                goto out_free;
+                       }
 
                        if ((some_file[0] == '\0') &&
                            (strlen(line) < sizeof(some_file)))