Whamcloud - gitweb
LU-6142 utils: Fix style issues for lfs.c
[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.gnu.org/licenses/gpl-2.0.html
19  *
20  * GPL HEADER END
21  */
22 /*
23  * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
24  * Use is subject to license terms.
25  *
26  * Copyright (c) 2011, 2017, Intel Corporation.
27  */
28 /*
29  * This file is part of Lustre, http://www.lustre.org/
30  * Lustre is a trademark of Sun Microsystems, Inc.
31  *
32  * lustre/utils/lfs.c
33  *
34  * Author: Peter J. Braam <braam@clusterfs.com>
35  * Author: Phil Schwan <phil@clusterfs.com>
36  * Author: Robert Read <rread@clusterfs.com>
37  */
38
39 /* for O_DIRECTORY */
40 #ifndef _GNU_SOURCE
41 #define _GNU_SOURCE
42 #endif
43
44 #include <stdlib.h>
45 #include <stdio.h>
46 #include <inttypes.h>
47 #include <getopt.h>
48 #include <string.h>
49 #include <mntent.h>
50 #include <unistd.h>
51 #include <errno.h>
52 #include <err.h>
53 #include <pwd.h>
54 #include <grp.h>
55 #include <sys/ioctl.h>
56 #include <sys/quota.h>
57 #include <sys/time.h>
58 #include <sys/types.h>
59 #include <sys/stat.h>
60 #include <sys/param.h>
61 #include <sys/xattr.h>
62 #include <fcntl.h>
63 #include <dirent.h>
64 #include <time.h>
65 #include <ctype.h>
66 #include <zlib.h>
67 #include <libgen.h>
68 #include <asm/byteorder.h>
69 #include "lfs_project.h"
70
71 #include <libcfs/util/string.h>
72 #include <libcfs/util/ioctl.h>
73 #include <libcfs/util/parser.h>
74 #include <libcfs/util/string.h>
75 #include <lustre/lustreapi.h>
76 #include <linux/lustre/lustre_ver.h>
77 #include <linux/lustre/lustre_param.h>
78 #include <linux/lnet/nidstr.h>
79 #include <lnetconfig/cyaml.h>
80 #include "lstddef.h"
81
82 /* all functions */
83 static int lfs_find(int argc, char **argv);
84 static int lfs_getstripe(int argc, char **argv);
85 static int lfs_getdirstripe(int argc, char **argv);
86 static int lfs_setdirstripe(int argc, char **argv);
87 static int lfs_rmentry(int argc, char **argv);
88 static int lfs_osts(int argc, char **argv);
89 static int lfs_mdts(int argc, char **argv);
90 static int lfs_df(int argc, char **argv);
91 static int lfs_getname(int argc, char **argv);
92 static int lfs_check(int argc, char **argv);
93 #ifdef HAVE_SYS_QUOTA_H
94 static int lfs_setquota(int argc, char **argv);
95 static int lfs_quota(int argc, char **argv);
96 static int lfs_project(int argc, char **argv);
97 #endif
98 static int lfs_flushctx(int argc, char **argv);
99 static int lfs_poollist(int argc, char **argv);
100 static int lfs_changelog(int argc, char **argv);
101 static int lfs_changelog_clear(int argc, char **argv);
102 static int lfs_fid2path(int argc, char **argv);
103 static int lfs_path2fid(int argc, char **argv);
104 static int lfs_rmfid(int argc, char **argv);
105 static int lfs_data_version(int argc, char **argv);
106 static int lfs_hsm_state(int argc, char **argv);
107 static int lfs_hsm_set(int argc, char **argv);
108 static int lfs_hsm_clear(int argc, char **argv);
109 static int lfs_hsm_action(int argc, char **argv);
110 static int lfs_hsm_archive(int argc, char **argv);
111 static int lfs_hsm_restore(int argc, char **argv);
112 static int lfs_hsm_release(int argc, char **argv);
113 static int lfs_hsm_remove(int argc, char **argv);
114 static int lfs_hsm_cancel(int argc, char **argv);
115 static int lfs_swap_layouts(int argc, char **argv);
116 static int lfs_mv(int argc, char **argv);
117 static int lfs_ladvise(int argc, char **argv);
118 static int lfs_getsom(int argc, char **argv);
119 static int lfs_heat_get(int argc, char **argv);
120 static int lfs_heat_set(int argc, char **argv);
121 static int lfs_mirror(int argc, char **argv);
122 static int lfs_mirror_list_commands(int argc, char **argv);
123 static int lfs_list_commands(int argc, char **argv);
124 static inline int lfs_mirror_resync(int argc, char **argv);
125 static inline int lfs_mirror_verify(int argc, char **argv);
126 static inline int lfs_mirror_read(int argc, char **argv);
127 static inline int lfs_mirror_write(int argc, char **argv);
128 static inline int lfs_mirror_copy(int argc, char **argv);
129 static int lfs_pcc_attach(int argc, char **argv);
130 static int lfs_pcc_attach_fid(int argc, char **argv);
131 static int lfs_pcc_detach(int argc, char **argv);
132 static int lfs_pcc_detach_fid(int argc, char **argv);
133 static int lfs_pcc_state(int argc, char **argv);
134 static int lfs_pcc(int argc, char **argv);
135 static int lfs_pcc_list_commands(int argc, char **argv);
136 static int lfs_migrate_to_dom(int fd, int fdv, char *name,
137                               __u64 migration_flags,
138                               struct llapi_stripe_param *param,
139                               struct llapi_layout *layout);
140
141 enum setstripe_origin {
142         SO_SETSTRIPE,
143         SO_MIGRATE,
144         SO_MIGRATE_MDT,
145         SO_MIRROR_CREATE,
146         SO_MIRROR_EXTEND,
147         SO_MIRROR_SPLIT,
148         SO_MIRROR_DELETE,
149 };
150
151 static int lfs_setstripe_internal(int argc, char **argv,
152                                   enum setstripe_origin opc);
153
154 static inline int lfs_setstripe(int argc, char **argv)
155 {
156         return lfs_setstripe_internal(argc, argv, SO_SETSTRIPE);
157 }
158
159 static inline int lfs_setstripe_migrate(int argc, char **argv)
160 {
161         return lfs_setstripe_internal(argc, argv, SO_MIGRATE);
162 }
163
164 static inline int lfs_mirror_create(int argc, char **argv)
165 {
166         return lfs_setstripe_internal(argc, argv, SO_MIRROR_CREATE);
167 }
168
169 static inline int lfs_mirror_extend(int argc, char **argv)
170 {
171         return lfs_setstripe_internal(argc, argv, SO_MIRROR_EXTEND);
172 }
173
174 static inline int lfs_mirror_split(int argc, char **argv)
175 {
176         return lfs_setstripe_internal(argc, argv, SO_MIRROR_SPLIT);
177 }
178
179 static inline int lfs_mirror_delete(int argc, char **argv)
180 {
181         return lfs_setstripe_internal(argc, argv, SO_MIRROR_DELETE);
182 }
183
184 /* Setstripe and migrate share mostly the same parameters */
185 #define SSM_CMD_COMMON(cmd) \
186         "usage: "cmd" [--component-end|-E <comp_end>]\n"                \
187         "                 [--stripe-count|-c <stripe_count>]\n"         \
188         "                 [--overstripe-count|-C <stripe_count>]\n"     \
189         "                 [--stripe-index|-i <start_ost_idx>]\n"        \
190         "                 [--stripe-size|-S <stripe_size>]\n"           \
191         "                 [--extension-size|--ext-size|-z]\n"           \
192         "                 [--layout|-L <pattern>]\n"                    \
193         "                 [--mirror_count|-N[mirror_count]]\n"          \
194         "                 [--ost|-o <ost_indices>]\n"                   \
195         "                 [--pool|-p <pool_name>]\n"                    \
196         "                 [--yaml|-y <yaml_template_file>]\n"           \
197         "                 [--copy=<lustre_src>]\n"
198
199 #define SSM_HELP_COMMON \
200         "\tstripe_count: Number of OSTs to stripe over (0=fs default, -1 all)\n" \
201         "\t              Using -C instead of -c allows overstriping, which\n" \
202         "\t              will place more than one stripe per OST if\n" \
203         "\t              stripe_count is greater than the number of OSTs\n" \
204         "\tstart_ost_idx: OST index of first stripe (-1=default round robin)\n"\
205         "\tstripe_size:  Number of bytes on each OST (0=fs default)\n" \
206         "\t              Can be specified with K, M or G (for KB, MB, GB\n" \
207         "\t              respectively)\n"                               \
208         "\textension_size:\n"                                           \
209         "\t              Number of bytes the previous component is extended\n" \
210         "\t              each time. Can be specified with K, M, G (for KB,\n" \
211         "\t              MB, GB respectively)\n"                        \
212         "\tpool_name:    Name of OST pool to use (default none)\n"      \
213         "\tlayout:       stripe pattern type: raid0, mdt (default raid0)\n"\
214         "\tost_indices:  List of OST indices, can be repeated multiple times\n"\
215         "\t              Indices be specified in a format of:\n"        \
216         "\t                -o <ost_1>,<ost_i>-<ost_j>,<ost_n>\n"        \
217         "\t              Or:\n"                                         \
218         "\t                -o <ost_1> -o <ost_i>-<ost_j> -o <ost_n>\n"  \
219         "\t              If --pool is set with --ost then the OSTs\n"   \
220         "\t              must be the members of the pool.\n"            \
221         "\tcomp_end:     Extent end of component, start after previous end.\n"\
222         "\t              Can be specified with K, M or G (for KB, MB, GB\n" \
223         "\t              respectively, -1 for EOF). Must be a multiple of\n"\
224         "\t              stripe_size.\n"                                      \
225         "\tyaml_template_file:\n"                                             \
226         "\t              YAML layout template file, can't be used with -c,\n" \
227         "\t              -i, -S, -p, -o, or -E arguments.\n"                  \
228         "\tlustre_src:   Lustre file/dir whose layout info is used to set\n"  \
229         "\t              another lustre file or directory, can't used with\n" \
230         "\t              -c, -i, -S, -p, -o, or -E arguments.\n"
231
232 #define MIRROR_CREATE_HELP                                                     \
233         "\tmirror_count: Number of mirrors to be created with the upcoming\n"  \
234         "\t              setstripe layout options\n"                           \
235         "\t              It defaults to 1 if not specified; if specified,\n"   \
236         "\t              it must follow the option without a space.\n"         \
237         "\t              The option can also be repeated multiple times to\n"  \
238         "\t              separate mirrors that have different layouts.\n"      \
239         "\tSETSTRIPE_OPTIONS: Mirror layout as with 'setstripe'\n"             \
240         "\t              It can be a plain layout or a composite layout.\n"    \
241         "\t              If not specified, the stripe options inherited\n"     \
242         "\t              from the previous component will be used.\n"          \
243         "\tflags:        set flags to the component of the current mirror.\n"  \
244         "\t              Only \"prefer\" flag is supported so far.\n"
245
246 #define MIRROR_EXTEND_HELP                                                     \
247         MIRROR_CREATE_HELP                                                     \
248         "\tvictim_file:  The layout of victim_file will be split and used\n"   \
249         "\t              as a mirror added to the mirrored file.\n"            \
250         "\tno-verify:    This option indicates not to verify the mirror(s)\n"  \
251         "\t              from victim file(s) in case the victim file(s)\n"     \
252         "\t              contains the same data as the original mirrored\n"    \
253         "\t              file.\n"
254
255 #define MIRROR_EXTEND_USAGE                                                    \
256         "                 {--mirror-count|-N[mirror_count]}\n"                 \
257         "                 [SETSTRIPE_OPTIONS|-f|--file <victim_file>]\n"       \
258         "                 [--no-verify]\n"
259
260 #define SETSTRIPE_USAGE                                                 \
261         SSM_CMD_COMMON("setstripe")                                     \
262         MIRROR_EXTEND_USAGE                                             \
263         "                 <directory|filename>\n"                       \
264         SSM_HELP_COMMON                                                 \
265         MIRROR_EXTEND_HELP
266
267 #define MIGRATE_USAGE                                                   \
268         SSM_CMD_COMMON("migrate  ")                                     \
269         "                 [--block|-b] [--non-block|-n]\n"              \
270         "                 [--non-direct|-D] [--verbose|-v]\n"           \
271         "                 <filename>\n"                                 \
272         SSM_HELP_COMMON                                                 \
273         "\n"                                                            \
274         "\tblock:        Block file access during data migration (default)\n" \
275         "\tnon-block:    Abort migrations if concurrent access is detected\n" \
276         "\tnon-direct:   Do not use direct I/O to copy file contents\n" \
277         "\tverbose:      Print each filename as it is migrated\n"       \
278
279 #define SETDIRSTRIPE_USAGE                                              \
280         "               [--mdt-count|-c stripe_count>\n"                \
281         "               [--mdt-hash|-H mdt_hash]\n"                     \
282         "               [--mdt-index|-i mdt_index[,mdt_index,...]\n"    \
283         "               [--default|-D] [--mode|-o mode] <dir>\n"        \
284         "\tstripe_count: stripe count of the striped directory\n"       \
285         "\tmdt_index: MDT index of first stripe\n"                      \
286         "\tmdt_hash:  hash type of the striped directory. mdt types:\n" \
287         "       crush     CRUSH hash algorithm (default)\n" \
288         "       fnv_1a_64 FNV-1a hash algorithm\n"              \
289         "       all_char  sum of characters % MDT_COUNT (not recommended)\n" \
290         "\tdefault_stripe: set default dirstripe of the directory\n"    \
291         "\tmode: the file access permission of the directory (octal)\n" \
292         "To create dir with a foreign (free format) layout :\n" \
293         "setdirstripe|mkdir --foreign[=<foreign_type>] -x|-xattr <string> " \
294                 "[--mode|-o mode] [--flags <hex>] <dir>\n" \
295         "\tmode: the mode of the directory\n" \
296         "\tforeign_type: none or daos\n"
297
298 /**
299  * command_t mirror_cmdlist - lfs mirror commands.
300  */
301 command_t mirror_cmdlist[] = {
302         { .pc_name = "create", .pc_func = lfs_mirror_create,
303           .pc_help = "Create a mirrored file.\n"
304                 "usage: lfs mirror create "
305                 "<--mirror-count|-N[mirror_count]> "
306                 "[SETSTRIPE_OPTIONS] ... <filename|directory> ...\n"
307           MIRROR_CREATE_HELP },
308         { .pc_name = "delete", .pc_func = lfs_mirror_delete,
309           .pc_help = "Delete a mirror from a file.\n"
310         "usage: lfs mirror delete {--mirror-id <mirror_id> |\n"
311         "\t               --component-id|--comp-id|-I <comp_id> |\n"
312         "\t               -p <pool>} <mirrored_file> ...\n"
313         },
314         { .pc_name = "extend", .pc_func = lfs_mirror_extend,
315           .pc_help = "Extend a mirrored file.\n"
316                 "usage: lfs mirror extend "
317                 "<--mirror-count|-N[mirror_count]> [--no-verify] "
318                 "[SETSTRIPE_OPTIONS|-f <victim_file>] ... <filename> ...\n"
319           MIRROR_EXTEND_HELP },
320         { .pc_name = "split", .pc_func = lfs_mirror_split,
321           .pc_help = "Split a mirrored file.\n"
322         "usage: lfs mirror split <--mirror-id <mirror_id> |\n"
323         "\t             --component-id|-I <comp_id>|-p <pool>> [--destroy|-d]\n"
324         "\t             [-f <new_file>] <mirrored_file> ...\n"
325         "\tmirror_id:   The numerical unique identifier for a mirror. It\n"
326         "\t             can be fetched by lfs getstripe command.\n"
327         "\tcomp_id:     Unique component ID within a mirror.\n"
328         "\tpool:        Components on specified pool.\n"
329         "\tnew_file:    This option indicates the layout of the split\n"
330         "\t             mirror will be stored into. If not specified,\n"
331         "\t             a new file named <mirrored_file>.mirror~<mirror_id>\n"
332         "\t             will be used.\n" },
333         { .pc_name = "read", .pc_func = lfs_mirror_read,
334           .pc_help = "Read the content of a specified mirror of a file.\n"
335                 "usage: lfs mirror read <--mirror-id|-N <mirror_id> "
336                 "[--outfile|-o <output_file>] <mirrored_file>\n" },
337         { .pc_name = "write", .pc_func = lfs_mirror_write,
338           .pc_help = "Write to a specified mirror of a file.\n"
339                 "usage: lfs mirror write <--mirror-id|-N <mirror_id> "
340                 "[--inputfile|-i <input_file>] <mirrored_file>\n" },
341         { .pc_name = "copy", .pc_func = lfs_mirror_copy,
342           .pc_help = "Copy a specified mirror to other mirror(s) of a file.\n"
343                 "usage: lfs mirror copy <--read-mirror|-i <id0>> "
344                 "<--write-mirror|-o <id1,id2>> <mirrored_file>\n" },
345         { .pc_name = "resync", .pc_func = lfs_mirror_resync,
346           .pc_help = "Resynchronizes out-of-sync mirrored file(s).\n"
347                 "usage: lfs mirror resync [--only <mirror_id[,...]>] "
348                 "<mirrored file> [<mirrored file2>...]\n"},
349         { .pc_name = "verify", .pc_func = lfs_mirror_verify,
350           .pc_help = "Verify mirrored file(s).\n"
351                 "usage: lfs mirror verify "
352                 "[--only <mirror_id,mirror_id2[,...]>] "
353                 "[--verbose|-v] <mirrored_file> [<mirrored_file2> ...]\n"},
354         { .pc_name = "list-commands", .pc_func = lfs_mirror_list_commands,
355           .pc_help = "list commands supported by lfs mirror"},
356         { .pc_name = "help", .pc_func = Parser_help, .pc_help = "help" },
357         { .pc_name = "exit", .pc_func = Parser_quit, .pc_help = "quit" },
358         { .pc_name = "quit", .pc_func = Parser_quit, .pc_help = "quit" },
359         { .pc_help = NULL }
360 };
361
362 /**
363  * command_t pcc_cmdlist - lfs pcc commands.
364  */
365 command_t pcc_cmdlist[] = {
366         { .pc_name = "attach", .pc_func = lfs_pcc_attach,
367           .pc_help = "Attach given files to the Persistent Client Cache.\n"
368                 "usage: lfs pcc attach <--id|-i NUM> <file> ...\n"
369                 "\t-i: archive id for RW-PCC\n" },
370         { .pc_name = "attach_fid", .pc_func = lfs_pcc_attach_fid,
371           .pc_help = "Attach given files into PCC by FID(s).\n"
372                 "usage: lfs pcc attach_id <--id|-i NUM> <--mnt|-m mnt> "
373                 "<fid> ...\n"
374                 "\t-i: archive id for RW-PCC\n"
375                 "\t-m: Lustre mount point\n" },
376         { .pc_name = "state", .pc_func = lfs_pcc_state,
377           .pc_help = "Display the PCC state for given files.\n"
378                 "usage: lfs pcc state <file> ...\n" },
379         { .pc_name = "detach", .pc_func = lfs_pcc_detach,
380           .pc_help = "Detach given files from the Persistent Client Cache.\n"
381                 "usage: lfs pcc detach <file> ...\n" },
382         { .pc_name = "detach_fid", .pc_func = lfs_pcc_detach_fid,
383           .pc_help = "Detach given files from PCC by FID(s).\n"
384                 "usage: lfs pcc detach_fid <mntpath> <fid>...\n" },
385         { .pc_name = "list-commands", .pc_func = lfs_pcc_list_commands,
386           .pc_help = "list commands supported by lfs pcc"},
387         { .pc_name = "help", .pc_func = Parser_help, .pc_help = "help" },
388         { .pc_name = "exit", .pc_func = Parser_quit, .pc_help = "quit" },
389         { .pc_name = "quit", .pc_func = Parser_quit, .pc_help = "quit" },
390         { .pc_help = NULL }
391 };
392
393 /* all available commands */
394 command_t cmdlist[] = {
395         {"setstripe", lfs_setstripe, 0,
396          "To create a file with specified striping/composite layout, or\n"
397          "create/replace the default layout on an existing directory:\n"
398          SSM_CMD_COMMON("setstripe")
399          "                 [--mode <mode>]\n"
400          "                 <directory|filename>\n"
401          " or\n"
402          "To add component(s) to an existing composite file:\n"
403          SSM_CMD_COMMON("setstripe --component-add")
404          SSM_HELP_COMMON
405          "To totally delete the default striping from an existing directory:\n"
406          "usage: setstripe [--delete|-d] <directory>\n"
407          " or\n"
408          "To create a mirrored file or set s default mirror layout on a directory:\n"
409          "usage: setstripe {--mirror-count|-N}[mirror_count] [SETSTRIPE_OPTIONS] <directory|filename>\n"
410          " or\n"
411          "To delete the last component(s) from an existing composite file\n"
412          "(note that this will also delete any data in those components):\n"
413          "usage: setstripe --component-del [--component-id|-I <comp_id>]\n"
414          "                               [--component-flags|-F <comp_flags>]\n"
415          "                               <filename>\n"
416          "\tcomp_id:     Unique component ID to delete\n"
417          "\tcomp_flags:  'init' indicating all instantiated components\n"
418          "\t             '^init' indicating all uninstantiated components\n"
419          "\t-I and -F cannot be specified at the same time\n"
420          "To create a file with a foreign (free format) layout:\n"
421          "usage: setstripe --foreign[=<foreign_type>]\n"
422          "                 --xattr|-x <layout_string> [--flags <hex>]\n"
423          "                 [--mode <mode>] <filename>\n"},
424         {"getstripe", lfs_getstripe, 0,
425          "To list the layout pattern for a given file or files in a\n"
426          "directory or recursively for all files in a directory tree.\n"
427          "usage: getstripe [--ost|-O <uuid>] [--quiet|-q] [--verbose|-v]\n"
428          "                 [--stripe-count|-c] [--stripe-index|-i] [--fid|-F]\n"
429          "                 [--pool|-p] [--stripe-size|-S] [--directory|-d]\n"
430          "                 [--mdt-index|-m] [--recursive|-r] [--raw|-R]\n"
431          "                 [--layout|-L] [--generation|-g] [--yaml|-y]\n"
432          "                 [--component-id[=comp_id]|-I[comp_id]]\n"
433          "                 [--component-flags[=comp_flags]]\n"
434          "                 [--component-count]\n"
435          "                 [--extension-size|--ext-size|-z]\n"
436          "                 [--component-start[=[+-]comp_start]]\n"
437          "                 [--component-end[=[+-]comp_end]|-E[[+-]comp_end]]\n"
438          "                 [[!] --mirror-index=[+-]<index> |\n"
439          "                  [!] --mirror-id=[+-]<id>]\n"
440          "                 <directory|filename> ..."},
441         {"setdirstripe", lfs_setdirstripe, 0,
442          "Create striped directory on specified MDT, same as mkdir.\n"
443          "May be restricted to root or group users, depending on settings.\n"
444          "usage: setdirstripe [OPTION] <directory>\n"
445          SETDIRSTRIPE_USAGE},
446         {"getdirstripe", lfs_getdirstripe, 0,
447          "To list the layout pattern info for a given directory\n"
448          "or recursively for all directories in a directory tree.\n"
449          "usage: getdirstripe [--mdt-count|-c] [--mdt-index|-m|-i]\n"
450          "                    [--mdt-hash|-H] [--obd|-O <uuid>]\n"
451          "                    [--recursive|-r] [--yaml|-y]\n"
452          "                    [--verbose|-v] [--default|-D] <dir> ..."},
453         {"mkdir", lfs_setdirstripe, 0,
454          "Create striped directory on specified MDT, same as setdirstripe.\n"
455          "usage: mkdir [OPTION] <directory>\n"
456          SETDIRSTRIPE_USAGE},
457         {"rm_entry", lfs_rmentry, 0,
458          "To remove the name entry of the remote directory. Note: This\n"
459          "command will only delete the name entry, i.e. the remote directory\n"
460          "will become inaccessable after this command. This can only be done\n"
461          "by the administrator\n"
462          "usage: rm_entry <dir>\n"},
463         {"pool_list", lfs_poollist, 0,
464          "List pools or pool OSTs\n"
465          "usage: pool_list <fsname>[.<pool>] | <pathname>\n"},
466         {"find", lfs_find, 0,
467          "find files matching given attributes recursively in directory tree.\n"
468          "usage: find <directory|filename> ...\n"
469          "     [[!] --atime|-A [+-]N[smhdwy]] [[!] --ctime|-C [+-]N[smhdwy]]\n"
470          "     [[!] --mtime|-M [+-]N[smhdwy]]\n"
471          "     [[!] --btime|--Btime|-B [+-]N[smhdwy]]\n"
472          "     [[!] --newer[XY] <reference>] [[!] --blocks|-b N]\n"
473          "     [--maxdepth|-D N] [[!] --mdt-index|--mdt|-m <uuid|index,...>]\n"
474          "     [[!] --name|-n <pattern>] [[!] --ost|-O <uuid|index,...>]\n"
475          "     [--print|-P] [--print0|-0] [[!] --size|-s [+-]N[bkMGTPE]]\n"
476          "     [[!] --stripe-count|-c [+-]<stripes>]\n"
477          "     [[!] --stripe-index|-i <index,...>]\n"
478          "     [[!] --stripe-size|-S [+-]N[kMGT]] [[!] --type|-t <filetype>]\n"
479          "     [[!] --extension-size|--ext-size|-z [+-]N[kMGT]]\n"
480          "     [[!] --gid|-g|--group|-G <gid>|<gname>]\n"
481          "     [[!] --uid|-u|--user|-U <uid>|<uname>] [[!] --pool <pool>]\n"
482          "     [[!] --projid <projid>]\n"
483          "     [[!] --foreign[=<foreign_type>]]\n"
484          "     [[!] --layout|-L released,raid0,mdt]\n"
485          "     [[!] --foreign[=<foreign_type>]]\n"
486          "     [[!] --component-count [+-]<comp_cnt>]\n"
487          "     [[!] --component-start [+-]N[kMGTPE]]\n"
488          "     [[!] --component-end|-E [+-]N[kMGTPE]]\n"
489          "     [[!] --component-flags {init,stale,prefer,offline,nosync,extension}]\n"
490          "     [[!] --mirror-count|-N [+-]<n>]\n"
491          "     [[!] --mirror-state <[^]state>]\n"
492          "     [[!] --mdt-count|-T [+-]<stripes>]\n"
493          "     [[!] --mdt-hash|-H <hashtype>\n"
494          "     [[!] --mdt-index|-m <uuid|index,...>]\n"
495          "\t !: used before an option indicates 'NOT' requested attribute\n"
496          "\t -: used before a value indicates less than requested value\n"
497          "\t +: used before a value indicates more than requested value\n"
498          "\thashtype:   hash type of the striped directory.\n"
499          "\t            fnv_1a_64 FNV-1a hash algorithm\n"
500          "\t            all_char  sum of characters % MDT_COUNT\n"},
501         {"check", lfs_check, 0,
502          "Display the status of MGTs, MDTs or OSTs (as specified in the command)\n"
503          "or all the servers (MGTs, MDTs and OSTs).\n"
504          "usage: check <mgts|osts|mdts|all>"},
505         {"osts", lfs_osts, 0, "list OSTs connected to client "
506          "[for specified path only]\n" "usage: osts [path]"},
507         {"mdts", lfs_mdts, 0, "list MDTs connected to client "
508          "[for specified path only]\n" "usage: mdts [path]"},
509         {"df", lfs_df, 0,
510          "report filesystem disk space usage or inodes usage "
511          "of each MDS and all OSDs or a batch belonging to a specific pool.\n"
512          "Usage: df [--inodes|-i] [--human-readable|-h] [--lazy|-l]\n"
513          "          [--pool|-p <fsname>[.<pool>]] [path]"},
514         {"getname", lfs_getname, 0,
515          "list instances and specified mount points [for specified path only]\n"
516          "Usage: getname [--help|-h] [--instance|-i] [--fsname|-n] [path ...]"},
517 #ifdef HAVE_SYS_QUOTA_H
518         {"setquota", lfs_setquota, 0, "Set filesystem quotas.\n"
519          "usage: setquota <-u|-g|-p> <uname>|<uid>|<gname>|<gid>|<projid>\n"
520          "                -b <block-softlimit> -B <block-hardlimit>\n"
521          "                -i <inode-softlimit> -I <inode-hardlimit> <filesystem>\n"
522          "       setquota <-u|--user|-g|--group|-p|--projid> <uname>|<uid>|<gname>|<gid>|<projid>\n"
523          "                [--block-softlimit <block-softlimit>]\n"
524          "                [--block-hardlimit <block-hardlimit>]\n"
525          "                [--inode-softlimit <inode-softlimit>]\n"
526          "                [--inode-hardlimit <inode-hardlimit>] <filesystem>\n"
527          "       setquota [-t] <-u|--user|-g|--group|-p|--projid>\n"
528          "                [--block-grace 'notify'|<block-grace>]\n"
529          "                [--inode-grace 'notify'|<inode-grace>] <filesystem>\n"
530          "       setquota <-U|-G|-P>\n"
531          "                -b <block-softlimit> -B <block-hardlimit>\n"
532          "                -i <inode-softlimit> -I <inode-hardlimit> <filesystem>\n"
533          "       setquota <-U|--default-usr|-G|--default-grp|-P|--default-prj>\n"
534          "                [--block-softlimit <block-softlimit>]\n"
535          "                [--block-hardlimit <block-hardlimit>]\n"
536          "                [--inode-softlimit <inode-softlimit>]\n"
537          "                [--inode-hardlimit <inode-hardlimit>] <filesystem>\n"
538          "       setquota <-u|-g|-p> <uname>|<uid>|<gname>|<gid>|<projid>\n"
539          "                <-d|--default>\n"
540          "       -b can be used instead of --block-softlimit/--block-grace\n"
541          "       -B can be used instead of --block-hardlimit\n"
542          "       -i can be used instead of --inode-softlimit/--inode-grace\n"
543          "       -I can be used instead of --inode-hardlimit\n"
544          "       -d can be used instead of --default\n\n"
545          "Note: The total quota space will be split into many qunits and\n"
546          "      balanced over all server targets, the minimal qunit size is\n"
547          "      1M bytes for block space and 1K inodes for inode space.\n\n"
548          "      The maximum quota grace time is 2^48 - 1 seconds.\n\n"
549          "      Quota space rebalancing process will stop when this mininum\n"
550          "      value is reached. As a result, quota exceeded can be returned\n"
551          "      while many targets still have 1MB or 1K inodes of spare\n"
552          "      quota space.\n\n"
553          "      When setting the grace time, 'notify' can be used as grace to\n"
554          "      be notified after the quota is over soft limit but prevents\n"
555          "      the soft limit from becoming the hard limit."},
556         {"quota", lfs_quota, 0, "Display disk usage and limits.\n"
557          "usage: quota [-q] [-v] [-h] [-o <obd_uuid>|-i <mdt_idx>|-I "
558                        "<ost_idx>]\n"
559          "             [<-u|-g|-p> <uname>|<uid>|<gname>|<gid>|<projid>] <filesystem>\n"
560          "       quota [-o <obd_uuid>|-i <mdt_idx>|-I <ost_idx>] -t <-u|-g|-p> <filesystem>\n"
561         "        quota [-q] [-v] [h] <-U|-G|-P> <filesystem>"},
562         {"project", lfs_project, 0,
563          "Change or list project attribute for specified file or directory.\n"
564          "usage: project [-d|-r] <file|directory...>\n"
565          "         list project ID and flags on file(s) or directories\n"
566          "       project [-p id] [-s] [-r] <file|directory...>\n"
567          "         set project ID and/or inherit flag for specified file(s) or directories\n"
568          "       project -c [-d|-r [-p id] [-0]] <file|directory...>\n"
569          "         check project ID and flags on file(s) or directories, print outliers\n"
570          "       project -C [-r] [-k] <file|directory...>\n"
571          "         clear the project inherit flag and ID on the file or directory\n"
572         },
573 #endif
574         {"flushctx", lfs_flushctx, 0, "Flush security context for current user.\n"
575          "usage: flushctx [-k] [mountpoint...]"},
576         {"changelog", lfs_changelog, 0,
577          "Show the metadata changes on an MDT."
578          "\nusage: changelog <mdtname> [startrec [endrec]]"},
579         {"changelog_clear", lfs_changelog_clear, 0,
580          "Indicate that old changelog records up to <endrec> are no longer of "
581          "interest to consumer <id>, allowing the system to free up space.\n"
582          "An <endrec> of 0 means all records.\n"
583          "usage: changelog_clear <mdtname> <id> <endrec>"},
584         {"fid2path", lfs_fid2path, 0,
585          "Resolve the full path(s) for given FID(s). For a specific hardlink "
586          "specify link number <linkno>.\n"
587          "usage: fid2path [-c] [--link|-l <linkno>] <fsname|root> <fid> ..."},
588         {"path2fid", lfs_path2fid, 0, "Display the fid(s) for a given path(s).\n"
589          "usage: path2fid [--parents] <path> ..."},
590         {"rmfid", lfs_rmfid, 0, "Remove file(s) by FID(s)\n"
591          "usage: rmfid <fsname|rootpath> <fid> ..."},
592         {"data_version", lfs_data_version, 0, "Display file data version for "
593          "a given path.\n" "usage: data_version [-n|-r|-w] <path>"},
594         {"hsm_state", lfs_hsm_state, 0, "Display the HSM information (states, "
595          "undergoing actions) for given files.\n usage: hsm_state <file> ..."},
596         {"hsm_set", lfs_hsm_set, 0, "Set HSM user flag on specified files.\n"
597          "usage: hsm_set [--norelease] [--noarchive] [--dirty] [--exists] "
598          "[--archived] [--lost] [--archive-id NUM] <file> ..."},
599         {"hsm_clear", lfs_hsm_clear, 0, "Clear HSM user flag on specified "
600          "files.\n"
601          "usage: hsm_clear [--norelease] [--noarchive] [--dirty] [--exists] "
602          "[--archived] [--lost] <file> ..."},
603         {"hsm_action", lfs_hsm_action, 0, "Display current HSM request for "
604          "given files.\n" "usage: hsm_action <file> ..."},
605         {"hsm_archive", lfs_hsm_archive, 0,
606          "Archive file to external storage.\n"
607          "usage: hsm_archive [--filelist FILELIST] [--data DATA] [--archive NUM] "
608          "<file> ..."},
609         {"hsm_restore", lfs_hsm_restore, 0,
610          "Restore file from external storage.\n"
611          "usage: hsm_restore [--filelist FILELIST] [--data DATA] <file> ..."},
612         {"hsm_release", lfs_hsm_release, 0,
613          "Release files from Lustre.\n"
614          "usage: hsm_release [--filelist FILELIST] [--data DATA] <file> ..."},
615         {"hsm_remove", lfs_hsm_remove, 0,
616          "Remove file copy from external storage.\n"
617          "usage: hsm_remove [--filelist FILELIST] [--data DATA] "
618          "[--archive NUM]\n"
619          "                  (FILE [FILE ...] | "
620          "--mntpath MOUNTPATH FID [FID ...])\n"
621          "\n"
622          "Note: To remove an archived copy of a file already deleted from a "
623          "Lustre FS, the\n"
624          "--mntpath option and a list of FIDs must be specified"
625         },
626         {"hsm_cancel", lfs_hsm_cancel, 0,
627          "Cancel requests related to specified files.\n"
628          "usage: hsm_cancel [--filelist FILELIST] [--data DATA] <file> ..."},
629         {"swap_layouts", lfs_swap_layouts, 0, "Swap layouts between 2 files.\n"
630          "usage: swap_layouts <path1> <path2>"},
631         {"migrate", lfs_setstripe_migrate, 0,
632          "migrate a directory between MDTs.\n"
633          "usage: migrate [--mdt-count|-c] <stripe_count>\n"
634          "               [--mdt-hash|-H] <hash_type>\n"
635          "               [--mdt-index|-m] <start_mdt_index>\n"
636          "               [--verbose|-v]\n"
637          "               <directory>\n"
638          "\tmdt:        MDTs to stripe over, if only one MDT is specified\n"
639          "                      it's the MDT index of first stripe\n"
640          "\tmdt_count:  number of MDTs to stripe a directory over\n"
641          "\tmdt_hash:   hash type of the striped directory. mdt types:\n"
642          "              all_char  (type 1)sum of characters % MDT_COUNT\n"
643          "              fnv_1a_64 (type 2)FNV-1a hash algorithm (default)\n"
644          "              crush     (type 3)CRUSH hash algorithm\n"
645          "\n"
646          "migrate file objects from one OST "
647          "layout\nto another (may be not safe with concurent writes).\n"
648          "usage: migrate  "
649          "[--stripe-count|-c] <stripe_count>\n"
650          "[--overstripe-count|-C] <stripe_count>\n"
651          "              [--stripe-index|-i] <start_ost_index>\n"
652          "              [--stripe-size|-S] <stripe_size>\n"
653          "              [--pool|-p] <pool_name>\n"
654          "              [--ost|-o] <ost_indices>\n"
655          "              [--block|-b]\n"
656          "              [--non-block|-n]\n"
657          "              [--non-direct|-D]\n"
658          "              <file|directory>\n"
659          "\tstripe_count:     number of OSTs to stripe a file over\n"
660          "\t              Using -C instead of -c allows overstriping, which\n"
661          "\t              will place more than one stripe per OST if\n"
662          "\t              stripe_count is greater than the number of OSTs\n"
663          "\tstripe_ost_index: index of the first OST to stripe a file over\n"
664          "\tstripe_size:      number of bytes to store before moving to the next OST\n"
665          "\tpool_name:        name of the predefined pool of OSTs\n"
666          "\tost_indices:      OSTs to stripe over, in order\n"
667          "\tblock:        Block file access during data migration (default)\n"
668          "\tnon-block:    Abort migrations if concurrent access is detected\n"
669          "\tnon-direct:       do not use direct I/O to copy file contents.\n"},
670         {"mv", lfs_mv, 0,
671          "To move directories between MDTs. This command is deprecated, "
672          "use \"migrate\" instead.\n"
673          "usage: mv <directory|filename> [--mdt-index|-m] <mdt_index> "
674          "[--verbose|-v]\n"},
675         {"ladvise", lfs_ladvise, 0,
676          "Provide servers with advice about access patterns for a file.\n"
677          "usage: ladvise [--advice|-a ADVICE] [--start|-s START[kMGT]]\n"
678          "               [--background|-b] [--unset|-u]\n\n"
679          "               {[--end|-e END[kMGT]] | [--length|-l LENGTH[kMGT]]}\n"
680          "               {[--mode|-m [READ,WRITE]}\n"
681          "               <file> ...\n"},
682         {"mirror", lfs_mirror, mirror_cmdlist,
683          "lfs commands used to manage files with mirrored components:\n"
684          "lfs mirror create - create a mirrored file or directory\n"
685          "lfs mirror extend - add mirror(s) to an existing file\n"
686          "lfs mirror split  - split a mirror from an existing mirrored file\n"
687          "lfs mirror resync - resynchronize out-of-sync mirrored file(s)\n"
688          "lfs mirror read   - read a mirror content of a mirrored file\n"
689          "lfs mirror write  - write to a mirror of a mirrored file\n"
690          "lfs mirror copy   - copy a mirror to other mirror(s) of a file\n"
691          "lfs mirror verify - verify mirrored file(s)\n"},
692         {"getsom", lfs_getsom, 0, "To list the SOM info for a given file.\n"
693          "usage: getsom [-s] [-b] [-f] <path>\n"
694          "\t-s: Only show the size value of the SOM data for a given file\n"
695          "\t-b: Only show the blocks value of the SOM data for a given file\n"
696          "\t-f: Only show the flags value of the SOM data for a given file\n"},
697         {"heat_get", lfs_heat_get, 0,
698          "To get heat of files.\n"
699          "usage: heat_get <file> ...\n"},
700         {"heat_set", lfs_heat_set, 0,
701          "To set heat flags of files.\n"
702          "usage: heat_set [--clear|-c] [--off|-o] [--on|-O] <file> ...\n"
703          "\t--clear|-c: Clear file heat for given files\n"
704          "\t--off|-o:   Turn off file heat for given files\n"
705          "\t--on|-O:    Turn on file heat for given files\n"},
706         {"pcc", lfs_pcc, pcc_cmdlist,
707          "lfs commands used to interact with PCC features:\n"
708          "lfs pcc attach - attach given files to Persistent Client Cache\n"
709          "lfs pcc attach_fid - attach given files into PCC by FID(s)\n"
710          "lfs pcc state  - display the PCC state for given files\n"
711          "lfs pcc detach - detach given files from Persistent Client Cache\n"
712          "lfs pcc detach_fid - detach given files from PCC by FID(s)\n"},
713         {"help", Parser_help, 0, "help"},
714         {"exit", Parser_quit, 0, "quit"},
715         {"quit", Parser_quit, 0, "quit"},
716         {"--version", Parser_version, 0,
717          "output build version of the utility and exit"},
718         {"--list-commands", lfs_list_commands, 0,
719          "list commands supported by the utility and exit"},
720         { 0, 0, 0, NULL }
721 };
722
723 static int check_hashtype(const char *hashtype)
724 {
725         int type_num = atoi(hashtype);
726         int i;
727
728         /* numeric hash type */
729         if (hashtype && strlen(hashtype) == 1 &&
730             (type_num > 0 && type_num < LMV_HASH_TYPE_MAX))
731                 return type_num;
732         /* string hash type */
733         for (i = LMV_HASH_TYPE_ALL_CHARS; i < LMV_HASH_TYPE_MAX; i++)
734                 if (strcmp(hashtype, mdt_hash_name[i]) == 0)
735                         return i;
736
737         return 0;
738 }
739
740 static uint32_t check_foreign_type_name(const char *foreign_type_name)
741 {
742         uint32_t i;
743
744         for (i = 0; i < LU_FOREIGN_TYPE_UNKNOWN; i++) {
745                 if (!lu_foreign_types[i].lft_name)
746                         break;
747                 if (strcmp(foreign_type_name,
748                            lu_foreign_types[i].lft_name) == 0)
749                         return lu_foreign_types[i].lft_type;
750         }
751
752         return LU_FOREIGN_TYPE_UNKNOWN;
753 }
754
755 static const char *error_loc = "syserror";
756
757 enum {
758         MIGRATION_NONBLOCK      = 0x0001,
759         MIGRATION_MIRROR        = 0x0002,
760         MIGRATION_NONDIRECT     = 0x0004,
761         MIGRATION_VERBOSE       = 0x0008,
762 };
763
764 static int lfs_component_create(char *fname, int open_flags, mode_t open_mode,
765                                 struct llapi_layout *layout);
766
767 static int
768 migrate_open_files(const char *name, __u64 migration_flags,
769                    const struct llapi_stripe_param *param,
770                    struct llapi_layout *layout, int *fd_src, int *fd_tgt)
771 {
772         int                      fd = -1;
773         int                      fdv = -1;
774         int                      rflags;
775         int                      mdt_index;
776         int                      random_value;
777         char                     parent[PATH_MAX];
778         char                     volatile_file[PATH_MAX];
779         char                    *ptr;
780         int                      rc;
781         struct stat              st;
782         struct stat              stv;
783
784         if (!param && !layout) {
785                 error_loc = "layout information";
786                 return -EINVAL;
787         }
788
789         /* search for file directory pathname */
790         if (strlen(name) > sizeof(parent) - 1) {
791                 error_loc = "source file name";
792                 return -ERANGE;
793         }
794
795         strncpy(parent, name, sizeof(parent));
796         ptr = strrchr(parent, '/');
797         if (!ptr) {
798                 if (!getcwd(parent, sizeof(parent))) {
799                         error_loc = "getcwd";
800                         return -errno;
801                 }
802         } else {
803                 if (ptr == parent) /* leading '/' */
804                         ptr = parent + 1;
805                 *ptr = '\0';
806         }
807
808         /* open file, direct io */
809         /* even if the file is only read, WR mode is nedeed to allow
810          * layout swap on fd
811          */
812         rflags = O_RDWR;
813         if (!(migration_flags & MIGRATION_NONDIRECT))
814                 rflags |= O_DIRECT;
815         fd = open(name, rflags);
816         if (fd < 0) {
817                 rc = -errno;
818                 error_loc = "cannot open source file";
819                 return rc;
820         }
821
822         rc = llapi_file_fget_mdtidx(fd, &mdt_index);
823         if (rc < 0) {
824                 error_loc = "cannot get MDT index";
825                 goto out;
826         }
827
828         do {
829                 int open_flags = O_WRONLY | O_CREAT | O_EXCL | O_NOFOLLOW;
830                 mode_t open_mode = S_IRUSR | S_IWUSR;
831
832                 random_value = random();
833                 rc = snprintf(volatile_file, sizeof(volatile_file),
834                               "%s/%s:%.4X:%.4X", parent, LUSTRE_VOLATILE_HDR,
835                               mdt_index, random_value);
836                 if (rc >= sizeof(volatile_file)) {
837                         rc = -ENAMETOOLONG;
838                         break;
839                 }
840
841                 /* create, open a volatile file, use caching (ie no directio) */
842                 if (layout)
843                         fdv = lfs_component_create(volatile_file, open_flags,
844                                                    open_mode, layout);
845                 else
846                         fdv = llapi_file_open_param(volatile_file, open_flags,
847                                                     open_mode, param);
848         } while (fdv < 0 && (rc = fdv) == -EEXIST);
849
850         if (rc < 0) {
851                 error_loc = "cannot create volatile file";
852                 goto out;
853         }
854
855         /*
856          * In case the MDT does not support creation of volatile files
857          * we should try to unlink it.
858          */
859         (void)unlink(volatile_file);
860
861         /*
862          * Not-owner (root?) special case.
863          * Need to set owner/group of volatile file like original.
864          * This will allow to pass related check during layout_swap.
865          */
866         rc = fstat(fd, &st);
867         if (rc != 0) {
868                 rc = -errno;
869                 error_loc = "cannot stat source file";
870                 goto out;
871         }
872
873         rc = fstat(fdv, &stv);
874         if (rc != 0) {
875                 rc = -errno;
876                 error_loc = "cannot stat volatile";
877                 goto out;
878         }
879
880         if (st.st_uid != stv.st_uid || st.st_gid != stv.st_gid) {
881                 rc = fchown(fdv, st.st_uid, st.st_gid);
882                 if (rc != 0) {
883                         rc = -errno;
884                         error_loc = "cannot change ownwership of volatile";
885                         goto out;
886                 }
887         }
888
889 out:
890         if (rc < 0) {
891                 if (fd > 0)
892                         close(fd);
893                 if (fdv > 0)
894                         close(fdv);
895         } else {
896                 *fd_src = fd;
897                 *fd_tgt = fdv;
898                 error_loc = NULL;
899         }
900         return rc;
901 }
902
903 static int migrate_copy_data(int fd_src, int fd_dst, int (*check_file)(int))
904 {
905         struct llapi_layout *layout;
906         size_t   buf_size = 4 * 1024 * 1024;
907         void    *buf = NULL;
908         ssize_t  rsize = -1;
909         ssize_t  wsize = 0;
910         size_t   rpos = 0;
911         size_t   wpos = 0;
912         off_t    bufoff = 0;
913         int      rc;
914
915         layout = llapi_layout_get_by_fd(fd_src, 0);
916         if (layout) {
917                 uint64_t stripe_size;
918
919                 rc = llapi_layout_stripe_size_get(layout, &stripe_size);
920                 if (rc == 0)
921                         buf_size = stripe_size;
922
923                 llapi_layout_free(layout);
924         }
925
926         /* Use a page-aligned buffer for direct I/O */
927         rc = posix_memalign(&buf, getpagesize(), buf_size);
928         if (rc != 0)
929                 return -rc;
930
931         while (1) {
932                 /*
933                  * read new data only if we have written all
934                  * previously read data
935                  */
936                 if (wpos == rpos) {
937                         if (check_file) {
938                                 rc = check_file(fd_src);
939                                 if (rc < 0)
940                                         break;
941                         }
942
943                         rsize = read(fd_src, buf, buf_size);
944                         if (rsize < 0) {
945                                 rc = -errno;
946                                 break;
947                         }
948                         rpos += rsize;
949                         bufoff = 0;
950                 }
951                 /* eof ? */
952                 if (rsize == 0)
953                         break;
954
955                 wsize = write(fd_dst, buf + bufoff, rpos - wpos);
956                 if (wsize < 0) {
957                         rc = -errno;
958                         break;
959                 }
960                 wpos += wsize;
961                 bufoff += wsize;
962         }
963
964         if (rc == 0) {
965                 rc = fsync(fd_dst);
966                 if (rc < 0)
967                         rc = -errno;
968         }
969
970         free(buf);
971         return rc;
972 }
973
974 static int migrate_copy_timestamps(int fd, int fdv)
975 {
976         struct stat st;
977
978         if (fstat(fd, &st) == 0) {
979                 struct timeval tv[2] = {
980                         {.tv_sec = st.st_atime},
981                         {.tv_sec = st.st_mtime}
982                 };
983
984                 return futimes(fdv, tv);
985         }
986
987         return -errno;
988 }
989
990 static int migrate_block(int fd, int fdv)
991 {
992         __u64   dv1;
993         int     gid;
994         int     rc;
995         int     rc2;
996
997         rc = llapi_get_data_version(fd, &dv1, LL_DV_RD_FLUSH);
998         if (rc < 0) {
999                 error_loc = "cannot get dataversion";
1000                 return rc;
1001         }
1002
1003         do
1004                 gid = random();
1005         while (gid == 0);
1006
1007         /*
1008          * The grouplock blocks all concurrent accesses to the file.
1009          * It has to be taken after llapi_get_data_version as it would
1010          * block it too.
1011          */
1012         rc = llapi_group_lock(fd, gid);
1013         if (rc < 0) {
1014                 error_loc = "cannot get group lock";
1015                 return rc;
1016         }
1017
1018         rc = migrate_copy_data(fd, fdv, NULL);
1019         if (rc < 0) {
1020                 error_loc = "data copy failed";
1021                 goto out_unlock;
1022         }
1023
1024         /* Make sure we keep original atime/mtime values */
1025         rc = migrate_copy_timestamps(fd, fdv);
1026         if (rc < 0) {
1027                 error_loc = "timestamp copy failed";
1028                 goto out_unlock;
1029         }
1030
1031         /*
1032          * swap layouts
1033          * for a migration we need to check data version on file did
1034          * not change.
1035          *
1036          * Pass in gid=0 since we already own grouplock.
1037          */
1038         rc = llapi_fswap_layouts_grouplock(fd, fdv, dv1, 0, 0,
1039                                            SWAP_LAYOUTS_CHECK_DV1);
1040         if (rc == -EAGAIN) {
1041                 error_loc = "file changed";
1042                 goto out_unlock;
1043         } else if (rc < 0) {
1044                 error_loc = "cannot swap layout";
1045                 goto out_unlock;
1046         }
1047
1048 out_unlock:
1049         rc2 = llapi_group_unlock(fd, gid);
1050         if (rc2 < 0 && rc == 0) {
1051                 error_loc = "unlock group lock";
1052                 rc = rc2;
1053         }
1054
1055         return rc;
1056 }
1057
1058 /**
1059  * Internal helper for migrate_copy_data(). Check lease and report error if
1060  * need be.
1061  *
1062  * \param[in]  fd           File descriptor on which to check the lease.
1063  *
1064  * \retval 0       Migration can keep on going.
1065  * \retval -errno  Error occurred, abort migration.
1066  */
1067 static int check_lease(int fd)
1068 {
1069         int rc;
1070
1071         rc = llapi_lease_check(fd);
1072         if (rc > 0)
1073                 return 0; /* llapi_check_lease returns > 0 on success. */
1074
1075         return -EBUSY;
1076 }
1077
1078 static int migrate_nonblock(int fd, int fdv)
1079 {
1080         __u64   dv1;
1081         __u64   dv2;
1082         int     rc;
1083
1084         rc = llapi_get_data_version(fd, &dv1, LL_DV_RD_FLUSH);
1085         if (rc < 0) {
1086                 error_loc = "cannot get data version";
1087                 return rc;
1088         }
1089
1090         rc = migrate_copy_data(fd, fdv, check_lease);
1091         if (rc < 0) {
1092                 error_loc = "data copy failed";
1093                 return rc;
1094         }
1095
1096         rc = llapi_get_data_version(fd, &dv2, LL_DV_RD_FLUSH);
1097         if (rc != 0) {
1098                 error_loc = "cannot get data version";
1099                 return rc;
1100         }
1101
1102         if (dv1 != dv2) {
1103                 rc = -EAGAIN;
1104                 error_loc = "source file changed";
1105                 return rc;
1106         }
1107
1108         /* Make sure we keep original atime/mtime values */
1109         rc = migrate_copy_timestamps(fd, fdv);
1110         if (rc < 0) {
1111                 error_loc = "timestamp copy failed";
1112                 return rc;
1113         }
1114
1115         return 0;
1116 }
1117
1118 static int lfs_component_set(char *fname, int comp_id,
1119                              __u32 flags, __u32 neg_flags)
1120 {
1121         __u32 ids[2];
1122         __u32 flags_array[2];
1123         size_t count = 0;
1124         int rc;
1125
1126         if (flags) {
1127                 ids[count] = comp_id;
1128                 flags_array[count] = flags;
1129                 ++count;
1130         }
1131
1132         if (neg_flags) {
1133                 if (neg_flags & LCME_FL_STALE) {
1134                         fprintf(stderr,
1135                                 "%s: cannot clear 'stale' flags from component. Please use lfs-mirror-resync(1) instead\n",
1136                                 progname);
1137                         return -EINVAL;
1138                 }
1139
1140                 ids[count] = comp_id;
1141                 flags_array[count] = neg_flags | LCME_FL_NEG;
1142                 ++count;
1143         }
1144
1145         rc = llapi_layout_file_comp_set(fname, ids, flags_array, count);
1146         if (rc) {
1147                 if (errno == EUCLEAN) {
1148                         rc = -errno;
1149                         fprintf(stderr,
1150                                 "%s: cannot set 'stale' flag on component '%#x' of the last non-stale mirror of '%s'\n",
1151                                 progname, comp_id, fname);
1152                 } else {
1153                         fprintf(stderr,
1154                                 "%s: cannot change the flags of component '%#x' of file '%s': %x / ^(%x)\n",
1155                                 progname, comp_id, fname, flags, neg_flags);
1156                 }
1157         }
1158
1159         return rc;
1160 }
1161
1162 static int lfs_component_del(char *fname, __u32 comp_id,
1163                              __u32 flags, __u32 neg_flags)
1164 {
1165         int     rc = 0;
1166
1167         if (flags && neg_flags)
1168                 return -EINVAL;
1169
1170         if (!flags && neg_flags)
1171                 flags = neg_flags | LCME_FL_NEG;
1172
1173         if ((flags && comp_id) || (!flags && !comp_id))
1174                 return -EINVAL;
1175
1176         if (flags) {
1177                 if (flags & ~LCME_KNOWN_FLAGS) {
1178                         fprintf(stderr,
1179                                 "%s setstripe: unknown flags %#x\n",
1180                                 progname, flags);
1181                         return -EINVAL;
1182                 }
1183         } else if (comp_id > LCME_ID_MAX) {
1184                 fprintf(stderr, "%s setstripe: invalid component id %u\n",
1185                         progname, comp_id);
1186                 return -EINVAL;
1187         }
1188
1189         rc = llapi_layout_file_comp_del(fname, comp_id, flags);
1190         if (rc)
1191                 fprintf(stderr,
1192                         "%s setstripe: cannot delete component %#x from '%s': %s\n",
1193                         progname, comp_id, fname, strerror(errno));
1194         return rc;
1195 }
1196
1197 static int lfs_component_add(char *fname, struct llapi_layout *layout)
1198 {
1199         int     rc;
1200
1201         if (!layout)
1202                 return -EINVAL;
1203
1204         rc = llapi_layout_file_comp_add(fname, layout);
1205         if (rc)
1206                 fprintf(stderr, "Add layout component(s) to %s failed. %s\n",
1207                         fname, strerror(errno));
1208         return rc;
1209 }
1210
1211 static int lfs_component_create(char *fname, int open_flags, mode_t open_mode,
1212                                 struct llapi_layout *layout)
1213 {
1214         struct stat     st;
1215         int     fd;
1216
1217         if (!layout)
1218                 return -EINVAL;
1219
1220         fd = lstat(fname, &st);
1221         if (fd == 0 && S_ISDIR(st.st_mode))
1222                 open_flags = O_DIRECTORY | O_RDONLY;
1223
1224         fd = llapi_layout_file_open(fname, open_flags, open_mode, layout);
1225         if (fd < 0)
1226                 fprintf(stderr, "%s: cannot %s '%s': %s\n", progname,
1227                         S_ISDIR(st.st_mode) ?
1228                                 "set default composite layout for" :
1229                                 "create composite file",
1230                         fname, strerror(errno));
1231         return fd;
1232 }
1233
1234 static int lfs_migrate(char *name, __u64 migration_flags,
1235                        struct llapi_stripe_param *param,
1236                        struct llapi_layout *layout)
1237 {
1238         struct llapi_layout *existing;
1239         uint64_t dom_new, dom_cur;
1240         int fd = -1;
1241         int fdv = -1;
1242         int rc;
1243
1244         rc = migrate_open_files(name, migration_flags, param, layout,
1245                                 &fd, &fdv);
1246         if (rc < 0)
1247                 goto out;
1248
1249         rc = llapi_layout_dom_size(layout, &dom_new);
1250         if (rc) {
1251                 error_loc = "cannot get new layout DoM size";
1252                 goto out;
1253         }
1254         /* special case for migration to DOM layout*/
1255         existing = llapi_layout_get_by_fd(fd, 0);
1256         if (!existing) {
1257                 error_loc = "cannot get existing layout";
1258                 goto out;
1259         }
1260
1261         rc = llapi_layout_dom_size(existing, &dom_cur);
1262         if (rc) {
1263                 error_loc = "cannot get current layout DoM size";
1264                 goto out;
1265         }
1266
1267         /*
1268          * if file has DoM layout already then migration is possible to
1269          * the new layout with the same DoM component via swap layout,
1270          * if new layout used bigger DOM size, then mirroring is used
1271          */
1272         if (dom_new > dom_cur) {
1273                 rc = lfs_migrate_to_dom(fd, fdv, name, migration_flags, param,
1274                                         layout);
1275                 if (rc)
1276                         error_loc = "cannot migrate to DOM layout";
1277                 goto out_closed;
1278         }
1279
1280         if (!(migration_flags & MIGRATION_NONBLOCK)) {
1281                 /*
1282                  * Blocking mode (forced if servers do not support file lease).
1283                  * It is also the default mode, since we cannot distinguish
1284                  * between a broken lease and a server that does not support
1285                  * atomic swap/close (LU-6785)
1286                  */
1287                 rc = migrate_block(fd, fdv);
1288                 goto out;
1289         }
1290
1291         rc = llapi_lease_acquire(fd, LL_LEASE_RDLCK);
1292         if (rc < 0) {
1293                 error_loc = "cannot get lease";
1294                 goto out;
1295         }
1296
1297         rc = migrate_nonblock(fd, fdv);
1298         if (rc < 0) {
1299                 llapi_lease_release(fd);
1300                 goto out;
1301         }
1302
1303         /*
1304          * Atomically put lease, swap layouts and close.
1305          * for a migration we need to check data version on file did
1306          * not change.
1307          */
1308         rc = llapi_fswap_layouts(fd, fdv, 0, 0, SWAP_LAYOUTS_CLOSE);
1309         if (rc < 0) {
1310                 error_loc = "cannot swap layout";
1311                 goto out;
1312         }
1313
1314 out:
1315         if (fd >= 0)
1316                 close(fd);
1317
1318         if (fdv >= 0)
1319                 close(fdv);
1320 out_closed:
1321         if (rc < 0)
1322                 fprintf(stderr, "error: %s: %s: %s: %s\n",
1323                         progname, name, error_loc, strerror(-rc));
1324         else if (migration_flags & MIGRATION_VERBOSE)
1325                 printf("%s\n", name);
1326
1327         return rc;
1328 }
1329
1330 static int comp_str2flags(char *string, __u32 *flags, __u32 *neg_flags)
1331 {
1332         char *name;
1333
1334         if (!string)
1335                 return -EINVAL;
1336
1337         *flags = 0;
1338         *neg_flags = 0;
1339         for (name = strtok(string, ","); name; name = strtok(NULL, ",")) {
1340                 bool found = false;
1341                 int i;
1342
1343                 for (i = 0; i < ARRAY_SIZE(comp_flags_table); i++) {
1344                         __u32 comp_flag = comp_flags_table[i].cfn_flag;
1345                         const char *comp_name = comp_flags_table[i].cfn_name;
1346
1347                         if (strcmp(name, comp_name) == 0) {
1348                                 *flags |= comp_flag;
1349                                 found = true;
1350                         } else if (strncmp(name, "^", 1) == 0 &&
1351                                    strcmp(name + 1, comp_name) == 0) {
1352                                 *neg_flags |= comp_flag;
1353                                 found = true;
1354                         }
1355                 }
1356                 if (!found) {
1357                         llapi_printf(LLAPI_MSG_ERROR,
1358                                      "%s: component flag '%s' not supported\n",
1359                                      progname, name);
1360                         return -EINVAL;
1361                 }
1362         }
1363
1364         if (!*flags && !*neg_flags)
1365                 return -EINVAL;
1366
1367         /* don't allow to set and exclude the same flag */
1368         if (*flags & *neg_flags)
1369                 return -EINVAL;
1370
1371         return 0;
1372 }
1373
1374 static int mirror_str2state(char *string, __u16 *state, __u16 *neg_state)
1375 {
1376         if (!string)
1377                 return -EINVAL;
1378
1379         *state = 0;
1380         *neg_state = 0;
1381
1382         if (strncmp(string, "^", 1) == 0) {
1383                 *neg_state = llapi_layout_string_flags(string + 1);
1384                 if (*neg_state != 0)
1385                         return 0;
1386         } else {
1387                 *state = llapi_layout_string_flags(string);
1388                 if (*state != 0)
1389                         return 0;
1390         }
1391
1392         llapi_printf(LLAPI_MSG_ERROR,
1393                      "%s: mirrored file state '%s' not supported\n",
1394                      progname, string);
1395         return -EINVAL;
1396 }
1397
1398 /**
1399  * struct mirror_args - Command-line arguments for mirror(s).
1400  * @m_count:  Number of mirrors to be created with this layout.
1401  * @m_flags:  Mirror level flags, only 'prefer' is supported.
1402  * @m_layout: Mirror layout.
1403  * @m_file:   A victim file. Its layout will be split and used as a mirror.
1404  * @m_next:   Point to the next node of the list.
1405  *
1406  * Command-line arguments for mirror(s) will be parsed and stored in
1407  * a linked list that consists of this structure.
1408  */
1409 struct mirror_args {
1410         __u32                   m_count;
1411         __u32                   m_flags;
1412         struct llapi_layout     *m_layout;
1413         const char              *m_file;
1414         struct mirror_args      *m_next;
1415         bool                    m_inherit;
1416 };
1417
1418 /**
1419  * enum mirror_flags - Flags for extending a mirrored file.
1420  * @MF_NO_VERIFY: Indicates not to verify the mirror(s) from victim file(s)
1421  *             in case the victim file(s) contains the same data as the
1422  *             original mirrored file.
1423  * @MF_DESTROY: Indicates to delete the mirror from the mirrored file.
1424  * @MF_COMP_ID: specified component id instead of mirror id
1425  *
1426  * Flags for extending a mirrored file.
1427  */
1428 enum mirror_flags {
1429         MF_NO_VERIFY    = 0x1,
1430         MF_DESTROY      = 0x2,
1431         MF_COMP_ID      = 0x4,
1432         MF_COMP_POOL    = 0x8,
1433 };
1434
1435 /**
1436  * mirror_create_sanity_check() - Check mirror list.
1437  * @list:  A linked list that stores the mirror arguments.
1438  *
1439  * This function does a sanity check on @list for creating
1440  * a mirrored file.
1441  *
1442  * Return: 0 on success or a negative error code on failure.
1443  */
1444 static int mirror_create_sanity_check(const char *fname,
1445                                       struct mirror_args *list)
1446 {
1447         int rc = 0;
1448         bool has_m_file = false;
1449         bool has_m_layout = false;
1450
1451         if (!list)
1452                 return -EINVAL;
1453
1454         if (fname) {
1455                 struct llapi_layout *layout;
1456
1457                 layout = llapi_layout_get_by_path(fname, 0);
1458                 if (!layout) {
1459                         fprintf(stderr,
1460                                 "error: %s: file '%s' couldn't get layout\n",
1461                                 progname, fname);
1462                         return -ENODATA;
1463                 }
1464
1465                 rc = llapi_layout_sanity(layout, false, true);
1466
1467                 llapi_layout_free(layout);
1468
1469                 if (rc) {
1470                         llapi_layout_sanity_perror(rc);
1471                         return rc;
1472                 }
1473         }
1474
1475         while (list) {
1476                 if (list->m_file) {
1477                         has_m_file = true;
1478                         llapi_layout_free(list->m_layout);
1479
1480                         list->m_layout =
1481                                 llapi_layout_get_by_path(list->m_file, 0);
1482                         if (!list->m_layout) {
1483                                 fprintf(stderr,
1484                                         "error: %s: file '%s' has no layout\n",
1485                                         progname, list->m_file);
1486                                 return -ENODATA;
1487                         }
1488                 } else {
1489                         has_m_layout = true;
1490                         if (!list->m_layout) {
1491                                 fprintf(stderr, "error: %s: no mirror layout\n",
1492                                         progname);
1493                                 return -EINVAL;
1494                         }
1495                 }
1496
1497                 rc = llapi_layout_sanity(list->m_layout, false, true);
1498                 if (rc) {
1499                         llapi_layout_sanity_perror(rc);
1500                         return rc;
1501                 }
1502
1503                 list = list->m_next;
1504         }
1505
1506         if (has_m_file && has_m_layout) {
1507                 fprintf(stderr,
1508                         "error: %s: -f <victim_file> option should not be specified with setstripe options\n",
1509                         progname);
1510                 return -EINVAL;
1511         }
1512
1513         return 0;
1514 }
1515
1516 static int mirror_set_flags(struct llapi_layout *layout, void *cbdata)
1517 {
1518         __u32 mirror_flags = *(__u32 *)cbdata;
1519         uint32_t flags;
1520         int rc;
1521
1522         rc = llapi_layout_comp_flags_get(layout, &flags);
1523         if (rc < 0)
1524                 return rc;
1525
1526         if (!flags) {
1527                 rc = llapi_layout_comp_flags_set(layout, mirror_flags);
1528                 if (rc)
1529                         return rc;
1530         }
1531
1532         return LLAPI_LAYOUT_ITER_CONT;
1533 }
1534
1535 /**
1536  * mirror_create() - Create a mirrored file.
1537  * @fname:        The file to be created.
1538  * @mirror_list:  A linked list that stores the mirror arguments.
1539  *
1540  * This function creates a mirrored file @fname with the mirror(s)
1541  * from @mirror_list.
1542  *
1543  * Return: 0 on success or a negative error code on failure.
1544  */
1545 static int mirror_create(char *fname, struct mirror_args *mirror_list)
1546 {
1547         struct llapi_layout *layout = NULL;
1548         struct mirror_args *cur_mirror = NULL;
1549         uint16_t mirror_count = 0;
1550         int i = 0;
1551         int rc = 0;
1552
1553         rc = mirror_create_sanity_check(NULL, mirror_list);
1554         if (rc)
1555                 return rc;
1556
1557         cur_mirror = mirror_list;
1558         while (cur_mirror) {
1559                 rc = llapi_layout_comp_iterate(cur_mirror->m_layout,
1560                                                mirror_set_flags,
1561                                                &cur_mirror->m_flags);
1562                 if (rc) {
1563                         rc = -errno;
1564                         fprintf(stderr, "%s: failed to set mirror flags\n",
1565                                 progname);
1566                         goto error;
1567                 }
1568
1569                 for (i = 0; i < cur_mirror->m_count; i++) {
1570                         rc = llapi_layout_merge(&layout, cur_mirror->m_layout);
1571                         if (rc) {
1572                                 rc = -errno;
1573                                 fprintf(stderr,
1574                                         "error: %s: merge layout failed: %s\n",
1575                                         progname, strerror(errno));
1576                                 goto error;
1577                         }
1578                 }
1579                 mirror_count += cur_mirror->m_count;
1580                 cur_mirror = cur_mirror->m_next;
1581         }
1582
1583         if (!layout) {
1584                 fprintf(stderr, "error: %s: layout is NULL\n", progname);
1585                 return -EINVAL;
1586         }
1587
1588         rc = llapi_layout_mirror_count_set(layout, mirror_count);
1589         if (rc) {
1590                 rc = -errno;
1591                 fprintf(stderr, "error: %s: set mirror count failed: %s\n",
1592                         progname, strerror(errno));
1593                 goto error;
1594         }
1595
1596         rc = lfs_component_create(fname, O_CREAT | O_WRONLY, 0666,
1597                                   layout);
1598         if (rc >= 0) {
1599                 close(rc);
1600                 rc = 0;
1601         }
1602
1603 error:
1604         llapi_layout_free(layout);
1605         return rc;
1606 }
1607
1608 /**
1609  * Compare files and check lease on @fd.
1610  *
1611  * \retval bytes number of bytes are the same
1612  */
1613 static ssize_t mirror_file_compare(int fd, int fdv)
1614 {
1615         const size_t buflen = 4 * 1024 * 1024; /* 4M */
1616         void *buf;
1617         ssize_t bytes_done = 0;
1618         ssize_t bytes_read = 0;
1619
1620         buf = malloc(buflen * 2);
1621         if (!buf)
1622                 return -ENOMEM;
1623
1624         while (1) {
1625                 if (!llapi_lease_check(fd)) {
1626                         bytes_done = -EBUSY;
1627                         break;
1628                 }
1629
1630                 bytes_read = read(fd, buf, buflen);
1631                 if (bytes_read <= 0)
1632                         break;
1633
1634                 if (bytes_read != read(fdv, buf + buflen, buflen))
1635                         break;
1636
1637                 /*
1638                  * XXX: should compute the checksum on each buffer and then
1639                  * compare checksum to avoid cache collision
1640                  */
1641                 if (memcmp(buf, buf + buflen, bytes_read))
1642                         break;
1643
1644                 bytes_done += bytes_read;
1645         }
1646
1647         free(buf);
1648
1649         return bytes_done;
1650 }
1651
1652 static int mirror_extend_file(const char *fname, const char *victim_file,
1653                               enum mirror_flags mirror_flags)
1654 {
1655         int fd = -1;
1656         int fdv = -1;
1657         struct stat stbuf;
1658         struct stat stbuf_v;
1659         struct ll_ioc_lease *data = NULL;
1660         int rc;
1661
1662         fd = open(fname, O_RDWR);
1663         if (fd < 0) {
1664                 error_loc = "open source file";
1665                 rc = -errno;
1666                 goto out;
1667         }
1668
1669         fdv = open(victim_file, O_RDWR);
1670         if (fdv < 0) {
1671                 error_loc = "open target file";
1672                 rc = -errno;
1673                 goto out;
1674         }
1675
1676         if (fstat(fd, &stbuf) || fstat(fdv, &stbuf_v)) {
1677                 error_loc = "stat source or target file";
1678                 rc = -errno;
1679                 goto out;
1680         }
1681
1682         if (stbuf.st_dev != stbuf_v.st_dev) {
1683                 error_loc = "stat source and target file";
1684                 rc = -EXDEV;
1685                 goto out;
1686         }
1687
1688         /* mirrors should be of the same size */
1689         if (stbuf.st_size != stbuf_v.st_size) {
1690                 error_loc = "file sizes don't match";
1691                 rc = -EINVAL;
1692                 goto out;
1693         }
1694
1695         rc = llapi_lease_acquire(fd, LL_LEASE_RDLCK);
1696         if (rc < 0) {
1697                 error_loc = "cannot get lease";
1698                 goto out;
1699         }
1700
1701         if (!(mirror_flags & MF_NO_VERIFY)) {
1702                 ssize_t ret;
1703                 /* mirrors should have the same contents */
1704                 ret = mirror_file_compare(fd, fdv);
1705                 if (ret != stbuf.st_size) {
1706                         error_loc = "file busy or contents don't match";
1707                         rc = ret < 0 ? ret : -EINVAL;
1708                         goto out;
1709                 }
1710         }
1711
1712         /* Get rid of caching pages from clients */
1713         rc = llapi_file_flush(fd);
1714         if (rc < 0) {
1715                 error_loc = "cannot get data version";
1716                 goto out;
1717         }
1718
1719         rc = llapi_file_flush(fdv);
1720         if (rc < 0) {
1721                 error_loc = "cannot get data version";
1722                 goto out;
1723         }
1724
1725         /* Make sure we keep original atime/mtime values */
1726         rc = migrate_copy_timestamps(fd, fdv);
1727         if (rc < 0) {
1728                 error_loc = "cannot copy timestamp";
1729                 goto out;
1730         }
1731
1732         /* Atomically put lease, merge layouts and close. */
1733         data = calloc(1, offsetof(typeof(*data), lil_ids[1]));
1734         if (!data) {
1735                 error_loc = "memory allocation";
1736                 goto out;
1737         }
1738         data->lil_mode = LL_LEASE_UNLCK;
1739         data->lil_flags = LL_LEASE_LAYOUT_MERGE;
1740         data->lil_count = 1;
1741         data->lil_ids[0] = fdv;
1742         rc = llapi_lease_set(fd, data);
1743         if (rc < 0) {
1744                 error_loc = "cannot merge layout";
1745                 goto out;
1746         } else if (rc == 0) {
1747                 rc = -EBUSY;
1748                 error_loc = "lost lease lock";
1749                 goto out;
1750         }
1751         rc = 0;
1752
1753 out:
1754         if (data)
1755                 free(data);
1756         if (fd >= 0)
1757                 close(fd);
1758         if (fdv >= 0)
1759                 close(fdv);
1760         if (!rc)
1761                 (void) unlink(victim_file);
1762         if (rc < 0)
1763                 fprintf(stderr, "error: %s: %s: %s: %s\n",
1764                         progname, fname, error_loc, strerror(-rc));
1765         return rc;
1766 }
1767
1768 static int mirror_extend_layout(char *name, struct llapi_layout *m_layout,
1769                                 bool inherit)
1770 {
1771         struct llapi_layout *f_layout = NULL;
1772         struct ll_ioc_lease *data = NULL;
1773         int fd = -1;
1774         int fdv = -1;
1775         int rc = 0;
1776
1777         if (inherit) {
1778                 f_layout = llapi_layout_get_by_path(name, 0);
1779                 if (!f_layout) {
1780                         fprintf(stderr, "%s: cannot get layout\n", progname);
1781                         goto out;
1782                 }
1783                 rc = llapi_layout_get_last_init_comp(f_layout);
1784                 if (rc) {
1785                         fprintf(stderr, "%s: cannot get the last init comp\n",
1786                                 progname);
1787                         goto out;
1788                 }
1789                 rc = llapi_layout_mirror_inherit(f_layout, m_layout);
1790                 if (rc) {
1791                         fprintf(stderr,
1792                                 "%s: cannot inherit from the last init comp\n",
1793                                 progname);
1794                         goto out;
1795                 }
1796         }
1797         rc = migrate_open_files(name, 0, NULL, m_layout, &fd, &fdv);
1798         if (rc < 0)
1799                 goto out;
1800
1801         rc = llapi_lease_acquire(fd, LL_LEASE_RDLCK);
1802         if (rc < 0) {
1803                 error_loc = "cannot get lease";
1804                 goto out;
1805         }
1806
1807         rc = migrate_nonblock(fd, fdv);
1808         if (rc < 0) {
1809                 llapi_lease_release(fd);
1810                 goto out;
1811         }
1812
1813         /* Atomically put lease, merge layouts and close. */
1814         data = calloc(1, offsetof(typeof(*data), lil_ids[1]));
1815         if (!data) {
1816                 error_loc = "memory allocation";
1817                 goto out;
1818         }
1819         data->lil_mode = LL_LEASE_UNLCK;
1820         data->lil_flags = LL_LEASE_LAYOUT_MERGE;
1821         data->lil_count = 1;
1822         data->lil_ids[0] = fdv;
1823         rc = llapi_lease_set(fd, data);
1824         if (rc < 0) {
1825                 error_loc = "cannot merge layout";
1826                 goto out;
1827         } else if (rc == 0) {
1828                 rc = -EBUSY;
1829                 error_loc = "lost lease lock";
1830                 goto out;
1831         }
1832         rc = 0;
1833
1834 out:
1835         if (data)
1836                 free(data);
1837         if (fd >= 0)
1838                 close(fd);
1839         if (fdv >= 0)
1840                 close(fdv);
1841         if (rc < 0)
1842                 fprintf(stderr, "error: %s: %s: %s: %s\n",
1843                         progname, name, error_loc, strerror(-rc));
1844         return rc;
1845 }
1846
1847 static int mirror_extend(char *fname, struct mirror_args *mirror_list,
1848                          enum mirror_flags mirror_flags)
1849 {
1850         int rc;
1851
1852         rc = mirror_create_sanity_check(fname, mirror_list);
1853         if (rc)
1854                 return rc;
1855
1856         while (mirror_list) {
1857                 if (mirror_list->m_file) {
1858                         rc = mirror_extend_file(fname, mirror_list->m_file,
1859                                                 mirror_flags);
1860                 } else {
1861                         __u32 mirror_count = mirror_list->m_count;
1862
1863                         while (mirror_count > 0) {
1864                                 rc = mirror_extend_layout(fname,
1865                                                         mirror_list->m_layout,
1866                                                         mirror_list->m_inherit);
1867                                 if (rc)
1868                                         break;
1869
1870                                 --mirror_count;
1871                         }
1872                 }
1873                 if (rc)
1874                         break;
1875
1876                 mirror_list = mirror_list->m_next;
1877         }
1878
1879         return rc;
1880 }
1881
1882 static int find_mirror_id(struct llapi_layout *layout, void *cbdata)
1883 {
1884         uint32_t id;
1885         int rc;
1886
1887         rc = llapi_layout_mirror_id_get(layout, &id);
1888         if (rc < 0)
1889                 return rc;
1890
1891         if ((__u16)id == *(__u16 *)cbdata)
1892                 return LLAPI_LAYOUT_ITER_STOP;
1893
1894         return LLAPI_LAYOUT_ITER_CONT;
1895 }
1896
1897 static int find_comp_id(struct llapi_layout *layout, void *cbdata)
1898 {
1899         uint32_t id;
1900         int rc;
1901
1902         rc = llapi_layout_comp_id_get(layout, &id);
1903         if (rc < 0)
1904                 return rc;
1905
1906         if (id == *(__u32 *)cbdata)
1907                 return LLAPI_LAYOUT_ITER_STOP;
1908
1909         return LLAPI_LAYOUT_ITER_CONT;
1910 }
1911
1912 struct pool_to_id_cbdata {
1913         const char *pool;
1914         __u32 id;
1915 };
1916
1917 static int find_comp_id_by_pool(struct llapi_layout *layout, void *cbdata)
1918 {
1919         char buf[LOV_MAXPOOLNAME + 1];
1920         struct pool_to_id_cbdata *d = (void *)cbdata;
1921         uint32_t id;
1922         int rc;
1923
1924         rc = llapi_layout_pool_name_get(layout, buf, sizeof(buf));
1925         if (rc < 0)
1926                 return rc;
1927         if (strcmp(d->pool, buf))
1928                 return LLAPI_LAYOUT_ITER_CONT;
1929
1930         rc = llapi_layout_mirror_id_get(layout, &id);
1931         if (rc < 0)
1932                 return rc;
1933         d->id = id;
1934
1935         return LLAPI_LAYOUT_ITER_STOP;
1936 }
1937
1938 struct collect_ids_data {
1939         __u16   *cid_ids;
1940         int     cid_count;
1941         __u16   cid_exclude;
1942 };
1943
1944 static int collect_mirror_id(struct llapi_layout *layout, void *cbdata)
1945 {
1946         struct collect_ids_data *cid = cbdata;
1947         uint32_t id;
1948         int rc;
1949
1950         rc = llapi_layout_mirror_id_get(layout, &id);
1951         if (rc < 0)
1952                 return rc;
1953
1954         if ((__u16)id != cid->cid_exclude) {
1955                 int i;
1956
1957                 for (i = 0; i < cid->cid_count; i++) {
1958                         /* already collected the mirror id */
1959                         if (id == cid->cid_ids[i])
1960                                 return LLAPI_LAYOUT_ITER_CONT;
1961                 }
1962                 cid->cid_ids[cid->cid_count] = id;
1963                 cid->cid_count++;
1964         }
1965
1966         return LLAPI_LAYOUT_ITER_CONT;
1967 }
1968
1969 /**
1970  * last_non_stale_mirror() - Check if a mirror is the last non-stale mirror.
1971  * @mirror_id: Mirror id to be checked.
1972  * @layout:    Mirror component list.
1973  *
1974  * This function checks if a mirror with specified @mirror_id is the last
1975  * non-stale mirror of a layout @layout.
1976  *
1977  * Return: true or false.
1978  */
1979 static inline
1980 bool last_non_stale_mirror(__u16 mirror_id, struct llapi_layout *layout)
1981 {
1982         __u16 mirror_ids[128] = { 0 };
1983         struct collect_ids_data cid = { .cid_ids = mirror_ids,
1984                                         .cid_count = 0,
1985                                         .cid_exclude = mirror_id, };
1986         int i;
1987
1988         llapi_layout_comp_iterate(layout, collect_mirror_id, &cid);
1989
1990         for (i = 0; i < cid.cid_count; i++) {
1991                 struct llapi_resync_comp comp_array[1024] = { { 0 } };
1992                 int comp_size = 0;
1993
1994                 comp_size = llapi_mirror_find_stale(layout, comp_array,
1995                                                     ARRAY_SIZE(comp_array),
1996                                                     &mirror_ids[i], 1);
1997                 if (comp_size == 0)
1998                         return false;
1999         }
2000
2001         return true;
2002 }
2003
2004 static int mirror_split(const char *fname, __u32 id, const char *pool,
2005                         enum mirror_flags mflags, const char *victim_file)
2006 {
2007         struct llapi_layout *layout;
2008         char parent[PATH_MAX];
2009         char victim[PATH_MAX];
2010         int flags = O_CREAT | O_EXCL | O_LOV_DELAY_CREATE | O_NOFOLLOW;
2011         char *ptr;
2012         struct ll_ioc_lease *data;
2013         uint16_t mirror_count;
2014         __u32 mirror_id;
2015         int mdt_index;
2016         int fd, fdv;
2017         int rc;
2018
2019         /* check fname contains mirror with mirror_id/comp_id */
2020         layout = llapi_layout_get_by_path(fname, 0);
2021         if (!layout) {
2022                 fprintf(stderr,
2023                         "error %s: file '%s' couldn't get layout\n",
2024                         progname, fname);
2025                 return -EINVAL;
2026         }
2027
2028         rc = llapi_layout_sanity(layout, false, true);
2029         if (rc) {
2030                 llapi_layout_sanity_perror(rc);
2031                 goto free_layout;
2032         }
2033
2034         rc = llapi_layout_mirror_count_get(layout, &mirror_count);
2035         if (rc) {
2036                 fprintf(stderr,
2037                         "error %s: file '%s' couldn't get mirror count\n",
2038                         progname, fname);
2039                 goto free_layout;
2040         }
2041         if (mirror_count < 2) {
2042                 fprintf(stderr,
2043                         "error %s: file '%s' has %d component, cannot split\n",
2044                         progname, fname, mirror_count);
2045                 goto free_layout;
2046         }
2047
2048         if (mflags & MF_COMP_POOL) {
2049                 struct pool_to_id_cbdata data = { .pool = pool };
2050
2051                 rc = llapi_layout_comp_iterate(layout, find_comp_id_by_pool,
2052                                                &data);
2053                 mirror_id = data.id;
2054         } else if (mflags & MF_COMP_ID) {
2055                 rc = llapi_layout_comp_iterate(layout, find_comp_id, &id);
2056                 mirror_id = mirror_id_of(id);
2057         } else {
2058                 rc = llapi_layout_comp_iterate(layout, find_mirror_id, &id);
2059                 mirror_id = id;
2060         }
2061         if (rc < 0) {
2062                 fprintf(stderr, "error %s: failed to iterate layout of '%s'\n",
2063                         progname, fname);
2064                 goto free_layout;
2065         } else if (rc == LLAPI_LAYOUT_ITER_CONT) {
2066                 if (mflags & MF_COMP_POOL) {
2067                         fprintf(stderr,
2068                                 "error %s: file '%s' does not contain mirror with pool '%s'\n",
2069                                 progname, fname, pool);
2070                         goto free_layout;
2071                 } else if (mflags & MF_COMP_ID) {
2072                         fprintf(stderr,
2073                                 "error %s: file '%s' does not contain mirror with comp-id %u\n",
2074                                 progname, fname, id);
2075                         goto free_layout;
2076                 } else {
2077                         fprintf(stderr,
2078                                 "error %s: file '%s' does not contain mirror with id %u\n",
2079                                 progname, fname, id);
2080                         goto free_layout;
2081                 }
2082         }
2083
2084         fd = open(fname, O_RDWR);
2085         if (fd < 0) {
2086                 fprintf(stderr,
2087                         "error %s: open file '%s' failed: %s\n",
2088                         progname, fname, strerror(errno));
2089                 goto free_layout;
2090         }
2091
2092         /* get victim file directory pathname */
2093         if (strlen(fname) > sizeof(parent) - 1) {
2094                 fprintf(stderr, "error %s: file name of '%s' too long\n",
2095                         progname, fname);
2096                 rc = -ERANGE;
2097                 goto close_fd;
2098         }
2099         strncpy(parent, fname, sizeof(parent));
2100         ptr = strrchr(parent, '/');
2101         if (!ptr) {
2102                 if (!getcwd(parent, sizeof(parent))) {
2103                         fprintf(stderr, "error %s: getcwd failed: %s\n",
2104                                 progname, strerror(errno));
2105                         rc = -errno;
2106                         goto close_fd;
2107                 }
2108         } else {
2109                 if (ptr == parent)
2110                         ptr = parent + 1;
2111                 *ptr = '\0';
2112         }
2113
2114         rc = llapi_file_fget_mdtidx(fd, &mdt_index);
2115         if (rc < 0) {
2116                 fprintf(stderr, "%s: cannot get MDT index of '%s'\n",
2117                         progname, fname);
2118                 goto close_fd;
2119         }
2120
2121         if (!victim_file) {
2122                 /* use a temp file to store the splitted layout */
2123                 if (mflags & MF_DESTROY) {
2124                         if (last_non_stale_mirror(mirror_id, layout)) {
2125                                 rc = -EUCLEAN;
2126                                 fprintf(stderr,
2127                                         "%s: cannot destroy the last non-stale mirror of file '%s'\n",
2128                                         progname, fname);
2129                                 goto close_fd;
2130                         }
2131
2132                         fdv = llapi_create_volatile_idx(parent, mdt_index,
2133                                                         O_LOV_DELAY_CREATE);
2134                 } else {
2135                         snprintf(victim, sizeof(victim), "%s.mirror~%u",
2136                                  fname, mirror_id);
2137                         fdv = open(victim, flags, S_IRUSR | S_IWUSR);
2138                 }
2139         } else {
2140                 /* user specified victim file */
2141                 fdv = open(victim_file, flags, S_IRUSR | S_IWUSR);
2142         }
2143
2144         if (fdv < 0) {
2145                 fprintf(stderr,
2146                         "error %s: create victim file failed: %s\n",
2147                         progname, strerror(errno));
2148                 goto close_fd;
2149         }
2150
2151         /* get lease lock of fname */
2152         rc = llapi_lease_acquire(fd, LL_LEASE_WRLCK);
2153         if (rc < 0) {
2154                 fprintf(stderr,
2155                         "error %s: cannot get lease of file '%s': %d\n",
2156                         progname, fname, rc);
2157                 goto close_victim;
2158         }
2159
2160         /* Atomatically put lease, split layouts and close. */
2161         data = malloc(offsetof(typeof(*data), lil_ids[2]));
2162         if (!data) {
2163                 rc = -ENOMEM;
2164                 goto close_victim;
2165         }
2166
2167         data->lil_mode = LL_LEASE_UNLCK;
2168         data->lil_flags = LL_LEASE_LAYOUT_SPLIT;
2169         data->lil_count = 2;
2170         data->lil_ids[0] = fdv;
2171         data->lil_ids[1] = mirror_id;
2172         rc = llapi_lease_set(fd, data);
2173         if (rc <= 0) {
2174                 if (rc == 0) /* lost lease lock */
2175                         rc = -EBUSY;
2176                 fprintf(stderr,
2177                         "error %s: cannot split '%s': %s\n",
2178                         progname, fname, strerror(-rc));
2179         } else {
2180                 rc = 0;
2181         }
2182         free(data);
2183
2184 close_victim:
2185         close(fdv);
2186 close_fd:
2187         close(fd);
2188 free_layout:
2189         llapi_layout_free(layout);
2190         return rc;
2191 }
2192
2193 static inline
2194 int lfs_mirror_resync_file(const char *fname, struct ll_ioc_lease *ioc,
2195                            __u16 *mirror_ids, int ids_nr);
2196
2197 static int lfs_migrate_to_dom(int fd, int fdv, char *name,
2198                               __u64 migration_flags,
2199                               struct llapi_stripe_param *param,
2200                               struct llapi_layout *layout)
2201 {
2202         struct ll_ioc_lease *data = NULL;
2203         int rc;
2204
2205         rc = llapi_lease_acquire(fd, LL_LEASE_RDLCK);
2206         if (rc < 0) {
2207                 error_loc = "cannot get lease";
2208                 goto out_close;
2209         }
2210
2211         /* Atomically put lease, merge layouts, resync and close. */
2212         data = calloc(1, offsetof(typeof(*data), lil_ids[1024]));
2213         if (!data) {
2214                 error_loc = "memory allocation";
2215                 goto out_close;
2216         }
2217         data->lil_mode = LL_LEASE_UNLCK;
2218         data->lil_flags = LL_LEASE_LAYOUT_MERGE;
2219         data->lil_count = 1;
2220         data->lil_ids[0] = fdv;
2221         rc = llapi_lease_set(fd, data);
2222         if (rc < 0) {
2223                 error_loc = "cannot merge layout";
2224                 goto out_close;
2225         } else if (rc == 0) {
2226                 rc = -EBUSY;
2227                 error_loc = "lost lease lock";
2228                 goto out_close;
2229         }
2230         close(fd);
2231         close(fdv);
2232
2233         rc = lfs_mirror_resync_file(name, data, NULL, 0);
2234         if (rc) {
2235                 error_loc = "cannot resync file";
2236                 goto out;
2237         }
2238
2239         /* delete first mirror now */
2240         rc = mirror_split(name, 1, NULL, MF_DESTROY, NULL);
2241         if (rc < 0)
2242                 error_loc = "cannot delete old layout";
2243         goto out;
2244
2245 out_close:
2246         close(fd);
2247         close(fdv);
2248 out:
2249         if (rc < 0)
2250                 fprintf(stderr, "error: %s: %s: %s: %s\n",
2251                         progname, name, error_loc, strerror(-rc));
2252         else if (migration_flags & MIGRATION_VERBOSE)
2253                 printf("%s\n", name);
2254         if (data)
2255                 free(data);
2256         return rc;
2257 }
2258
2259 /**
2260  * Parse a string containing an target index list into an array of integers.
2261  *
2262  * The input string contains a comma delimited list of individual
2263  * indices and ranges, for example "1,2-4,7". Add the indices into the
2264  * \a tgts array and remove duplicates.
2265  *
2266  * \param[out] tgts             array to store indices in
2267  * \param[in] size              size of \a tgts array
2268  * \param[in] offset            starting index in \a tgts
2269  * \param[in] arg               string containing OST index list
2270  * \param[in/out] overstriping  index list may contain duplicates
2271  *
2272  * \retval positive    number of indices in \a tgts
2273  * \retval -EINVAL     unable to parse \a arg
2274  */
2275 static int parse_targets(__u32 *tgts, int size, int offset, char *arg,
2276                          unsigned long long *pattern)
2277 {
2278         int rc;
2279         int nr = offset;
2280         int slots = size - offset;
2281         char *ptr = NULL;
2282         bool overstriped = false;
2283         bool end_of_loop;
2284
2285         if (!arg)
2286                 return -EINVAL;
2287
2288         end_of_loop = false;
2289         while (!end_of_loop) {
2290                 int start_index = 0;
2291                 int end_index = 0;
2292                 int i;
2293                 char *endptr = NULL;
2294
2295                 rc = -EINVAL;
2296
2297                 ptr = strchrnul(arg, ',');
2298
2299                 end_of_loop = *ptr == '\0';
2300                 *ptr = '\0';
2301
2302                 start_index = strtol(arg, &endptr, 0);
2303                 if (endptr == arg) /* no data at all */
2304                         break;
2305                 if (*endptr != '-' && *endptr != '\0') /* has invalid data */
2306                         break;
2307
2308                 end_index = start_index;
2309                 if (*endptr == '-') {
2310                         end_index = strtol(endptr + 1, &endptr, 0);
2311                         if (*endptr != '\0')
2312                                 break;
2313                         if (end_index < start_index)
2314                                 break;
2315                 }
2316
2317                 for (i = start_index; i <= end_index && slots > 0; i++) {
2318                         int j;
2319
2320                         /* remove duplicate */
2321                         for (j = 0; j < offset; j++) {
2322                                 if (tgts[j] == i && pattern &&
2323                                     *pattern == LLAPI_LAYOUT_OVERSTRIPING)
2324                                         overstriped = true;
2325                                 else if (tgts[j] == i)
2326                                         return -EINVAL;
2327                         }
2328
2329                         j = offset;
2330
2331                         if (j == offset) { /* check complete */
2332                                 tgts[nr++] = i;
2333                                 --slots;
2334                         }
2335                 }
2336
2337                 if (slots == 0 && i < end_index)
2338                         break;
2339
2340                 *ptr = ',';
2341                 arg = ++ptr;
2342                 offset = nr;
2343                 rc = 0;
2344         }
2345         if (!end_of_loop && ptr)
2346                 *ptr = ',';
2347
2348         if (!overstriped && pattern)
2349                 *pattern = LLAPI_LAYOUT_DEFAULT;
2350
2351         return rc < 0 ? rc : nr;
2352 }
2353
2354 struct lfs_setstripe_args {
2355         unsigned long long       lsa_comp_end;
2356         unsigned long long       lsa_stripe_size;
2357         unsigned long long       lsa_extension_size;
2358         long long                lsa_stripe_count;
2359         long long                lsa_stripe_off;
2360         __u32                    lsa_comp_flags;
2361         __u32                    lsa_comp_neg_flags;
2362         unsigned long long       lsa_pattern;
2363         unsigned int             lsa_mirror_count;
2364         int                      lsa_nr_tgts;
2365         bool                     lsa_first_comp;
2366         bool                     lsa_extension_comp;
2367         __u32                   *lsa_tgts;
2368         char                    *lsa_pool_name;
2369 };
2370
2371 static inline void setstripe_args_init(struct lfs_setstripe_args *lsa)
2372 {
2373         unsigned int mirror_count = lsa->lsa_mirror_count;
2374         bool first_comp = lsa->lsa_first_comp;
2375
2376         memset(lsa, 0, sizeof(*lsa));
2377
2378         lsa->lsa_stripe_size = LLAPI_LAYOUT_DEFAULT;
2379         lsa->lsa_stripe_count = LLAPI_LAYOUT_DEFAULT;
2380         lsa->lsa_stripe_off = LLAPI_LAYOUT_DEFAULT;
2381         lsa->lsa_pattern = LLAPI_LAYOUT_RAID0;
2382         lsa->lsa_pool_name = NULL;
2383
2384         lsa->lsa_mirror_count = mirror_count;
2385         lsa->lsa_first_comp = first_comp;
2386 }
2387
2388 /**
2389  * setstripe_args_init_inherit() - Initialize and inherit stripe options.
2390  * @lsa: Stripe options to be initialized and inherited.
2391  *
2392  * This function initializes stripe options in @lsa and inherit
2393  * stripe_size, stripe_count and OST pool_name options.
2394  *
2395  * Return: void.
2396  */
2397 static inline void setstripe_args_init_inherit(struct lfs_setstripe_args *lsa)
2398 {
2399         unsigned long long stripe_size;
2400         long long stripe_count;
2401         char *pool_name = NULL;
2402
2403         stripe_size = lsa->lsa_stripe_size;
2404         stripe_count = lsa->lsa_stripe_count;
2405         pool_name = lsa->lsa_pool_name;
2406
2407         setstripe_args_init(lsa);
2408
2409         lsa->lsa_stripe_size = stripe_size;
2410         lsa->lsa_stripe_count = stripe_count;
2411         lsa->lsa_pool_name = pool_name;
2412 }
2413
2414 static inline bool setstripe_args_specified(struct lfs_setstripe_args *lsa)
2415 {
2416         return (lsa->lsa_stripe_size != LLAPI_LAYOUT_DEFAULT ||
2417                 lsa->lsa_stripe_count != LLAPI_LAYOUT_DEFAULT ||
2418                 lsa->lsa_stripe_off != LLAPI_LAYOUT_DEFAULT ||
2419                 lsa->lsa_pattern != LLAPI_LAYOUT_RAID0 ||
2420                 lsa->lsa_comp_end != 0);
2421 }
2422
2423 /**
2424  * comp_args_to_layout() - Create or extend a composite layout.
2425  * @composite:       Pointer to the composite layout.
2426  * @lsa:             Stripe options for the new component.
2427  *
2428  * This function creates or extends a composite layout by adding a new
2429  * component with stripe options from @lsa.
2430  *
2431  * Return: 0 on success or an error code on failure.
2432  */
2433 static int comp_args_to_layout(struct llapi_layout **composite,
2434                                struct lfs_setstripe_args *lsa,
2435                                bool set_extent)
2436 {
2437         struct llapi_layout *layout = *composite;
2438         uint64_t prev_end = 0;
2439         uint64_t size;
2440         int i = 0, rc;
2441
2442 new_comp:
2443         if (!layout) {
2444                 layout = llapi_layout_alloc();
2445                 if (!layout) {
2446                         fprintf(stderr, "Alloc llapi_layout failed. %s\n",
2447                                 strerror(errno));
2448                         errno = ENOMEM;
2449                         return -1;
2450                 }
2451                 *composite = layout;
2452                 lsa->lsa_first_comp = true;
2453         } else {
2454                 uint64_t start;
2455
2456                 /*
2457                  * Get current component extent, current component
2458                  * must be the tail component.
2459                  */
2460                 rc = llapi_layout_comp_extent_get(layout, &start, &prev_end);
2461                 if (rc) {
2462                         fprintf(stderr, "Get comp extent failed. %s\n",
2463                                 strerror(errno));
2464                         return rc;
2465                 }
2466
2467                 if (lsa->lsa_first_comp) {
2468                         prev_end = 0;
2469                         rc = llapi_layout_add_first_comp(layout);
2470                 } else {
2471                         rc = llapi_layout_comp_add(layout);
2472                 }
2473                 if (rc) {
2474                         fprintf(stderr, "Add component failed. %s\n",
2475                                 strerror(errno));
2476                         return rc;
2477                 }
2478         }
2479
2480         rc = llapi_layout_comp_flags_set(layout, lsa->lsa_comp_flags);
2481         if (rc) {
2482                 fprintf(stderr, "Set flags 0x%x failed: %s\n",
2483                         lsa->lsa_comp_flags, strerror(errno));
2484                 return rc;
2485         }
2486
2487         if (set_extent) {
2488                 uint64_t comp_end = lsa->lsa_comp_end;
2489
2490                 /*
2491                  * The extendable component is 0-length, so it can be removed
2492                  * if there is insufficient space to extend it.
2493                  */
2494                 if (lsa->lsa_extension_comp)
2495                         comp_end = prev_end;
2496
2497                 rc = llapi_layout_comp_extent_set(layout, prev_end,
2498                                                   comp_end);
2499                 if (rc) {
2500                         fprintf(stderr, "Set extent [%lu, %lu) failed. %s\n",
2501                                 prev_end, comp_end, strerror(errno));
2502                         return rc;
2503                 }
2504         }
2505         /* reset lsa_first_comp */
2506         lsa->lsa_first_comp = false;
2507
2508         /* Data-on-MDT component setting */
2509         if (lsa->lsa_pattern == LLAPI_LAYOUT_MDT) {
2510                 /*
2511                  * In case of Data-on-MDT patterns the only extra option
2512                  * applicable is stripe size option.
2513                  */
2514                 if (lsa->lsa_stripe_count != LLAPI_LAYOUT_DEFAULT) {
2515                         fprintf(stderr,
2516                                 "Option 'stripe-count' can't be specified with Data-on-MDT component: %lld\n",
2517                                 lsa->lsa_stripe_count);
2518                         errno = EINVAL;
2519                         return -1;
2520                 }
2521                 if (lsa->lsa_stripe_size != LLAPI_LAYOUT_DEFAULT) {
2522                         fprintf(stderr,
2523                                 "Option 'stripe-size' can't be specified with Data-on-MDT component: %llu\n",
2524                                 lsa->lsa_stripe_size);
2525                         errno = EINVAL;
2526                         return -1;
2527                 }
2528                 if (lsa->lsa_nr_tgts != 0) {
2529                         fprintf(stderr,
2530                                 "Option 'ost-list' can't be specified with Data-on-MDT component: '%i'\n",
2531                                 lsa->lsa_nr_tgts);
2532                         errno = EINVAL;
2533                         return -1;
2534                 }
2535                 if (lsa->lsa_stripe_off != LLAPI_LAYOUT_DEFAULT) {
2536                         fprintf(stderr,
2537                                 "Option 'stripe-offset' can't be specified with Data-on-MDT component: %lld\n",
2538                                 lsa->lsa_stripe_off);
2539                         errno = EINVAL;
2540                         return -1;
2541                 }
2542                 if (lsa->lsa_pool_name != 0) {
2543                         fprintf(stderr,
2544                                 "Option 'pool' can't be specified with Data-on-MDT component: '%s'\n",
2545                                 lsa->lsa_pool_name);
2546                         errno = EINVAL;
2547                         return -1;
2548                 }
2549
2550                 rc = llapi_layout_pattern_set(layout, lsa->lsa_pattern);
2551                 if (rc) {
2552                         fprintf(stderr, "Set stripe pattern %#llx failed. %s\n",
2553                                 lsa->lsa_pattern,
2554                                 strerror(errno));
2555                         return rc;
2556                 }
2557                 /* Data-on-MDT component has always single stripe up to end */
2558                 lsa->lsa_stripe_size = lsa->lsa_comp_end;
2559         } else if (lsa->lsa_pattern == LLAPI_LAYOUT_OVERSTRIPING) {
2560                 rc = llapi_layout_pattern_set(layout, lsa->lsa_pattern);
2561                 if (rc) {
2562                         fprintf(stderr, "Set stripe pattern %#llx failed. %s\n",
2563                                 lsa->lsa_pattern,
2564                                 strerror(errno));
2565                         return rc;
2566                 }
2567         }
2568
2569         size = lsa->lsa_comp_flags & LCME_FL_EXTENSION ?
2570                 lsa->lsa_extension_size : lsa->lsa_stripe_size;
2571
2572         if (lsa->lsa_comp_flags & LCME_FL_EXTENSION)
2573                 rc = llapi_layout_extension_size_set(layout, size);
2574         else
2575                 rc = llapi_layout_stripe_size_set(layout, size);
2576
2577         if (rc) {
2578                 fprintf(stderr, "Set stripe size %lu failed: %s\n",
2579                         size, strerror(errno));
2580                 return rc;
2581         }
2582
2583         rc = llapi_layout_stripe_count_set(layout, lsa->lsa_stripe_count);
2584         if (rc) {
2585                 fprintf(stderr, "Set stripe count %lld failed: %s\n",
2586                         lsa->lsa_stripe_count, strerror(errno));
2587                 return rc;
2588         }
2589
2590         if (lsa->lsa_pool_name) {
2591                 rc = llapi_layout_pool_name_set(layout, lsa->lsa_pool_name);
2592                 if (rc) {
2593                         fprintf(stderr, "Set pool name: %s failed. %s\n",
2594                                 lsa->lsa_pool_name, strerror(errno));
2595                         return rc;
2596                 }
2597         } else {
2598                 rc = llapi_layout_pool_name_set(layout, "");
2599                 if (rc) {
2600                         fprintf(stderr, "Clear pool name failed: %s\n",
2601                                 strerror(errno));
2602                         return rc;
2603                 }
2604         }
2605
2606         if (lsa->lsa_nr_tgts > 0) {
2607                 if (lsa->lsa_stripe_count > 0 &&
2608                     lsa->lsa_stripe_count != LLAPI_LAYOUT_DEFAULT &&
2609                     lsa->lsa_stripe_count != LLAPI_LAYOUT_WIDE &&
2610                     lsa->lsa_nr_tgts != lsa->lsa_stripe_count) {
2611                         fprintf(stderr, "stripe_count(%lld) != nr_tgts(%d)\n",
2612                                 lsa->lsa_stripe_count,
2613                                 lsa->lsa_nr_tgts);
2614                         errno = EINVAL;
2615                         return -1;
2616                 }
2617                 for (i = 0; i < lsa->lsa_nr_tgts; i++) {
2618                         rc = llapi_layout_ost_index_set(layout, i,
2619                                                         lsa->lsa_tgts[i]);
2620                         if (rc)
2621                                 break;
2622                 }
2623         } else if (lsa->lsa_stripe_off != LLAPI_LAYOUT_DEFAULT &&
2624                    lsa->lsa_stripe_off != -1) {
2625                 rc = llapi_layout_ost_index_set(layout, 0, lsa->lsa_stripe_off);
2626         }
2627         if (rc) {
2628                 fprintf(stderr, "Set ost index %d failed. %s\n",
2629                         i, strerror(errno));
2630                 return rc;
2631         }
2632
2633         /* Create the second, virtual component of extension space */
2634         if (lsa->lsa_extension_comp) {
2635                 lsa->lsa_comp_flags |= LCME_FL_EXTENSION;
2636                 lsa->lsa_extension_comp = false;
2637                 goto new_comp;
2638         }
2639
2640         return rc;
2641 }
2642
2643 static int build_component(struct llapi_layout **layout,
2644                            struct lfs_setstripe_args *lsa, bool set_extent)
2645 {
2646         int rc;
2647
2648         rc = comp_args_to_layout(layout, lsa, set_extent);
2649         if (rc)
2650                 return rc;
2651
2652         if (lsa->lsa_mirror_count > 0) {
2653                 rc = llapi_layout_mirror_count_set(*layout,
2654                                                    lsa->lsa_mirror_count);
2655                 if (rc)
2656                         return rc;
2657
2658                 rc = llapi_layout_flags_set(*layout, LCM_FL_RDONLY);
2659                 if (rc)
2660                         return rc;
2661                 lsa->lsa_mirror_count = 0;
2662         }
2663
2664         return rc;
2665 }
2666
2667 static int build_prev_component(struct llapi_layout **layout,
2668                                 struct lfs_setstripe_args *prev,
2669                                 struct lfs_setstripe_args *lsa,
2670                                 bool set_extent)
2671 {
2672         int extension = lsa->lsa_comp_flags & LCME_FL_EXTENSION;
2673         int rc;
2674
2675         if (prev->lsa_stripe_size) {
2676                 if (extension) {
2677                         prev->lsa_comp_end = lsa->lsa_comp_end;
2678                         prev->lsa_extension_size = lsa->lsa_extension_size;
2679                         prev->lsa_extension_comp = true;
2680                 }
2681
2682                 rc = build_component(layout, prev, true);
2683                 if (rc)
2684                         return rc;
2685         }
2686
2687         /*
2688          * Copy lsa to previous lsa;
2689          * if this is an extension component, make the previous invalid;
2690          */
2691         if (extension)
2692                 prev->lsa_stripe_size = 0;
2693         else
2694                 *prev = *lsa;
2695
2696         return 0;
2697 }
2698
2699 static int build_layout_from_yaml_node(struct cYAML *node,
2700                                        struct llapi_layout **layout,
2701                                        struct lfs_setstripe_args *lsa,
2702                                        struct lfs_setstripe_args *prevp)
2703 {
2704         struct lfs_setstripe_args prev = { 0 };
2705         __u32 *osts = lsa->lsa_tgts;
2706         char *string;
2707         int rc = 0;
2708
2709         if (!prevp)
2710                 prevp = &prev;
2711
2712         while (node) {
2713                 string = node->cy_string;
2714
2715                 if (node->cy_type == CYAML_TYPE_OBJECT) {
2716                         /* go deep to sub blocks */
2717                         if (string && !strncmp(string, "component", 9) &&
2718                             strncmp(string, "component0", 10) &&
2719                             strncmp(string, "components", 10)) {
2720                                 rc = build_prev_component(layout, prevp, lsa,
2721                                                           true);
2722                                 if (rc)
2723                                         return rc;
2724
2725                                 /* initialize lsa. */
2726                                 setstripe_args_init(lsa);
2727                                 lsa->lsa_first_comp = false;
2728                                 lsa->lsa_tgts = osts;
2729                         }
2730
2731                         rc = build_layout_from_yaml_node(node->cy_child, layout,
2732                                                          lsa, prevp);
2733                         if (rc)
2734                                 return rc;
2735                 } else {
2736                         if (!node->cy_string)
2737                                 return -EINVAL;
2738
2739                         /* skip leading lmm_ if present, to simplify parsing */
2740                         if (strncmp(string, "lmm_", 4) == 0)
2741                                 string += 4;
2742
2743                         if (node->cy_type == CYAML_TYPE_STRING) {
2744                                 if (!strcmp(string, "lcme_extent.e_end")) {
2745                                         if (!strcmp(node->cy_valuestring, "EOF") ||
2746                                             !strcmp(node->cy_valuestring, "eof"))
2747                                                 lsa->lsa_comp_end = LUSTRE_EOF;
2748                                 } else if (!strcmp(string, "pool")) {
2749                                         lsa->lsa_pool_name = node->cy_valuestring;
2750                                 } else if (!strcmp(string, "pattern")) {
2751                                         if (!strcmp(node->cy_valuestring, "mdt"))
2752                                                 lsa->lsa_pattern = LLAPI_LAYOUT_MDT;
2753                                         if (!strcmp(node->cy_valuestring,
2754                                                     "raid0,overstriped"))
2755                                                 lsa->lsa_pattern =
2756                                                         LLAPI_LAYOUT_OVERSTRIPING;
2757                                 } else if (!strcmp(string, "lcme_flags")) {
2758                                         rc = comp_str2flags(node->cy_valuestring,
2759                                                             &lsa->lsa_comp_flags,
2760                                                             &lsa->lsa_comp_neg_flags);
2761                                         if (rc)
2762                                                 return rc;
2763                                         /*
2764                                          * Only template flags have meaning in
2765                                          * the layout for a new file
2766                                          */
2767                                         lsa->lsa_comp_flags &= LCME_TEMPLATE_FLAGS;
2768                                 }
2769                         } else if (node->cy_type == CYAML_TYPE_NUMBER) {
2770                                 if (!strcmp(string, "lcm_mirror_count")) {
2771                                         lsa->lsa_mirror_count = node->cy_valueint;
2772                                 } else if (!strcmp(string, "lcme_extent.e_start")) {
2773                                         if (node->cy_valueint == 0)
2774                                                 lsa->lsa_first_comp = true;
2775                                 } else if (!strcmp(string, "lcme_extent.e_end")) {
2776                                         if (node->cy_valueint == -1)
2777                                                 lsa->lsa_comp_end = LUSTRE_EOF;
2778                                         else
2779                                                 lsa->lsa_comp_end = node->cy_valueint;
2780                                 } else if (!strcmp(string, "stripe_count")) {
2781                                         lsa->lsa_stripe_count = node->cy_valueint;
2782                                 } else if (!strcmp(string, "stripe_size")) {
2783                                         lsa->lsa_stripe_size = node->cy_valueint;
2784                                 } else if (!strcmp(string, "extension_size")) {
2785                                         lsa->lsa_extension_size = node->cy_valueint;
2786                                         lsa->lsa_extension_comp = true;
2787                                 } else if (!strcmp(string, "stripe_offset")) {
2788                                         lsa->lsa_stripe_off = node->cy_valueint;
2789                                 } else if (!strcmp(string, "l_ost_idx")) {
2790                                         osts[lsa->lsa_nr_tgts] = node->cy_valueint;
2791                                         lsa->lsa_nr_tgts++;
2792                                 }
2793                         }
2794                 }
2795                 node = node->cy_next;
2796         }
2797
2798         if (prevp == &prev) {
2799                 rc = build_prev_component(layout, prevp, lsa, true);
2800                 if (rc)
2801                         return rc;
2802
2803                 if (!(lsa->lsa_comp_flags & LCME_FL_EXTENSION))
2804                         rc = build_component(layout, lsa, *layout != NULL);
2805         }
2806
2807         return rc;
2808 }
2809
2810 static int lfs_comp_create_from_yaml(char *template,
2811                                      struct llapi_layout **layout,
2812                                      struct lfs_setstripe_args *lsa,
2813                                      __u32 *osts)
2814 {
2815         struct cYAML *tree = NULL, *err_rc = NULL;
2816         int rc = 0;
2817
2818         tree = cYAML_build_tree(template, NULL, 0, &err_rc, false);
2819         if (!tree) {
2820                 fprintf(stderr, "%s: cannot parse YAML file %s\n",
2821                         progname, template);
2822                 cYAML_build_error(-EINVAL, -1, "yaml", "from comp yaml",
2823                                   "can't parse", &err_rc);
2824                 cYAML_print_tree2file(stderr, err_rc);
2825                 cYAML_free_tree(err_rc);
2826                 rc = -EINVAL;
2827                 goto err;
2828         }
2829
2830         /* initialize lsa for plain file */
2831         setstripe_args_init(lsa);
2832         lsa->lsa_tgts = osts;
2833
2834         rc = build_layout_from_yaml_node(tree, layout, lsa, NULL);
2835         if (rc) {
2836                 fprintf(stderr, "%s: cannot build layout from YAML file %s.\n",
2837                         progname, template);
2838                 goto err;
2839         }
2840         /* clean clean lsa */
2841         setstripe_args_init(lsa);
2842
2843 err:
2844         if (tree)
2845                 cYAML_free_tree(tree);
2846         return rc;
2847 }
2848
2849 /**
2850  * Get the extension size from the next (SEL) component and extend the
2851  * current component on it. The start of the next component is to be
2852  * adjusted as well.
2853  *
2854  * \param[in] layout    the current layout
2855  * \param[in] start     the start of the current component
2856  * \param[in,out] end   the end of the current component
2857  * \param[in] offset    the offset to adjust the end position to instead of
2858  *                      extension size
2859  *
2860  * \retval 0            - extended successfully
2861  * \retval < 0          - error
2862  */
2863 static int layout_extend_comp(struct llapi_layout *layout,
2864                               uint64_t start, uint64_t *end,
2865                               uint64_t offset)
2866 {
2867         uint64_t size, next_start, next_end;
2868         int rc;
2869
2870         rc = llapi_layout_comp_use(layout, LLAPI_LAYOUT_COMP_USE_NEXT);
2871         if (rc < 0) {
2872                 fprintf(stderr,
2873                         "%s setstripe: cannot move component cursor: %s\n",
2874                         progname, strerror(errno));
2875                 return rc;
2876         }
2877
2878         /*
2879          * Even if the @size will not be used below, this will fail if
2880          * this is not a SEL component - a good confirmation we are
2881          * working on right components.
2882          */
2883         rc = llapi_layout_extension_size_get(layout, &size);
2884         if (rc < 0) {
2885                 fprintf(stderr,
2886                         "%s setstripe: cannot get component ext size: %s\n",
2887                         progname, strerror(errno));
2888                 return rc;
2889         }
2890
2891         rc = llapi_layout_comp_extent_get(layout, &next_start, &next_end);
2892         if (rc) {
2893                 fprintf(stderr, "%s setstripe: cannot get extent: %s\n",
2894                         progname, strerror(errno));
2895                 return rc;
2896         }
2897
2898         next_start += offset ?: size;
2899         rc = llapi_layout_comp_extent_set(layout, next_start, next_end);
2900         if (rc) {
2901                 fprintf(stderr, "%s setstripe: cannot set extent: %s\n",
2902                         progname, strerror(errno));
2903                 return rc;
2904         }
2905
2906         rc = llapi_layout_comp_use(layout, LLAPI_LAYOUT_COMP_USE_PREV);
2907         if (rc < 0) {
2908                 fprintf(stderr,
2909                         "%s setstripe: cannot move component cursor: %s\n",
2910                         progname, strerror(errno));
2911                 return rc;
2912         }
2913
2914         *end += offset ?: size;
2915         rc = llapi_layout_comp_extent_set(layout, start, *end);
2916         if (rc) {
2917                 fprintf(stderr, "%s setstripe: cannot set extent: %s\n",
2918                         progname, strerror(errno));
2919                 return rc;
2920         }
2921
2922         return 0;
2923 }
2924
2925 /**
2926  * In 'lfs setstripe --component-add' mode, we need to fetch the extent
2927  * end of the last component in the existing file, and adjust the
2928  * first extent start of the components to be added accordingly.
2929  *
2930  * In the create mode, we need to check if the first component is an extendable
2931  * SEL component and extend its length to the extension size (first component
2932  * of the PFL file is initialised at the create time, cannot be 0-lenght.
2933  */
2934 static int layout_adjust_first_extent(char *fname, struct llapi_layout *layout,
2935                                       bool comp_add)
2936 {
2937         struct llapi_layout *head;
2938         uint64_t start = 0, prev_end = 0;
2939         uint64_t end;
2940         int rc, ret = 0;
2941
2942         if (!layout || !(comp_add || llapi_layout_is_composite(layout)))
2943                 return 0;
2944
2945         errno = 0;
2946         while (comp_add) {
2947                 head = llapi_layout_get_by_path(fname, 0);
2948                 if (!head) {
2949                         fprintf(stderr,
2950                                 "%s setstripe: cannot read layout from '%s': %s\n",
2951                                 progname, fname, strerror(errno));
2952                         return -EINVAL;
2953                 } else if (errno == ENODATA) {
2954                         /*
2955                          * file without LOVEA, this component-add will be turned
2956                          * into a component-create.
2957                          */
2958                         llapi_layout_free(head);
2959                         ret = -ENODATA;
2960
2961                         /*
2962                          * the new layout will be added to an empty one, it
2963                          * still needs to be adjusted below
2964                          */
2965                         comp_add = 0;
2966                         break;
2967                 } else if (!llapi_layout_is_composite(head)) {
2968                         fprintf(stderr,
2969                                 "%s setstripe: '%s' not a composite file\n",
2970                                 progname, fname);
2971                         llapi_layout_free(head);
2972                         return -EINVAL;
2973                 }
2974
2975                 rc = llapi_layout_comp_extent_get(head, &start, &prev_end);
2976                 if (rc) {
2977                         fprintf(stderr,
2978                                 "%s setstripe: cannot get prev extent: %s\n",
2979                                 progname, strerror(errno));
2980                         llapi_layout_free(head);
2981                         return rc;
2982                 }
2983
2984                 llapi_layout_free(head);
2985                 break;
2986         }
2987
2988         /* Make sure we use the first component of the layout to be added. */
2989         rc = llapi_layout_comp_use(layout, LLAPI_LAYOUT_COMP_USE_FIRST);
2990         if (rc < 0) {
2991                 fprintf(stderr,
2992                         "%s setstripe: cannot move component cursor: %s\n",
2993                         progname, strerror(errno));
2994                 return rc;
2995         }
2996
2997         rc = llapi_layout_comp_extent_get(layout, &start, &end);
2998         if (rc) {
2999                 fprintf(stderr, "%s setstripe: cannot get extent: %s\n",
3000                         progname, strerror(errno));
3001                 return rc;
3002         }
3003
3004         if (start == 0 && end == 0) {
3005                 rc = layout_extend_comp(layout, start, &end,
3006                                         comp_add ? prev_end : 0);
3007                 if (rc)
3008                         return rc;
3009         }
3010
3011         if (start > prev_end || end < prev_end) {
3012                 fprintf(stderr,
3013                         "%s setstripe: first extent [%lu, %lu) not adjacent with extent end %lu\n",
3014                         progname, start, end, prev_end);
3015                 return -EINVAL;
3016         }
3017
3018         rc = llapi_layout_comp_extent_set(layout, prev_end, end);
3019         if (rc) {
3020                 fprintf(stderr,
3021                         "%s setstripe: cannot set component extent [%lu, %lu): %s\n",
3022                         progname, prev_end, end, strerror(errno));
3023                 return rc;
3024         }
3025
3026         return ret;
3027 }
3028
3029 static int mirror_adjust_first_extents(struct mirror_args *list)
3030 {
3031         int rc = 0;
3032
3033         if (!list)
3034                 return 0;
3035
3036         while (list) {
3037                 rc = layout_adjust_first_extent(NULL, list->m_layout, false);
3038                 if (rc)
3039                         break;
3040                 list = list->m_next;
3041         }
3042
3043         return rc;
3044 }
3045
3046 static inline bool arg_is_eof(char *arg)
3047 {
3048         return !strncmp(arg, "-1", strlen("-1")) ||
3049                !strncmp(arg, "EOF", strlen("EOF")) ||
3050                !strncmp(arg, "eof", strlen("eof"));
3051 }
3052
3053 /**
3054  * lfs_mirror_alloc() - Allocate a mirror argument structure.
3055  *
3056  * Return: Valid mirror_args pointer on success and
3057  *         NULL if memory allocation fails.
3058  */
3059 static struct mirror_args *lfs_mirror_alloc(void)
3060 {
3061         struct mirror_args *mirror = NULL;
3062
3063         while (1) {
3064                 mirror = calloc(1, sizeof(*mirror));
3065                 if (mirror) {
3066                         mirror->m_inherit = false;
3067                         break;
3068                 }
3069
3070                 sleep(1);
3071         }
3072
3073         return mirror;
3074 }
3075
3076 /**
3077  * lfs_mirror_free() - Free memory allocated for a mirror argument
3078  *                     structure.
3079  * @mirror: Previously allocated mirror argument structure by
3080  *          lfs_mirror_alloc().
3081  *
3082  * Free memory allocated for @mirror.
3083  *
3084  * Return: void.
3085  */
3086 static void lfs_mirror_free(struct mirror_args *mirror)
3087 {
3088         if (mirror->m_layout)
3089                 llapi_layout_free(mirror->m_layout);
3090         free(mirror);
3091 }
3092
3093 /**
3094  * lfs_mirror_list_free() - Free memory allocated for a mirror list.
3095  * @mirror_list: Previously allocated mirror list.
3096  *
3097  * Free memory allocated for @mirror_list.
3098  *
3099  * Return: void.
3100  */
3101 static void lfs_mirror_list_free(struct mirror_args *mirror_list)
3102 {
3103         struct mirror_args *next_mirror = NULL;
3104
3105         while (mirror_list) {
3106                 next_mirror = mirror_list->m_next;
3107                 lfs_mirror_free(mirror_list);
3108                 mirror_list = next_mirror;
3109         }
3110 }
3111
3112 enum {
3113         LFS_POOL_OPT = 3,
3114         LFS_COMP_COUNT_OPT,
3115         LFS_COMP_START_OPT,
3116         LFS_COMP_FLAGS_OPT,
3117         LFS_COMP_DEL_OPT,
3118         LFS_COMP_SET_OPT,
3119         LFS_COMP_ADD_OPT,
3120         LFS_COMP_NO_VERIFY_OPT,
3121         LFS_PROJID_OPT,
3122         LFS_LAYOUT_FLAGS_OPT, /* used for mirror and foreign flags */
3123         LFS_MIRROR_ID_OPT,
3124         LFS_MIRROR_STATE_OPT,
3125         LFS_LAYOUT_COPY,
3126         LFS_MIRROR_INDEX_OPT,
3127         LFS_LAYOUT_FOREIGN_OPT,
3128         LFS_MODE_OPT,
3129         LFS_NEWERXY_OPT,
3130 };
3131
3132 /* functions */
3133 static int lfs_setstripe_internal(int argc, char **argv,
3134                                   enum setstripe_origin opc)
3135 {
3136         struct lfs_setstripe_args        lsa = { 0 };
3137         struct llapi_stripe_param       *param = NULL;
3138         struct find_param                migrate_mdt_param = {
3139                 .fp_max_depth = -1,
3140                 .fp_mdt_index = -1,
3141         };
3142         char                            *fname;
3143         int                              result = 0;
3144         int                              result2 = 0;
3145         char                            *end;
3146         int                              c;
3147         int                              delete = 0;
3148         unsigned long long               size_units = 1;
3149         bool                             migrate_mode = false;
3150         bool                             migrate_mdt_mode = false;
3151         bool                             setstripe_mode = false;
3152         bool                             migration_block = false;
3153         __u64                            migration_flags = 0;
3154         __u32                            tgts[LOV_MAX_STRIPE_COUNT] = { 0 };
3155         int                              comp_del = 0, comp_set = 0;