Whamcloud - gitweb
378cc78a036daaf82d48824592003c2eb7cf1c89
[fs/lustre-release.git] / lustre / utils / lfs.c
1 /*
2  * GPL HEADER START
3  *
4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License version 2 only,
8  * as published by the Free Software Foundation.
9  *
10  * This program is distributed in the hope that it will be useful, but
11  * WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * General Public License version 2 for more details (a copy is included
14  * in the LICENSE file that accompanied this code).
15  *
16  * You should have received a copy of the GNU General Public License
17  * version 2 along with this program; If not, see
18  * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
19  *
20  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
21  * CA 95054 USA or visit www.sun.com if you need additional information or
22  * have any questions.
23  *
24  * GPL HEADER END
25  */
26 /*
27  * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
28  * Use is subject to license terms.
29  *
30  * Copyright (c) 2011, 2014, Intel Corporation.
31  */
32 /*
33  * This file is part of Lustre, http://www.lustre.org/
34  * Lustre is a trademark of Sun Microsystems, Inc.
35  *
36  * lustre/utils/lfs.c
37  *
38  * Author: Peter J. Braam <braam@clusterfs.com>
39  * Author: Phil Schwan <phil@clusterfs.com>
40  * Author: Robert Read <rread@clusterfs.com>
41  */
42
43 /* for O_DIRECTORY */
44 #ifndef _GNU_SOURCE
45 #define _GNU_SOURCE
46 #endif
47
48 #include <stdlib.h>
49 #include <stdio.h>
50 #include <getopt.h>
51 #include <string.h>
52 #include <mntent.h>
53 #include <unistd.h>
54 #include <errno.h>
55 #include <err.h>
56 #include <pwd.h>
57 #include <grp.h>
58 #include <sys/ioctl.h>
59 #include <sys/quota.h>
60 #include <sys/time.h>
61 #include <sys/types.h>
62 #include <sys/stat.h>
63 #include <fcntl.h>
64 #include <dirent.h>
65 #include <time.h>
66 #include <ctype.h>
67 #ifdef HAVE_SYS_QUOTA_H
68 # include <sys/quota.h>
69 #endif
70
71 #include <libcfs/util/string.h>
72 #include <libcfs/util/ioctl.h>
73 #include <libcfs/util/parser.h>
74 #include <lustre/lustreapi.h>
75 #include <lustre_ver.h>
76
77 /* all functions */
78 static int lfs_setstripe(int argc, char **argv);
79 static int lfs_find(int argc, char **argv);
80 static int lfs_getstripe(int argc, char **argv);
81 static int lfs_getdirstripe(int argc, char **argv);
82 static int lfs_setdirstripe(int argc, char **argv);
83 static int lfs_rmentry(int argc, char **argv);
84 static int lfs_osts(int argc, char **argv);
85 static int lfs_mdts(int argc, char **argv);
86 static int lfs_df(int argc, char **argv);
87 static int lfs_getname(int argc, char **argv);
88 static int lfs_check(int argc, char **argv);
89 #ifdef HAVE_SYS_QUOTA_H
90 static int lfs_setquota(int argc, char **argv);
91 static int lfs_quota(int argc, char **argv);
92 #endif
93 static int lfs_flushctx(int argc, char **argv);
94 static int lfs_join(int argc, char **argv);
95 static int lfs_lsetfacl(int argc, char **argv);
96 static int lfs_lgetfacl(int argc, char **argv);
97 static int lfs_rsetfacl(int argc, char **argv);
98 static int lfs_rgetfacl(int argc, char **argv);
99 static int lfs_cp(int argc, char **argv);
100 static int lfs_ls(int argc, char **argv);
101 static int lfs_poollist(int argc, char **argv);
102 static int lfs_changelog(int argc, char **argv);
103 static int lfs_changelog_clear(int argc, char **argv);
104 static int lfs_fid2path(int argc, char **argv);
105 static int lfs_path2fid(int argc, char **argv);
106 static int lfs_data_version(int argc, char **argv);
107 static int lfs_hsm_state(int argc, char **argv);
108 static int lfs_hsm_set(int argc, char **argv);
109 static int lfs_hsm_clear(int argc, char **argv);
110 static int lfs_hsm_action(int argc, char **argv);
111 static int lfs_hsm_archive(int argc, char **argv);
112 static int lfs_hsm_restore(int argc, char **argv);
113 static int lfs_hsm_release(int argc, char **argv);
114 static int lfs_hsm_remove(int argc, char **argv);
115 static int lfs_hsm_cancel(int argc, char **argv);
116 static int lfs_swap_layouts(int argc, char **argv);
117 static int lfs_mv(int argc, char **argv);
118
119 /* Setstripe and migrate share mostly the same parameters */
120 #define SSM_CMD_COMMON(cmd) \
121         "usage: "cmd" [--stripe-count|-c <stripe_count>]\n"             \
122         "                 [--stripe-index|-i <start_ost_idx>]\n"        \
123         "                 [--stripe-size|-S <stripe_size>]\n"           \
124         "                 [--pool|-p <pool_name>]\n"                    \
125         "                 [--ost-list|-o <ost_indices>]\n"
126
127 #define SSM_HELP_COMMON \
128         "\tstripe_size:  Number of bytes on each OST (0 filesystem default)\n" \
129         "\t              Can be specified with k, m or g (in KB, MB and GB\n" \
130         "\t              respectively)\n"                               \
131         "\tstart_ost_idx: OST index of first stripe (-1 default)\n"     \
132         "\tstripe_count: Number of OSTs to stripe over (0 default, -1 all)\n" \
133         "\tpool_name:    Name of OST pool to use (default none)\n"      \
134         "\tost_indices:  List of OST indices, can be repeated multiple times\n"\
135         "\t              Indices be specified in a format of:\n"        \
136         "\t                -o <ost_1>,<ost_i>-<ost_j>,<ost_n>\n"        \
137         "\t              Or:\n"                                         \
138         "\t                -o <ost_1> -o <ost_i>-<ost_j> -o <ost_n>\n"  \
139         "\t              If --pool is set with --ost-list, then the OSTs\n" \
140         "\t              must be the members of the pool."
141
142 #define SETSTRIPE_USAGE                                         \
143         SSM_CMD_COMMON("setstripe")                             \
144         "                 <directory|filename>\n"               \
145         SSM_HELP_COMMON
146
147 #define MIGRATE_USAGE                                                   \
148         SSM_CMD_COMMON("migrate  ")                                     \
149         "                 [--block|-b]\n"                               \
150         "                 <filename>\n"                                 \
151         SSM_HELP_COMMON                                                 \
152         "\n"                                                            \
153         "\tblock:        Block file access during data migration\n"     \
154
155 static const char       *progname;
156 static bool              file_lease_supported = true;
157
158 /* all available commands */
159 command_t cmdlist[] = {
160         {"setstripe", lfs_setstripe, 0,
161          "Create a new file with a specific striping pattern or\n"
162          "set the default striping pattern on an existing directory or\n"
163          "delete the default striping pattern from an existing directory\n"
164          "usage: setstripe -d <directory>   (to delete default striping)\n"\
165          " or\n"
166          SETSTRIPE_USAGE},
167         {"getstripe", lfs_getstripe, 0,
168          "To list the striping info for a given file or files in a\n"
169          "directory or recursively for all files in a directory tree.\n"
170          "usage: getstripe [--ost|-O <uuid>] [--quiet | -q] [--verbose | -v]\n"
171          "                 [--stripe-count|-c] [--stripe-index|-i]\n"
172          "                 [--pool|-p] [--stripe-size|-S] [--directory|-d]\n"
173          "                 [--mdt-index|-M] [--recursive|-r] [--raw|-R]\n"
174          "                 [--layout|-L]\n"
175          "                 <directory|filename> ..."},
176         {"setdirstripe", lfs_setdirstripe, 0,
177          "To create a striped directory on a specified MDT. This can only\n"
178          "be done on MDT0 with the right of administrator.\n"
179          "usage: setdirstripe <--count|-c stripe_count>\n"
180          "              [--index|-i mdt_index] [--hash-type|-t hash_type]\n"
181          "              [--default_stripe|-D ] [--mode|-m mode] <dir>\n"
182          "\tstripe_count: stripe count of the striped directory\n"
183          "\tmdt_index:  MDT index of first stripe\n"
184          "\thash_type:  hash type of the striped directory. Hash types:\n"
185          "      fnv_1a_64 FNV-1a hash algorithm (default)\n"
186          "      all_char  sum of characters % MDT_COUNT (not recommended)\n"
187          "\tdefault_stripe: set default dirstripe of the directory\n"
188          "\tmode: the mode of the directory\n"},
189         {"getdirstripe", lfs_getdirstripe, 0,
190          "To list the striping info for a given directory\n"
191          "or recursively for all directories in a directory tree.\n"
192          "usage: getdirstripe [--obd|-O <uuid>] [--quiet|-q] [--verbose|-v]\n"
193          "               [--count|-c ] [--index|-i ] [--raw|-R]\n"
194          "               [--recursive | -r] [ --default_stripe | -D ] <dir> "},
195         {"mkdir", lfs_setdirstripe, 0,
196          "To create a striped directory on a specified MDT. This can only\n"
197          "be done on MDT0 with the right of administrator.\n"
198          "usage: mkdir <--count|-c stripe_count>\n"
199          "              [--index|-i mdt_index] [--hash-type|-t hash_type]\n"
200          "              [--default_stripe|-D ] [--mode|-m mode] <dir>\n"
201          "\tstripe_count: stripe count of the striped directory\n"
202          "\tmdt_index:  MDT index of first stripe\n"
203          "\thash_type:  hash type of the striped directory. Hash types:\n"
204          "      fnv_1a_64 FNV-1a hash algorithm (default)\n"
205          "      all_char  sum of characters % MDT_COUNT (not recommended)\n"
206          "\tdefault_stripe: set default dirstripe of the directory\n"
207          "\tmode: the mode of the directory\n"},
208         {"rm_entry", lfs_rmentry, 0,
209          "To remove the name entry of the remote directory. Note: This\n"
210          "command will only delete the name entry, i.e. the remote directory\n"
211          "will become inaccessable after this command. This can only be done\n"
212          "by the administrator\n"
213          "usage: rm_entry <dir>\n"},
214         {"pool_list", lfs_poollist, 0,
215          "List pools or pool OSTs\n"
216          "usage: pool_list <fsname>[.<pool>] | <pathname>\n"},
217         {"find", lfs_find, 0,
218          "find files matching given attributes recursively in directory tree.\n"
219          "usage: find <directory|filename> ...\n"
220          "     [[!] --atime|-A [+-]N] [[!] --ctime|-C [+-]N]\n"
221          "     [[!] --mtime|-M [+-]N] [[!] --mdt|-m <uuid|index,...>]\n"
222          "     [--maxdepth|-D N] [[!] --name|-n <pattern>]\n"
223          "     [[!] --ost|-O <uuid|index,...>] [--print|-p] [--print0|-P]\n"
224          "     [[!] --size|-s [+-]N[bkMGTPE]]\n"
225          "     [[!] --stripe-count|-c [+-]<stripes>]\n"
226          "     [[!] --stripe-index|-i <index,...>]\n"
227          "     [[!] --stripe-size|-S [+-]N[kMGT]] [[!] --type|-t <filetype>]\n"
228          "     [[!] --gid|-g|--group|-G <gid>|<gname>]\n"
229          "     [[!] --uid|-u|--user|-U <uid>|<uname>] [[!] --pool <pool>]\n"
230          "     [[!] --layout|-L released,raid0]\n"
231          "\t !: used before an option indicates 'NOT' requested attribute\n"
232          "\t -: used before a value indicates 'AT MOST' requested value\n"
233          "\t +: used before a value indicates 'AT LEAST' requested value\n"},
234         {"check", lfs_check, 0,
235          "Display the status of MDS or OSTs (as specified in the command)\n"
236          "or all the servers (MDS and OSTs).\n"
237          "usage: check <osts|mds|servers>"},
238         {"join", lfs_join, 0,
239          "join two lustre files into one.\n"
240          "obsolete, HEAD does not support it anymore.\n"},
241         {"osts", lfs_osts, 0, "list OSTs connected to client "
242          "[for specified path only]\n" "usage: osts [path]"},
243         {"mdts", lfs_mdts, 0, "list MDTs connected to client "
244          "[for specified path only]\n" "usage: mdts [path]"},
245         {"df", lfs_df, 0,
246          "report filesystem disk space usage or inodes usage"
247          "of each MDS and all OSDs or a batch belonging to a specific pool .\n"
248          "Usage: df [-i] [-h] [--lazy|-l] [--pool|-p <fsname>[.<pool>] [path]"},
249         {"getname", lfs_getname, 0, "list instances and specified mount points "
250          "[for specified path only]\n"
251          "Usage: getname [-h]|[path ...] "},
252 #ifdef HAVE_SYS_QUOTA_H
253         {"setquota", lfs_setquota, 0, "Set filesystem quotas.\n"
254          "usage: setquota <-u|-g> <uname>|<uid>|<gname>|<gid>\n"
255          "                -b <block-softlimit> -B <block-hardlimit>\n"
256          "                -i <inode-softlimit> -I <inode-hardlimit> <filesystem>\n"
257          "       setquota <-u|--user|-g|--group> <uname>|<uid>|<gname>|<gid>\n"
258          "                [--block-softlimit <block-softlimit>]\n"
259          "                [--block-hardlimit <block-hardlimit>]\n"
260          "                [--inode-softlimit <inode-softlimit>]\n"
261          "                [--inode-hardlimit <inode-hardlimit>] <filesystem>\n"
262          "       setquota [-t] <-u|--user|-g|--group>\n"
263          "                [--block-grace <block-grace>]\n"
264          "                [--inode-grace <inode-grace>] <filesystem>\n"
265          "       -b can be used instead of --block-softlimit/--block-grace\n"
266          "       -B can be used instead of --block-hardlimit\n"
267          "       -i can be used instead of --inode-softlimit/--inode-grace\n"
268          "       -I can be used instead of --inode-hardlimit\n\n"
269          "Note: The total quota space will be split into many qunits and\n"
270          "      balanced over all server targets, the minimal qunit size is\n"
271          "      1M bytes for block space and 1K inodes for inode space.\n\n"
272          "      Quota space rebalancing process will stop when this mininum\n"
273          "      value is reached. As a result, quota exceeded can be returned\n"
274          "      while many targets still have 1MB or 1K inodes of spare\n"
275          "      quota space."},
276         {"quota", lfs_quota, 0, "Display disk usage and limits.\n"
277          "usage: quota [-q] [-v] [-h] [-o <obd_uuid>|-i <mdt_idx>|-I "
278                        "<ost_idx>]\n"
279          "             [<-u|-g> <uname>|<uid>|<gname>|<gid>] <filesystem>\n"
280          "       quota [-o <obd_uuid>|-i <mdt_idx>|-I <ost_idx>] -t <-u|-g> <filesystem>"},
281 #endif
282         {"flushctx", lfs_flushctx, 0, "Flush security context for current user.\n"
283          "usage: flushctx [-k] [mountpoint...]"},
284         {"lsetfacl", lfs_lsetfacl, 0,
285          "Remote user setfacl for user/group on the same remote client.\n"
286          "usage: lsetfacl [-bkndRLPvh] [{-m|-x} acl_spec] [{-M|-X} acl_file] file ..."},
287         {"lgetfacl", lfs_lgetfacl, 0,
288          "Remote user getfacl for user/group on the same remote client.\n"
289          "usage: lgetfacl [-dRLPvh] file ..."},
290         {"rsetfacl", lfs_rsetfacl, 0,
291          "Remote user setfacl for user/group on other clients.\n"
292          "usage: rsetfacl [-bkndRLPvh] [{-m|-x} acl_spec] [{-M|-X} acl_file] file ..."},
293         {"rgetfacl", lfs_rgetfacl, 0,
294          "Remote user getfacl for user/group on other clients.\n"
295          "usage: rgetfacl [-dRLPvh] file ..."},
296         {"cp", lfs_cp, 0,
297          "Remote user copy files and directories.\n"
298          "usage: cp [OPTION]... [-T] SOURCE DEST\n\tcp [OPTION]... SOURCE... DIRECTORY\n\tcp [OPTION]... -t DIRECTORY SOURCE..."},
299         {"ls", lfs_ls, 0,
300          "Remote user list directory contents.\n"
301          "usage: ls [OPTION]... [FILE]..."},
302         {"changelog", lfs_changelog, 0,
303          "Show the metadata changes on an MDT."
304          "\nusage: changelog <mdtname> [startrec [endrec]]"},
305         {"changelog_clear", lfs_changelog_clear, 0,
306          "Indicate that old changelog records up to <endrec> are no longer of "
307          "interest to consumer <id>, allowing the system to free up space.\n"
308          "An <endrec> of 0 means all records.\n"
309          "usage: changelog_clear <mdtname> <id> <endrec>"},
310         {"fid2path", lfs_fid2path, 0,
311          "Resolve the full path(s) for given FID(s). For a specific hardlink "
312          "specify link number <linkno>.\n"
313         /* "For a historical link name, specify changelog record <recno>.\n" */
314          "usage: fid2path [--link <linkno>] <fsname|rootpath> <fid> ..."
315                 /* [ --rec <recno> ] */ },
316         {"path2fid", lfs_path2fid, 0, "Display the fid(s) for a given path(s).\n"
317          "usage: path2fid [--parents] <path> ..."},
318         {"data_version", lfs_data_version, 0, "Display file data version for "
319          "a given path.\n" "usage: data_version -[n|r|w] <path>"},
320         {"hsm_state", lfs_hsm_state, 0, "Display the HSM information (states, "
321          "undergoing actions) for given files.\n usage: hsm_state <file> ..."},
322         {"hsm_set", lfs_hsm_set, 0, "Set HSM user flag on specified files.\n"
323          "usage: hsm_set [--norelease] [--noarchive] [--dirty] [--exists] "
324          "[--archived] [--lost] <file> ..."},
325         {"hsm_clear", lfs_hsm_clear, 0, "Clear HSM user flag on specified "
326          "files.\n"
327          "usage: hsm_clear [--norelease] [--noarchive] [--dirty] [--exists] "
328          "[--archived] [--lost] <file> ..."},
329         {"hsm_action", lfs_hsm_action, 0, "Display current HSM request for "
330          "given files.\n" "usage: hsm_action <file> ..."},
331         {"hsm_archive", lfs_hsm_archive, 0,
332          "Archive file to external storage.\n"
333          "usage: hsm_archive [--filelist FILELIST] [--data DATA] [--archive NUM] "
334          "<file> ..."},
335         {"hsm_restore", lfs_hsm_restore, 0,
336          "Restore file from external storage.\n"
337          "usage: hsm_restore [--filelist FILELIST] [--data DATA] <file> ..."},
338         {"hsm_release", lfs_hsm_release, 0,
339          "Release files from Lustre.\n"
340          "usage: hsm_release [--filelist FILELIST] [--data DATA] <file> ..."},
341         {"hsm_remove", lfs_hsm_remove, 0,
342          "Remove file copy from external storage.\n"
343          "usage: hsm_remove [--filelist FILELIST] [--data DATA]\n"
344          "                  [--mntpath MOUNTPATH] [--archive NUM] <file|FID> ...\n"
345          "\n"
346          "Note: To remove files from the archive that have been deleted on\n"
347          "Lustre, set mntpath and optionally archive. In that case, all the\n"
348          "positional arguments and entries in the file list must be FIDs."
349         },
350         {"hsm_cancel", lfs_hsm_cancel, 0,
351          "Cancel requests related to specified files.\n"
352          "usage: hsm_cancel [--filelist FILELIST] [--data DATA] <file> ..."},
353         {"swap_layouts", lfs_swap_layouts, 0, "Swap layouts between 2 files.\n"
354          "usage: swap_layouts <path1> <path2>"},
355         {"migrate", lfs_setstripe, 0, "migrate file from one OST layout to "
356          "another.\n" MIGRATE_USAGE},
357         {"mv", lfs_mv, 0,
358          "To move directories between MDTs.\n"
359          "usage: mv <directory|filename> [--mdt-index|-M] <mdt_index> "
360          "[--verbose|-v]\n"},
361         {"help", Parser_help, 0, "help"},
362         {"exit", Parser_quit, 0, "quit"},
363         {"quit", Parser_quit, 0, "quit"},
364         {"--version", Parser_version, 0,
365          "output build version of the utility and exit"},
366         { 0, 0, 0, NULL }
367 };
368
369
370 #define MIGRATION_BLOCKS 1
371
372 /**
373  * Internal helper for migrate_copy_data(). Check lease and report error if
374  * need be.
375  *
376  * \param[in]  fd           File descriptor on which to check the lease.
377  * \param[out] lease_broken Set to true if the lease was broken.
378  * \param[in]  group_locked Whether a group lock was taken or not.
379  * \param[in]  path         Name of the file being processed, for error
380  *                          reporting
381  *
382  * \retval 0       Migration can keep on going.
383  * \retval -errno  Error occurred, abort migration.
384  */
385 static int check_lease(int fd, bool *lease_broken, bool group_locked,
386                        const char *path)
387 {
388         int rc;
389
390         if (!file_lease_supported)
391                 return 0;
392
393         rc = llapi_lease_check(fd);
394         if (rc > 0)
395                 return 0; /* llapi_check_lease returns > 0 on success. */
396
397         if (!group_locked) {
398                 fprintf(stderr, "%s: cannot migrate '%s': file busy\n",
399                         progname, path);
400                 rc = rc ? rc : -EAGAIN;
401         } else {
402                 fprintf(stderr, "%s: external attempt to access file '%s' "
403                         "blocked until migration ends.\n", progname, path);
404                 rc = 0;
405         }
406         *lease_broken = true;
407         return rc;
408 }
409
410 static int migrate_copy_data(int fd_src, int fd_dst, size_t buf_size,
411                              bool group_locked, const char *fname)
412 {
413         void    *buf = NULL;
414         ssize_t  rsize = -1;
415         ssize_t  wsize = 0;
416         size_t   rpos = 0;
417         size_t   wpos = 0;
418         off_t    bufoff = 0;
419         int      rc;
420         bool     lease_broken = false;
421
422         /* Use a page-aligned buffer for direct I/O */
423         rc = posix_memalign(&buf, getpagesize(), buf_size);
424         if (rc != 0)
425                 return -rc;
426
427         while (1) {
428                 /* read new data only if we have written all
429                  * previously read data */
430                 if (wpos == rpos) {
431                         if (!lease_broken) {
432                                 rc = check_lease(fd_src, &lease_broken,
433                                                  group_locked, fname);
434                                 if (rc < 0)
435                                         goto out;
436                         }
437                         rsize = read(fd_src, buf, buf_size);
438                         if (rsize < 0) {
439                                 rc = -errno;
440                                 fprintf(stderr, "%s: %s: read failed: %s\n",
441                                         progname, fname, strerror(-rc));
442                                 goto out;
443                         }
444                         rpos += rsize;
445                         bufoff = 0;
446                 }
447                 /* eof ? */
448                 if (rsize == 0)
449                         break;
450
451                 wsize = write(fd_dst, buf + bufoff, rpos - wpos);
452                 if (wsize < 0) {
453                         rc = -errno;
454                         fprintf(stderr,
455                                 "%s: %s: write failed on volatile: %s\n",
456                                 progname, fname, strerror(-rc));
457                         goto out;
458                 }
459                 wpos += wsize;
460                 bufoff += wsize;
461         }
462
463         rc = fsync(fd_dst);
464         if (rc < 0) {
465                 rc = -errno;
466                 fprintf(stderr, "%s: %s: fsync failed: %s\n",
467                         progname, fname, strerror(-rc));
468         }
469
470 out:
471         free(buf);
472         return rc;
473 }
474
475 static int migrate_copy_timestamps(int fdv, const struct stat *st)
476 {
477         struct timeval  tv[2] = {
478                 {.tv_sec = st->st_atime},
479                 {.tv_sec = st->st_mtime}
480         };
481
482         return futimes(fdv, tv);
483 }
484
485 static int migrate_block(int fd, int fdv, const struct stat *st,
486                          size_t buf_size, const char *name)
487 {
488         __u64   dv1;
489         int     gid;
490         int     rc;
491         int     rc2;
492
493         rc = llapi_get_data_version(fd, &dv1, LL_DV_RD_FLUSH);
494         if (rc < 0) {
495                 fprintf(stderr, "%s: %s: cannot get dataversion: %s\n",
496                         progname, name, strerror(-rc));
497                 return rc;
498         }
499
500         do
501                 gid = random();
502         while (gid == 0);
503
504         /* The grouplock blocks all concurrent accesses to the file.
505          * It has to be taken after llapi_get_data_version as it would
506          * block it too. */
507         rc = llapi_group_lock(fd, gid);
508         if (rc < 0) {
509                 fprintf(stderr, "%s: %s: cannot get group lock: %s\n",
510                         progname, name, strerror(-rc));
511                 return rc;
512         }
513
514         rc = migrate_copy_data(fd, fdv, buf_size, true, name);
515         if (rc < 0) {
516                 fprintf(stderr, "%s: %s: data copy failed\n", progname, name);
517                 goto out_unlock;
518         }
519
520         /* Make sure we keep original atime/mtime values */
521         rc = migrate_copy_timestamps(fdv, st);
522         if (rc < 0) {
523                 fprintf(stderr, "%s: %s: timestamp copy failed\n",
524                         progname, name);
525                 goto out_unlock;
526         }
527
528         /* swap layouts
529          * for a migration we need to check data version on file did
530          * not change.
531          *
532          * Pass in gid=0 since we already own grouplock. */
533         rc = llapi_fswap_layouts_grouplock(fd, fdv, dv1, 0, 0,
534                                            SWAP_LAYOUTS_CHECK_DV1);
535         if (rc == -EAGAIN) {
536                 fprintf(stderr, "%s: %s: dataversion changed during copy, "
537                         "migration aborted\n", progname, name);
538                 goto out_unlock;
539         } else if (rc < 0) {
540                 fprintf(stderr, "%s: %s: cannot swap layouts: %s\n", progname,
541                         name, strerror(-rc));
542                 goto out_unlock;
543         }
544
545 out_unlock:
546         rc2 = llapi_group_unlock(fd, gid);
547         if (rc2 < 0 && rc == 0) {
548                 fprintf(stderr, "%s: %s: putting group lock failed: %s\n",
549                         progname, name, strerror(-rc2));
550                 rc = rc2;
551         }
552
553         return rc;
554 }
555
556 static int migrate_nonblock(int fd, int fdv, const struct stat *st,
557                             size_t buf_size, const char *name)
558 {
559         __u64   dv1;
560         __u64   dv2;
561         int     rc;
562
563         rc = llapi_get_data_version(fd, &dv1, LL_DV_RD_FLUSH);
564         if (rc < 0) {
565                 fprintf(stderr, "%s: %s: cannot get data version: %s\n",
566                         progname, name, strerror(-rc));
567                 return rc;
568         }
569
570         rc = migrate_copy_data(fd, fdv, buf_size, false, name);
571         if (rc < 0) {
572                 fprintf(stderr, "%s: %s: data copy failed\n", progname, name);
573                 return rc;
574         }
575
576         rc = llapi_get_data_version(fd, &dv2, LL_DV_RD_FLUSH);
577         if (rc != 0) {
578                 fprintf(stderr, "%s: %s: cannot get data version: %s\n",
579                         progname, name, strerror(-rc));
580                 return rc;
581         }
582
583         if (dv1 != dv2) {
584                 rc = -EAGAIN;
585                 fprintf(stderr, "%s: %s: data version changed during "
586                                 "migration\n",
587                         progname, name);
588                 return rc;
589         }
590
591         /* Make sure we keep original atime/mtime values */
592         rc = migrate_copy_timestamps(fdv, st);
593         if (rc < 0) {
594                 fprintf(stderr, "%s: %s: timestamp copy failed\n",
595                         progname, name);
596                 return rc;
597         }
598
599         /* Atomically put lease, swap layouts and close.
600          * for a migration we need to check data version on file did
601          * not change. */
602         rc = llapi_fswap_layouts(fd, fdv, 0, 0, SWAP_LAYOUTS_CLOSE);
603         if (rc < 0) {
604                 fprintf(stderr, "%s: %s: cannot swap layouts: %s\n",
605                         progname, name, strerror(-rc));
606                 return rc;
607         }
608
609         return 0;
610 }
611
612 static int lfs_migrate(char *name, __u64 migration_flags,
613                        struct llapi_stripe_param *param)
614 {
615         int                      fd = -1;
616         int                      fdv = -1;
617         char                     volatile_file[PATH_MAX +
618                                                 LUSTRE_VOLATILE_HDR_LEN + 4];
619         char                     parent[PATH_MAX];
620         char                    *ptr;
621         int                      rc;
622         struct lov_user_md      *lum = NULL;
623         int                      lum_size;
624         int                      buf_size;
625         bool                     have_lease_rdlck = false;
626         struct stat              st;
627         struct stat              stv;
628
629         /* find the right size for the IO and allocate the buffer */
630         lum_size = lov_user_md_size(LOV_MAX_STRIPE_COUNT, LOV_USER_MAGIC_V3);
631         lum = malloc(lum_size);
632         if (lum == NULL) {
633                 rc = -ENOMEM;
634                 goto free;
635         }
636
637         rc = llapi_file_get_stripe(name, lum);
638         /* failure can happen for many reasons and some may be not real errors
639          * (eg: no stripe)
640          * in case of a real error, a later call will fail with better
641          * error management */
642         if (rc < 0)
643                 buf_size = 1024 * 1024;
644         else
645                 buf_size = lum->lmm_stripe_size;
646
647         /* open file, direct io */
648         /* even if the file is only read, WR mode is nedeed to allow
649          * layout swap on fd */
650         fd = open(name, O_RDWR | O_DIRECT);
651         if (fd == -1) {
652                 rc = -errno;
653                 fprintf(stderr, "%s: %s: cannot open: %s\n", progname, name,
654                         strerror(-rc));
655                 goto free;
656         }
657
658         if (file_lease_supported) {
659                 rc = llapi_lease_get(fd, LL_LEASE_RDLCK);
660                 if (rc == -EOPNOTSUPP) {
661                         /* Older servers do not support file lease.
662                          * Disable related checks. This opens race conditions
663                          * as explained in LU-4840 */
664                         file_lease_supported = false;
665                 } else if (rc < 0) {
666                         fprintf(stderr, "%s: %s: cannot get open lease: %s\n",
667                                 progname, name, strerror(-rc));
668                         goto error;
669                 } else {
670                         have_lease_rdlck = true;
671                 }
672         }
673
674         /* search for file directory pathname */
675         if (strlen(name) > sizeof(parent)-1) {
676                 rc = -E2BIG;
677                 goto error;
678         }
679         strncpy(parent, name, sizeof(parent));
680         ptr = strrchr(parent, '/');
681         if (ptr == NULL) {
682                 if (getcwd(parent, sizeof(parent)) == NULL) {
683                         rc = -errno;
684                         goto error;
685                 }
686         } else {
687                 if (ptr == parent)
688                         strcpy(parent, "/");
689                 else
690                         *ptr = '\0';
691         }
692
693         rc = snprintf(volatile_file, sizeof(volatile_file), "%s/%s::", parent,
694                       LUSTRE_VOLATILE_HDR);
695         if (rc >= sizeof(volatile_file)) {
696                 rc = -E2BIG;
697                 goto error;
698         }
699
700         /* create, open a volatile file, use caching (ie no directio) */
701         /* exclusive create is not needed because volatile files cannot
702          * conflict on name by construction */
703         fdv = llapi_file_open_param(volatile_file, O_CREAT | O_WRONLY, 0644,
704                                     param);
705         if (fdv < 0) {
706                 rc = fdv;
707                 fprintf(stderr, "%s: %s: cannot create volatile file in"
708                                 " directory: %s\n",
709                         progname, parent, strerror(-rc));
710                 goto error;
711         }
712
713         /* Not-owner (root?) special case.
714          * Need to set owner/group of volatile file like original.
715          * This will allow to pass related check during layout_swap.
716          */
717         rc = fstat(fd, &st);
718         if (rc != 0) {
719                 rc = -errno;
720                 fprintf(stderr, "%s: %s: cannot stat: %s\n", progname, name,
721                         strerror(errno));
722                 goto error;
723         }
724         rc = fstat(fdv, &stv);
725         if (rc != 0) {
726                 rc = -errno;
727                 fprintf(stderr, "%s: %s: cannot stat: %s\n", progname,
728                         volatile_file, strerror(errno));
729                 goto error;
730         }
731         if (st.st_uid != stv.st_uid || st.st_gid != stv.st_gid) {
732                 rc = fchown(fdv, st.st_uid, st.st_gid);
733                 if (rc != 0) {
734                         rc = -errno;
735                         fprintf(stderr, "%s: %s: cannot chown: %s\n", progname,
736                                 name, strerror(errno));
737                         goto error;
738                 }
739         }
740
741         if (migration_flags & MIGRATION_BLOCKS || !file_lease_supported) {
742                 /* Blocking mode, forced if servers do not support file lease */
743                 rc = migrate_block(fd, fdv, &st, buf_size, name);
744         } else {
745                 rc = migrate_nonblock(fd, fdv, &st, buf_size, name);
746                 if (rc == 0) {
747                         have_lease_rdlck = false;
748                         fdv = -1; /* The volatile file is closed as we put the
749                                    * lease in non-blocking mode. */
750                 }
751         }
752
753 error:
754         if (have_lease_rdlck)
755                 llapi_lease_put(fd);
756
757         if (fd >= 0)
758                 close(fd);
759
760         if (fdv >= 0)
761                 close(fdv);
762
763 free:
764         if (lum)
765                 free(lum);
766
767         return rc;
768 }
769
770 /**
771  * Parse a string containing an OST index list into an array of integers.
772  *
773  * The input string contains a comma delimited list of individual
774  * indices and ranges, for example "1,2-4,7". Add the indices into the
775  * \a osts array and remove duplicates.
776  *
777  * \param[out] osts    array to store indices in
778  * \param[in] size     size of \a osts array
779  * \param[in] offset   starting index in \a osts
780  * \param[in] arg      string containing OST index list
781  *
782  * \retval positive    number of indices in \a osts
783  * \retval -EINVAL     unable to parse \a arg
784  */
785 static int parse_targets(__u32 *osts, int size, int offset, char *arg)
786 {
787         int rc;
788         int nr = offset;
789         int slots = size - offset;
790         char *ptr = NULL;
791         bool end_of_loop;
792
793         if (arg == NULL)
794                 return -EINVAL;
795
796         end_of_loop = false;
797         while (!end_of_loop) {
798                 int start_index;
799                 int end_index;
800                 int i;
801                 char *endptr = NULL;
802
803                 rc = -EINVAL;
804
805                 ptr = strchrnul(arg, ',');
806
807                 end_of_loop = *ptr == '\0';
808                 *ptr = '\0';
809
810                 start_index = strtol(arg, &endptr, 0);
811                 if (endptr == arg) /* no data at all */
812                         break;
813                 if (*endptr != '-' && *endptr != '\0') /* has invalid data */
814                         break;
815                 if (start_index < 0)
816                         break;
817
818                 end_index = start_index;
819                 if (*endptr == '-') {
820                         end_index = strtol(endptr + 1, &endptr, 0);
821                         if (*endptr != '\0')
822                                 break;
823                         if (end_index < start_index)
824                                 break;
825                 }
826
827                 for (i = start_index; i <= end_index && slots > 0; i++) {
828                         int j;
829
830                         /* remove duplicate */
831                         for (j = 0; j < offset; j++) {
832                                 if (osts[j] == i)
833                                         break;
834                         }
835                         if (j == offset) { /* no duplicate */
836                                 osts[nr++] = i;
837                                 --slots;
838                         }
839                 }
840                 if (slots == 0 && i < end_index)
841                         break;
842
843                 *ptr = ',';
844                 arg = ++ptr;
845                 offset = nr;
846                 rc = 0;
847         }
848         if (!end_of_loop && ptr != NULL)
849                 *ptr = ',';
850
851         return rc < 0 ? rc : nr;
852 }
853
854 /* functions */
855 static int lfs_setstripe(int argc, char **argv)
856 {
857         struct llapi_stripe_param       *param;
858         char                            *fname;
859         int                              result;
860         int                              result2 = 0;
861         unsigned long long               st_size;
862         int                              st_offset, st_count;
863         char                            *end;
864         int                              c;
865         int                              delete = 0;
866         char                            *stripe_size_arg = NULL;
867         char                            *stripe_off_arg = NULL;
868         char                            *stripe_count_arg = NULL;
869         char                            *pool_name_arg = NULL;
870         unsigned long long               size_units = 1;
871         bool                             migrate_mode = false;
872         __u64                            migration_flags = 0;
873         __u32                            osts[LOV_MAX_STRIPE_COUNT] = { 0 };
874         int                              nr_osts = 0;
875
876         struct option            long_opts[] = {
877                 /* valid only in migrate mode */
878                 {"block",        no_argument,       0, 'b'},
879 #if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(2, 9, 53, 0)
880                 /* This formerly implied "stripe-count", but was explicitly
881                  * made "stripe-count" for consistency with other options,
882                  * and to separate it from "mdt-count" when DNE arrives. */
883                 {"count",        required_argument, 0, 'c'},
884 #endif
885                 {"stripe-count", required_argument, 0, 'c'},
886                 {"stripe_count", required_argument, 0, 'c'},
887                 {"delete",       no_argument,       0, 'd'},
888 #if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(2, 9, 53, 0)
889                 /* This formerly implied "stripe-index", but was explicitly
890                  * made "stripe-index" for consistency with other options,
891                  * and to separate it from "mdt-index" when DNE arrives. */
892                 {"index",        required_argument, 0, 'i'},
893 #endif
894                 {"stripe-index", required_argument, 0, 'i'},
895                 {"stripe_index", required_argument, 0, 'i'},
896                 {"ost-list",     required_argument, 0, 'o'},
897                 {"ost_list",     required_argument, 0, 'o'},
898                 {"pool",         required_argument, 0, 'p'},
899 #if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(2, 9, 53, 0)
900                 /* This formerly implied "--stripe-size", but was confusing
901                  * with "lfs find --size|-s", which means "file size", so use
902                  * the consistent "--stripe-size|-S" for all commands. */
903                 {"size",         required_argument, 0, 's'},
904 #endif
905                 {"stripe-size",  required_argument, 0, 'S'},
906                 {"stripe_size",  required_argument, 0, 'S'},
907                 {0, 0, 0, 0}
908         };
909
910         st_size = 0;
911         st_offset = -1;
912         st_count = 0;
913
914         if (strcmp(argv[0], "migrate") == 0)
915                 migrate_mode = true;
916
917         while ((c = getopt_long(argc, argv, "bc:di:o:p:s:S:",
918                                 long_opts, NULL)) >= 0) {
919                 switch (c) {
920                 case 0:
921                         /* Long options. */
922                         break;
923                 case 'b':
924                         if (!migrate_mode) {
925                                 fprintf(stderr, "--block is valid only for"
926                                                 " migrate mode\n");
927                                 return CMD_HELP;
928                         }
929                         migration_flags |= MIGRATION_BLOCKS;
930                         break;
931                 case 'c':
932 #if LUSTRE_VERSION_CODE >= OBD_OCD_VERSION(2, 6, 53, 0)
933                         if (strcmp(argv[optind - 1], "--count") == 0)
934                                 fprintf(stderr, "warning: '--count' deprecated"
935                                         ", use '--stripe-count' instead\n");
936 #endif
937                         stripe_count_arg = optarg;
938                         break;
939                 case 'd':
940                         /* delete the default striping pattern */
941                         delete = 1;
942                         break;
943                 case 'o':
944                         nr_osts = parse_targets(osts,
945                                                 sizeof(osts) / sizeof(__u32),
946                                                 nr_osts, optarg);
947                         if (nr_osts < 0) {
948                                 fprintf(stderr,
949                                         "error: %s: bad OST indices '%s'\n",
950                                         argv[0], optarg);
951                                 return CMD_HELP;
952                         }
953
954                         if (st_offset == -1) /* first in the command line */
955                                 st_offset = osts[0];
956                         break;
957                 case 'i':
958 #if LUSTRE_VERSION_CODE >= OBD_OCD_VERSION(2, 6, 53, 0)
959                         if (strcmp(argv[optind - 1], "--index") == 0)
960                                 fprintf(stderr, "warning: '--index' deprecated"
961                                         ", use '--stripe-index' instead\n");
962 #endif
963                         stripe_off_arg = optarg;
964                         break;
965 #if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(2, 9, 53, 0)
966                 case 's':
967 #if LUSTRE_VERSION_CODE >= OBD_OCD_VERSION(2, 6, 53, 0)
968                         fprintf(stderr, "warning: '--size|-s' deprecated, "
969                                 "use '--stripe-size|-S' instead\n");
970 #endif
971 #endif /* LUSTRE_VERSION_CODE < OBD_OCD_VERSION(2, 9, 53, 0) */
972                 case 'S':
973                         stripe_size_arg = optarg;
974                         break;
975                 case 'p':
976                         pool_name_arg = optarg;
977                         break;
978                 default:
979                         return CMD_HELP;
980                 }
981         }
982
983         fname = argv[optind];
984
985         if (delete &&
986             (stripe_size_arg != NULL || stripe_off_arg != NULL ||
987              stripe_count_arg != NULL || pool_name_arg != NULL)) {
988                 fprintf(stderr, "error: %s: cannot specify -d with "
989                         "-s, -c, -o, or -p options\n",
990                         argv[0]);
991                 return CMD_HELP;
992         }
993
994         if (optind == argc) {
995                 fprintf(stderr, "error: %s: missing filename|dirname\n",
996                         argv[0]);
997                 return CMD_HELP;
998         }
999
1000         if (pool_name_arg && strlen(pool_name_arg) > LOV_MAXPOOLNAME) {
1001                 fprintf(stderr,
1002                         "error: %s: pool name '%s' is too long (max is %d characters)\n",
1003                         argv[0], pool_name_arg, LOV_MAXPOOLNAME);
1004                 return CMD_HELP;
1005         }
1006
1007         /* get the stripe size */
1008         if (stripe_size_arg != NULL) {
1009                 result = llapi_parse_size(stripe_size_arg, &st_size,
1010                                           &size_units, 0);
1011                 if (result) {
1012                         fprintf(stderr, "error: %s: bad stripe size '%s'\n",
1013                                 argv[0], stripe_size_arg);
1014                         return CMD_HELP;
1015                 }
1016         }
1017         /* get the stripe offset */
1018         if (stripe_off_arg != NULL) {
1019                 st_offset = strtol(stripe_off_arg, &end, 0);
1020                 if (*end != '\0') {
1021                         fprintf(stderr, "error: %s: bad stripe offset '%s'\n",
1022                                 argv[0], stripe_off_arg);
1023                         return CMD_HELP;
1024                 }
1025         }
1026         /* get the stripe count */
1027         if (stripe_count_arg != NULL) {
1028                 st_count = strtoul(stripe_count_arg, &end, 0);
1029                 if (*end != '\0') {
1030                         fprintf(stderr, "error: %s: bad stripe count '%s'\n",
1031                                 argv[0], stripe_count_arg);
1032                         return CMD_HELP;
1033                 }
1034         }
1035
1036         /* initialize stripe parameters */
1037         param = calloc(1, offsetof(typeof(*param), lsp_osts[nr_osts]));
1038         if (param == NULL) {
1039                 fprintf(stderr, "error: %s: run out of memory\n", argv[0]);
1040                 return CMD_HELP;
1041         }
1042
1043         param->lsp_stripe_size = st_size;
1044         param->lsp_stripe_offset = st_offset;
1045         param->lsp_stripe_count = st_count;
1046         param->lsp_stripe_pattern = 0;
1047         param->lsp_pool = pool_name_arg;
1048         param->lsp_is_specific = false;
1049         if (nr_osts > 0) {
1050                 if (st_count > 0 && nr_osts != st_count) {
1051                         fprintf(stderr, "error: %s: stripe count '%d' doesn't "
1052                                 "match the number of OSTs: %d\n",
1053                                 argv[0], st_count, nr_osts);
1054                         free(param);
1055                         return CMD_HELP;
1056                 }
1057
1058                 param->lsp_is_specific = true;
1059                 param->lsp_stripe_count = nr_osts;
1060                 memcpy(param->lsp_osts, osts, sizeof(*osts) * nr_osts);
1061         }
1062
1063         for (fname = argv[optind]; fname != NULL; fname = argv[++optind]) {
1064                 if (migrate_mode) {
1065                         result = lfs_migrate(fname, migration_flags, param);
1066                 } else {
1067                         result = llapi_file_open_param(fname,
1068                                                        O_CREAT | O_WRONLY,
1069                                                        0644, param);
1070                         if (result >= 0) {
1071                                 close(result);
1072                                 result = 0;
1073                         }
1074                 }
1075                 if (result) {
1076                         /* Save the first error encountered. */
1077                         if (result2 == 0)
1078                                 result2 = result;
1079                         fprintf(stderr,
1080                                 "error: %s: %s stripe file '%s' failed\n",
1081                                 argv[0], migrate_mode ? "migrate" : "create",
1082                                 fname);
1083                         continue;
1084                 }
1085         }
1086
1087         free(param);
1088         return result2;
1089 }
1090
1091 static int lfs_poollist(int argc, char **argv)
1092 {
1093         if (argc != 2)
1094                 return CMD_HELP;
1095
1096         return llapi_poollist(argv[1]);
1097 }
1098
1099 static int set_time(time_t *time, time_t *set, char *str)
1100 {
1101         time_t t;
1102         int res = 0;
1103
1104         if (str[0] == '+')
1105                 res = 1;
1106         else if (str[0] == '-')
1107                 res = -1;
1108
1109         if (res)
1110                 str++;
1111
1112         t = strtol(str, NULL, 0);
1113         if (*time < t * 24 * 60 * 60) {
1114                 if (res)
1115                         str--;
1116                 fprintf(stderr, "Wrong time '%s' is specified.\n", str);
1117                 return INT_MAX;
1118         }
1119
1120         *set = *time - t * 24 * 60 * 60;
1121         return res;
1122 }
1123
1124 #define USER 0
1125 #define GROUP 1
1126
1127 static int name2id(unsigned int *id, char *name, int type)
1128 {
1129         if (type == USER) {
1130                 struct passwd *entry;
1131
1132                 if (!(entry = getpwnam(name))) {
1133                         if (!errno)
1134                                 errno = ENOENT;
1135                         return -1;
1136                 }
1137
1138                 *id = entry->pw_uid;
1139         } else {
1140                 struct group *entry;
1141
1142                 if (!(entry = getgrnam(name))) {
1143                         if (!errno)
1144                                 errno = ENOENT;
1145                         return -1;
1146                 }
1147
1148                 *id = entry->gr_gid;
1149         }
1150
1151         return 0;
1152 }
1153
1154 static int id2name(char **name, unsigned int id, int type)
1155 {
1156         if (type == USER) {
1157                 struct passwd *entry;
1158
1159                 if (!(entry = getpwuid(id))) {
1160                         if (!errno)
1161                                 errno = ENOENT;
1162                         return -1;
1163                 }
1164
1165                 *name = entry->pw_name;
1166         } else {
1167                 struct group *entry;
1168
1169                 if (!(entry = getgrgid(id))) {
1170                         if (!errno)
1171                                 errno = ENOENT;
1172                         return -1;
1173                 }
1174
1175                 *name = entry->gr_name;
1176         }
1177
1178         return 0;
1179 }
1180
1181 static int name2layout(__u32 *layout, char *name)
1182 {
1183         char *ptr, *lyt;
1184
1185         *layout = 0;
1186         for (ptr = name; ; ptr = NULL) {
1187                 lyt = strtok(ptr, ",");
1188                 if (lyt == NULL)
1189                         break;
1190                 if (strcmp(lyt, "released") == 0)
1191                         *layout |= LOV_PATTERN_F_RELEASED;
1192                 else if (strcmp(lyt, "raid0") == 0)
1193                         *layout |= LOV_PATTERN_RAID0;
1194                 else
1195                         return -1;
1196         }
1197         return 0;
1198 }
1199
1200 #define FIND_POOL_OPT 3
1201 static int lfs_find(int argc, char **argv)
1202 {
1203         int c, rc;
1204         int ret = 0;
1205         time_t t;
1206         struct find_param param = {
1207                 .fp_max_depth = -1,
1208                 .fp_quiet = 1,
1209         };
1210         struct option long_opts[] = {
1211                 {"atime",        required_argument, 0, 'A'},
1212                 {"stripe-count", required_argument, 0, 'c'},
1213                 {"stripe_count", required_argument, 0, 'c'},
1214                 {"ctime",        required_argument, 0, 'C'},
1215                 {"maxdepth",     required_argument, 0, 'D'},
1216                 {"gid",          required_argument, 0, 'g'},
1217                 {"group",        required_argument, 0, 'G'},
1218                 {"stripe-index", required_argument, 0, 'i'},
1219                 {"stripe_index", required_argument, 0, 'i'},
1220                 {"layout",       required_argument, 0, 'L'},
1221                 {"mdt",          required_argument, 0, 'm'},
1222                 {"mtime",        required_argument, 0, 'M'},
1223                 {"name",         required_argument, 0, 'n'},
1224      /* reserve {"or",           no_argument,     , 0, 'o'}, to match find(1) */
1225                 {"obd",          required_argument, 0, 'O'},
1226                 {"ost",          required_argument, 0, 'O'},
1227                 /* no short option for pool, p/P already used */
1228                 {"pool",         required_argument, 0, FIND_POOL_OPT},
1229                 {"print0",       no_argument,       0, 'p'},
1230                 {"print",        no_argument,       0, 'P'},
1231                 {"size",         required_argument, 0, 's'},
1232                 {"stripe-size",  required_argument, 0, 'S'},
1233                 {"stripe_size",  required_argument, 0, 'S'},
1234                 {"type",         required_argument, 0, 't'},
1235                 {"uid",          required_argument, 0, 'u'},
1236                 {"user",         required_argument, 0, 'U'},
1237                 {0, 0, 0, 0}
1238         };
1239         int pathstart = -1;
1240         int pathend = -1;
1241         int neg_opt = 0;
1242         time_t *xtime;
1243         int *xsign;
1244         int isoption;
1245         char *endptr;
1246
1247         time(&t);
1248
1249         /* when getopt_long_only() hits '!' it returns 1, puts "!" in optarg */
1250         while ((c = getopt_long_only(argc, argv,
1251                                      "-A:c:C:D:g:G:i:L:m:M:n:O:Ppqrs:S:t:u:U:v",
1252                                      long_opts, NULL)) >= 0) {
1253                 xtime = NULL;
1254                 xsign = NULL;
1255                 if (neg_opt)
1256                         --neg_opt;
1257                 /* '!' is part of option */
1258                 /* when getopt_long_only() finds a string which is not
1259                  * an option nor a known option argument it returns 1
1260                  * in that case if we already have found pathstart and pathend
1261                  * (i.e. we have the list of pathnames),
1262                  * the only supported value is "!"
1263                  */
1264                 isoption = (c != 1) || (strcmp(optarg, "!") == 0);
1265                 if (!isoption && pathend != -1) {
1266                         fprintf(stderr, "err: %s: filename|dirname must either "
1267                                         "precede options or follow options\n",
1268                                         argv[0]);
1269                         ret = CMD_HELP;
1270                         goto err;
1271                 }
1272                 if (!isoption && pathstart == -1)
1273                         pathstart = optind - 1;
1274                 if (isoption && pathstart != -1 && pathend == -1)
1275                         pathend = optind - 2;
1276                 switch (c) {
1277                 case 0:
1278                         /* Long options. */
1279                         break;
1280                 case 1:
1281                         /* unknown; opt is "!" or path component,
1282                          * checking done above.
1283                          */
1284                         if (strcmp(optarg, "!") == 0)
1285                                 neg_opt = 2;
1286                         break;
1287                 case 'A':
1288                         xtime = &param.fp_atime;
1289                         xsign = &param.fp_asign;
1290                         param.fp_exclude_atime = !!neg_opt;
1291                         /* no break, this falls through to 'C' for ctime */
1292                 case 'C':
1293                         if (c == 'C') {
1294                                 xtime = &param.fp_ctime;
1295                                 xsign = &param.fp_csign;
1296                                 param.fp_exclude_ctime = !!neg_opt;
1297                         }
1298                         /* no break, this falls through to 'M' for mtime */
1299                 case 'M':
1300                         if (c == 'M') {
1301                                 xtime = &param.fp_mtime;
1302                                 xsign = &param.fp_msign;
1303                                 param.fp_exclude_mtime = !!neg_opt;
1304                         }
1305                         rc = set_time(&t, xtime, optarg);
1306                         if (rc == INT_MAX) {
1307                                 ret = -1;
1308                                 goto err;
1309                         }
1310                         if (rc)
1311                                 *xsign = rc;
1312                         break;
1313                 case 'c':
1314                         if (optarg[0] == '+') {
1315                                 param.fp_stripe_count_sign = -1;
1316                                 optarg++;
1317                         } else if (optarg[0] == '-') {
1318                                 param.fp_stripe_count_sign =  1;
1319                                 optarg++;
1320                         }
1321
1322                         param.fp_stripe_count = strtoul(optarg, &endptr, 0);
1323                         if (*endptr != '\0') {
1324                                 fprintf(stderr,"error: bad stripe_count '%s'\n",
1325                                         optarg);
1326                                 ret = -1;
1327                                 goto err;
1328                         }
1329                         param.fp_check_stripe_count = 1;
1330                         param.fp_exclude_stripe_count = !!neg_opt;
1331                         break;
1332                 case 'D':
1333                         param.fp_max_depth = strtol(optarg, 0, 0);
1334                         break;
1335                 case 'g':
1336                 case 'G':
1337                         rc = name2id(&param.fp_gid, optarg, GROUP);
1338                         if (rc) {
1339                                 param.fp_gid = strtoul(optarg, &endptr, 10);
1340                                 if (*endptr != '\0') {
1341                                         fprintf(stderr, "Group/GID: %s cannot "
1342                                                 "be found.\n", optarg);
1343                                         ret = -1;
1344                                         goto err;
1345                                 }
1346                         }
1347                         param.fp_exclude_gid = !!neg_opt;
1348                         param.fp_check_gid = 1;
1349                         break;
1350                 case 'L':
1351                         ret = name2layout(&param.fp_layout, optarg);
1352                         if (ret)
1353                                 goto err;
1354                         param.fp_exclude_layout = !!neg_opt;
1355                         param.fp_check_layout = 1;
1356                         break;
1357                 case 'u':
1358                 case 'U':
1359                         rc = name2id(&param.fp_uid, optarg, USER);
1360                         if (rc) {
1361                                 param.fp_uid = strtoul(optarg, &endptr, 10);
1362                                 if (*endptr != '\0') {
1363                                         fprintf(stderr, "User/UID: %s cannot "
1364                                                 "be found.\n", optarg);
1365                                         ret = -1;
1366                                         goto err;
1367                                 }
1368                         }
1369                         param.fp_exclude_uid = !!neg_opt;
1370                         param.fp_check_uid = 1;
1371                         break;
1372                 case FIND_POOL_OPT:
1373                         if (strlen(optarg) > LOV_MAXPOOLNAME) {
1374                                 fprintf(stderr,
1375                                         "Pool name %s is too long"
1376                                         " (max is %d)\n", optarg,
1377                                         LOV_MAXPOOLNAME);
1378                                 ret = -1;
1379                                 goto err;
1380                         }
1381                         /* we do check for empty pool because empty pool
1382                          * is used to find V1 lov attributes */
1383                         strncpy(param.fp_poolname, optarg, LOV_MAXPOOLNAME);
1384                         param.fp_poolname[LOV_MAXPOOLNAME] = '\0';
1385                         param.fp_exclude_pool = !!neg_opt;
1386                         param.fp_check_pool = 1;
1387                         break;
1388                 case 'n':
1389                         param.fp_pattern = (char *)optarg;
1390                         param.fp_exclude_pattern = !!neg_opt;
1391                         break;
1392                 case 'm':
1393                 case 'i':
1394                 case 'O': {
1395                         char *buf, *token, *next, *p;
1396                         int len = 1;
1397                         void *tmp;
1398
1399                         buf = strdup(optarg);
1400                         if (buf == NULL) {
1401                                 ret = -ENOMEM;
1402                                 goto err;
1403                         }
1404
1405                         param.fp_exclude_obd = !!neg_opt;
1406
1407                         token = buf;
1408                         while (token && *token) {
1409                                 token = strchr(token, ',');
1410                                 if (token) {
1411                                         len++;
1412                                         token++;
1413                                 }
1414                         }
1415                         if (c == 'm') {
1416                                 param.fp_exclude_mdt = !!neg_opt;
1417                                 param.fp_num_alloc_mdts += len;
1418                                 tmp = realloc(param.fp_mdt_uuid,
1419                                               param.fp_num_alloc_mdts *
1420                                               sizeof(*param.fp_mdt_uuid));
1421                                 if (tmp == NULL) {
1422                                         ret = -ENOMEM;
1423                                         goto err_free;
1424                                 }
1425
1426                                 param.fp_mdt_uuid = tmp;
1427                         } else {
1428                                 param.fp_exclude_obd = !!neg_opt;
1429                                 param.fp_num_alloc_obds += len;
1430                                 tmp = realloc(param.fp_obd_uuid,
1431                                               param.fp_num_alloc_obds *
1432                                               sizeof(*param.fp_obd_uuid));
1433                                 if (tmp == NULL) {
1434                                         ret = -ENOMEM;
1435                                         goto err_free;
1436                                 }
1437
1438                                 param.fp_obd_uuid = tmp;
1439                         }
1440                         for (token = buf; token && *token; token = next) {
1441                                 struct obd_uuid *puuid;
1442                                 if (c == 'm') {
1443                                         puuid =
1444                                         &param.fp_mdt_uuid[param.fp_num_mdts++];
1445                                 } else {
1446                                         puuid =
1447                                         &param.fp_obd_uuid[param.fp_num_obds++];
1448                                 }
1449                                 p = strchr(token, ',');
1450                                 next = 0;
1451                                 if (p) {
1452                                         *p = 0;
1453                                         next = p+1;
1454                                 }
1455
1456                                 if (strlen(token) > sizeof(puuid->uuid) - 1) {
1457                                         ret = -E2BIG;
1458                                         goto err_free;
1459                                 }
1460
1461                                 strncpy(puuid->uuid, token,
1462                                         sizeof(puuid->uuid));
1463                         }
1464 err_free:
1465                         if (buf)
1466                                 free(buf);
1467                         break;
1468                 }
1469                 case 'p':
1470                         param.fp_zero_end = 1;
1471                         break;
1472                 case 'P':
1473                         break;
1474                 case 's':
1475                         if (optarg[0] == '+') {
1476                                 param.fp_size_sign = -1;
1477                                 optarg++;
1478                         } else if (optarg[0] == '-') {
1479                                 param.fp_size_sign =  1;
1480                                 optarg++;
1481                         }
1482
1483                         ret = llapi_parse_size(optarg, &param.fp_size,
1484                                                &param.fp_size_units, 0);
1485                         if (ret) {
1486                                 fprintf(stderr, "error: bad file size '%s'\n",
1487                                         optarg);
1488                                 goto err;
1489                         }
1490                         param.fp_check_size = 1;
1491                         param.fp_exclude_size = !!neg_opt;
1492                         break;
1493                 case 'S':
1494                         if (optarg[0] == '+') {
1495                                 param.fp_stripe_size_sign = -1;
1496                                 optarg++;
1497                         } else if (optarg[0] == '-') {
1498                                 param.fp_stripe_size_sign =  1;
1499                                 optarg++;
1500                         }
1501
1502                         ret = llapi_parse_size(optarg, &param.fp_stripe_size,
1503                                                &param.fp_stripe_size_units, 0);
1504                         if (ret) {
1505                                 fprintf(stderr, "error: bad stripe_size '%s'\n",
1506                                         optarg);
1507                                 goto err;
1508                         }
1509                         param.fp_check_stripe_size = 1;
1510                         param.fp_exclude_stripe_size = !!neg_opt;
1511                         break;
1512                 case 't':
1513                         param.fp_exclude_type = !!neg_opt;
1514                         switch (optarg[0]) {
1515                         case 'b':
1516                                 param.fp_type = S_IFBLK;
1517                                 break;
1518                         case 'c':
1519                                 param.fp_type = S_IFCHR;
1520                                 break;
1521                         case 'd':
1522                                 param.fp_type = S_IFDIR;
1523                                 break;
1524                         case 'f':
1525                                 param.fp_type = S_IFREG;
1526                                 break;
1527                         case 'l':
1528                                 param.fp_type = S_IFLNK;
1529                                 break;
1530                         case 'p':
1531                                 param.fp_type = S_IFIFO;
1532                                 break;
1533                         case 's':
1534                                 param.fp_type = S_IFSOCK;
1535                                 break;
1536                         default:
1537                                 fprintf(stderr, "error: %s: bad type '%s'\n",
1538                                         argv[0], optarg);
1539                                 ret = CMD_HELP;
1540                                 goto err;
1541                         };
1542                         break;
1543                 default:
1544                         ret = CMD_HELP;
1545                         goto err;
1546                 };
1547         }
1548
1549         if (pathstart == -1) {
1550                 fprintf(stderr, "error: %s: no filename|pathname\n",
1551                         argv[0]);
1552                 ret = CMD_HELP;
1553                 goto err;
1554         } else if (pathend == -1) {
1555                 /* no options */
1556                 pathend = argc;
1557         }
1558
1559         do {
1560                 rc = llapi_find(argv[pathstart], &param);
1561                 if (rc != 0 && ret == 0)
1562                         ret = rc;
1563         } while (++pathstart < pathend);
1564
1565         if (ret)
1566                 fprintf(stderr, "error: %s failed for %s.\n",
1567                         argv[0], argv[optind - 1]);
1568 err:
1569         if (param.fp_obd_uuid && param.fp_num_alloc_obds)
1570                 free(param.fp_obd_uuid);
1571
1572         if (param.fp_mdt_uuid && param.fp_num_alloc_mdts)
1573                 free(param.fp_mdt_uuid);
1574
1575         return ret;
1576 }
1577
1578 static int lfs_getstripe_internal(int argc, char **argv,
1579                                   struct find_param *param)
1580 {
1581         struct option long_opts[] = {
1582 #if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(2, 9, 53, 0)
1583                 /* This formerly implied "stripe-count", but was explicitly
1584                  * made "stripe-count" for consistency with other options,
1585                  * and to separate it from "mdt-count" when DNE arrives. */
1586                 {"count",               no_argument,            0, 'c'},
1587 #endif
1588                 {"stripe-count",        no_argument,            0, 'c'},
1589                 {"stripe_count",        no_argument,            0, 'c'},
1590                 {"directory",           no_argument,            0, 'd'},
1591                 {"default",             no_argument,            0, 'D'},
1592                 {"generation",          no_argument,            0, 'g'},
1593 #if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(2, 9, 53, 0)
1594                 /* This formerly implied "stripe-index", but was explicitly
1595                  * made "stripe-index" for consistency with other options,
1596                  * and to separate it from "mdt-index" when DNE arrives. */
1597                 {"index",               no_argument,            0, 'i'},
1598 #endif
1599                 {"stripe-index",        no_argument,            0, 'i'},
1600                 {"stripe_index",        no_argument,            0, 'i'},
1601                 {"layout",              no_argument,            0, 'L'},
1602                 {"mdt-index",           no_argument,            0, 'M'},
1603                 {"mdt_index",           no_argument,            0, 'M'},
1604 #if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(2, 9, 53, 0)
1605                 /* This formerly implied "stripe-index", but was confusing
1606                  * with "file offset" (which will eventually be needed for
1607                  * with different layouts by offset), so deprecate it. */
1608                 {"offset",              no_argument,            0, 'o'},
1609 #endif
1610                 {"obd",                 required_argument,      0, 'O'},
1611                 {"ost",                 required_argument,      0, 'O'},
1612                 {"pool",                no_argument,            0, 'p'},
1613                 {"quiet",               no_argument,            0, 'q'},
1614                 {"recursive",           no_argument,            0, 'r'},
1615                 {"raw",                 no_argument,            0, 'R'},
1616 #if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(2, 9, 53, 0)
1617                 /* This formerly implied "--stripe-size", but was confusing
1618                  * with "lfs find --size|-s", which means "file size", so use
1619                  * the consistent "--stripe-size|-S" for all commands. */
1620                 {"size",                no_argument,            0, 's'},
1621 #endif
1622                 {"stripe-size",         no_argument,            0, 'S'},
1623                 {"stripe_size",         no_argument,            0, 'S'},
1624                 {"verbose",             no_argument,            0, 'v'},
1625                 {0, 0, 0, 0}
1626         };
1627         int c, rc;
1628
1629         param->fp_max_depth = 1;
1630         while ((c = getopt_long(argc, argv, "cdDghiLMoO:pqrRsSv",
1631                                 long_opts, NULL)) != -1) {
1632                 switch (c) {
1633                 case 'O':
1634                         if (param->fp_obd_uuid) {
1635                                 fprintf(stderr,
1636                                         "error: %s: only one obduuid allowed",
1637                                         argv[0]);
1638                                 return CMD_HELP;
1639                         }
1640                         param->fp_obd_uuid = (struct obd_uuid *)optarg;
1641                         break;
1642                 case 'q':
1643                         param->fp_quiet++;
1644                         break;
1645                 case 'd':
1646                         param->fp_max_depth = 0;
1647                         break;
1648                 case 'D':
1649                         param->fp_get_default_lmv = 1;
1650                         break;
1651                 case 'r':
1652                         param->fp_recursive = 1;
1653                         break;
1654                 case 'v':
1655                         param->fp_verbose = VERBOSE_ALL | VERBOSE_DETAIL;
1656                         break;
1657                 case 'c':
1658 #if LUSTRE_VERSION_CODE >= OBD_OCD_VERSION(2, 6, 53, 0)
1659                         if (strcmp(argv[optind - 1], "--count") == 0)
1660                                 fprintf(stderr, "warning: '--count' deprecated,"
1661                                         " use '--stripe-count' instead\n");
1662 #endif
1663                         if (!(param->fp_verbose & VERBOSE_DETAIL)) {
1664                                 param->fp_verbose |= VERBOSE_COUNT;
1665                                 param->fp_max_depth = 0;
1666                         }
1667                         break;
1668 #if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(2, 9, 53, 0)
1669                 case 's':
1670 #if LUSTRE_VERSION_CODE >= OBD_OCD_VERSION(2, 6, 53, 0)
1671                         fprintf(stderr, "warning: '--size|-s' deprecated, "
1672                                 "use '--stripe-size|-S' instead\n");
1673 #endif
1674 #endif /* LUSTRE_VERSION_CODE < OBD_OCD_VERSION(2, 9, 53, 0) */
1675                 case 'S':
1676                         if (!(param->fp_verbose & VERBOSE_DETAIL)) {
1677                                 param->fp_verbose |= VERBOSE_SIZE;
1678                                 param->fp_max_depth = 0;
1679                         }
1680                         break;
1681 #if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(2, 9, 53, 0)
1682                 case 'o':
1683                         fprintf(stderr, "warning: '--offset|-o' deprecated, "
1684                                 "use '--stripe-index|-i' instead\n");
1685 #endif
1686                 case 'i':
1687 #if LUSTRE_VERSION_CODE >= OBD_OCD_VERSION(2, 6, 53, 0)
1688                         if (strcmp(argv[optind - 1], "--index") == 0)
1689                                 fprintf(stderr, "warning: '--index' deprecated"
1690                                         ", use '--stripe-index' instead\n");
1691 #endif
1692                         if (!(param->fp_verbose & VERBOSE_DETAIL)) {
1693                                 param->fp_verbose |= VERBOSE_OFFSET;
1694                                 param->fp_max_depth = 0;
1695                         }
1696                         break;
1697                 case 'p':
1698                         if (!(param->fp_verbose & VERBOSE_DETAIL)) {
1699                                 param->fp_verbose |= VERBOSE_POOL;
1700                                 param->fp_max_depth = 0;
1701                         }
1702                         break;
1703                 case 'g':
1704                         if (!(param->fp_verbose & VERBOSE_DETAIL)) {
1705                                 param->fp_verbose |= VERBOSE_GENERATION;
1706                                 param->fp_max_depth = 0;
1707                         }
1708                         break;
1709                 case 'L':
1710                         if (!(param->fp_verbose & VERBOSE_DETAIL)) {
1711                                 param->fp_verbose |= VERBOSE_LAYOUT;
1712                                 param->fp_max_depth = 0;
1713                         }
1714                         break;
1715                 case 'M':
1716                         if (!(param->fp_verbose & VERBOSE_DETAIL))
1717                                 param->fp_max_depth = 0;
1718                         param->fp_verbose |= VERBOSE_MDTINDEX;
1719                         break;
1720                 case 'R':
1721                         param->fp_raw = 1;
1722                         break;
1723                 default:
1724                         return CMD_HELP;
1725                 }
1726         }
1727
1728         if (optind >= argc)
1729                 return CMD_HELP;
1730
1731         if (param->fp_recursive)
1732                 param->fp_max_depth = -1;
1733
1734         if (!param->fp_verbose)
1735                 param->fp_verbose = VERBOSE_ALL;
1736         if (param->fp_quiet)
1737                 param->fp_verbose = VERBOSE_OBJID;
1738
1739         do {
1740                 rc = llapi_getstripe(argv[optind], param);
1741         } while (++optind < argc && !rc);
1742
1743         if (rc)
1744                 fprintf(stderr, "error: %s failed for %s.\n",
1745                         argv[0], argv[optind - 1]);
1746         return rc;
1747 }
1748
1749 static int lfs_tgts(int argc, char **argv)
1750 {
1751         char mntdir[PATH_MAX] = {'\0'}, path[PATH_MAX] = {'\0'};
1752         struct find_param param;
1753         int index = 0, rc=0;
1754
1755         if (argc > 2)
1756                 return CMD_HELP;
1757
1758         if (argc == 2 && !realpath(argv[1], path)) {
1759                 rc = -errno;
1760                 fprintf(stderr, "error: invalid path '%s': %s\n",
1761                         argv[1], strerror(-rc));
1762                 return rc;
1763         }
1764
1765         while (!llapi_search_mounts(path, index++, mntdir, NULL)) {
1766                 /* Check if we have a mount point */
1767                 if (mntdir[0] == '\0')
1768                         continue;
1769
1770                 memset(&param, 0, sizeof(param));
1771                 if (!strcmp(argv[0], "mdts"))
1772                         param.fp_get_lmv = 1;
1773
1774                 rc = llapi_ostlist(mntdir, &param);
1775                 if (rc) {
1776                         fprintf(stderr, "error: %s: failed on %s\n",
1777                                 argv[0], mntdir);
1778                 }
1779                 if (path[0] != '\0')
1780                         break;
1781                 memset(mntdir, 0, PATH_MAX);
1782         }
1783
1784         return rc;
1785 }
1786
1787 static int lfs_getstripe(int argc, char **argv)
1788 {
1789         struct find_param param = { 0 };
1790         return lfs_getstripe_internal(argc, argv, &param);
1791 }
1792
1793 /* functions */
1794 static int lfs_getdirstripe(int argc, char **argv)
1795 {
1796         struct find_param param = { 0 };
1797
1798         param.fp_get_lmv = 1;
1799         return lfs_getstripe_internal(argc, argv, &param);
1800 }
1801
1802 /* functions */
1803 static int lfs_setdirstripe(int argc, char **argv)
1804 {
1805         char                    *dname;
1806         int                     result;
1807         unsigned int            stripe_offset = -1;
1808         unsigned int            stripe_count = 1;
1809         enum lmv_hash_type      hash_type;
1810         char                    *end;
1811         int                     c;
1812         char                    *stripe_offset_opt = NULL;
1813         char                    *stripe_count_opt = NULL;
1814         char                    *stripe_hash_opt = NULL;
1815         char                    *mode_opt = NULL;
1816         bool                    default_stripe = false;
1817         mode_t                  mode = S_IRWXU | S_IRWXG | S_IRWXO;
1818         mode_t                  previous_mode = 0;
1819         bool                    delete = false;
1820
1821         struct option long_opts[] = {
1822                 {"count",       required_argument, 0, 'c'},
1823                 {"delete",      no_argument, 0, 'd'},
1824                 {"index",       required_argument, 0, 'i'},
1825                 {"mode",        required_argument, 0, 'm'},
1826                 {"hash-type",   required_argument, 0, 't'},
1827                 {"default_stripe", no_argument, 0, 'D'},
1828                 {0, 0, 0, 0}
1829         };
1830
1831         while ((c = getopt_long(argc, argv, "c:dDi:m:t:", long_opts,
1832                                 NULL)) >= 0) {
1833                 switch (c) {
1834                 case 0:
1835                         /* Long options. */
1836                         break;
1837                 case 'c':
1838                         stripe_count_opt = optarg;
1839                         break;
1840                 case 'd':
1841                         delete = true;
1842                         default_stripe = true;
1843                         break;
1844                 case 'D':
1845                         default_stripe = true;
1846                         break;
1847                 case 'i':
1848                         stripe_offset_opt = optarg;
1849                         break;
1850                 case 'm':
1851                         mode_opt = optarg;
1852                         break;
1853                 case 't':
1854                         stripe_hash_opt = optarg;
1855                         break;
1856                 default:
1857                         fprintf(stderr, "error: %s: option '%s' "
1858                                         "unrecognized\n",
1859                                         argv[0], argv[optind - 1]);
1860                         return CMD_HELP;
1861                 }
1862         }
1863
1864         if (optind == argc) {
1865                 fprintf(stderr, "error: %s: missing dirname\n",
1866                         argv[0]);
1867                 return CMD_HELP;
1868         }
1869
1870         if (!delete && stripe_offset_opt == NULL && stripe_count_opt == NULL) {
1871                 fprintf(stderr, "error: %s: missing stripe offset and count.\n",
1872                         argv[0]);
1873                 return CMD_HELP;
1874         }
1875
1876         if (stripe_offset_opt != NULL) {
1877                 /* get the stripe offset */
1878                 stripe_offset = strtoul(stripe_offset_opt, &end, 0);
1879                 if (*end != '\0') {
1880                         fprintf(stderr, "error: %s: bad stripe offset '%s'\n",
1881                                 argv[0], stripe_offset_opt);
1882                         return CMD_HELP;
1883                 }
1884         }
1885
1886         if (delete) {
1887                 if (stripe_offset_opt != NULL || stripe_count_opt != NULL) {
1888                         fprintf(stderr, "error: %s: cannot specify -d with -s,"
1889                                 " or -i options.\n", argv[0]);
1890                         return CMD_HELP;
1891                 } else {
1892                         stripe_count = 0;
1893                 }
1894         }
1895
1896
1897         if (mode_opt != NULL) {
1898                 mode = strtoul(mode_opt, &end, 8);
1899                 if (*end != '\0') {
1900                         fprintf(stderr, "error: %s: bad mode '%s'\n",
1901                                 argv[0], mode_opt);
1902                         return CMD_HELP;
1903                 }
1904                 previous_mode = umask(0);
1905         }
1906
1907         if (stripe_hash_opt == NULL ||
1908             strcmp(stripe_hash_opt, LMV_HASH_NAME_FNV_1A_64) == 0) {
1909                 hash_type = LMV_HASH_TYPE_FNV_1A_64;
1910         } else if (strcmp(stripe_hash_opt, LMV_HASH_NAME_ALL_CHARS) == 0) {
1911                 hash_type = LMV_HASH_TYPE_ALL_CHARS;
1912         } else {
1913                 fprintf(stderr, "error: %s: bad stripe hash type '%s'\n",
1914                         argv[0], stripe_hash_opt);
1915                 return CMD_HELP;
1916         }
1917
1918         /* get the stripe count */
1919         if (stripe_count_opt != NULL) {
1920                 stripe_count = strtoul(stripe_count_opt, &end, 0);
1921                 if (*end != '\0') {
1922                         fprintf(stderr, "error: %s: bad stripe count '%s'\n",
1923                                 argv[0], stripe_count_opt);
1924                         return CMD_HELP;
1925                 }
1926         }
1927
1928         dname = argv[optind];
1929         do {
1930                 if (default_stripe) {
1931                         result = llapi_dir_set_default_lmv_stripe(dname,
1932                                                     stripe_offset, stripe_count,
1933                                                     hash_type, NULL);
1934                 } else {
1935                         result = llapi_dir_create_pool(dname, mode,
1936                                                        stripe_offset,
1937                                                        stripe_count, hash_type,
1938                                                        NULL);
1939                 }
1940
1941                 if (result) {
1942                         fprintf(stderr, "error: %s: create stripe dir '%s' "
1943                                 "failed\n", argv[0], dname);
1944                         break;
1945                 }
1946                 dname = argv[++optind];
1947         } while (dname != NULL);
1948
1949         if (mode_opt != NULL)
1950                 umask(previous_mode);
1951
1952         return result;
1953 }
1954
1955 /* functions */
1956 static int lfs_rmentry(int argc, char **argv)
1957 {
1958         char *dname;
1959         int   index;
1960         int   result = 0;
1961
1962         if (argc <= 1) {
1963                 fprintf(stderr, "error: %s: missing dirname\n",
1964                         argv[0]);
1965                 return CMD_HELP;
1966         }
1967
1968         index = 1;
1969         dname = argv[index];
1970         while (dname != NULL) {
1971                 result = llapi_direntry_remove(dname);
1972                 if (result) {
1973                         fprintf(stderr, "error: %s: remove dir entry '%s' "
1974                                 "failed\n", argv[0], dname);
1975                         break;
1976                 }
1977                 dname = argv[++index];
1978         }
1979         return result;
1980 }
1981
1982 static int lfs_mv(int argc, char **argv)
1983 {
1984         struct  find_param param = {
1985                 .fp_max_depth = -1,
1986                 .fp_mdt_index = -1,
1987         };
1988         char   *end;
1989         int     c;
1990         int     rc = 0;
1991         struct option long_opts[] = {
1992                 {"mdt-index", required_argument, 0, 'M'},
1993                 {"verbose",     no_argument,       0, 'v'},
1994                 {0, 0, 0, 0}
1995         };
1996
1997         while ((c = getopt_long(argc, argv, "M:v", long_opts, NULL)) != -1) {
1998                 switch (c) {
1999                 case 'M': {
2000                         param.fp_mdt_index = strtoul(optarg, &end, 0);
2001                         if (*end != '\0') {
2002                                 fprintf(stderr, "%s: invalid MDT index'%s'\n",
2003                                         argv[0], optarg);
2004                                 return CMD_HELP;
2005                         }
2006                         break;
2007                 }
2008                 case 'v': {
2009                         param.fp_verbose = VERBOSE_DETAIL;
2010                         break;
2011                 }
2012                 default:
2013                         fprintf(stderr, "error: %s: unrecognized option '%s'\n",
2014                                 argv[0], argv[optind - 1]);
2015                         return CMD_HELP;
2016                 }
2017         }
2018
2019         if (param.fp_mdt_index == -1) {
2020                 fprintf(stderr, "%s: MDT index must be specified\n", argv[0]);
2021                 return CMD_HELP;
2022         }
2023
2024         if (optind >= argc) {
2025                 fprintf(stderr, "%s: missing operand path\n", argv[0]);
2026                 return CMD_HELP;
2027         }
2028
2029         param.fp_migrate = 1;
2030         rc = llapi_mv(argv[optind], &param);
2031         if (rc != 0)
2032                 fprintf(stderr, "%s: cannot migrate '%s' to MDT%04x: %s\n",
2033                         argv[0], argv[optind], param.fp_mdt_index,
2034                         strerror(-rc));
2035         return rc;
2036 }
2037
2038 static int lfs_osts(int argc, char **argv)
2039 {
2040         return lfs_tgts(argc, argv);
2041 }
2042
2043 static int lfs_mdts(int argc, char **argv)
2044 {
2045         return lfs_tgts(argc, argv);
2046 }
2047
2048 #define COOK(value)                                                     \
2049 ({                                                                      \
2050         int radix = 0;                                                  \
2051         while (value > 1024) {                                          \
2052                 value /= 1024;                                          \
2053                 radix++;                                                \
2054         }                                                               \
2055         radix;                                                          \
2056 })
2057 #define UUF     "%-20s"
2058 #define CSF     "%11s"
2059 #define CDF     "%11llu"
2060 #define HDF     "%8.1f%c"
2061 #define RSF     "%4s"
2062 #define RDF     "%3d%%"
2063
2064 static int showdf(char *mntdir, struct obd_statfs *stat,
2065                   char *uuid, int ishow, int cooked,
2066                   char *type, int index, int rc)
2067 {
2068         long long avail, used, total;
2069         double ratio = 0;
2070         char *suffix = "KMGTPEZY";
2071         /* Note if we have >2^64 bytes/fs these buffers will need to be grown */
2072         char tbuf[3 * sizeof(__u64)];
2073         char ubuf[3 * sizeof(__u64)];
2074         char abuf[3 * sizeof(__u64)];
2075         char rbuf[3 * sizeof(__u64)];
2076
2077         if (!uuid || !stat)
2078                 return -EINVAL;
2079
2080         switch (rc) {
2081         case 0:
2082                 if (ishow) {
2083                         avail = stat->os_ffree;
2084                         used = stat->os_files - stat->os_ffree;
2085                         total = stat->os_files;
2086                 } else {
2087                         int shift = cooked ? 0 : 10;
2088
2089                         avail = (stat->os_bavail * stat->os_bsize) >> shift;
2090                         used  = ((stat->os_blocks - stat->os_bfree) *
2091                                  stat->os_bsize) >> shift;
2092                         total = (stat->os_blocks * stat->os_bsize) >> shift;
2093                 }
2094
2095                 if ((used + avail) > 0)
2096                         ratio = (double)used / (double)(used + avail);
2097
2098                 if (cooked) {
2099                         int i;
2100                         double cook_val;
2101
2102                         cook_val = (double)total;
2103                         i = COOK(cook_val);
2104                         if (i > 0)
2105                                 sprintf(tbuf, HDF, cook_val, suffix[i - 1]);
2106                         else
2107                                 sprintf(tbuf, CDF, total);
2108
2109                         cook_val = (double)used;
2110                         i = COOK(cook_val);
2111                         if (i > 0)
2112                                 sprintf(ubuf, HDF, cook_val, suffix[i - 1]);
2113                         else
2114                                 sprintf(ubuf, CDF, used);
2115
2116                         cook_val = (double)avail;
2117                         i = COOK(cook_val);
2118                         if (i > 0)
2119                                 sprintf(abuf, HDF, cook_val, suffix[i - 1]);
2120                         else
2121                                 sprintf(abuf, CDF, avail);
2122                 } else {
2123                         sprintf(tbuf, CDF, total);
2124                         sprintf(ubuf, CDF, used);
2125                         sprintf(abuf, CDF, avail);
2126                 }
2127
2128                 sprintf(rbuf, RDF, (int)(ratio * 100 + 0.5));
2129                 printf(UUF" "CSF" "CSF" "CSF" "RSF" %-s",
2130                        uuid, tbuf, ubuf, abuf, rbuf, mntdir);
2131                 if (type)
2132                         printf("[%s:%d]\n", type, index);
2133                 else
2134                         printf("\n");
2135
2136                 break;
2137         case -ENODATA:
2138                 printf(UUF": inactive device\n", uuid);
2139                 break;
2140         default:
2141                 printf(UUF": %s\n", uuid, strerror(-rc));
2142                 break;
2143         }
2144
2145         return 0;
2146 }
2147
2148 struct ll_stat_type {
2149         int   st_op;
2150         char *st_name;
2151 };
2152
2153 static int mntdf(char *mntdir, char *fsname, char *pool, int ishow,
2154                 int cooked, int lazy)
2155 {
2156         struct obd_statfs stat_buf, sum = { .os_bsize = 1 };
2157         struct obd_uuid uuid_buf;
2158         char *poolname = NULL;
2159         struct ll_stat_type types[] = { { LL_STATFS_LMV, "MDT" },
2160                                         { LL_STATFS_LOV, "OST" },
2161                                         { 0, NULL } };
2162         struct ll_stat_type *tp;
2163         __u64 ost_ffree = 0;
2164         __u32 index;
2165         __u32 type;
2166         int rc;
2167
2168         if (pool) {
2169                 poolname = strchr(pool, '.');
2170                 if (poolname != NULL) {
2171                         if (strncmp(fsname, pool, strlen(fsname))) {
2172                                 fprintf(stderr, "filesystem name incorrect\n");
2173                                 return -ENODEV;
2174                         }
2175                         poolname++;
2176                 } else
2177                         poolname = pool;
2178         }
2179
2180         if (ishow)
2181                 printf(UUF" "CSF" "CSF" "CSF" "RSF" %-s\n",
2182                        "UUID", "Inodes", "IUsed", "IFree",
2183                        "IUse%", "Mounted on");
2184         else
2185                 printf(UUF" "CSF" "CSF" "CSF" "RSF" %-s\n",
2186                        "UUID", cooked ? "bytes" : "1K-blocks",
2187                        "Used", "Available", "Use%", "Mounted on");
2188
2189         for (tp = types; tp->st_name != NULL; tp++) {
2190                 for (index = 0; ; index++) {
2191                         memset(&stat_buf, 0, sizeof(struct obd_statfs));
2192                         memset(&uuid_buf, 0, sizeof(struct obd_uuid));
2193                         type = lazy ? tp->st_op | LL_STATFS_NODELAY : tp->st_op;
2194                         rc = llapi_obd_statfs(mntdir, type, index,
2195                                               &stat_buf, &uuid_buf);
2196                         if (rc == -ENODEV)
2197                                 break;
2198
2199                         if (rc == -EAGAIN)
2200                                 continue;
2201
2202                         if (poolname && tp->st_op == LL_STATFS_LOV &&
2203                             llapi_search_ost(fsname, poolname,
2204                                              obd_uuid2str(&uuid_buf)) != 1)
2205                                 continue;
2206
2207                         /* the llapi_obd_statfs() call may have returned with
2208                          * an error, but if it filled in uuid_buf we will at
2209                          * lease use that to print out a message for that OBD.
2210                          * If we didn't get anything in the uuid_buf, then fill
2211                          * it in so that we can print an error message. */
2212                         if (uuid_buf.uuid[0] == '\0')
2213                                 sprintf(uuid_buf.uuid, "%s%04x",
2214                                         tp->st_name, index);
2215                         showdf(mntdir, &stat_buf, obd_uuid2str(&uuid_buf),
2216                                ishow, cooked, tp->st_name, index, rc);
2217
2218                         if (rc == 0) {
2219                                 if (tp->st_op == LL_STATFS_LMV) {
2220                                         sum.os_ffree += stat_buf.os_ffree;
2221                                         sum.os_files += stat_buf.os_files;
2222                                 } else /* if (tp->st_op == LL_STATFS_LOV) */ {
2223                                         sum.os_blocks += stat_buf.os_blocks *
2224                                                 stat_buf.os_bsize;
2225                                         sum.os_bfree  += stat_buf.os_bfree *
2226                                                 stat_buf.os_bsize;
2227                                         sum.os_bavail += stat_buf.os_bavail *
2228                                                 stat_buf.os_bsize;
2229                                         ost_ffree += stat_buf.os_ffree;
2230                                 }
2231                         } else if (rc == -EINVAL || rc == -EFAULT) {
2232                                 break;
2233                         }
2234                 }
2235         }
2236
2237         /* If we don't have as many objects free on the OST as inodes
2238          * on the MDS, we reduce the total number of inodes to
2239          * compensate, so that the "inodes in use" number is correct.
2240          * Matches ll_statfs_internal() so the results are consistent. */
2241         if (ost_ffree < sum.os_ffree) {
2242                 sum.os_files = (sum.os_files - sum.os_ffree) + ost_ffree;
2243                 sum.os_ffree = ost_ffree;
2244         }
2245         printf("\n");
2246         showdf(mntdir, &sum, "filesystem summary:", ishow, cooked, NULL, 0, 0);
2247         printf("\n");
2248         return 0;
2249 }
2250
2251 static int lfs_df(int argc, char **argv)
2252 {
2253         char mntdir[PATH_MAX] = {'\0'}, path[PATH_MAX] = {'\0'};
2254         int ishow = 0, cooked = 0;
2255         int lazy = 0;
2256         int c, rc = 0, index = 0;
2257         char fsname[PATH_MAX] = "", *pool_name = NULL;
2258         struct option long_opts[] = {
2259                 {"pool", required_argument, 0, 'p'},
2260                 {"lazy", 0, 0, 'l'},
2261                 {0, 0, 0, 0}
2262         };
2263
2264         while ((c = getopt_long(argc, argv, "hilp:", long_opts, NULL)) != -1) {
2265                 switch (c) {
2266                 case 'i':
2267                         ishow = 1;
2268                         break;
2269                 case 'h':
2270                         cooked = 1;
2271                         break;
2272                 case 'l':
2273                         lazy = 1;
2274                         break;
2275                 case 'p':
2276                         pool_name = optarg;
2277                         break;
2278                 default:
2279                         return CMD_HELP;
2280                 }
2281         }
2282         if (optind < argc && !realpath(argv[optind], path)) {
2283                 rc = -errno;
2284                 fprintf(stderr, "error: invalid path '%s': %s\n",
2285                         argv[optind], strerror(-rc));
2286                 return rc;
2287         }
2288
2289         while (!llapi_search_mounts(path, index++, mntdir, fsname)) {
2290                 /* Check if we have a mount point */
2291                 if (mntdir[0] == '\0')
2292                         continue;
2293
2294                 rc = mntdf(mntdir, fsname, pool_name, ishow, cooked, lazy);
2295                 if (rc || path[0] != '\0')
2296                         break;
2297                 fsname[0] = '\0'; /* avoid matching in next loop */
2298                 mntdir[0] = '\0'; /* avoid matching in next loop */
2299         }
2300
2301         return rc;
2302 }
2303
2304 static int lfs_getname(int argc, char **argv)
2305 {
2306         char mntdir[PATH_MAX] = "", path[PATH_MAX] = "", fsname[PATH_MAX] = "";
2307         int rc = 0, index = 0, c;
2308         char buf[sizeof(struct obd_uuid)];
2309
2310         while ((c = getopt(argc, argv, "h")) != -1)
2311                 return CMD_HELP;
2312
2313         if (optind == argc) { /* no paths specified, get all paths. */
2314                 while (!llapi_search_mounts(path, index++, mntdir, fsname)) {
2315                         rc = llapi_getname(mntdir, buf, sizeof(buf));
2316                         if (rc < 0) {
2317                                 fprintf(stderr,
2318                                         "cannot get name for `%s': %s\n",
2319                                         mntdir, strerror(-rc));
2320                                 break;
2321                         }
2322
2323                         printf("%s %s\n", buf, mntdir);
2324
2325                         path[0] = fsname[0] = mntdir[0] = 0;
2326                 }
2327         } else { /* paths specified, only attempt to search these. */
2328                 for (; optind < argc; optind++) {
2329                         rc = llapi_getname(argv[optind], buf, sizeof(buf));
2330                         if (rc < 0) {
2331                                 fprintf(stderr,
2332                                         "cannot get name for `%s': %s\n",
2333                                         argv[optind], strerror(-rc));
2334                                 break;
2335                         }
2336
2337                         printf("%s %s\n", buf, argv[optind]);
2338                 }
2339         }
2340         return rc;
2341 }
2342
2343 static int lfs_check(int argc, char **argv)
2344 {
2345         int rc;
2346         char mntdir[PATH_MAX] = {'\0'};
2347         int num_types = 1;
2348         char *obd_types[2];
2349         char obd_type1[4];
2350         char obd_type2[4];
2351
2352         if (argc != 2)
2353                 return CMD_HELP;
2354
2355         obd_types[0] = obd_type1;
2356         obd_types[1] = obd_type2;
2357
2358         if (strcmp(argv[1], "osts") == 0) {
2359                 strcpy(obd_types[0], "osc");
2360         } else if (strcmp(argv[1], "mds") == 0) {
2361                 strcpy(obd_types[0], "mdc");
2362         } else if (strcmp(argv[1], "servers") == 0) {
2363                 num_types = 2;
2364                 strcpy(obd_types[0], "osc");
2365                 strcpy(obd_types[1], "mdc");
2366         } else {
2367                 fprintf(stderr, "error: %s: option '%s' unrecognized\n",
2368                                 argv[0], argv[1]);
2369                         return CMD_HELP;
2370         }
2371
2372         rc = llapi_search_mounts(NULL, 0, mntdir, NULL);
2373         if (rc < 0 || mntdir[0] == '\0') {
2374                 fprintf(stderr, "No suitable Lustre mount found\n");
2375                 return rc;
2376         }
2377
2378         rc = llapi_target_check(num_types, obd_types, mntdir);
2379         if (rc)
2380                 fprintf(stderr, "error: %s: %s status failed\n",
2381                                 argv[0],argv[1]);
2382
2383         return rc;
2384
2385 }
2386
2387 static int lfs_join(int argc, char **argv)
2388 {
2389         fprintf(stderr, "join two lustre files into one.\n"
2390                         "obsolete, HEAD does not support it anymore.\n");
2391         return 0;
2392 }
2393
2394 #ifdef HAVE_SYS_QUOTA_H
2395 #define ARG2INT(nr, str, msg)                                           \
2396 do {                                                                    \
2397         char *endp;                                                     \
2398         nr = strtol(str, &endp, 0);                                     \
2399         if (*endp) {                                                    \
2400                 fprintf(stderr, "error: bad %s: %s\n", msg, str);       \
2401                 return CMD_HELP;                                        \
2402         }                                                               \
2403 } while (0)
2404
2405 #define ADD_OVERFLOW(a,b) ((a + b) < a) ? (a = ULONG_MAX) : (a = a + b)
2406
2407 /* Convert format time string "XXwXXdXXhXXmXXs" into seconds value
2408  * returns the value or ULONG_MAX on integer overflow or incorrect format
2409  * Notes:
2410  *        1. the order of specifiers is arbitrary (may be: 5w3s or 3s5w)
2411  *        2. specifiers may be encountered multiple times (2s3s is 5 seconds)
2412  *        3. empty integer value is interpreted as 0
2413  */
2414 static unsigned long str2sec(const char* timestr)
2415 {
2416         const char spec[] = "smhdw";
2417         const unsigned long mult[] = {1, 60, 60*60, 24*60*60, 7*24*60*60};
2418         unsigned long val = 0;
2419         char *tail;
2420
2421         if (strpbrk(timestr, spec) == NULL) {
2422                 /* no specifiers inside the time string,
2423                    should treat it as an integer value */
2424                 val = strtoul(timestr, &tail, 10);
2425                 return *tail ? ULONG_MAX : val;
2426         }
2427
2428         /* format string is XXwXXdXXhXXmXXs */
2429         while (*timestr) {
2430                 unsigned long v;
2431                 int ind;
2432                 char* ptr;
2433
2434                 v = strtoul(timestr, &tail, 10);
2435                 if (v == ULONG_MAX || *tail == '\0')
2436                         /* value too large (ULONG_MAX or more)
2437                            or missing specifier */
2438                         goto error;
2439
2440                 ptr = strchr(spec, *tail);
2441                 if (ptr == NULL)
2442                         /* unknown specifier */
2443                         goto error;
2444
2445                 ind = ptr - spec;
2446
2447                 /* check if product will overflow the type */
2448                 if (!(v < ULONG_MAX / mult[ind]))
2449                         goto error;
2450
2451                 ADD_OVERFLOW(val, mult[ind] * v);
2452                 if (val == ULONG_MAX)
2453                         goto error;
2454
2455                 timestr = tail + 1;
2456         }
2457
2458         return val;
2459
2460 error:
2461         return ULONG_MAX;
2462 }
2463
2464 #define ARG2ULL(nr, str, def_units)                                     \
2465 do {                                                                    \
2466         unsigned long long limit, units = def_units;                    \
2467         int rc;                                                         \
2468                                                                         \
2469         rc = llapi_parse_size(str, &limit, &units, 1);                  \
2470         if (rc < 0) {                                                   \
2471                 fprintf(stderr, "error: bad limit value %s\n", str);    \
2472                 return CMD_HELP;                                        \
2473         }                                                               \
2474         nr = limit;                                                     \
2475 } while (0)
2476
2477 static inline int has_times_option(int argc, char **argv)
2478 {
2479         int i;
2480
2481         for (i = 1; i < argc; i++)
2482                 if (!strcmp(argv[i], "-t"))
2483                         return 1;
2484
2485         return 0;
2486 }
2487
2488 int lfs_setquota_times(int argc, char **argv)
2489 {
2490         int c, rc;
2491         struct if_quotactl qctl;
2492         char *mnt, *obd_type = (char *)qctl.obd_type;
2493         struct obd_dqblk *dqb = &qctl.qc_dqblk;
2494         struct obd_dqinfo *dqi = &qctl.qc_dqinfo;
2495         struct option long_opts[] = {
2496                 {"block-grace",     required_argument, 0, 'b'},
2497                 {"group",           no_argument,       0, 'g'},
2498                 {"inode-grace",     required_argument, 0, 'i'},
2499                 {"times",           no_argument,       0, 't'},
2500                 {"user",            no_argument,       0, 'u'},
2501                 {0, 0, 0, 0}
2502         };
2503
2504         memset(&qctl, 0, sizeof(qctl));
2505         qctl.qc_cmd  = LUSTRE_Q_SETINFO;
2506         qctl.qc_type = UGQUOTA;
2507
2508         while ((c = getopt_long(argc, argv, "b:gi:tu", long_opts, NULL)) != -1) {
2509                 switch (c) {
2510                 case 'u':
2511                 case 'g':
2512                         if (qctl.qc_type != UGQUOTA) {
2513                                 fprintf(stderr, "error: -u and -g can't be used "
2514                                                 "more than once\n");
2515                                 return CMD_HELP;
2516                         }
2517                         qctl.qc_type = (c == 'u') ? USRQUOTA : GRPQUOTA;
2518                         break;
2519                 case 'b':
2520                         if ((dqi->dqi_bgrace = str2sec(optarg)) == ULONG_MAX) {
2521                                 fprintf(stderr, "error: bad block-grace: %s\n",
2522                                         optarg);
2523                                 return CMD_HELP;
2524                         }
2525                         dqb->dqb_valid |= QIF_BTIME;
2526                         break;
2527                 case 'i':
2528                         if ((dqi->dqi_igrace = str2sec(optarg)) == ULONG_MAX) {
2529                                 fprintf(stderr, "error: bad inode-grace: %s\n",
2530                                         optarg);
2531                                 return CMD_HELP;
2532                         }
2533                         dqb->dqb_valid |= QIF_ITIME;
2534                         break;
2535                 case 't': /* Yes, of course! */
2536                         break;
2537                 default: /* getopt prints error message for us when opterr != 0 */
2538                         return CMD_HELP;
2539                 }
2540         }
2541
2542         if (qctl.qc_type == UGQUOTA) {
2543                 fprintf(stderr, "error: neither -u nor -g specified\n");
2544                 return CMD_HELP;
2545         }
2546
2547         if (optind != argc - 1) {
2548                 fprintf(stderr, "error: unexpected parameters encountered\n");
2549                 return CMD_HELP;
2550         }
2551
2552         mnt = argv[optind];
2553         rc = llapi_quotactl(mnt, &qctl);
2554         if (rc) {
2555                 if (*obd_type)
2556                         fprintf(stderr, "%s %s ", obd_type,
2557                                 obd_uuid2str(&qctl.obd_uuid));
2558                 fprintf(stderr, "setquota failed: %s\n", strerror(-rc));
2559                 return rc;
2560         }
2561
2562         return 0;
2563 }
2564
2565 #define BSLIMIT (1 << 0)
2566 #define BHLIMIT (1 << 1)
2567 #define ISLIMIT (1 << 2)
2568 #define IHLIMIT (1 << 3)
2569
2570 int lfs_setquota(int argc, char **argv)
2571 {
2572         int c, rc;
2573         struct if_quotactl qctl;
2574         char *mnt, *obd_type = (char *)qctl.obd_type;
2575         struct obd_dqblk *dqb = &qctl.qc_dqblk;
2576         struct option long_opts[] = {
2577                 {"block-softlimit", required_argument, 0, 'b'},
2578                 {"block-hardlimit", required_argument, 0, 'B'},
2579                 {"group",           required_argument, 0, 'g'},
2580                 {"inode-softlimit", required_argument, 0, 'i'},
2581                 {"inode-hardlimit", required_argument, 0, 'I'},
2582                 {"user",            required_argument, 0, 'u'},
2583                 {0, 0, 0, 0}
2584         };
2585         unsigned limit_mask = 0;
2586         char *endptr;
2587
2588         if (has_times_option(argc, argv))
2589                 return lfs_setquota_times(argc, argv);
2590
2591         memset(&qctl, 0, sizeof(qctl));
2592         qctl.qc_cmd  = LUSTRE_Q_SETQUOTA;
2593         qctl.qc_type = UGQUOTA; /* UGQUOTA makes no sense for setquota,
2594                                  * so it can be used as a marker that qc_type
2595                                  * isn't reinitialized from command line */
2596
2597         while ((c = getopt_long(argc, argv, "b:B:g:i:I:u:", long_opts, NULL)) != -1) {
2598                 switch (c) {
2599                 case 'u':
2600                 case 'g':
2601                         if (qctl.qc_type != UGQUOTA) {
2602                                 fprintf(stderr, "error: -u and -g can't be used"
2603                                                 " more than once\n");
2604                                 return CMD_HELP;
2605                         }
2606                         qctl.qc_type = (c == 'u') ? USRQUOTA : GRPQUOTA;
2607                         rc = name2id(&qctl.qc_id, optarg,
2608                                      (qctl.qc_type == USRQUOTA) ? USER : GROUP);
2609                         if (rc) {
2610                                 qctl.qc_id = strtoul(optarg, &endptr, 10);
2611                                 if (*endptr != '\0') {
2612                                         fprintf(stderr, "error: can't find id "
2613                                                 "for name %s\n", optarg);
2614                                         return CMD_HELP;
2615                                 }
2616                         }
2617                         break;
2618                 case 'b':
2619                         ARG2ULL(dqb->dqb_bsoftlimit, optarg, 1024);
2620                         dqb->dqb_bsoftlimit >>= 10;
2621                         limit_mask |= BSLIMIT;
2622                         if (dqb->dqb_bsoftlimit &&
2623                             dqb->dqb_bsoftlimit <= 1024) /* <= 1M? */
2624                                 fprintf(stderr, "warning: block softlimit is "
2625                                         "smaller than the miminal qunit size, "
2626                                         "please see the help of setquota or "
2627                                         "Lustre manual for details.\n");
2628                         break;
2629                 case 'B':
2630                         ARG2ULL(dqb->dqb_bhardlimit, optarg, 1024);
2631                         dqb->dqb_bhardlimit >>= 10;
2632                         limit_mask |= BHLIMIT;
2633                         if (dqb->dqb_bhardlimit &&
2634                             dqb->dqb_bhardlimit <= 1024) /* <= 1M? */
2635                                 fprintf(stderr, "warning: block hardlimit is "
2636                                         "smaller than the miminal qunit size, "
2637                                         "please see the help of setquota or "
2638                                         "Lustre manual for details.\n");
2639                         break;
2640                 case 'i':
2641                         ARG2ULL(dqb->dqb_isoftlimit, optarg, 1);
2642                         limit_mask |= ISLIMIT;
2643                         if (dqb->dqb_isoftlimit &&
2644                             dqb->dqb_isoftlimit <= 1024) /* <= 1K inodes? */
2645                                 fprintf(stderr, "warning: inode softlimit is "
2646                                         "smaller than the miminal qunit size, "
2647                                         "please see the help of setquota or "
2648                                         "Lustre manual for details.\n");
2649                         break;
2650                 case 'I':
2651                         ARG2ULL(dqb->dqb_ihardlimit, optarg, 1);
2652                         limit_mask |= IHLIMIT;
2653                         if (dqb->dqb_ihardlimit &&
2654                             dqb->dqb_ihardlimit <= 1024) /* <= 1K inodes? */
2655                                 fprintf(stderr, "warning: inode hardlimit is "
2656                                         "smaller than the miminal qunit size, "
2657                                         "please see the help of setquota or "
2658                                         "Lustre manual for details.\n");
2659                         break;
2660                 default: /* getopt prints error message for us when opterr != 0 */
2661                         return CMD_HELP;
2662                 }
2663         }
2664
2665         if (qctl.qc_type == UGQUOTA) {
2666                 fprintf(stderr, "error: neither -u nor -g was specified\n");
2667                 return CMD_HELP;
2668         }
2669
2670         if (limit_mask == 0) {
2671                 fprintf(stderr, "error: at least one limit must be specified\n");
2672                 return CMD_HELP;
2673         }
2674
2675         if (optind != argc - 1) {
2676                 fprintf(stderr, "error: unexpected parameters encountered\n");
2677                 return CMD_HELP;
2678         }
2679
2680         mnt = argv[optind];
2681
2682         if ((!(limit_mask & BHLIMIT) ^ !(limit_mask & BSLIMIT)) ||
2683             (!(limit_mask & IHLIMIT) ^ !(limit_mask & ISLIMIT))) {
2684                 /* sigh, we can't just set blimits/ilimits */
2685                 struct if_quotactl tmp_qctl = {.qc_cmd  = LUSTRE_Q_GETQUOTA,
2686                                                .qc_type = qctl.qc_type,
2687                                                .qc_id   = qctl.qc_id};
2688
2689                 rc = llapi_quotactl(mnt, &tmp_qctl);
2690                 if (rc < 0) {
2691                         fprintf(stderr, "error: setquota failed while retrieving"
2692                                         " current quota settings (%s)\n",
2693                                         strerror(-rc));
2694                         return rc;
2695                 }
2696
2697                 if (!(limit_mask & BHLIMIT))
2698                         dqb->dqb_bhardlimit = tmp_qctl.qc_dqblk.dqb_bhardlimit;
2699                 if (!(limit_mask & BSLIMIT))
2700                         dqb->dqb_bsoftlimit = tmp_qctl.qc_dqblk.dqb_bsoftlimit;
2701                 if (!(limit_mask & IHLIMIT))
2702                         dqb->dqb_ihardlimit = tmp_qctl.qc_dqblk.dqb_ihardlimit;
2703                 if (!(limit_mask & ISLIMIT))
2704                         dqb->dqb_isoftlimit = tmp_qctl.qc_dqblk.dqb_isoftlimit;
2705
2706                 /* Keep grace times if we have got no softlimit arguments */
2707                 if ((limit_mask & BHLIMIT) && !(limit_mask & BSLIMIT)) {
2708                         dqb->dqb_valid |= QIF_BTIME;
2709                         dqb->dqb_btime = tmp_qctl.qc_dqblk.dqb_btime;
2710                 }
2711
2712                 if ((limit_mask & IHLIMIT) && !(limit_mask & ISLIMIT)) {
2713                         dqb->dqb_valid |= QIF_ITIME;
2714                         dqb->dqb_itime = tmp_qctl.qc_dqblk.dqb_itime;
2715                 }
2716         }
2717
2718         dqb->dqb_valid |= (limit_mask & (BHLIMIT | BSLIMIT)) ? QIF_BLIMITS : 0;
2719         dqb->dqb_valid |= (limit_mask & (IHLIMIT | ISLIMIT)) ? QIF_ILIMITS : 0;
2720
2721         rc = llapi_quotactl(mnt, &qctl);
2722         if (rc) {
2723                 if (*obd_type)
2724                         fprintf(stderr, "%s %s ", obd_type,
2725                                 obd_uuid2str(&qctl.obd_uuid));
2726                 fprintf(stderr, "setquota failed: %s\n", strerror(-rc));
2727                 return rc;
2728         }
2729
2730         return 0;
2731 }
2732
2733 static inline char *type2name(int check_type)
2734 {
2735         if (check_type == USRQUOTA)
2736                 return "user";
2737         else if (check_type == GRPQUOTA)
2738                 return "group";
2739         else
2740                 return "unknown";
2741 }
2742
2743 /* Converts seconds value into format string
2744  * result is returned in buf
2745  * Notes:
2746  *        1. result is in descenting order: 1w2d3h4m5s
2747  *        2. zero fields are not filled (except for p. 3): 5d1s
2748  *        3. zero seconds value is presented as "0s"
2749  */
2750 static char * __sec2str(time_t seconds, char *buf)
2751 {
2752         const char spec[] = "smhdw";
2753         const unsigned long mult[] = {1, 60, 60*60, 24*60*60, 7*24*60*60};
2754         unsigned long c;
2755         char *tail = buf;
2756         int i;
2757
2758         for (i = sizeof(mult) / sizeof(mult[0]) - 1 ; i >= 0; i--) {
2759                 c = seconds / mult[i];
2760
2761                 if (c > 0 || (i == 0 && buf == tail))
2762                         tail += snprintf(tail, 40-(tail-buf), "%lu%c", c, spec[i]);
2763
2764                 seconds %= mult[i];
2765         }
2766
2767         return tail;
2768 }
2769
2770 static void sec2str(time_t seconds, char *buf, int rc)
2771 {
2772         char *tail = buf;
2773
2774         if (rc)
2775                 *tail++ = '[';
2776
2777         tail = __sec2str(seconds, tail);
2778
2779         if (rc && tail - buf < 39) {
2780                 *tail++ = ']';
2781                 *tail++ = 0;
2782         }
2783 }
2784
2785 static void diff2str(time_t seconds, char *buf, time_t now)
2786 {
2787
2788         buf[0] = 0;
2789         if (!seconds)
2790                 return;
2791         if (seconds <= now) {
2792                 strcpy(buf, "none");
2793                 return;
2794         }
2795         __sec2str(seconds - now, buf);
2796 }
2797
2798 static void print_quota_title(char *name, struct if_quotactl *qctl,
2799                               bool human_readable)
2800 {
2801         printf("Disk quotas for %s %s (%cid %u):\n",
2802                type2name(qctl->qc_type), name,
2803                *type2name(qctl->qc_type), qctl->qc_id);
2804         printf("%15s%8s %7s%8s%8s%8s %7s%8s%8s\n",
2805                "Filesystem", human_readable ? "used" : "kbytes",
2806                "quota", "limit", "grace",
2807                "files", "quota", "limit", "grace");
2808 }
2809
2810 static void kbytes2str(__u64 num, char *buf, bool h)
2811 {
2812         if (!h) {
2813                 sprintf(buf, LPU64, num);
2814         } else {
2815                 if (num >> 30)
2816                         sprintf(buf, "%5.4gT", (double)num / (1 << 30));
2817                 else if (num >> 20)
2818                         sprintf(buf, "%5.4gG", (double)num / (1 << 20));
2819                 else if (num >> 10)
2820                         sprintf(buf, "%5.4gM", (double)num / (1 << 10));
2821                 else
2822                         sprintf(buf, LPU64"%s", num, "k");
2823         }
2824 }
2825
2826 static void print_quota(char *mnt, struct if_quotactl *qctl, int type,
2827                         int rc, bool h)
2828 {
2829         time_t now;
2830
2831         time(&now);
2832
2833         if (qctl->qc_cmd == LUSTRE_Q_GETQUOTA || qctl->qc_cmd == Q_GETOQUOTA) {
2834                 int bover = 0, iover = 0;
2835                 struct obd_dqblk *dqb = &qctl->qc_dqblk;
2836                 char numbuf[3][32];
2837                 char timebuf[40];
2838                 char strbuf[32];
2839
2840                 if (dqb->dqb_bhardlimit &&
2841                     lustre_stoqb(dqb->dqb_curspace) >= dqb->dqb_bhardlimit) {
2842                         bover = 1;
2843                 } else if (dqb->dqb_bsoftlimit && dqb->dqb_btime) {
2844                         if (dqb->dqb_btime > now) {
2845                                 bover = 2;
2846                         } else {
2847                                 bover = 3;
2848                         }
2849                 }
2850
2851                 if (dqb->dqb_ihardlimit &&
2852                     dqb->dqb_curinodes >= dqb->dqb_ihardlimit) {
2853                         iover = 1;
2854                 } else if (dqb->dqb_isoftlimit && dqb->dqb_itime) {
2855                         if (dqb->dqb_itime > now) {
2856                                 iover = 2;
2857                         } else {
2858                                 iover = 3;
2859                         }
2860                 }
2861
2862
2863                 if (strlen(mnt) > 15)
2864                         printf("%s\n%15s", mnt, "");
2865                 else
2866                         printf("%15s", mnt);
2867
2868                 if (bover)
2869                         diff2str(dqb->dqb_btime, timebuf, now);
2870
2871                 kbytes2str(lustre_stoqb(dqb->dqb_curspace), strbuf, h);
2872                 if (rc == -EREMOTEIO)
2873                         sprintf(numbuf[0], "%s*", strbuf);
2874                 else
2875                         sprintf(numbuf[0], (dqb->dqb_valid & QIF_SPACE) ?
2876                                 "%s" : "[%s]", strbuf);
2877
2878                 kbytes2str(dqb->dqb_bsoftlimit, strbuf, h);
2879                 if (type == QC_GENERAL)
2880                         sprintf(numbuf[1], (dqb->dqb_valid & QIF_BLIMITS) ?
2881                                 "%s" : "[%s]", strbuf);
2882                 else
2883                         sprintf(numbuf[1], "%s", "-");
2884
2885                 kbytes2str(dqb->dqb_bhardlimit, strbuf, h);
2886                 sprintf(numbuf[2], (dqb->dqb_valid & QIF_BLIMITS) ?
2887                         "%s" : "[%s]", strbuf);
2888
2889                 printf(" %7s%c %6s %7s %7s",
2890                        numbuf[0], bover ? '*' : ' ', numbuf[1],
2891                        numbuf[2], bover > 1 ? timebuf : "-");
2892
2893                 if (iover)
2894                         diff2str(dqb->dqb_itime, timebuf, now);
2895
2896                 sprintf(numbuf[0], (dqb->dqb_valid & QIF_INODES) ?
2897                         LPU64 : "["LPU64"]", dqb->dqb_curinodes);
2898
2899                 if (type == QC_GENERAL)
2900                         sprintf(numbuf[1], (dqb->dqb_valid & QIF_ILIMITS) ?
2901                                 LPU64 : "["LPU64"]", dqb->dqb_isoftlimit);
2902                 else
2903                         sprintf(numbuf[1], "%s", "-");
2904
2905                 sprintf(numbuf[2], (dqb->dqb_valid & QIF_ILIMITS) ?
2906                         LPU64 : "["LPU64"]", dqb->dqb_ihardlimit);
2907
2908                 if (type != QC_OSTIDX)
2909                         printf(" %7s%c %6s %7s %7s",
2910                                numbuf[0], iover ? '*' : ' ', numbuf[1],
2911                                numbuf[2], iover > 1 ? timebuf : "-");
2912                 else
2913                         printf(" %7s %7s %7s %7s", "-", "-", "-", "-");
2914                 printf("\n");
2915
2916         } else if (qctl->qc_cmd == LUSTRE_Q_GETINFO ||
2917                    qctl->qc_cmd == Q_GETOINFO) {
2918                 char bgtimebuf[40];
2919                 char igtimebuf[40];
2920
2921                 sec2str(qctl->qc_dqinfo.dqi_bgrace, bgtimebuf, rc);
2922                 sec2str(qctl->qc_dqinfo.dqi_igrace, igtimebuf, rc);
2923                 printf("Block grace time: %s; Inode grace time: %s\n",
2924                        bgtimebuf, igtimebuf);
2925         }
2926 }
2927
2928 static int print_obd_quota(char *mnt, struct if_quotactl *qctl, int is_mdt,
2929                            bool h, __u64 *total)
2930 {
2931         int rc = 0, rc1 = 0, count = 0;
2932         __u32 valid = qctl->qc_valid;
2933
2934         rc = llapi_get_obd_count(mnt, &count, is_mdt);
2935         if (rc) {
2936                 fprintf(stderr, "can not get %s count: %s\n",
2937                         is_mdt ? "mdt": "ost", strerror(-rc));
2938                 return rc;
2939         }
2940
2941         for (qctl->qc_idx = 0; qctl->qc_idx < count; qctl->qc_idx++) {
2942                 qctl->qc_valid = is_mdt ? QC_MDTIDX : QC_OSTIDX;
2943                 rc = llapi_quotactl(mnt, qctl);
2944                 if (rc) {
2945                         /* It is remote client case. */
2946                         if (-rc == EOPNOTSUPP) {
2947                                 rc = 0;
2948                                 goto out;
2949                         }
2950
2951                         if (!rc1)
2952                                 rc1 = rc;
2953                         fprintf(stderr, "quotactl %s%d failed.\n",
2954                                 is_mdt ? "mdt": "ost", qctl->qc_idx);
2955                         continue;
2956                 }
2957
2958                 print_quota(obd_uuid2str(&qctl->obd_uuid), qctl,
2959                             qctl->qc_valid, 0, h);
2960                 *total += is_mdt ? qctl->qc_dqblk.dqb_ihardlimit :
2961                                    qctl->qc_dqblk.dqb_bhardlimit;
2962         }
2963 out:
2964         qctl->qc_valid = valid;
2965         return rc ? : rc1;
2966 }
2967
2968 static int lfs_quota(int argc, char **argv)
2969 {
2970         int c;
2971         char *mnt, *name = NULL;
2972         struct if_quotactl qctl = { .qc_cmd = LUSTRE_Q_GETQUOTA,
2973                                     .qc_type = UGQUOTA };
2974         char *obd_type = (char *)qctl.obd_type;
2975         char *obd_uuid = (char *)qctl.obd_uuid.uuid;
2976         int rc, rc1 = 0, rc2 = 0, rc3 = 0,
2977             verbose = 0, pass = 0, quiet = 0, inacc;
2978         char *endptr;
2979         __u32 valid = QC_GENERAL, idx = 0;
2980         __u64 total_ialloc = 0, total_balloc = 0;
2981         bool human_readable = false;
2982
2983         while ((c = getopt(argc, argv, "gi:I:o:qtuvh")) != -1) {
2984                 switch (c) {
2985                 case 'u':
2986                         if (qctl.qc_type != UGQUOTA) {
2987                                 fprintf(stderr, "error: use either -u or -g\n");
2988                                 return CMD_HELP;
2989                         }
2990                         qctl.qc_type = USRQUOTA;
2991                         break;
2992                 case 'g':
2993                         if (qctl.qc_type != UGQUOTA) {
2994                                 fprintf(stderr, "error: use either -u or -g\n");
2995                                 return CMD_HELP;
2996                         }
2997                         qctl.qc_type = GRPQUOTA;
2998                         break;
2999                 case 't':
3000                         qctl.qc_cmd = LUSTRE_Q_GETINFO;
3001                         break;
3002                 case 'o':
3003                         valid = qctl.qc_valid = QC_UUID;
3004                         strlcpy(obd_uuid, optarg, sizeof(qctl.obd_uuid));
3005                         break;
3006                 case 'i':
3007                         valid = qctl.qc_valid = QC_MDTIDX;
3008                         idx = qctl.qc_idx = atoi(optarg);
3009                         break;
3010                 case 'I':
3011                         valid = qctl.qc_valid = QC_OSTIDX;
3012                         idx = qctl.qc_idx = atoi(optarg);
3013                         break;
3014                 case 'v':
3015                         verbose = 1;
3016                         break;
3017                 case 'q':
3018                         quiet = 1;
3019                         break;
3020                 case 'h':
3021                         human_readable = true;
3022                         break;
3023                 default:
3024                         fprintf(stderr, "error: %s: option '-%c' "
3025                                         "unrecognized\n", argv[0], c);
3026                         return CMD_HELP;
3027                 }
3028         }
3029
3030         /* current uid/gid info for "lfs quota /path/to/lustre/mount" */
3031         if (qctl.qc_cmd == LUSTRE_Q_GETQUOTA && qctl.qc_type == UGQUOTA &&
3032             optind == argc - 1) {
3033 ug_output:
3034                 memset(&qctl, 0, sizeof(qctl)); /* spoiled by print_*_quota */
3035                 qctl.qc_cmd = LUSTRE_Q_GETQUOTA;
3036                 qctl.qc_valid = valid;
3037                 qctl.qc_idx = idx;
3038                 if (pass++ == 0) {
3039                         qctl.qc_type = USRQUOTA;
3040                         qctl.qc_id = geteuid();
3041                 } else {
3042                         qctl.qc_type = GRPQUOTA;
3043                         qctl.qc_id = getegid();
3044                 }
3045                 rc = id2name(&name, qctl.qc_id,
3046                              (qctl.qc_type == USRQUOTA) ? USER : GROUP);
3047                 if (rc)
3048                         name = "<unknown>";
3049         /* lfs quota -u username /path/to/lustre/mount */
3050         } else if (qctl.qc_cmd == LUSTRE_Q_GETQUOTA) {
3051                 /* options should be followed by u/g-name and mntpoint */
3052                 if (optind + 2 != argc || qctl.qc_type == UGQUOTA) {
3053                         fprintf(stderr, "error: missing quota argument(s)\n");
3054                         return CMD_HELP;
3055                 }
3056
3057                 name = argv[optind++];
3058                 rc = name2id(&qctl.qc_id, name,
3059                              (qctl.qc_type == USRQUOTA) ? USER : GROUP);
3060                 if (rc) {
3061                         qctl.qc_id = strtoul(name, &endptr, 10);
3062                         if (*endptr != '\0') {
3063                                 fprintf(stderr, "error: can't find id for name "
3064                                         "%s\n", name);
3065                                 return CMD_HELP;
3066                         }
3067                 }
3068         } else if (optind + 1 != argc || qctl.qc_type == UGQUOTA) {
3069                 fprintf(stderr, "error: missing quota info argument(s)\n");
3070                 return CMD_HELP;
3071         }
3072
3073         mnt = argv[optind];
3074
3075         rc1 = llapi_quotactl(mnt, &qctl);
3076         if (rc1 < 0) {
3077                 switch (rc1) {
3078                 case -ESRCH:
3079                         fprintf(stderr, "%s quotas are not enabled.\n",
3080                                 qctl.qc_type == USRQUOTA ? "user" : "group");
3081                         goto out;
3082                 case -EPERM:
3083                         fprintf(stderr, "Permission denied.\n");
3084                 case -ENOENT:
3085                         /* We already got a "No such file..." message. */
3086                         goto out;
3087                 default:
3088                         fprintf(stderr, "Unexpected quotactl error: %s\n",
3089                                 strerror(-rc1));
3090                 }
3091         }
3092
3093         if (qctl.qc_cmd == LUSTRE_Q_GETQUOTA && !quiet)
3094                 print_quota_title(name, &qctl, human_readable);
3095
3096         if (rc1 && *obd_type)
3097                 fprintf(stderr, "%s %s ", obd_type, obd_uuid);
3098
3099         if (qctl.qc_valid != QC_GENERAL)
3100                 mnt = "";
3101
3102         inacc = (qctl.qc_cmd == LUSTRE_Q_GETQUOTA) &&
3103                 ((qctl.qc_dqblk.dqb_valid & (QIF_LIMITS|QIF_USAGE)) !=
3104                  (QIF_LIMITS|QIF_USAGE));
3105
3106         print_quota(mnt, &qctl, QC_GENERAL, rc1, human_readable);
3107
3108         if (qctl.qc_valid == QC_GENERAL && qctl.qc_cmd != LUSTRE_Q_GETINFO &&
3109             verbose) {
3110                 char strbuf[32];
3111
3112                 rc2 = print_obd_quota(mnt, &qctl, 1, human_readable,
3113                                       &total_ialloc);
3114                 rc3 = print_obd_quota(mnt, &qctl, 0, human_readable,
3115                                       &total_balloc);
3116                 kbytes2str(total_balloc, strbuf, human_readable);
3117                 printf("Total allocated inode limit: "LPU64", total "
3118                        "allocated block limit: %s\n", total_ialloc, strbuf);
3119         }
3120
3121         if (rc1 || rc2 || rc3 || inacc)
3122                 printf("Some errors happened when getting quota info. "
3123                        "Some devices may be not working or deactivated. "
3124                        "The data in \"[]\" is inaccurate.\n");
3125
3126 out:
3127         if (pass == 1)
3128                 goto ug_output;
3129
3130         return rc1;
3131 }
3132 #endif /* HAVE_SYS_QUOTA_H! */
3133
3134 static int flushctx_ioctl(char *mp)
3135 {
3136         int fd, rc;
3137
3138         fd = open(mp, O_RDONLY);
3139         if (fd == -1) {
3140                 fprintf(stderr, "flushctx: error open %s: %s\n",
3141                         mp, strerror(errno));
3142                 return -1;
3143         }
3144
3145         rc = ioctl(fd, LL_IOC_FLUSHCTX);
3146         if (rc == -1)
3147                 fprintf(stderr, "flushctx: error ioctl %s: %s\n",
3148                         mp, strerror(errno));
3149
3150         close(fd);
3151         return rc;
3152 }
3153
3154 static int lfs_flushctx(int argc, char **argv)
3155 {
3156         int     kdestroy = 0, c;
3157         char    mntdir[PATH_MAX] = {'\0'};
3158         int     index = 0;
3159         int     rc = 0;
3160
3161         while ((c = getopt(argc, argv, "k")) != -1) {
3162                 switch (c) {
3163                 case 'k':
3164                         kdestroy = 1;
3165                         break;
3166                 default:
3167                         fprintf(stderr, "error: %s: option '-%c' "
3168                                         "unrecognized\n", argv[0], c);
3169                         return CMD_HELP;
3170                 }
3171         }
3172
3173         if (kdestroy) {
3174             if ((rc = system("kdestroy > /dev/null")) != 0) {
3175                 rc = WEXITSTATUS(rc);
3176                 fprintf(stderr, "error destroying tickets: %d, continuing\n", rc);
3177             }
3178         }
3179
3180         if (optind >= argc) {
3181                 /* flush for all mounted lustre fs. */
3182                 while (!llapi_search_mounts(NULL, index++, mntdir, NULL)) {
3183                         /* Check if we have a mount point */
3184                         if (mntdir[0] == '\0')
3185                                 continue;
3186
3187                         if (flushctx_ioctl(mntdir))
3188                                 rc = -1;
3189
3190                         mntdir[0] = '\0'; /* avoid matching in next loop */
3191                 }
3192         } else {
3193                 /* flush fs as specified */
3194                 while (optind < argc) {
3195                         if (flushctx_ioctl(argv[optind++]))
3196                                 rc = -1;
3197                 }
3198         }
3199         return rc;
3200 }
3201
3202 static int lfs_lsetfacl(int argc, char **argv)
3203 {
3204         argv[0]++;
3205         return(llapi_lsetfacl(argc, argv));
3206 }
3207
3208 static int lfs_lgetfacl(int argc, char **argv)
3209 {
3210         argv[0]++;
3211         return(llapi_lgetfacl(argc, argv));
3212 }
3213
3214 static int lfs_rsetfacl(int argc, char **argv)
3215 {
3216         argv[0]++;
3217         return(llapi_rsetfacl(argc, argv));
3218 }
3219
3220 static int lfs_rgetfacl(int argc, char **argv)
3221 {
3222         argv[0]++;
3223         return(llapi_rgetfacl(argc, argv));
3224 }
3225
3226 static int lfs_cp(int argc, char **argv)
3227 {
3228         return(llapi_cp(argc, argv));
3229 }
3230
3231 static int lfs_ls(int argc, char **argv)
3232 {
3233         return(llapi_ls(argc, argv));
3234 }
3235
3236 static int lfs_changelog(int argc, char **argv)
3237 {
3238         void *changelog_priv;
3239         struct changelog_rec *rec;
3240         long long startrec = 0, endrec = 0;
3241         char *mdd;
3242         struct option long_opts[] = {
3243                 {"follow", no_argument, 0, 'f'},
3244                 {0, 0, 0, 0}
3245         };
3246         char short_opts[] = "f";
3247         int rc, follow = 0;
3248
3249         while ((rc = getopt_long(argc, argv, short_opts,
3250                                 long_opts, NULL)) != -1) {
3251                 switch (rc) {
3252                 case 'f':
3253                         follow++;
3254                         break;
3255                 case '?':
3256                         return CMD_HELP;
3257                 default:
3258                         fprintf(stderr, "error: %s: option '%s' unrecognized\n",
3259                                 argv[0], argv[optind - 1]);
3260                         return CMD_HELP;
3261                 }
3262         }
3263         if (optind >= argc)
3264                 return CMD_HELP;
3265
3266         mdd = argv[optind++];
3267         if (argc > optind)
3268                 startrec = strtoll(argv[optind++], NULL, 10);
3269         if (argc > optind)
3270                 endrec = strtoll(argv[optind++], NULL, 10);
3271
3272         rc = llapi_changelog_start(&changelog_priv,
3273                                    CHANGELOG_FLAG_BLOCK |
3274                                    CHANGELOG_FLAG_JOBID |
3275                                    (follow ? CHANGELOG_FLAG_FOLLOW : 0),
3276                                    mdd, startrec);
3277         if (rc < 0) {
3278                 fprintf(stderr, "Can't start changelog: %s\n",
3279                         strerror(errno = -rc));
3280                 return rc;
3281         }
3282
3283         while ((rc = llapi_changelog_recv(changelog_priv, &rec)) == 0) {
3284                 time_t secs;
3285                 struct tm ts;
3286
3287                 if (endrec && rec->cr_index > endrec) {
3288                         llapi_changelog_free(&rec);
3289                         break;
3290                 }
3291                 if (rec->cr_index < startrec) {
3292                         llapi_changelog_free(&rec);
3293                         continue;
3294                 }
3295
3296                 secs = rec->cr_time >> 30;
3297                 gmtime_r(&secs, &ts);
3298                 printf(LPU64" %02d%-5s %02d:%02d:%02d.%06d %04d.%02d.%02d "
3299                        "0x%x t="DFID, rec->cr_index, rec->cr_type,
3300                        changelog_type2str(rec->cr_type),
3301                        ts.tm_hour, ts.tm_min, ts.tm_sec,
3302                        (int)(rec->cr_time & ((1<<30) - 1)),
3303                        ts.tm_year + 1900, ts.tm_mon + 1, ts.tm_mday,
3304                        rec->cr_flags & CLF_FLAGMASK, PFID(&rec->cr_tfid));
3305
3306                 if (rec->cr_flags & CLF_JOBID) {
3307                         struct changelog_ext_jobid *jid =
3308                                 changelog_rec_jobid(rec);
3309
3310                         if (jid->cr_jobid[0] != '\0')
3311                                 printf(" j=%s", jid->cr_jobid);
3312                 }
3313
3314                 if (rec->cr_namelen)
3315                         printf(" p="DFID" %.*s", PFID(&rec->cr_pfid),
3316                                rec->cr_namelen, changelog_rec_name(rec));
3317
3318                 if (rec->cr_flags & CLF_RENAME) {
3319                         struct changelog_ext_rename *rnm =
3320                                 changelog_rec_rename(rec);
3321
3322                         if (!fid_is_zero(&rnm->cr_sfid))
3323                                 printf(" s="DFID" sp="DFID" %.*s",
3324                                        PFID(&rnm->cr_sfid),
3325                                        PFID(&rnm->cr_spfid),
3326                                        (int)changelog_rec_snamelen(rec),
3327                                        changelog_rec_sname(rec));
3328                 }
3329                 printf("\n");
3330
3331                 llapi_changelog_free(&rec);
3332         }
3333
3334         llapi_changelog_fini(&changelog_priv);
3335
3336         if (rc < 0)
3337                 fprintf(stderr, "Changelog: %s\n", strerror(errno = -rc));
3338
3339         return (rc == 1 ? 0 : rc);
3340 }
3341
3342 static int lfs_changelog_clear(int argc, char **argv)
3343 {
3344         long long endrec;
3345         int rc;
3346
3347         if (argc != 4)
3348                 return CMD_HELP;
3349
3350         endrec = strtoll(argv[3], NULL, 10);
3351
3352         rc = llapi_changelog_clear(argv[1], argv[2], endrec);
3353         if (rc)
3354                 fprintf(stderr, "%s error: %s\n", argv[0],
3355                         strerror(errno = -rc));
3356         return rc;
3357 }
3358
3359 static int lfs_fid2path(int argc, char **argv)
3360 {
3361         struct option long_opts[] = {
3362                 {"cur", no_argument, 0, 'c'},
3363                 {"link", required_argument, 0, 'l'},
3364                 {"rec", required_argument, 0, 'r'},
3365                 {0, 0, 0, 0}
3366         };
3367         char  short_opts[] = "cl:r:";
3368         char *device, *fid, *path;
3369         long long recno = -1;
3370         int linkno = -1;
3371         int lnktmp;
3372         int printcur = 0;
3373         int rc = 0;
3374
3375         while ((rc = getopt_long(argc, argv, short_opts,
3376                                 long_opts, NULL)) != -1) {
3377                 switch (rc) {
3378                 case 'c':
3379                         printcur++;
3380                         break;
3381                 case 'l':
3382                         linkno = strtol(optarg, NULL, 10);
3383                         break;
3384                 case 'r':
3385                         recno = strtoll(optarg, NULL, 10);
3386                         break;
3387                 case '?':
3388                         return CMD_HELP;
3389                 default:
3390                         fprintf(stderr, "error: %s: option '%s' unrecognized\n",
3391                                 argv[0], argv[optind - 1]);
3392                         return CMD_HELP;
3393                 }
3394         }
3395
3396         if (argc < 3)
3397                 return CMD_HELP;
3398
3399         device = argv[optind++];
3400         path = calloc(1, PATH_MAX);
3401         if (path == NULL) {
3402                 fprintf(stderr, "error: Not enough memory\n");
3403                 return -errno;
3404         }
3405
3406         rc = 0;
3407         while (optind < argc) {
3408                 fid = argv[optind++];
3409
3410                 lnktmp = (linkno >= 0) ? linkno : 0;
3411                 while (1) {
3412                         int oldtmp = lnktmp;
3413                         long long rectmp = recno;
3414                         int rc2;
3415                         rc2 = llapi_fid2path(device, fid, path, PATH_MAX,
3416                                              &rectmp, &lnktmp);
3417                         if (rc2 < 0) {
3418                                 fprintf(stderr, "%s: error on FID %s: %s\n",
3419                                         argv[0], fid, strerror(errno = -rc2));
3420                                 if (rc == 0)
3421                                         rc = rc2;
3422                                 break;
3423                         }
3424
3425                         if (printcur)
3426                                 fprintf(stdout, "%lld ", rectmp);
3427                         if (device[0] == '/') {
3428                                 fprintf(stdout, "%s", device);
3429                                 if (device[strlen(device) - 1] != '/')
3430                                         fprintf(stdout, "/");
3431                         } else if (path[0] == '\0') {
3432                                 fprintf(stdout, "/");
3433                         }
3434                         fprintf(stdout, "%s\n", path);
3435
3436                         if (linkno >= 0)
3437                                 /* specified linkno */
3438                                 break;
3439                         if (oldtmp == lnktmp)
3440                                 /* no more links */
3441                                 break;
3442                 }
3443         }
3444
3445         free(path);
3446         return rc;
3447 }
3448
3449 static int lfs_path2fid(int argc, char **argv)
3450 {
3451         struct option     long_opts[] = {
3452                 {"parents", no_argument, 0, 'p'},
3453                 {0, 0, 0, 0}
3454         };
3455         char            **path;
3456         const char        short_opts[] = "p";
3457         const char       *sep = "";
3458         lustre_fid        fid;
3459         int               rc = 0;
3460         bool              show_parents = false;
3461