X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=lustre%2Futils%2Flfs.c;h=079d2a04b533cac6574775fc4936445e78a48697;hp=9a5ecdf6f8d57ced3ed0652a5ae94dc346bd663f;hb=c1d0a355a6a64ec97c9f56c38ba036e5e50cd8c4;hpb=82298b9cf8d6a4e4a8529366536815bcf80c6bd6 diff --git a/lustre/utils/lfs.c b/lustre/utils/lfs.c index 9a5ecdf..079d2a0 100644 --- a/lustre/utils/lfs.c +++ b/lustre/utils/lfs.c @@ -58,12 +58,14 @@ #include #include #include +#include #include #include #include #include #include #include +#include #include "lfs_project.h" #include @@ -96,13 +98,12 @@ static int lfs_quota(int argc, char **argv); static int lfs_project(int argc, char **argv); #endif static int lfs_flushctx(int argc, char **argv); -static int lfs_cp(int argc, char **argv); -static int lfs_ls(int argc, char **argv); static int lfs_poollist(int argc, char **argv); static int lfs_changelog(int argc, char **argv); static int lfs_changelog_clear(int argc, char **argv); static int lfs_fid2path(int argc, char **argv); static int lfs_path2fid(int argc, char **argv); +static int lfs_rmfid(int argc, char **argv); static int lfs_data_version(int argc, char **argv); static int lfs_hsm_state(int argc, char **argv); static int lfs_hsm_set(int argc, char **argv); @@ -116,18 +117,37 @@ static int lfs_hsm_cancel(int argc, char **argv); static int lfs_swap_layouts(int argc, char **argv); static int lfs_mv(int argc, char **argv); static int lfs_ladvise(int argc, char **argv); +static int lfs_getsom(int argc, char **argv); +static int lfs_heat_get(int argc, char **argv); +static int lfs_heat_set(int argc, char **argv); static int lfs_mirror(int argc, char **argv); static int lfs_mirror_list_commands(int argc, char **argv); static int lfs_list_commands(int argc, char **argv); static inline int lfs_mirror_resync(int argc, char **argv); static inline int lfs_mirror_verify(int argc, char **argv); +static inline int lfs_mirror_read(int argc, char **argv); +static inline int lfs_mirror_write(int argc, char **argv); +static inline int lfs_mirror_copy(int argc, char **argv); +static int lfs_pcc_attach(int argc, char **argv); +static int lfs_pcc_attach_fid(int argc, char **argv); +static int lfs_pcc_detach(int argc, char **argv); +static int lfs_pcc_detach_fid(int argc, char **argv); +static int lfs_pcc_state(int argc, char **argv); +static int lfs_pcc(int argc, char **argv); +static int lfs_pcc_list_commands(int argc, char **argv); +static int lfs_migrate_to_dom(int fd, int fdv, char *name, + __u64 migration_flags, + struct llapi_stripe_param *param, + struct llapi_layout *layout); enum setstripe_origin { SO_SETSTRIPE, SO_MIGRATE, + SO_MIGRATE_MDT, SO_MIRROR_CREATE, SO_MIRROR_EXTEND, SO_MIRROR_SPLIT, + SO_MIRROR_DELETE, }; static int lfs_setstripe_internal(int argc, char **argv, enum setstripe_origin opc); @@ -152,11 +172,16 @@ static inline int lfs_mirror_split(int argc, char **argv) { return lfs_setstripe_internal(argc, argv, SO_MIRROR_SPLIT); } +static inline int lfs_mirror_delete(int argc, char **argv) +{ + return lfs_setstripe_internal(argc, argv, SO_MIRROR_DELETE); +} /* Setstripe and migrate share mostly the same parameters */ #define SSM_CMD_COMMON(cmd) \ "usage: "cmd" [--component-end|-E ]\n" \ " [--stripe-count|-c ]\n" \ + " [--overstripe-count|-C ]\n" \ " [--stripe-index|-i ]\n" \ " [--stripe-size|-S ]\n" \ " [--layout|-L ]\n" \ @@ -167,6 +192,9 @@ static inline int lfs_mirror_split(int argc, char **argv) #define SSM_HELP_COMMON \ "\tstripe_count: Number of OSTs to stripe over (0=fs default, -1 all)\n" \ + "\t Using -C instead of -c allows overstriping, which\n" \ + "\t will place more than one stripe per OST if\n" \ + "\t stripe_count is greater than the number of OSTs\n" \ "\tstart_ost_idx: OST index of first stripe (-1=default round robin)\n"\ "\tstripe_size: Number of bytes on each OST (0=fs default)\n" \ "\t Can be specified with K, M or G (for KB, MB, GB\n" \ @@ -228,28 +256,34 @@ static inline int lfs_mirror_split(int argc, char **argv) #define MIGRATE_USAGE \ SSM_CMD_COMMON("migrate ") \ - " [--block|-b]\n" \ - " [--non-block|-n]\n" \ - " [--non-direct|-D]\n" \ + " [--block|-b] [--non-block|-n]\n" \ + " [--non-direct|-D] [--verbose|-v]\n" \ " \n" \ SSM_HELP_COMMON \ "\n" \ "\tblock: Block file access during data migration (default)\n" \ "\tnon-block: Abort migrations if concurrent access is detected\n" \ - "\tnon-direct: Do not use direct I/O to copy file contents\n" \ - -#define SETDIRSTRIPE_USAGE \ - " [--mdt-count|-c stripe_count>\n" \ - " [--mdt-index|-i mdt_index]\n" \ - " [--mdt-hash|-H mdt_hash]\n" \ - " [--default|-D] [--mode|-m mode] \n" \ + "\tnon-direct: Do not use direct I/O to copy file contents\n" \ + "\tverbose: Print each filename as it is migrated\n" \ + +#define SETDIRSTRIPE_USAGE \ + " [--mdt-count|-c stripe_count>\n" \ + " [--mdt-hash|-H mdt_hash]\n" \ + " [--mdt-index|-i mdt_index[,mdt_index,...]\n" \ + " [--default|-D] [--mode|-o mode] \n" \ "\tstripe_count: stripe count of the striped directory\n" \ "\tmdt_index: MDT index of first stripe\n" \ "\tmdt_hash: hash type of the striped directory. mdt types:\n" \ " fnv_1a_64 FNV-1a hash algorithm (default)\n" \ " all_char sum of characters % MDT_COUNT (not recommended)\n" \ + " space create subdirectories with balanced space usage\n" \ "\tdefault_stripe: set default dirstripe of the directory\n" \ - "\tmode: the mode of the directory\n" + "\tmode: the file access permission of the directory (octal)\n" \ + "To create dir with a foreign (free format) layout :\n" \ + "setdirstripe|mkdir --foreign[=] -x|-xattr " \ + "[--mode|-m mode] [--flags ] \n" \ + "\tmode: the mode of the directory\n" \ + "\tforeign_type: none or daos\n" /** * command_t mirror_cmdlist - lfs mirror commands. @@ -259,26 +293,43 @@ command_t mirror_cmdlist[] = { .pc_help = "Create a mirrored file.\n" "usage: lfs mirror create " "<--mirror-count|-N[mirror_count]> " - "[setstripe options] ... \n" + "[setstripe options] ... ...\n" MIRROR_CREATE_HELP }, + { .pc_name = "delete", .pc_func = lfs_mirror_delete, + .pc_help = "delete a mirror from a file.\n" + "usage: lfs mirror delete {--comp-id|-I |-p } ...\n" + }, { .pc_name = "extend", .pc_func = lfs_mirror_extend, .pc_help = "Extend a mirrored file.\n" "usage: lfs mirror extend " "<--mirror-count|-N[mirror_count]> [--no-verify] " - "[setstripe options|-f ] ... \n" + "[setstripe options|-f ] ... ...\n" MIRROR_EXTEND_HELP }, { .pc_name = "split", .pc_func = lfs_mirror_split, .pc_help = "Split a mirrored file.\n" - "usage: lfs mirror split <--mirror-id | \n" - "\t <--component-id|-I > [--destroy|-d] \n" - "\t [-f ] \n" + "usage: lfs mirror split <--mirror-id |\n" + "\t <--component-id|-I |-p > [--destroy|-d]\n" + "\t [-f ] ...\n" "\tmirror_id: The numerical unique identifier for a mirror. It\n" "\t can be fetched by lfs getstripe command.\n" "\tcomp_id: Unique component ID within a mirror.\n" + "\tpool: Components on specified pool.\n" "\tnew_file: This option indicates the layout of the split\n" "\t mirror will be stored into. If not specified,\n" "\t a new file named .mirror~\n" "\t will be used.\n" }, + { .pc_name = "read", .pc_func = lfs_mirror_read, + .pc_help = "Read the content of a specified mirror of a file.\n" + "usage: lfs mirror read <--mirror-id|-N " + "[--outfile|-o ] \n" }, + { .pc_name = "write", .pc_func = lfs_mirror_write, + .pc_help = "Write to a specified mirror of a file.\n" + "usage: lfs mirror write <--mirror-id|-N " + "[--inputfile|-i ] \n" }, + { .pc_name = "copy", .pc_func = lfs_mirror_copy, + .pc_help = "Copy a specified mirror to other mirror(s) of a file.\n" + "usage: lfs mirror copy <--read-mirror|-i > " + "<--write-mirror|-o > \n" }, { .pc_name = "resync", .pc_func = lfs_mirror_resync, .pc_help = "Resynchronizes out-of-sync mirrored file(s).\n" "usage: lfs mirror resync [--only ] " @@ -288,7 +339,7 @@ command_t mirror_cmdlist[] = { "usage: lfs mirror verify " "[--only ] " "[--verbose|-v] [ ...]\n"}, - { .pc_name = "--list-commands", .pc_func = lfs_mirror_list_commands, + { .pc_name = "list-commands", .pc_func = lfs_mirror_list_commands, .pc_help = "list commands supported by lfs mirror"}, { .pc_name = "help", .pc_func = Parser_help, .pc_help = "help" }, { .pc_name = "exit", .pc_func = Parser_quit, .pc_help = "quit" }, @@ -296,12 +347,44 @@ command_t mirror_cmdlist[] = { { .pc_help = NULL } }; +/** + * command_t pcc_cmdlist - lfs pcc commands. + */ +command_t pcc_cmdlist[] = { + { .pc_name = "attach", .pc_func = lfs_pcc_attach, + .pc_help = "Attach given files to the Persistent Client Cache.\n" + "usage: lfs pcc attach <--id|-i NUM> ...\n" + "\t-i: archive id for RW-PCC\n" }, + { .pc_name = "attach_fid", .pc_func = lfs_pcc_attach_fid, + .pc_help = "Attach given files into PCC by FID(s).\n" + "usage: lfs pcc attach_id <--id|-i NUM> <--mnt|-m mnt> " + " ...\n" + "\t-i: archive id for RW-PCC\n" + "\t-m: Lustre mount point\n" }, + { .pc_name = "state", .pc_func = lfs_pcc_state, + .pc_help = "Display the PCC state for given files.\n" + "usage: lfs pcc state ...\n" }, + { .pc_name = "detach", .pc_func = lfs_pcc_detach, + .pc_help = "Detach given files from the Persistent Client Cache.\n" + "usage: lfs pcc detach ...\n" }, + { .pc_name = "detach_fid", .pc_func = lfs_pcc_detach_fid, + .pc_help = "Detach given files from PCC by FID(s).\n" + "usage: lfs pcc detach_fid ...\n" }, + { .pc_name = "list-commands", .pc_func = lfs_pcc_list_commands, + .pc_help = "list commands supported by lfs pcc"}, + { .pc_name = "help", .pc_func = Parser_help, .pc_help = "help" }, + { .pc_name = "exit", .pc_func = Parser_quit, .pc_help = "quit" }, + { .pc_name = "quit", .pc_func = Parser_quit, .pc_help = "quit" }, + { .pc_help = NULL } +}; + /* all available commands */ command_t cmdlist[] = { {"setstripe", lfs_setstripe, 0, "To create a file with specified striping/composite layout, or\n" "create/replace the default layout on an existing directory:\n" SSM_CMD_COMMON("setstripe") + " [--mode ]\n" " \n" " or\n" "To add component(s) to an existing composite file:\n" @@ -321,7 +404,11 @@ command_t cmdlist[] = { "\tcomp_id: Unique component ID to delete\n" "\tcomp_flags: 'init' indicating all instantiated components\n" "\t '^init' indicating all uninstantiated components\n" - "\t-I and -F cannot be specified at the same time\n"}, + "\t-I and -F cannot be specified at the same time\n" + "To create a file with a foreign (free format) layout:\n" + "usage: setstripe --foreign[=]\n" + " --xattr|-x [--flags ]\n" + " [--mode ] \n"}, {"getstripe", lfs_getstripe, 0, "To list the layout pattern for a given file or files in a\n" "directory or recursively for all files in a directory tree.\n" @@ -333,8 +420,11 @@ command_t cmdlist[] = { " [--component-id[=comp_id]|-I[comp_id]]\n" " [--component-flags[=comp_flags]]\n" " [--component-count]\n" + " [--extension-size|--ext-size|-z]\n" " [--component-start[=[+-]comp_start]]\n" " [--component-end[=[+-]comp_end]|-E[[+-]comp_end]]\n" + " [[!] --mirror-index=[+-] |\n" + " [!] --mirror-id=[+-]]\n" " ..."}, {"setdirstripe", lfs_setdirstripe, 0, "To create a striped directory on a specified MDT. This can only\n" @@ -347,7 +437,7 @@ command_t cmdlist[] = { "usage: getdirstripe [--mdt-count|-c] [--mdt-index|-m|-i]\n" " [--mdt-hash|-H] [--obd|-O ]\n" " [--recursive|-r] [--yaml|-y]\n" - " [--default|-D] ..."}, + " [--verbose|-v] [--default|-D] ..."}, {"mkdir", lfs_setdirstripe, 0, "To create a striped directory on a specified MDT. This can only\n" "be done on MDT0 with the right of administrator.\n" @@ -365,9 +455,9 @@ command_t cmdlist[] = { {"find", lfs_find, 0, "find files matching given attributes recursively in directory tree.\n" "usage: find ...\n" - " [[!] --atime|-A [+-]N] [[!] --ctime|-C [+-]N]\n" - " [[!] --mtime|-M [+-]N] [--maxdepth|-D N] [[!] --blocks|-b N]\n" - " [[!] --mdt-index|--mdt|-m ]\n" + " [[!] --atime|-A [+-]N[smhdwy]] [[!] --ctime|-C [+-]N[smhdwy]]\n" + " [[!] --mtime|-M [+-]N[smhdwy]] [[!] --blocks|-b N]\n" + " [--maxdepth|-D N] [[!] --mdt-index|--mdt|-m ]\n" " [[!] --name|-n ] [[!] --ost|-O ]\n" " [--print|-P] [--print0|-0] [[!] --size|-s [+-]N[bkMGTPE]]\n" " [[!] --stripe-count|-c [+-]]\n" @@ -376,7 +466,9 @@ command_t cmdlist[] = { " [[!] --gid|-g|--group|-G |]\n" " [[!] --uid|-u|--user|-U |] [[!] --pool ]\n" " [[!] --projid ]\n" + " [[!] --foreign[=]]\n" " [[!] --layout|-L released,raid0,mdt]\n" + " [[!] --foreign[=]]\n" " [[!] --component-count [+-]]\n" " [[!] --component-start [+-]N[kMGTPE]]\n" " [[!] --component-end|-E [+-]N[kMGTPE]]\n" @@ -385,32 +477,33 @@ command_t cmdlist[] = { " [[!] --mirror-state <[^]state>]\n" " [[!] --mdt-count|-T [+-]]\n" " [[!] --mdt-hash|-H \n" + " [[!] --mdt-index|-m ]\n" "\t !: used before an option indicates 'NOT' requested attribute\n" "\t -: used before a value indicates less than requested value\n" "\t +: used before a value indicates more than requested value\n" "\thashtype: hash type of the striped directory.\n" "\t fnv_1a_64 FNV-1a hash algorithm\n" "\t all_char sum of characters % MDT_COUNT\n"}, - {"check", lfs_check, 0, - "Display the status of MDS or OSTs (as specified in the command)\n" - "or all the servers (MDS and OSTs).\n" - "usage: check "}, - {"osts", lfs_osts, 0, "list OSTs connected to client " - "[for specified path only]\n" "usage: osts [path]"}, - {"mdts", lfs_mdts, 0, "list MDTs connected to client " - "[for specified path only]\n" "usage: mdts [path]"}, - {"df", lfs_df, 0, - "report filesystem disk space usage or inodes usage" - "of each MDS and all OSDs or a batch belonging to a specific pool .\n" - "Usage: df [-i] [-h] [--lazy|-l] [--pool|-p [.] [path]"}, - {"getname", lfs_getname, 0, "list instances and specified mount points " - "[for specified path only]\n" - "Usage: getname [-h]|[path ...] "}, + {"check", lfs_check, 0, + "Display the status of MGTs, MDTs or OSTs (as specified in the command)\n" + "or all the servers (MGTs, MDTs and OSTs).\n" + "usage: check "}, + {"osts", lfs_osts, 0, "list OSTs connected to client " + "[for specified path only]\n" "usage: osts [path]"}, + {"mdts", lfs_mdts, 0, "list MDTs connected to client " + "[for specified path only]\n" "usage: mdts [path]"}, + {"df", lfs_df, 0, + "report filesystem disk space usage or inodes usage " + "of each MDS and all OSDs or a batch belonging to a specific pool.\n" + "Usage: df [-i] [-h] [--lazy|-l] [--pool|-p [.] [path]"}, + {"getname", lfs_getname, 0, + "list instances and specified mount points [for specified path only]\n" + "Usage: getname [--help|-h] [--instance|-i] [--fsname|-n] [path ...]"}, #ifdef HAVE_SYS_QUOTA_H - {"setquota", lfs_setquota, 0, "Set filesystem quotas.\n" + {"setquota", lfs_setquota, 0, "Set filesystem quotas.\n" "usage: setquota <-u|-g|-p> ||||\n" - " -b -B \n" - " -i -I \n" + " -b -B \n" + " -i -I \n" " setquota <-u|--user|-g|--group|-p|--projid> ||||\n" " [--block-softlimit ]\n" " [--block-hardlimit ]\n" @@ -462,12 +555,6 @@ command_t cmdlist[] = { #endif {"flushctx", lfs_flushctx, 0, "Flush security context for current user.\n" "usage: flushctx [-k] [mountpoint...]"}, - {"cp", lfs_cp, 0, - "Remote user copy files and directories.\n" - "usage: cp [OPTION]... [-T] SOURCE DEST\n\tcp [OPTION]... SOURCE... DIRECTORY\n\tcp [OPTION]... -t DIRECTORY SOURCE..."}, - {"ls", lfs_ls, 0, - "Remote user list directory contents.\n" - "usage: ls [OPTION]... [FILE]..."}, {"changelog", lfs_changelog, 0, "Show the metadata changes on an MDT." "\nusage: changelog [startrec [endrec]]"}, @@ -479,11 +566,11 @@ command_t cmdlist[] = { {"fid2path", lfs_fid2path, 0, "Resolve the full path(s) for given FID(s). For a specific hardlink " "specify link number .\n" - /* "For a historical link name, specify changelog record .\n" */ - "usage: fid2path [--link ] ..." - /* [ --rec ] */ }, + "usage: fid2path [-c] [--link|-l ] ..."}, {"path2fid", lfs_path2fid, 0, "Display the fid(s) for a given path(s).\n" "usage: path2fid [--parents] ..."}, + {"rmfid", lfs_rmfid, 0, "Remove file(s) by FID(s)\n" + "usage: rmfid ..."}, {"data_version", lfs_data_version, 0, "Display file data version for " "a given path.\n" "usage: data_version -[n|r|w] "}, {"hsm_state", lfs_hsm_state, 0, "Display the HSM information (states, " @@ -525,14 +612,23 @@ command_t cmdlist[] = { "usage: swap_layouts "}, {"migrate", lfs_setstripe_migrate, 0, "migrate a directory between MDTs.\n" - "usage: migrate --mdt-index [--verbose|-v] " - "\n" - "\tmdt_idx: index of the destination MDT\n" + "usage: migrate [--mdt-count|-c] \n" + " [--mdt-hash|-H] \n" + " [--mdt-index|-m] \n" + " [--verbose|-v]\n" + " \n" + "\tmdt: MDTs to stripe over, if only one MDT is specified\n" + " it's the MDT index of first stripe\n" + "\tmdt_count: number of MDTs to stripe a directory over\n" + "\tmdt_hash: hash type of the striped directory. mdt types:\n" + " fnv_1a_64 FNV-1a hash algorithm (default)\n" + " all_char sum of characters % MDT_COUNT\n" "\n" "migrate file objects from one OST " "layout\nto another (may be not safe with concurent writes).\n" "usage: migrate " "[--stripe-count|-c] \n" + "[--overstripe-count|-C] \n" " [--stripe-index|-i] \n" " [--stripe-size|-S] \n" " [--pool|-p] \n" @@ -542,12 +638,15 @@ command_t cmdlist[] = { " [--non-direct|-D]\n" " \n" "\tstripe_count: number of OSTs to stripe a file over\n" + "\t Using -C instead of -c allows overstriping, which\n" + "\t will place more than one stripe per OST if\n" + "\t stripe_count is greater than the number of OSTs\n" "\tstripe_ost_index: index of the first OST to stripe a file over\n" "\tstripe_size: number of bytes to store before moving to the next OST\n" "\tpool_name: name of the predefined pool of OSTs\n" "\tost_indices: OSTs to stripe over, in order\n" - "\tblock: wait for the operation to return before continuing\n" - "\tnon-block: do not wait for the operation to return\n" + "\tblock: Block file access during data migration (default)\n" + "\tnon-block: Abort migrations if concurrent access is detected\n" "\tnon-direct: do not use direct I/O to copy file contents.\n"}, {"mv", lfs_mv, 0, "To move directories between MDTs. This command is deprecated, " @@ -567,7 +666,31 @@ command_t cmdlist[] = { "lfs mirror extend - add mirror(s) to an existing file\n" "lfs mirror split - split a mirror from an existing mirrored file\n" "lfs mirror resync - resynchronize out-of-sync mirrored file(s)\n" + "lfs mirror read - read a mirror content of a mirrored file\n" + "lfs mirror write - write to a mirror of a mirrored file\n" + "lfs mirror copy - copy a mirror to other mirror(s) of a file\n" "lfs mirror verify - verify mirrored file(s)\n"}, + {"getsom", lfs_getsom, 0, "To list the SOM info for a given file.\n" + "usage: getsom [-s] [-b] [-f] \n" + "\t-s: Only show the size value of the SOM data for a given file\n" + "\t-b: Only show the blocks value of the SOM data for a given file\n" + "\t-f: Only show the flags value of the SOM data for a given file\n"}, + {"heat_get", lfs_heat_get, 0, + "To get heat of files.\n" + "usage: heat_get ...\n"}, + {"heat_set", lfs_heat_set, 0, + "To set heat flags of files.\n" + "usage: heat_set [--clear|-c] [--off|-o] [--on|-O] ...\n" + "\t--clear|-c: Clear file heat for given files\n" + "\t--off|-o: Turn off file heat for given files\n" + "\t--on|-O: Turn on file heat for given files\n"}, + {"pcc", lfs_pcc, pcc_cmdlist, + "lfs commands used to interact with PCC features:\n" + "lfs pcc attach - attach given files to Persistent Client Cache\n" + "lfs pcc attach_fid - attach given files into PCC by FID(s)\n" + "lfs pcc state - display the PCC state for given files\n" + "lfs pcc detach - detach given files from Persistent Client Cache\n" + "lfs pcc detach_fid - detach given files from PCC by FID(s)\n"}, {"help", Parser_help, 0, "help"}, {"exit", Parser_quit, 0, "quit"}, {"quit", Parser_quit, 0, "quit"}, @@ -590,13 +713,28 @@ static int check_hashtype(const char *hashtype) return 0; } +static uint32_t check_foreign_type_name(const char *foreign_type_name) +{ + uint32_t i; + + for (i = 0; i < LU_FOREIGN_TYPE_UNKNOWN; i++) { + if (lu_foreign_types[i].lft_name == NULL) + break; + if (strcmp(foreign_type_name, + lu_foreign_types[i].lft_name) == 0) + return lu_foreign_types[i].lft_type; + } + + return LU_FOREIGN_TYPE_UNKNOWN; +} static const char *error_loc = "syserror"; enum { - MIGRATION_NONBLOCK = 1 << 0, - MIGRATION_MIRROR = 1 << 1, - MIGRATION_NONDIRECT = 1 << 2, + MIGRATION_NONBLOCK = 0x0001, + MIGRATION_MIRROR = 0x0002, + MIGRATION_NONDIRECT = 0x0004, + MIGRATION_VERBOSE = 0x0008, }; static int lfs_component_create(char *fname, int open_flags, mode_t open_mode, @@ -958,16 +1096,31 @@ static int lfs_component_set(char *fname, int comp_id, } if (neg_flags) { + if (neg_flags & LCME_FL_STALE) { + fprintf(stderr, "%s: cannot clear 'stale' flags from " + "component. Please use lfs-mirror-resync(1) " + "instead\n", progname); + return -EINVAL; + } + ids[count] = comp_id; flags_array[count] = neg_flags | LCME_FL_NEG; ++count; } rc = llapi_layout_file_comp_set(fname, ids, flags_array, count); - if (rc) - fprintf(stderr, - "%s: cannot change the flags of component '%#x' of file '%s': %x / ^(%x)\n", - progname, comp_id, fname, flags, neg_flags); + if (rc) { + if (errno == EUCLEAN) { + rc = -errno; + fprintf(stderr, + "%s: cannot set 'stale' flag on component '%#x' of the last non-stale mirror of '%s'\n", + progname, comp_id, fname); + } else { + fprintf(stderr, + "%s: cannot change the flags of component '%#x' of file '%s': %x / ^(%x)\n", + progname, comp_id, fname, flags, neg_flags); + } + } return rc; } @@ -986,7 +1139,6 @@ static int lfs_component_del(char *fname, __u32 comp_id, if ((flags && comp_id) || (!flags && !comp_id)) return -EINVAL; - /* LCME_FL_INIT is the only supported flag in PFL */ if (flags) { if (flags & ~LCME_KNOWN_FLAGS) { fprintf(stderr, @@ -1049,6 +1201,8 @@ static int lfs_migrate(char *name, __u64 migration_flags, struct llapi_stripe_param *param, struct llapi_layout *layout) { + struct llapi_layout *existing; + uint64_t dom_new, dom_cur; int fd = -1; int fdv = -1; int rc; @@ -1058,6 +1212,36 @@ static int lfs_migrate(char *name, __u64 migration_flags, if (rc < 0) goto out; + rc = llapi_layout_dom_size(layout, &dom_new); + if (rc) { + error_loc = "cannot get new layout DoM size"; + goto out; + } + /* special case for migration to DOM layout*/ + existing = llapi_layout_get_by_fd(fd, 0); + if (!existing) { + error_loc = "cannot get existing layout"; + goto out; + } + + rc = llapi_layout_dom_size(existing, &dom_cur); + if (rc) { + error_loc = "cannot get current layout DoM size"; + goto out; + } + + /* if file has DoM layout already then migration is possible to + * the new layout with the same DoM component via swap layout, + * if new layout used bigger DOM size, then mirroring is used + */ + if (dom_new > dom_cur) { + rc = lfs_migrate_to_dom(fd, fdv, name, migration_flags, param, + layout); + if (rc) + error_loc = "cannot migrate to DOM layout"; + goto out_closed; + } + if (!(migration_flags & MIGRATION_NONBLOCK)) { /* Blocking mode (forced if servers do not support file lease). * It is also the default mode, since we cannot distinguish @@ -1094,10 +1278,13 @@ out: if (fdv >= 0) close(fdv); - +out_closed: if (rc < 0) fprintf(stderr, "error: %s: %s: %s: %s\n", progname, name, error_loc, strerror(-rc)); + else if (migration_flags & MIGRATION_VERBOSE) + printf("%s\n", name); + return rc; } @@ -1188,69 +1375,6 @@ struct mirror_args { struct mirror_args *m_next; }; -static int mirror_sanity_check_flags(struct llapi_layout *layout, void *unused) -{ - uint32_t flags; - int rc; - - rc = llapi_layout_comp_flags_get(layout, &flags); - if (rc) - return -errno; - - if (flags & LCME_FL_NEG) { - fprintf(stderr, "error: %s: negative flags are not supported\n", - progname); - return -EINVAL; - } - - if (flags & LCME_FL_STALE) { - fprintf(stderr, "error: %s: setting '%s' is not supported\n", - progname, comp_flags_table[LCME_FL_STALE].cfn_name); - return -EINVAL; - } - - return LLAPI_LAYOUT_ITER_CONT; -} - -static inline int mirror_sanity_check_one(struct llapi_layout *layout) -{ - uint64_t start, end; - uint64_t pattern; - int rc; - - /* LU-10112: do not support dom+flr in phase 1 */ - rc = llapi_layout_comp_use(layout, LLAPI_LAYOUT_COMP_USE_FIRST); - if (rc) - return -errno; - - rc = llapi_layout_pattern_get(layout, &pattern); - if (rc) - return -errno; - - if (pattern == LOV_PATTERN_MDT || pattern == LLAPI_LAYOUT_MDT) { - fprintf(stderr, "error: %s: doesn't support dom+flr for now\n", - progname); - return -ENOTSUP; - } - - rc = llapi_layout_comp_use(layout, LLAPI_LAYOUT_COMP_USE_LAST); - if (rc) - return -errno; - - rc = llapi_layout_comp_extent_get(layout, &start, &end); - if (rc) - return -errno; - - if (end != LUSTRE_EOF) { - fprintf(stderr, "error: %s: mirror layout doesn't reach eof\n", - progname); - return -EINVAL; - } - - rc = llapi_layout_comp_iterate(layout, mirror_sanity_check_flags, NULL); - return rc; -} - /** * enum mirror_flags - Flags for extending a mirrored file. * @MF_NO_VERIFY: Indicates not to verify the mirror(s) from victim file(s) @@ -1265,6 +1389,7 @@ enum mirror_flags { MF_NO_VERIFY = 0x1, MF_DESTROY = 0x2, MF_COMP_ID = 0x4, + MF_COMP_POOL = 0x8, }; /** @@ -1297,11 +1422,14 @@ static int mirror_create_sanity_check(const char *fname, return -ENODATA; } - rc = mirror_sanity_check_one(layout); + rc = llapi_layout_sanity(layout, false, true); + llapi_layout_free(layout); - if (rc) + if (rc) { + llapi_layout_sanity_perror(rc); return rc; + } } while (list != NULL) { @@ -1326,9 +1454,11 @@ static int mirror_create_sanity_check(const char *fname, } } - rc = mirror_sanity_check_one(list->m_layout); - if (rc) + rc = llapi_layout_sanity(list->m_layout, false, true); + if (rc) { + llapi_layout_sanity_perror(rc); return rc; + } list = list->m_next; } @@ -1714,7 +1844,99 @@ static int find_comp_id(struct llapi_layout *layout, void *cbdata) return LLAPI_LAYOUT_ITER_CONT; } -static int mirror_split(const char *fname, __u32 id, + +struct pool_to_id_cbdata { + const char *pool; + __u32 id; +}; +static int find_comp_id_by_pool(struct llapi_layout *layout, void *cbdata) +{ + char buf[LOV_MAXPOOLNAME + 1]; + struct pool_to_id_cbdata *d = (void *)cbdata; + uint32_t id; + int rc; + + rc = llapi_layout_pool_name_get(layout, buf, sizeof(buf)); + if (rc < 0) + return rc; + if (strcmp(d->pool, buf)) + return LLAPI_LAYOUT_ITER_CONT; + + rc = llapi_layout_mirror_id_get(layout, &id); + if (rc < 0) + return rc; + d->id = id; + + return LLAPI_LAYOUT_ITER_STOP; +} + +struct collect_ids_data { + __u16 *cid_ids; + int cid_count; + __u16 cid_exclude; +}; + +static int collect_mirror_id(struct llapi_layout *layout, void *cbdata) +{ + struct collect_ids_data *cid = cbdata; + uint32_t id; + int rc; + + rc = llapi_layout_mirror_id_get(layout, &id); + if (rc < 0) + return rc; + + if ((__u16)id != cid->cid_exclude) { + int i; + + for (i = 0; i < cid->cid_count; i++) { + /* already collected the mirror id */ + if (id == cid->cid_ids[i]) + return LLAPI_LAYOUT_ITER_CONT; + } + cid->cid_ids[cid->cid_count] = id; + cid->cid_count++; + } + + return LLAPI_LAYOUT_ITER_CONT; +} + +/** + * last_non_stale_mirror() - Check if a mirror is the last non-stale mirror. + * @mirror_id: Mirror id to be checked. + * @layout: Mirror component list. + * + * This function checks if a mirror with specified @mirror_id is the last + * non-stale mirror of a layout @layout. + * + * Return: true or false. + */ +static inline +bool last_non_stale_mirror(__u16 mirror_id, struct llapi_layout *layout) +{ + __u16 mirror_ids[128] = { 0 }; + struct collect_ids_data cid = { .cid_ids = mirror_ids, + .cid_count = 0, + .cid_exclude = mirror_id, }; + int i; + + llapi_layout_comp_iterate(layout, collect_mirror_id, &cid); + + for (i = 0; i < cid.cid_count; i++) { + struct llapi_resync_comp comp_array[1024] = { { 0 } }; + int comp_size = 0; + + comp_size = llapi_mirror_find_stale(layout, comp_array, + ARRAY_SIZE(comp_array), + &mirror_ids[i], 1); + if (comp_size == 0) + return false; + } + + return true; +} + +static int mirror_split(const char *fname, __u32 id, const char *pool, enum mirror_flags mflags, const char *victim_file) { struct llapi_layout *layout; @@ -1737,9 +1959,11 @@ static int mirror_split(const char *fname, __u32 id, return -EINVAL; } - rc = mirror_sanity_check_one(layout); - if (rc) + rc = llapi_layout_sanity(layout, false, true); + if (rc) { + llapi_layout_sanity_perror(rc); goto free_layout; + } rc = llapi_layout_mirror_count_get(layout, &mirror_count); if (rc) { @@ -1755,7 +1979,13 @@ static int mirror_split(const char *fname, __u32 id, goto free_layout; } - if (mflags & MF_COMP_ID) { + if (mflags & MF_COMP_POOL) { + struct pool_to_id_cbdata data = { .pool = pool }; + + rc = llapi_layout_comp_iterate(layout, find_comp_id_by_pool, + &data); + id = data.id; + } else if (mflags & MF_COMP_ID) { rc = llapi_layout_comp_iterate(layout, find_comp_id, &id); id = mirror_id_of(id); } else { @@ -1812,6 +2042,14 @@ static int mirror_split(const char *fname, __u32 id, if (victim_file == NULL) { /* use a temp file to store the splitted layout */ if (mflags & MF_DESTROY) { + if (last_non_stale_mirror(id, layout)) { + rc = -EUCLEAN; + fprintf(stderr, + "%s: cannot destroy the last non-stale mirror of file '%s'\n", + progname, fname); + goto close_fd; + } + fdv = llapi_create_volatile_idx(parent, mdt_index, O_LOV_DELAY_CREATE); } else { @@ -1873,6 +2111,72 @@ free_layout: return rc; } +static inline +int lfs_mirror_resync_file(const char *fname, struct ll_ioc_lease *ioc, + __u16 *mirror_ids, int ids_nr); + +static int lfs_migrate_to_dom(int fd, int fdv, char *name, + __u64 migration_flags, + struct llapi_stripe_param *param, + struct llapi_layout *layout) +{ + struct ll_ioc_lease *data = NULL; + int rc; + + rc = llapi_lease_acquire(fd, LL_LEASE_RDLCK); + if (rc < 0) { + error_loc = "cannot get lease"; + goto out_close; + } + + /* Atomically put lease, merge layouts, resync and close. */ + data = calloc(1, offsetof(typeof(*data), lil_ids[1024])); + if (!data) { + error_loc = "memory allocation"; + goto out_close; + } + data->lil_mode = LL_LEASE_UNLCK; + data->lil_flags = LL_LEASE_LAYOUT_MERGE; + data->lil_count = 1; + data->lil_ids[0] = fdv; + rc = llapi_lease_set(fd, data); + if (rc < 0) { + error_loc = "cannot merge layout"; + goto out_close; + } else if (rc == 0) { + rc = -EBUSY; + error_loc = "lost lease lock"; + goto out_close; + } + close(fd); + close(fdv); + + rc = lfs_mirror_resync_file(name, data, NULL, 0); + if (rc) { + error_loc = "cannot resync file"; + goto out; + } + + /* delete first mirror now */ + rc = mirror_split(name, 1, NULL, MF_DESTROY, NULL); + if (rc < 0) + error_loc = "cannot delete old layout"; + goto out; + +out_close: + close(fd); + close(fdv); +out: + if (rc < 0) + fprintf(stderr, "error: %s: %s: %s: %s\n", + progname, name, error_loc, strerror(-rc)); + else if (migration_flags & MIGRATION_VERBOSE) + printf("%s\n", name); + if (data) + free(data); + return rc; +} + /** * Parse a string containing an target index list into an array of integers. * @@ -1880,20 +2184,23 @@ free_layout: * indices and ranges, for example "1,2-4,7". Add the indices into the * \a tgts array and remove duplicates. * - * \param[out] tgts array to store indices in - * \param[in] size size of \a tgts array - * \param[in] offset starting index in \a tgts - * \param[in] arg string containing OST index list + * \param[out] tgts array to store indices in + * \param[in] size size of \a tgts array + * \param[in] offset starting index in \a tgts + * \param[in] arg string containing OST index list + * \param[in/out] overstriping index list may contain duplicates * * \retval positive number of indices in \a tgts * \retval -EINVAL unable to parse \a arg */ -static int parse_targets(__u32 *tgts, int size, int offset, char *arg) +static int parse_targets(__u32 *tgts, int size, int offset, char *arg, + unsigned long long *pattern) { int rc; int nr = offset; int slots = size - offset; char *ptr = NULL; + bool overstriped = false; bool end_of_loop; if (arg == NULL) @@ -1901,8 +2208,8 @@ static int parse_targets(__u32 *tgts, int size, int offset, char *arg) end_of_loop = false; while (!end_of_loop) { - int start_index; - int end_index; + int start_index = 0; + int end_index = 0; int i; char *endptr = NULL; @@ -1933,14 +2240,21 @@ static int parse_targets(__u32 *tgts, int size, int offset, char *arg) /* remove duplicate */ for (j = 0; j < offset; j++) { - if (tgts[j] == i) - break; + if (tgts[j] == i && pattern && + *pattern == LLAPI_LAYOUT_OVERSTRIPING) + overstriped = true; + else if (tgts[j] == i) + return -EINVAL; } - if (j == offset) { /* no duplicate */ + + j = offset; + + if (j == offset) { /* check complete */ tgts[nr++] = i; --slots; } } + if (slots == 0 && i < end_index) break; @@ -1952,12 +2266,16 @@ static int parse_targets(__u32 *tgts, int size, int offset, char *arg) if (!end_of_loop && ptr != NULL) *ptr = ','; + if (!overstriped && pattern) + *pattern = LLAPI_LAYOUT_DEFAULT; + return rc < 0 ? rc : nr; } struct lfs_setstripe_args { unsigned long long lsa_comp_end; unsigned long long lsa_stripe_size; + unsigned long long lsa_extension_size; long long lsa_stripe_count; long long lsa_stripe_off; __u32 lsa_comp_flags; @@ -1966,6 +2284,7 @@ struct lfs_setstripe_args { unsigned int lsa_mirror_count; int lsa_nr_tgts; bool lsa_first_comp; + bool lsa_extension_comp; __u32 *lsa_tgts; char *lsa_pool_name; }; @@ -2019,7 +2338,6 @@ static inline bool setstripe_args_specified(struct lfs_setstripe_args *lsa) lsa->lsa_stripe_count != LLAPI_LAYOUT_DEFAULT || lsa->lsa_stripe_off != LLAPI_LAYOUT_DEFAULT || lsa->lsa_pattern != LLAPI_LAYOUT_RAID0 || - lsa->lsa_pool_name != NULL || lsa->lsa_comp_end != 0); } @@ -2039,16 +2357,20 @@ static int comp_args_to_layout(struct llapi_layout **composite, { struct llapi_layout *layout = *composite; uint64_t prev_end = 0; + uint64_t size; int i = 0, rc; +new_comp: if (layout == NULL) { layout = llapi_layout_alloc(); if (layout == NULL) { fprintf(stderr, "Alloc llapi_layout failed. %s\n", strerror(errno)); - return -ENOMEM; + errno = ENOMEM; + return -1; } *composite = layout; + lsa->lsa_first_comp = true; } else { uint64_t start; @@ -2074,18 +2396,32 @@ static int comp_args_to_layout(struct llapi_layout **composite, return rc; } } - /* reset lsa_first_comp */ - lsa->lsa_first_comp = false; + + rc = llapi_layout_comp_flags_set(layout, lsa->lsa_comp_flags); + if (rc) { + fprintf(stderr, "Set flags 0x%x failed: %s\n", + lsa->lsa_comp_flags, strerror(errno)); + return rc; + } if (set_extent) { + uint64_t comp_end = lsa->lsa_comp_end; + + /* The extendable component is 0-length, so it can be removed + * if there is insufficient space to extend it. */ + if (lsa->lsa_extension_comp) + comp_end = prev_end; + rc = llapi_layout_comp_extent_set(layout, prev_end, - lsa->lsa_comp_end); + comp_end); if (rc) { - fprintf(stderr, "Set extent [%lu, %llu) failed. %s\n", - prev_end, lsa->lsa_comp_end, strerror(errno)); + fprintf(stderr, "Set extent [%lu, %lu) failed. %s\n", + prev_end, comp_end, strerror(errno)); return rc; } } + /* reset lsa_first_comp */ + lsa->lsa_first_comp = false; /* Data-on-MDT component setting */ if (lsa->lsa_pattern == LLAPI_LAYOUT_MDT) { @@ -2095,47 +2431,68 @@ static int comp_args_to_layout(struct llapi_layout **composite, fprintf(stderr, "Option 'stripe-count' can't be " "specified with Data-on-MDT component: %lld\n", lsa->lsa_stripe_count); - return -EINVAL; + errno = EINVAL; + return -1; } if (lsa->lsa_stripe_size != LLAPI_LAYOUT_DEFAULT) { fprintf(stderr, "Option 'stripe-size' can't be " "specified with Data-on-MDT component: %llu\n", lsa->lsa_stripe_size); - return -EINVAL; + errno = EINVAL; + return -1; } if (lsa->lsa_nr_tgts != 0) { fprintf(stderr, "Option 'ost-list' can't be specified " "with Data-on-MDT component: '%i'\n", lsa->lsa_nr_tgts); - return -EINVAL; + errno = EINVAL; + return -1; } if (lsa->lsa_stripe_off != LLAPI_LAYOUT_DEFAULT) { fprintf(stderr, "Option 'stripe-offset' can't be " "specified with Data-on-MDT component: %lld\n", lsa->lsa_stripe_off); - return -EINVAL; + errno = EINVAL; + return -1; } if (lsa->lsa_pool_name != 0) { fprintf(stderr, "Option 'pool' can't be specified " "with Data-on-MDT component: '%s'\n", lsa->lsa_pool_name); - return -EINVAL; + errno = EINVAL; + return -1; } rc = llapi_layout_pattern_set(layout, lsa->lsa_pattern); if (rc) { fprintf(stderr, "Set stripe pattern %#llx failed. %s\n", - lsa->lsa_pattern, strerror(errno)); + lsa->lsa_pattern, + strerror(errno)); return rc; } /* Data-on-MDT component has always single stripe up to end */ lsa->lsa_stripe_size = lsa->lsa_comp_end; + } else if (lsa->lsa_pattern == LLAPI_LAYOUT_OVERSTRIPING) { + rc = llapi_layout_pattern_set(layout, lsa->lsa_pattern); + if (rc) { + fprintf(stderr, "Set stripe pattern %#llx failed. %s\n", + lsa->lsa_pattern, + strerror(errno)); + return rc; + } } - rc = llapi_layout_stripe_size_set(layout, lsa->lsa_stripe_size); + size = lsa->lsa_comp_flags & LCME_FL_EXTENSION ? + lsa->lsa_extension_size : lsa->lsa_stripe_size; + + if (lsa->lsa_comp_flags & LCME_FL_EXTENSION) + rc = llapi_layout_extension_size_set(layout, size); + else + rc = llapi_layout_stripe_size_set(layout, size); + if (rc) { - fprintf(stderr, "Set stripe size %llu failed: %s\n", - lsa->lsa_stripe_size, strerror(errno)); + fprintf(stderr, "Set stripe size %lu failed: %s\n", + size, strerror(errno)); return rc; } @@ -2146,13 +2503,6 @@ static int comp_args_to_layout(struct llapi_layout **composite, return rc; } - rc = llapi_layout_comp_flags_set(layout, lsa->lsa_comp_flags); - if (rc) { - fprintf(stderr, "Set flags 0x%x failed: %s\n", - lsa->lsa_comp_flags, strerror(errno)); - return rc; - } - if (lsa->lsa_pool_name != NULL) { rc = llapi_layout_pool_name_set(layout, lsa->lsa_pool_name); if (rc) { @@ -2175,8 +2525,10 @@ static int comp_args_to_layout(struct llapi_layout **composite, lsa->lsa_stripe_count != LLAPI_LAYOUT_WIDE && lsa->lsa_nr_tgts != lsa->lsa_stripe_count) { fprintf(stderr, "stripe_count(%lld) != nr_tgts(%d)\n", - lsa->lsa_stripe_count, lsa->lsa_nr_tgts); - return -EINVAL; + lsa->lsa_stripe_count, + lsa->lsa_nr_tgts); + errno = EINVAL; + return -1; } for (i = 0; i < lsa->lsa_nr_tgts; i++) { rc = llapi_layout_ost_index_set(layout, i, @@ -2194,7 +2546,14 @@ static int comp_args_to_layout(struct llapi_layout **composite, return rc; } - return 0; + /* Create the second, virtual component of extension space */ + if (lsa->lsa_extension_comp) { + lsa->lsa_comp_flags |= LCME_FL_EXTENSION; + lsa->lsa_extension_comp = false; + goto new_comp; + } + + return rc; } static int build_component(struct llapi_layout **layout, @@ -2230,59 +2589,78 @@ static int build_layout_from_yaml_node(struct cYAML *node, int rc = 0; while (node) { - string = node->cy_string; - /* skip leading lmm_ if present, to simplify parsing */ - if (string != NULL && strncmp(string, "lmm_", 4) == 0) - string += 4; - - if (node->cy_type == CYAML_TYPE_STRING) { - if (!strcmp(string, "lcme_extent.e_end")) { - if (!strcmp(node->cy_valuestring, "EOF") || - !strcmp(node->cy_valuestring, "eof")) - lsa->lsa_comp_end = LUSTRE_EOF; - } else if (!strcmp(string, "pool")) { - lsa->lsa_pool_name = node->cy_valuestring; - } else if (!strcmp(string, "pattern")) { - if (!strcmp(node->cy_valuestring, "mdt")) - lsa->lsa_pattern = LLAPI_LAYOUT_MDT; - } - } else if (node->cy_type == CYAML_TYPE_NUMBER) { - if (!strcmp(string, "lcm_mirror_count")) { - lsa->lsa_mirror_count = node->cy_valueint; - } else if (!strcmp(string, "lcme_extent.e_start")) { - if (node->cy_valueint != 0 || *layout != NULL) { - rc = build_component(layout, lsa, true); - if (rc) - return rc; - } - - if (node->cy_valueint == 0) - lsa->lsa_first_comp = true; - - /* initialize lsa */ - setstripe_args_init(lsa); - lsa->lsa_tgts = osts; - } else if (!strcmp(string, "lcme_extent.e_end")) { - if (node->cy_valueint == -1) - lsa->lsa_comp_end = LUSTRE_EOF; - else - lsa->lsa_comp_end = node->cy_valueint; - } else if (!strcmp(string, "stripe_count")) { - lsa->lsa_stripe_count = node->cy_valueint; - } else if (!strcmp(string, "stripe_size")) { - lsa->lsa_stripe_size = node->cy_valueint; - } else if (!strcmp(string, "stripe_offset")) { - lsa->lsa_stripe_off = node->cy_valueint; - } else if (!strcmp(string, "l_ost_idx")) { - osts[lsa->lsa_nr_tgts] = node->cy_valueint; - lsa->lsa_nr_tgts++; - } - } else if (node->cy_type == CYAML_TYPE_OBJECT) { + if (node->cy_type == CYAML_TYPE_OBJECT) { /* go deep to sub blocks */ rc = build_layout_from_yaml_node(node->cy_child, layout, lsa, osts); if (rc) return rc; + } else { + if (node->cy_string == NULL) + return -EINVAL; + + string = node->cy_string; + /* skip leading lmm_ if present, to simplify parsing */ + if (strncmp(string, "lmm_", 4) == 0) + string += 4; + + if (node->cy_type == CYAML_TYPE_STRING) { + if (!strcmp(string, "lcme_extent.e_end")) { + if (!strcmp(node->cy_valuestring, "EOF") || + !strcmp(node->cy_valuestring, "eof")) + lsa->lsa_comp_end = LUSTRE_EOF; + } else if (!strcmp(string, "pool")) { + lsa->lsa_pool_name = node->cy_valuestring; + } else if (!strcmp(string, "pattern")) { + if (!strcmp(node->cy_valuestring, "mdt")) + lsa->lsa_pattern = LLAPI_LAYOUT_MDT; + if (!strcmp(node->cy_valuestring, + "raid0,overstriped")) + lsa->lsa_pattern = + LLAPI_LAYOUT_OVERSTRIPING; + } else if (!strcmp(string, "lcme_flags")) { + rc = comp_str2flags(node->cy_valuestring, + &lsa->lsa_comp_flags, + &lsa->lsa_comp_neg_flags); + if (rc) + return rc; + /* Only template flags have meaning in + * the layout for a new file + */ + lsa->lsa_comp_flags &= LCME_TEMPLATE_FLAGS; + } + } else if (node->cy_type == CYAML_TYPE_NUMBER) { + if (!strcmp(string, "lcm_mirror_count")) { + lsa->lsa_mirror_count = node->cy_valueint; + } else if (!strcmp(string, "lcme_extent.e_start")) { + if (node->cy_valueint != 0 || *layout != NULL) { + rc = build_component(layout, lsa, true); + if (rc) + return rc; + } + + if (node->cy_valueint == 0) + lsa->lsa_first_comp = true; + + /* initialize lsa */ + setstripe_args_init(lsa); + lsa->lsa_tgts = osts; + } else if (!strcmp(string, "lcme_extent.e_end")) { + if (node->cy_valueint == -1) + lsa->lsa_comp_end = LUSTRE_EOF; + else + lsa->lsa_comp_end = node->cy_valueint; + } else if (!strcmp(string, "stripe_count")) { + lsa->lsa_stripe_count = node->cy_valueint; + } else if (!strcmp(string, "stripe_size")) { + lsa->lsa_stripe_size = node->cy_valueint; + } else if (!strcmp(string, "stripe_offset")) { + lsa->lsa_stripe_off = node->cy_valueint; + } else if (!strcmp(string, "l_ost_idx")) { + osts[lsa->lsa_nr_tgts] = node->cy_valueint; + lsa->lsa_nr_tgts++; + } + } } node = node->cy_next; } @@ -2331,50 +2709,133 @@ err: return rc; } -/* In 'lfs setstripe --component-add' mode, we need to fetch the extent - * end of the last component in the existing file, and adjust the - * first extent start of the components to be added accordingly. */ -static int adjust_first_extent(char *fname, struct llapi_layout *layout) +/** + * Get the extension size from the next (SEL) component and extend the + * current component on it. The start of the next component is to be + * adjusted as well. + * + * \param[in] layout the current layout + * \param[in] start the start of the current component + * \param[in,out] end the end of the current component + * \param[in] offset the offset to adjust the end position to instead of + * extension size + * + * \retval 0 - extended successfully + * \retval < 0 - error + */ +static int layout_extend_comp(struct llapi_layout *layout, + uint64_t start, uint64_t *end, + uint64_t offset) { - struct llapi_layout *head; - uint64_t start, end, stripe_size, prev_end = 0; + uint64_t size, next_start, next_end; int rc; - if (layout == NULL) { - fprintf(stderr, - "%s setstripe: layout must be specified\n", - progname); - return -EINVAL; + rc = llapi_layout_comp_use(layout, LLAPI_LAYOUT_COMP_USE_NEXT); + if (rc < 0) { + fprintf(stderr, "%s setstripe: cannot move component cursor: " + "%s\n", progname, strerror(errno)); + return rc; } - errno = 0; - head = llapi_layout_get_by_path(fname, 0); - if (head == NULL) { - fprintf(stderr, - "%s setstripe: cannot read layout from '%s': %s\n", - progname, fname, strerror(errno)); - return -EINVAL; - } else if (errno == ENODATA) { - /* file without LOVEA, this component-add will be turned - * into a component-create. */ - llapi_layout_free(head); - return -ENODATA; - } else if (!llapi_layout_is_composite(head)) { - fprintf(stderr, "%s setstripe: '%s' not a composite file\n", - progname, fname); - llapi_layout_free(head); - return -EINVAL; + /* Even if the @size will not be used below, this will fail if + * this is not a SEL component - a good confirmation we are + * working on right components. */ + rc = llapi_layout_extension_size_get(layout, &size); + if (rc < 0) { + fprintf(stderr, "%s setstripe: cannot get component ext size: " + "%s\n", progname, strerror(errno)); + return rc; } - rc = llapi_layout_comp_extent_get(head, &start, &prev_end); + rc = llapi_layout_comp_extent_get(layout, &next_start, &next_end); if (rc) { - fprintf(stderr, "%s setstripe: cannot get prev extent: %s\n", + fprintf(stderr, "%s setstripe: cannot get extent: %s\n", + progname, strerror(errno)); + return rc; + } + + next_start += offset ?: size; + rc = llapi_layout_comp_extent_set(layout, next_start, next_end); + if (rc) { + fprintf(stderr, "%s setstripe: cannot set extent: %s\n", + progname, strerror(errno)); + return rc; + } + + rc = llapi_layout_comp_use(layout, LLAPI_LAYOUT_COMP_USE_PREV); + if (rc < 0) { + fprintf(stderr, "%s setstripe: cannot move component cursor: " + "%s\n", progname, strerror(errno)); + return rc; + } + + *end += offset ?: size; + rc = llapi_layout_comp_extent_set(layout, start, *end); + if (rc) { + fprintf(stderr, "%s setstripe: cannot set extent: %s\n", progname, strerror(errno)); - llapi_layout_free(head); return rc; } - llapi_layout_free(head); + return 0; +} + +/** + * In 'lfs setstripe --component-add' mode, we need to fetch the extent + * end of the last component in the existing file, and adjust the + * first extent start of the components to be added accordingly. + * + * In the create mode, we need to check if the first component is an extendable + * SEL component and extend its length to the extension size (first component + * of the PFL file is initialised at the create time, cannot be 0-lenght. + */ +static int layout_adjust_first_extent(char *fname, struct llapi_layout *layout, + bool comp_add) +{ + struct llapi_layout *head; + uint64_t start = 0, prev_end = 0; + uint64_t end; + int rc, ret = 0; + + if (layout == NULL) + return 0; + + errno = 0; + while (comp_add) { + head = llapi_layout_get_by_path(fname, 0); + if (head == NULL) { + fprintf(stderr, + "%s setstripe: cannot read layout from '%s': " + "%s\n", progname, fname, strerror(errno)); + return -EINVAL; + } else if (errno == ENODATA) { + /* file without LOVEA, this component-add will be turned + * into a component-create. */ + llapi_layout_free(head); + ret = -ENODATA; + + /* the new layout will be added to an empty one, it + * still needs to be adjusted below */ + comp_add = 0; + break; + } else if (!llapi_layout_is_composite(head)) { + fprintf(stderr, "%s setstripe: '%s' not a composite " + "file\n", progname, fname); + llapi_layout_free(head); + return -EINVAL; + } + + rc = llapi_layout_comp_extent_get(head, &start, &prev_end); + if (rc) { + fprintf(stderr, "%s setstripe: cannot get prev " + "extent: %s\n", progname, strerror(errno)); + llapi_layout_free(head); + return rc; + } + + llapi_layout_free(head); + break; + } /* Make sure we use the first component of the layout to be added. */ rc = llapi_layout_comp_use(layout, LLAPI_LAYOUT_COMP_USE_FIRST); @@ -2392,37 +2853,46 @@ static int adjust_first_extent(char *fname, struct llapi_layout *layout) return rc; } - if (start > prev_end || end <= prev_end) { - fprintf(stderr, - "%s setstripe: first extent [%lu, %lu) not adjacent with extent end %lu\n", - progname, start, end, prev_end); - return -EINVAL; - } - - rc = llapi_layout_stripe_size_get(layout, &stripe_size); - if (rc) { - fprintf(stderr, "%s setstripe: cannot get stripe size: %s\n", - progname, strerror(errno)); - return rc; + if (start == 0 && end == 0) { + rc = layout_extend_comp(layout, start, &end, + comp_add ? prev_end : 0); + if (rc) + return rc; } - if (stripe_size != LLAPI_LAYOUT_DEFAULT && - (prev_end & (stripe_size - 1))) { - fprintf(stderr, - "%s setstripe: stripe size %lu not aligned with %lu\n", - progname, stripe_size, prev_end); + if (start > prev_end || end < prev_end) { + fprintf(stderr, "%s setstripe: first extent [%lu, %lu) not " + "adjacent with extent end %lu\n", + progname, start, end, prev_end); return -EINVAL; } rc = llapi_layout_comp_extent_set(layout, prev_end, end); if (rc) { - fprintf(stderr, - "%s setstripe: cannot set component extent [%lu, %lu): %s\n", + fprintf(stderr, "%s setstripe: cannot set component extent " + "[%lu, %lu): %s\n", progname, prev_end, end, strerror(errno)); return rc; } - return 0; + return ret; +} + +static int mirror_adjust_first_extents(struct mirror_args *list) +{ + int rc = 0; + + if (list == NULL) + return 0; + + while (list != NULL) { + rc = layout_adjust_first_extent(NULL, list->m_layout, false); + if (rc) + break; + list = list->m_next; + } + + return rc; } static inline bool arg_is_eof(char *arg) @@ -2499,10 +2969,13 @@ enum { LFS_COMP_ADD_OPT, LFS_COMP_NO_VERIFY_OPT, LFS_PROJID_OPT, - LFS_MIRROR_FLAGS_OPT, + LFS_LAYOUT_FLAGS_OPT, /* used for mirror and foreign flags */ LFS_MIRROR_ID_OPT, LFS_MIRROR_STATE_OPT, LFS_LAYOUT_COPY, + LFS_MIRROR_INDEX_OPT, + LFS_LAYOUT_FOREIGN_OPT, + LFS_MODE_OPT, }; /* functions */ @@ -2521,12 +2994,13 @@ static int lfs_setstripe_internal(int argc, char **argv, char *end; int c; int delete = 0; - char *mdt_idx_arg = NULL; unsigned long long size_units = 1; bool migrate_mode = false; + bool migrate_mdt_mode = false; + bool setstripe_mode = false; bool migration_block = false; __u64 migration_flags = 0; - __u32 osts[LOV_MAX_STRIPE_COUNT] = { 0 }; + __u32 tgts[LOV_MAX_STRIPE_COUNT] = { 0 }; int comp_del = 0, comp_set = 0; int comp_add = 0; __u32 comp_id = 0; @@ -2544,8 +3018,15 @@ static int lfs_setstripe_internal(int argc, char **argv, bool from_yaml = false; bool from_copy = false; char *template = NULL; + bool foreign_mode = false; + char *xattr = NULL; + uint32_t type = LU_FOREIGN_TYPE_NONE, flags = 0; + char *mode_opt = NULL; + mode_t previous_umask = 0; + mode_t mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH; struct option long_opts[] = { +/* find { .val = '0', .name = "null", .has_arg = no_argument }, */ /* find { .val = 'A', .name = "atime", .has_arg = required_argument }*/ /* --block is only valid in migrate mode */ { .val = 'b', .name = "block", .has_arg = no_argument }, @@ -2569,15 +3050,21 @@ static int lfs_setstripe_internal(int argc, char **argv, .has_arg = no_argument}, { .val = LFS_COMP_NO_VERIFY_OPT, .name = "no-verify", .has_arg = no_argument}, - { .val = LFS_MIRROR_FLAGS_OPT, + { .val = LFS_LAYOUT_FLAGS_OPT, .name = "flags", .has_arg = required_argument}, + { .val = LFS_LAYOUT_FOREIGN_OPT, + .name = "foreign", .has_arg = optional_argument}, { .val = LFS_MIRROR_ID_OPT, .name = "mirror-id", .has_arg = required_argument}, + { .val = LFS_MODE_OPT, + .name = "mode", .has_arg = required_argument}, { .val = LFS_LAYOUT_COPY, .name = "copy", .has_arg = required_argument}, { .val = 'c', .name = "stripe-count", .has_arg = required_argument}, { .val = 'c', .name = "stripe_count", .has_arg = required_argument}, -/* find { .val = 'C', .name = "ctime", .has_arg = required_argument }*/ + { .val = 'c', .name = "mdt-count", .has_arg = required_argument}, + { .val = 'C', .name = "overstripe-count", + .has_arg = required_argument}, { .val = 'd', .name = "delete", .has_arg = no_argument}, { .val = 'd', .name = "destroy", .has_arg = no_argument}, /* --non-direct is only valid in migrate mode */ @@ -2589,11 +3076,13 @@ static int lfs_setstripe_internal(int argc, char **argv, /* find { .val = 'F', .name = "fid", .has_arg = no_argument }, */ /* find { .val = 'g', .name = "gid", .has_arg = no_argument }, */ /* find { .val = 'G', .name = "group", .has_arg = required_argument }*/ -/* dirstripe { .val = 'H', .name = "mdt-hash", .has_arg = required_argument }*/ +/* find { .val = 'h', .name = "help", .has_arg = no_argument }, */ + { .val = 'H', .name = "mdt-hash", .has_arg = required_argument}, { .val = 'i', .name = "stripe-index", .has_arg = required_argument}, { .val = 'i', .name = "stripe_index", .has_arg = required_argument}, { .val = 'I', .name = "comp-id", .has_arg = required_argument}, { .val = 'I', .name = "component-id", .has_arg = required_argument}, +/* find { .val = 'l', .name = "lazy", .has_arg = no_argument }, */ { .val = 'L', .name = "layout", .has_arg = required_argument }, { .val = 'm', .name = "mdt", .has_arg = required_argument}, { .val = 'm', .name = "mdt-index", .has_arg = required_argument}, @@ -2619,18 +3108,28 @@ static int lfs_setstripe_internal(int argc, char **argv, /* find { .val = 'U', .name = "user", .has_arg = required_argument }*/ /* --verbose is only valid in migrate mode */ { .val = 'v', .name = "verbose", .has_arg = no_argument}, + { .val = 'x', .name = "xattr", .has_arg = required_argument }, { .val = 'y', .name = "yaml", .has_arg = required_argument }, + { .val = 'z', .name = "ext-size", .has_arg = required_argument}, + { .val = 'z', .name = "extension-size", .has_arg = required_argument}, { .name = NULL } }; setstripe_args_init(&lsa); migrate_mode = (opc == SO_MIGRATE); mirror_mode = (opc == SO_MIRROR_CREATE || opc == SO_MIRROR_EXTEND); + setstripe_mode = (opc == SO_SETSTRIPE); + if (opc == SO_MIRROR_DELETE) { + delete = 1; + mirror_flags = MF_DESTROY; + } snprintf(cmd, sizeof(cmd), "%s %s", progname, argv[0]); progname = cmd; - while ((c = getopt_long(argc, argv, "bc:dDE:f:i:I:m:N::no:p:L:s:S:vy:", + while ((c = getopt_long(argc, argv, + "bc:C:dDE:f:H:i:I:m:N::no:p:L:s:S:vx:y:z:", long_opts, NULL)) >= 0) { + size_units = 1; switch (c) { case 0: /* Long options. */ @@ -2651,14 +3150,6 @@ static int lfs_setstripe_internal(int argc, char **argv, progname); goto usage_error; } - if (lsa.lsa_comp_neg_flags & LCME_FL_STALE) { - fprintf(stderr, - "%s: cannot clear 'stale' flags from component. Please use lfs-mirror-resync(1) instead\n", - progname); - result = -EINVAL; - goto error; - } - break; case LFS_COMP_SET_OPT: comp_set = 1; @@ -2675,8 +3166,20 @@ static int lfs_setstripe_internal(int argc, char **argv, goto usage_error; } break; - case LFS_MIRROR_FLAGS_OPT: { - __u32 flags; + case LFS_LAYOUT_FLAGS_OPT: { + uint32_t neg_flags; + + /* check for numeric flags (foreign and mirror cases) */ + if (setstripe_mode && !mirror_mode && !last_mirror) { + flags = strtoul(optarg, &end, 16); + if (*end != '\0') { + fprintf(stderr, + "%s %s: bad flags '%s'\n", + progname, argv[0], optarg); + return CMD_HELP; + } + break; + } if (!mirror_mode || !last_mirror) { fprintf(stderr, "error: %s: --flags must be specified with --mirror-count|-N option\n", @@ -2685,17 +3188,17 @@ static int lfs_setstripe_internal(int argc, char **argv, } result = comp_str2flags(optarg, &last_mirror->m_flags, - &flags); + &neg_flags); if (result != 0) goto usage_error; - if (flags) { + if (neg_flags) { fprintf(stderr, "%s: inverted flags are not supported\n", progname); result = -EINVAL; goto usage_error; } - if (last_mirror->m_flags & ~LCME_USER_FLAGS) { + if (last_mirror->m_flags & ~LCME_USER_MIRROR_FLAGS) { fprintf(stderr, "%s: unsupported mirror flags: %s\n", progname, optarg); @@ -2704,6 +3207,37 @@ static int lfs_setstripe_internal(int argc, char **argv, } break; } + case LFS_LAYOUT_FOREIGN_OPT: + if (optarg != NULL) { + /* check pure numeric */ + type = strtoul(optarg, &end, 0); + if (*end) { + /* check name */ + type = check_foreign_type_name(optarg); + if (type == LU_FOREIGN_TYPE_UNKNOWN) { + fprintf(stderr, + "%s %s: unrecognized foreign type '%s'\n", + progname, argv[0], + optarg); + return CMD_HELP; + } + } + } + foreign_mode = true; + break; + case LFS_MODE_OPT: + mode_opt = optarg; + if (mode_opt != NULL) { + mode = strtoul(mode_opt, &end, 8); + if (*end != '\0') { + fprintf(stderr, + "%s %s: bad mode '%s'\n", + progname, argv[0], mode_opt); + return CMD_HELP; + } + previous_umask = umask(0); + } + break; case LFS_LAYOUT_COPY: from_copy = true; template = optarg; @@ -2717,6 +3251,9 @@ static int lfs_setstripe_internal(int argc, char **argv, } migration_block = true; break; + case 'C': + lsa.lsa_pattern = LLAPI_LAYOUT_OVERSTRIPING; + /* fall through */ case 'c': lsa.lsa_stripe_count = strtoul(optarg, &end, 0); if (*end != '\0') { @@ -2756,9 +3293,8 @@ static int lfs_setstripe_internal(int argc, char **argv, if (lsa.lsa_comp_end != 0) { result = comp_args_to_layout(lpp, &lsa, true); if (result) { - fprintf(stderr, - "%s %s: invalid layout\n", - progname, argv[0]); + fprintf(stderr, "%s: invalid layout\n", + progname); goto usage_error; } @@ -2779,6 +3315,20 @@ static int lfs_setstripe_internal(int argc, char **argv, } } break; + case 'H': + if (!migrate_mode) { + fprintf(stderr, "--mdt-hash is valid only for migrate command\n"); + return CMD_HELP; + } + + lsa.lsa_pattern = check_hashtype(optarg); + if (lsa.lsa_pattern == 0) { + fprintf(stderr, + "%s %s: bad stripe hash type '%s'\n", + progname, argv[0], optarg); + return CMD_HELP; + } + break; case 'i': lsa.lsa_stripe_off = strtol(optarg, &end, 0); if (*end != '\0') { @@ -2851,11 +3401,24 @@ static int lfs_setstripe_internal(int argc, char **argv, case 'm': if (!migrate_mode) { fprintf(stderr, - "%s %s: -m|--mdt-index valid only for migrate command\n", + "%s %s: -m|--mdt-index is valid only for migrate command\n", progname, argv[0]); goto usage_error; } - mdt_idx_arg = optarg; + migrate_mdt_mode = true; + lsa.lsa_nr_tgts = parse_targets(tgts, + sizeof(tgts) / sizeof(__u32), + lsa.lsa_nr_tgts, optarg, NULL); + if (lsa.lsa_nr_tgts < 0) { + fprintf(stderr, + "%s %s: invalid MDT target(s) '%s'\n", + progname, argv[0], optarg); + return CMD_HELP; + } + + lsa.lsa_tgts = tgts; + if (lsa.lsa_stripe_off == LLAPI_LAYOUT_DEFAULT) + lsa.lsa_stripe_off = tgts[0]; break; case 'n': if (!migrate_mode) { @@ -2914,9 +3477,15 @@ static int lfs_setstripe_internal(int argc, char **argv, fprintf(stderr, "warning: '--ost-list' is " "deprecated, use '--ost' instead\n"); #endif - lsa.lsa_nr_tgts = parse_targets(osts, - sizeof(osts) / sizeof(__u32), - lsa.lsa_nr_tgts, optarg); + /* -o allows overstriping, and must note it because + * parse_targets is shared with MDT striping, which + * does not allow duplicates + */ + lsa.lsa_pattern = LLAPI_LAYOUT_OVERSTRIPING; + lsa.lsa_nr_tgts = parse_targets(tgts, + sizeof(tgts) / sizeof(__u32), + lsa.lsa_nr_tgts, optarg, + &lsa.lsa_pattern); if (lsa.lsa_nr_tgts < 0) { fprintf(stderr, "%s %s: invalid OST target(s) '%s'\n", @@ -2924,9 +3493,9 @@ static int lfs_setstripe_internal(int argc, char **argv, goto usage_error; } - lsa.lsa_tgts = osts; + lsa.lsa_tgts = tgts; if (lsa.lsa_stripe_off == LLAPI_LAYOUT_DEFAULT) - lsa.lsa_stripe_off = osts[0]; + lsa.lsa_stripe_off = tgts[0]; break; case 'p': if (optarg == NULL) @@ -2956,11 +3525,28 @@ static int lfs_setstripe_internal(int argc, char **argv, goto usage_error; } migrate_mdt_param.fp_verbose = VERBOSE_DETAIL; + migration_flags = MIGRATION_VERBOSE; + break; + case 'x': + xattr = optarg; break; case 'y': from_yaml = true; template = optarg; break; + case 'z': + result = llapi_parse_size(optarg, + &lsa.lsa_extension_size, + &size_units, 0); + if (result) { + fprintf(stderr, + "%s %s: invalid extension size '%s'\n", + progname, argv[0], optarg); + goto usage_error; + } + + lsa.lsa_extension_comp = true; + break; default: fprintf(stderr, "%s %s: unrecognized option '%s'\n", progname, argv[0], argv[optind - 1]); @@ -2976,6 +3562,29 @@ static int lfs_setstripe_internal(int argc, char **argv, goto usage_error; } + if (xattr && !foreign_mode) { + /* only print a warning as this is harmless and will be ignored + */ + fprintf(stderr, + "%s %s: xattr has been specified for non-foreign layout\n", + progname, argv[0]); + } else if (foreign_mode && !xattr) { + fprintf(stderr, + "%s %s: xattr must be provided in foreign mode\n", + progname, argv[0]); + goto usage_error; + } + + if (foreign_mode && (!setstripe_mode || comp_add | comp_del || + comp_set || comp_id || delete || from_copy || + setstripe_args_specified(&lsa) || lsa.lsa_nr_tgts || + lsa.lsa_tgts)) { + fprintf(stderr, + "%s %s: only --xattr/--flags/--mode options are valid with --foreign\n", + progname, argv[0]); + return CMD_HELP; + } + if (mirror_mode && mirror_count == 0) { fprintf(stderr, "error: %s: --mirror-count|-N option is required\n", @@ -2991,8 +3600,12 @@ static int lfs_setstripe_internal(int argc, char **argv, if (lsa.lsa_comp_end != 0) { result = comp_args_to_layout(lpp, &lsa, true); - if (result) + if (result) { + fprintf(stderr, "error: %s: invalid layout\n", + progname); + result = -EINVAL; goto error; + } } if (mirror_flags & MF_NO_VERIFY) { @@ -3011,9 +3624,6 @@ static int lfs_setstripe_internal(int argc, char **argv, } } - /* Only LCME_FL_INIT flags is used in PFL, and it shouldn't be - * altered by user space tool, so we don't need to support the - * --component-set for this moment. */ if (comp_set && !comp_id) { fprintf(stderr, "%s %s: --component-set doesn't have component-id set\n", progname, argv[0]); @@ -3076,12 +3686,21 @@ static int lfs_setstripe_internal(int argc, char **argv, progname, argv[0]); goto usage_error; } + } - result = adjust_first_extent(fname, layout); + if (layout != NULL || mirror_list != NULL) { + if (mirror_list) + result = mirror_adjust_first_extents(mirror_list); + else + result = layout_adjust_first_extent(fname, layout, + comp_add); if (result == -ENODATA) comp_add = 0; - else if (result != 0) + else if (result != 0) { + fprintf(stderr, "error: %s: invalid layout\n", + progname); goto error; + } } if (from_yaml && from_copy) { @@ -3099,13 +3718,6 @@ static int lfs_setstripe_internal(int argc, char **argv, goto error; } - if (mdt_idx_arg != NULL && optind > 3) { - fprintf(stderr, - "%s %s: option -m cannot be used with other options\n", - progname, argv[0]); - goto usage_error; - } - if ((migration_flags & MIGRATION_NONBLOCK) && migration_block) { fprintf(stderr, "%s %s: options --non-block and --block are mutually exclusive\n", @@ -3113,22 +3725,69 @@ static int lfs_setstripe_internal(int argc, char **argv, goto usage_error; } - if (!comp_del && !comp_set && (opc != SO_MIRROR_SPLIT) && - comp_id != 0) { + if (!comp_del && !comp_set && opc != SO_MIRROR_SPLIT && + opc != SO_MIRROR_DELETE && comp_id != 0) { fprintf(stderr, - "%s %s: option -I can only be used with --component-del or --component-set or lfs mirror split\n", - progname, argv[0]); + "%s: option -I can only be used with --component-del or --component-set or lfs mirror split\n", + progname); goto usage_error; } - if (mdt_idx_arg != NULL) { + if (migrate_mdt_mode) { + struct lmv_user_md *lmu; + /* initialize migrate mdt parameters */ - migrate_mdt_param.fp_mdt_index = strtoul(mdt_idx_arg, &end, 0); - if (*end != '\0') { - fprintf(stderr, "%s %s: invalid MDT index '%s'\n", - progname, argv[0], mdt_idx_arg); + lmu = calloc(1, lmv_user_md_size(lsa.lsa_nr_tgts, + LMV_USER_MAGIC_SPECIFIC)); + if (!lmu) { + fprintf(stderr, + "%s %s: cannot allocate memory for lmv_user_md: %s\n", + progname, argv[0], strerror(ENOMEM)); + result = -ENOMEM; + goto error; + } + if (lsa.lsa_stripe_count != LLAPI_LAYOUT_DEFAULT) + lmu->lum_stripe_count = lsa.lsa_stripe_count; + if (lsa.lsa_stripe_off == LLAPI_LAYOUT_DEFAULT) { + fprintf(stderr, + "%s %s: migrate should specify MDT index\n", + progname, argv[0]); + free(lmu); goto usage_error; } + lmu->lum_stripe_offset = lsa.lsa_stripe_off; + if (lsa.lsa_pattern != LLAPI_LAYOUT_RAID0) + lmu->lum_hash_type = lsa.lsa_pattern; + else + lmu->lum_hash_type = LMV_HASH_TYPE_DEFAULT; + if (lsa.lsa_pool_name) { + strncpy(lmu->lum_pool_name, lsa.lsa_pool_name, + sizeof(lmu->lum_pool_name) - 1); + lmu->lum_pool_name[sizeof(lmu->lum_pool_name) - 1] = 0; + } + if (lsa.lsa_nr_tgts > 1) { + int i; + + if (lsa.lsa_stripe_count > 0 && + lsa.lsa_stripe_count != LLAPI_LAYOUT_DEFAULT && + lsa.lsa_stripe_count != lsa.lsa_nr_tgts) { + fprintf(stderr, + "error: %s: stripe count %lld doesn't match the number of MDTs: %d\n", + progname, lsa.lsa_stripe_count, + lsa.lsa_nr_tgts); + free(lmu); + goto usage_error; + } + + lmu->lum_magic = LMV_USER_MAGIC_SPECIFIC; + lmu->lum_stripe_count = lsa.lsa_nr_tgts; + for (i = 0; i < lsa.lsa_nr_tgts; i++) + lmu->lum_objects[i].lum_mds = lsa.lsa_tgts[i]; + } else { + lmu->lum_magic = LMV_USER_MAGIC; + } + + migrate_mdt_param.fp_lmv_md = lmu; migrate_mdt_param.fp_migrate = 1; } else if (layout == NULL) { /* initialize stripe parameters */ @@ -3154,6 +3813,14 @@ static int lfs_setstripe_internal(int argc, char **argv, param->lsp_stripe_offset = -1; else param->lsp_stripe_offset = lsa.lsa_stripe_off; + param->lsp_stripe_pattern = + llapi_pattern_to_lov(lsa.lsa_pattern); + if (param->lsp_stripe_pattern == EINVAL) { + fprintf(stderr, "error: %s: invalid stripe pattern\n", + argv[0]); + free(param); + goto usage_error; + } param->lsp_pool = lsa.lsa_pool_name; param->lsp_is_specific = false; if (lsa.lsa_nr_tgts > 0) { @@ -3161,9 +3828,9 @@ static int lfs_setstripe_internal(int argc, char **argv, lsa.lsa_stripe_count != LLAPI_LAYOUT_DEFAULT && lsa.lsa_stripe_count != LLAPI_LAYOUT_WIDE && lsa.lsa_nr_tgts != lsa.lsa_stripe_count) { - fprintf(stderr, "error: %s: stripe count %lld " - "doesn't match the number of OSTs: %d\n" - , argv[0], lsa.lsa_stripe_count, + fprintf(stderr, + "error: %s: stripe count %lld doesn't match the number of OSTs: %d\n", + argv[0], lsa.lsa_stripe_count, lsa.lsa_nr_tgts); free(param); goto usage_error; @@ -3171,15 +3838,15 @@ static int lfs_setstripe_internal(int argc, char **argv, param->lsp_is_specific = true; param->lsp_stripe_count = lsa.lsa_nr_tgts; - memcpy(param->lsp_osts, osts, - sizeof(*osts) * lsa.lsa_nr_tgts); + memcpy(param->lsp_osts, tgts, + sizeof(*tgts) * lsa.lsa_nr_tgts); } } if (from_yaml) { /* generate a layout from a YAML template */ result = lfs_comp_create_from_yaml(template, &layout, - &lsa, osts); + &lsa, tgts); if (result) { fprintf(stderr, "error: %s: can't create composite " "layout from template file %s\n", @@ -3197,7 +3864,7 @@ static int lfs_setstripe_internal(int argc, char **argv, } for (fname = argv[optind]; fname != NULL; fname = argv[++optind]) { - if (mdt_idx_arg != NULL) { + if (migrate_mdt_mode) { result = llapi_migrate_mdt(fname, &migrate_mdt_param); } else if (migrate_mode) { result = lfs_migrate(fname, migration_flags, param, @@ -3217,23 +3884,33 @@ static int lfs_setstripe_internal(int argc, char **argv, } else if (opc == SO_MIRROR_EXTEND) { result = mirror_extend(fname, mirror_list, mirror_flags); - } else if (opc == SO_MIRROR_SPLIT) { - if (mirror_id == 0 && comp_id == 0) { + } else if (opc == SO_MIRROR_SPLIT || opc == SO_MIRROR_DELETE) { + if (!mirror_id && !comp_id && !lsa.lsa_pool_name) { fprintf(stderr, - "%s %s: no mirror id or component id is specified\n", - progname, argv[0]); + "%s: no mirror specified to delete from '%s'\n", + progname, fname); goto usage_error; } - if (mirror_id != 0) + if (lsa.lsa_pool_name) + mirror_flags |= MF_COMP_POOL; + else if (mirror_id != 0) comp_id = mirror_id; else mirror_flags |= MF_COMP_ID; - result = mirror_split(fname, comp_id, mirror_flags, + result = mirror_split(fname, comp_id, lsa.lsa_pool_name, + mirror_flags, has_m_file ? mirror_list->m_file : NULL); } else if (layout != NULL) { result = lfs_component_create(fname, O_CREAT | O_WRONLY, - 0666, layout); + mode, layout); + if (result >= 0) { + close(result); + result = 0; + } + } else if (foreign_mode) { + result = llapi_file_create_foreign(fname, mode, type, + flags, xattr); if (result >= 0) { close(result); result = 0; @@ -3241,7 +3918,7 @@ static int lfs_setstripe_internal(int argc, char **argv, } else { result = llapi_file_open_param(fname, O_CREAT | O_WRONLY, - 0666, param); + mode, param); if (result >= 0) { close(result); result = 0; @@ -3255,7 +3932,11 @@ static int lfs_setstripe_internal(int argc, char **argv, } } + if (mode_opt != NULL) + umask(previous_umask); + free(param); + free(migrate_mdt_param.fp_lmv_md); llapi_layout_free(layout); lfs_mirror_list_free(mirror_list); return result2; @@ -3275,11 +3956,13 @@ static int lfs_poollist(int argc, char **argv) return llapi_poollist(argv[1]); } -static int set_time(time_t *time, time_t *set, char *str) +static time_t set_time(struct find_param *param, time_t *time, time_t *set, + char *str) { - time_t t; + long long t = 0; int res = 0; - char *endptr; + char *endptr = "AD"; + char *timebuf; if (str[0] == '+') res = 1; @@ -3289,23 +3972,48 @@ static int set_time(time_t *time, time_t *set, char *str) if (res) str++; - t = strtol(str, &endptr, 0); - if (*endptr != '\0') { - fprintf(stderr, - "%s find: bad time '%s': %s\n", - progname, str, strerror(EINVAL)); - return INT_MAX; + for (timebuf = str; *endptr && *(endptr + 1); timebuf = endptr + 1) { + long long val = strtoll(timebuf, &endptr, 0); + int unit = 1; + + switch (*endptr) { + case 'y': + unit *= 52; /* 52 weeks + 1 day below */ + case 'w': /* fallthrough */ + unit *= 7; + case '\0': /* days are default unit if none used */ + case 'd': /* fallthrough */ + unit = (unit + (*endptr == 'y')) * 24; + case 'h': /* fallthrough */ + unit *= 60; + case 'm': /* fallthrough */ + unit *= 60; + case 's': /* fallthrough */ + break; + /* don't need to multiply by 1 for seconds */ + default: + fprintf(stderr, + "%s find: bad time string '%s': %s\n", + progname, timebuf, strerror(EINVAL)); + return LONG_MAX; + } + + if (param->fp_time_margin == 0 || + (*endptr && unit < param->fp_time_margin)) + param->fp_time_margin = unit; + + t += val * unit; } - if (*time < t * 24 * 60 * 60) { + if (*time < t) { if (res != 0) str--; - fprintf(stderr, - "%s find: bad time '%s': too large\n", + fprintf(stderr, "%s find: bad time '%s': too large\n", progname, str); - return INT_MAX; + return LONG_MAX; } - *set = *time - t * 24 * 60 * 60; + *set = *time - t; + return res; } @@ -3377,6 +4085,8 @@ static int name2layout(__u32 *layout, char *name) *layout |= LOV_PATTERN_RAID0; else if (strcmp(layout_name, "mdt") == 0) *layout |= LOV_PATTERN_MDT; + else if (strcmp(layout_name, "overstriping") == 0) + *layout |= LOV_PATTERN_OVERSTRIPING; else return -1; } @@ -3391,6 +4101,7 @@ static int lfs_find(int argc, char **argv) struct find_param param = { .fp_max_depth = -1, .fp_quiet = 1, + .fp_time_margin = 24 * 60 * 60, }; struct option long_opts[] = { { .val = 'A', .name = "atime", .has_arg = required_argument }, @@ -3412,6 +4123,8 @@ static int lfs_find(int argc, char **argv) .has_arg = required_argument }, { .val = LFS_MIRROR_STATE_OPT, .name = "mirror-state", .has_arg = required_argument }, + { .val = LFS_LAYOUT_FOREIGN_OPT, + .name = "foreign", .has_arg = optional_argument}, { .val = 'c', .name = "stripe-count", .has_arg = required_argument }, { .val = 'c', .name = "stripe_count", .has_arg = required_argument }, { .val = 'C', .name = "ctime", .has_arg = required_argument }, @@ -3421,12 +4134,15 @@ static int lfs_find(int argc, char **argv) { .val = 'E', .name = "component-end", .has_arg = required_argument }, /* find { .val = 'F', .name = "fid", .has_arg = no_argument }, */ + { .val = LFS_LAYOUT_FOREIGN_OPT, + .name = "foreign", .has_arg = optional_argument}, { .val = 'g', .name = "gid", .has_arg = required_argument }, { .val = 'G', .name = "group", .has_arg = required_argument }, { .val = 'H', .name = "mdt-hash", .has_arg = required_argument }, { .val = 'i', .name = "stripe-index", .has_arg = required_argument }, { .val = 'i', .name = "stripe_index", .has_arg = required_argument }, /* getstripe { .val = 'I', .name = "comp-id", .has_arg = required_argument }*/ + { .val = 'l', .name = "lazy", .has_arg = no_argument }, { .val = 'L', .name = "layout", .has_arg = required_argument }, { .val = 'm', .name = "mdt", .has_arg = required_argument }, { .val = 'm', .name = "mdt-index", .has_arg = required_argument }, @@ -3454,22 +4170,26 @@ static int lfs_find(int argc, char **argv) { .val = 'T', .name = "mdt-count", .has_arg = required_argument }, { .val = 'u', .name = "uid", .has_arg = required_argument }, { .val = 'U', .name = "user", .has_arg = required_argument }, + { .val = 'z', .name = "extension-size", + .has_arg = required_argument }, + { .val = 'z', .name = "ext-size", .has_arg = required_argument }, /* getstripe { .val = 'v', .name = "verbose", .has_arg = no_argument }, */ /* getstripe { .val = 'y', .name = "yaml", .has_arg = no_argument }, */ { .name = NULL } }; - int pathstart = -1; - int pathend = -1; - int neg_opt = 0; - time_t *xtime; - int *xsign; - int isoption; - char *endptr; + int pathstart = -1; + int pathend = -1; + int pathbad = -1; + int neg_opt = 0; + time_t *xtime; + int *xsign; + int isoption; + char *endptr; - time(&t); + time(&t); /* when getopt_long_only() hits '!' it returns 1, puts "!" in optarg */ while ((c = getopt_long_only(argc, argv, - "-0A:b:c:C:D:E:g:G:H:i:L:m:M:n:N:O:Ppqrs:S:t:T:u:U:v", + "-0A:b:c:C:D:E:g:G:H:i:L:m:M:n:N:O:Ppqrs:S:t:T:u:U:vz:", long_opts, NULL)) >= 0) { xtime = NULL; xsign = NULL; @@ -3523,8 +4243,8 @@ static int lfs_find(int argc, char **argv) xsign = ¶m.fp_msign; param.fp_exclude_mtime = !!neg_opt; } - rc = set_time(&t, xtime, optarg); - if (rc == INT_MAX) { + rc = set_time(¶m, &t, xtime, optarg); + if (rc == LONG_MAX) { ret = -1; goto err; } @@ -3668,6 +4388,30 @@ static int lfs_find(int argc, char **argv) param.fp_check_comp_end = 1; param.fp_exclude_comp_end = !!neg_opt; break; + case LFS_LAYOUT_FOREIGN_OPT: { + /* all types by default */ + uint32_t type = LU_FOREIGN_TYPE_UNKNOWN; + + if (optarg != NULL) { + /* check pure numeric */ + type = strtoul(optarg, &endptr, 0); + if (*endptr) { + /* check name */ + type = check_foreign_type_name(optarg); + if (type == LU_FOREIGN_TYPE_UNKNOWN) { + fprintf(stderr, + "%s %s: unknown foreign type '%s'\n", + progname, argv[0], + optarg); + return CMD_HELP; + } + } + } + param.fp_foreign_type = type; + param.fp_check_foreign = 1; + param.fp_exclude_foreign = !!neg_opt; + break; + } case 'g': case 'G': rc = name2gid(¶m.fp_gid, optarg); @@ -3694,7 +4438,10 @@ static int lfs_find(int argc, char **argv) param.fp_check_hash_type = 1; param.fp_exclude_hash_type = !!neg_opt; break; - case 'L': + case 'l': + param.fp_lazy = 1; + break; + case 'L': ret = name2layout(¶m.fp_layout, optarg); if (ret) goto err; @@ -3949,31 +4696,55 @@ err_free: param.fp_check_mdt_count = 1; param.fp_exclude_mdt_count = !!neg_opt; break; - default: - ret = CMD_HELP; - goto err; - }; - } + case 'z': + if (optarg[0] == '+') { + param.fp_ext_size_sign = -1; + optarg++; + } else if (optarg[0] == '-') { + param.fp_ext_size_sign = 1; + optarg++; + } - if (pathstart == -1) { - fprintf(stderr, "error: %s: no filename|pathname\n", - argv[0]); - ret = CMD_HELP; - goto err; - } else if (pathend == -1) { - /* no options */ - pathend = argc; - } + ret = llapi_parse_size(optarg, ¶m.fp_ext_size, + ¶m.fp_ext_size_units, 0); + if (ret) { + fprintf(stderr, "error: bad ext-size '%s'\n", + optarg); + goto err; + } + param.fp_ext_size /= SEL_UNIT_SIZE; + param.fp_ext_size_units /= SEL_UNIT_SIZE; + param.fp_check_ext_size = 1; + param.fp_exclude_ext_size = !!neg_opt; + break; + default: + ret = CMD_HELP; + goto err; + }; + } + + if (pathstart == -1) { + fprintf(stderr, "error: %s: no filename|pathname\n", + argv[0]); + ret = CMD_HELP; + goto err; + } else if (pathend == -1) { + /* no options */ + pathend = argc; + } do { rc = llapi_find(argv[pathstart], ¶m); - if (rc != 0 && ret == 0) + if (rc && !ret) { ret = rc; + pathbad = pathstart; + } } while (++pathstart < pathend); - if (ret) - fprintf(stderr, "error: %s failed for %s.\n", - argv[0], argv[optind - 1]); + if (ret) + fprintf(stderr, "%s: failed for '%s': %s\n", + progname, argv[pathbad], strerror(-rc)); + err: if (param.fp_obd_uuid && param.fp_num_alloc_obds) free(param.fp_obd_uuid); @@ -4002,6 +4773,10 @@ static int lfs_getstripe_internal(int argc, char **argv, .name = "comp-start", .has_arg = optional_argument }, { .val = LFS_COMP_START_OPT, .name = "component-start", .has_arg = optional_argument }, + { .val = LFS_MIRROR_INDEX_OPT, + .name = "mirror-index", .has_arg = required_argument }, + { .val = LFS_MIRROR_ID_OPT, + .name = "mirror-id", .has_arg = required_argument }, { .val = 'c', .name = "stripe-count", .has_arg = no_argument }, { .val = 'c', .name = "stripe_count", .has_arg = no_argument }, /* find { .val = 'C', .name = "ctime", .has_arg = required_argument }*/ @@ -4017,12 +4792,14 @@ static int lfs_getstripe_internal(int argc, char **argv, { .val = 'i', .name = "stripe_index", .has_arg = no_argument }, { .val = 'I', .name = "comp-id", .has_arg = optional_argument }, { .val = 'I', .name = "component-id", .has_arg = optional_argument }, +/* find { .val = 'l', .name = "lazy", .has_arg = no_argument }, */ { .val = 'L', .name = "layout", .has_arg = no_argument }, { .val = 'm', .name = "mdt", .has_arg = no_argument }, { .val = 'm', .name = "mdt-index", .has_arg = no_argument }, { .val = 'm', .name = "mdt_index", .has_arg = no_argument }, /* find { .val = 'M', .name = "mtime", .has_arg = required_argument }*/ /* find { .val = 'n', .name = "name", .has_arg = required_argument }*/ + { .val = 'N', .name = "mirror-count", .has_arg = no_argument }, { .val = 'O', .name = "obd", .has_arg = required_argument }, { .val = 'O', .name = "ost", .has_arg = required_argument }, { .val = 'p', .name = "pool", .has_arg = no_argument }, @@ -4038,13 +4815,40 @@ static int lfs_getstripe_internal(int argc, char **argv, /* find { .val = 'U', .name = "user", .has_arg = required_argument }*/ { .val = 'v', .name = "verbose", .has_arg = no_argument }, { .val = 'y', .name = "yaml", .has_arg = no_argument }, + { .val = 'z', .name = "extension-size", .has_arg = no_argument }, + { .val = 'z', .name = "ext-size", .has_arg = no_argument }, { .name = NULL } }; int c, rc; + int neg_opt = 0; + int pathstart = -1, pathend = -1; + int isoption; char *end, *tmp; - while ((c = getopt_long(argc, argv, "cdDE::FghiI::LmMoO:pqrRsSvy", - long_opts, NULL)) != -1) { + while ((c = getopt_long(argc, argv, + "-cdDE::FghiI::LmMNoO:pqrRsSvyz", + long_opts, NULL)) != -1) { + if (neg_opt) + --neg_opt; + + /* '!' is part of option */ + isoption = (c != 1) || (strcmp(optarg, "!") == 0); + if (!isoption && pathend != -1) { + fprintf(stderr, + "error: %s: filename|dirname must either precede options or follow options\n", + argv[0]); + return CMD_HELP; + } + if (!isoption && pathstart == -1) + pathstart = optind - 1; + if (isoption && pathstart != -1 && pathend == -1) + pathend = optind - 2; + switch (c) { + case 1: + /* unknown: opt is "!" */ + if (strcmp(optarg, "!") == 0) + neg_opt = 2; + break; case 'c': if (!(param->fp_verbose & VERBOSE_DETAIL)) { param->fp_verbose |= VERBOSE_COUNT; @@ -4098,6 +4902,58 @@ static int lfs_getstripe_internal(int argc, char **argv, param->fp_max_depth = 0; } break; + case LFS_MIRROR_INDEX_OPT: + if (optarg[0] == '+') { + param->fp_mirror_index_sign = -1; + optarg++; + } else if (optarg[0] == '-') { + param->fp_mirror_index_sign = 1; + optarg++; + } + + param->fp_mirror_index = strtoul(optarg, &end, 0); + if (*end != '\0' || (param->fp_mirror_index == 0 && + param->fp_mirror_index_sign == 0 && neg_opt == 0)) { + fprintf(stderr, + "%s %s: invalid mirror index '%s'\n", + progname, argv[0], optarg); + return CMD_HELP; + } + if (param->fp_mirror_id != 0) { + fprintf(stderr, + "%s %s: can't specify both mirror index and mirror ID\n", + progname, argv[0]); + return CMD_HELP; + } + param->fp_check_mirror_index = 1; + param->fp_exclude_mirror_index = !!neg_opt; + break; + case LFS_MIRROR_ID_OPT: + if (optarg[0] == '+') { + param->fp_mirror_id_sign = -1; + optarg++; + } else if (optarg[0] == '-') { + param->fp_mirror_id_sign = 1; + optarg++; + } + + param->fp_mirror_id = strtoul(optarg, &end, 0); + if (*end != '\0' || (param->fp_mirror_id == 0 && + param->fp_mirror_id_sign == 0 && neg_opt == 0)) { + fprintf(stderr, + "%s %s: invalid mirror ID '%s'\n", + progname, argv[0], optarg); + return CMD_HELP; + } + if (param->fp_mirror_index != 0) { + fprintf(stderr, + "%s %s: can't specify both mirror index and mirror ID\n", + progname, argv[0]); + return CMD_HELP; + } + param->fp_check_mirror_id = 1; + param->fp_exclude_mirror_id = !!neg_opt; + break; case 'd': param->fp_max_depth = 0; break; @@ -4150,7 +5006,7 @@ static int lfs_getstripe_internal(int argc, char **argv, break; case 'i': if (!(param->fp_verbose & VERBOSE_DETAIL)) { - param->fp_verbose |= VERBOSE_OFFSET; + param->fp_verbose |= VERBOSE_STRIPE_OFFSET; param->fp_max_depth = 0; } break; @@ -4173,7 +5029,7 @@ static int lfs_getstripe_internal(int argc, char **argv, break; case 'L': if (!(param->fp_verbose & VERBOSE_DETAIL)) { - param->fp_verbose |= VERBOSE_LAYOUT; + param->fp_verbose |= VERBOSE_PATTERN; param->fp_max_depth = 0; } break; @@ -4187,6 +5043,12 @@ static int lfs_getstripe_internal(int argc, char **argv, param->fp_max_depth = 0; param->fp_verbose |= VERBOSE_MDTINDEX; break; + case 'N': + if (!(param->fp_verbose & VERBOSE_DETAIL)) { + param->fp_verbose |= VERBOSE_MIRROR_COUNT; + param->fp_max_depth = 0; + } + break; case 'O': if (param->fp_obd_uuid) { fprintf(stderr, @@ -4213,7 +5075,7 @@ static int lfs_getstripe_internal(int argc, char **argv, break; case 'S': if (!(param->fp_verbose & VERBOSE_DETAIL)) { - param->fp_verbose |= VERBOSE_SIZE; + param->fp_verbose |= VERBOSE_STRIPE_SIZE; param->fp_max_depth = 0; } break; @@ -4223,12 +5085,27 @@ static int lfs_getstripe_internal(int argc, char **argv, case 'y': param->fp_yaml = 1; break; + case 'z': + if (!(param->fp_verbose & VERBOSE_DETAIL)) { + param->fp_verbose |= VERBOSE_EXT_SIZE; + param->fp_max_depth = 0; + } + break; default: return CMD_HELP; } } - if (optind >= argc) + if (pathstart == -1) { + fprintf(stderr, "error: %s: no filename|pathname\n", + argv[0]); + return CMD_HELP; + } else if (pathend == -1) { + /* no options */ + pathend = argc; + } + + if (pathend > argc) return CMD_HELP; if (param->fp_recursive) @@ -4242,8 +5119,8 @@ static int lfs_getstripe_internal(int argc, char **argv, param->fp_verbose = VERBOSE_OBJID; do { - rc = llapi_getstripe(argv[optind], param); - } while (++optind < argc && !rc); + rc = llapi_getstripe(argv[pathstart], param); + } while (++pathstart < pathend && !rc); if (rc) fprintf(stderr, "error: %s failed for %s.\n", @@ -4310,6 +5187,7 @@ static int lfs_getdirstripe(int argc, char **argv) { .val = 'O', .name = "obd", .has_arg = required_argument }, { .val = 'r', .name = "recursive", .has_arg = no_argument }, { .val = 'T', .name = "mdt-count", .has_arg = no_argument }, + { .val = 'v', .name = "verbose", .has_arg = no_argument }, { .val = 'y', .name = "yaml", .has_arg = no_argument }, { .name = NULL } }; int c, rc; @@ -4317,7 +5195,7 @@ static int lfs_getdirstripe(int argc, char **argv) param.fp_get_lmv = 1; while ((c = getopt_long(argc, argv, - "cDHimO:rtTy", long_opts, NULL)) != -1) + "cDHimO:rtTvy", long_opts, NULL)) != -1) { switch (c) { case 'c': @@ -4329,7 +5207,7 @@ static int lfs_getdirstripe(int argc, char **argv) break; case 'i': case 'm': - param.fp_verbose |= VERBOSE_OFFSET; + param.fp_verbose |= VERBOSE_STRIPE_OFFSET; break; #if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(3, 0, 53, 0) case 't': @@ -4351,10 +5229,15 @@ static int lfs_getdirstripe(int argc, char **argv) case 'r': param.fp_recursive = 1; break; + case 'v': + param.fp_verbose |= VERBOSE_DETAIL; + break; case 'y': param.fp_yaml = 1; break; default: + fprintf(stderr, "%s %s: unrecognized option '%s'\n", + progname, argv[0], argv[optind - 1]); return CMD_HELP; } } @@ -4402,18 +5285,45 @@ enum mntdf_flags { #define RSF "%4s" #define RDF "%3d%%" -static inline int obd_statfs_ratio(const struct obd_statfs *st) +static inline int obd_statfs_ratio(const struct obd_statfs *st, bool inodes) { double avail, used, ratio = 0; - avail = st->os_bavail; - used = st->os_blocks - st->os_bfree; + if (inodes) { + avail = st->os_ffree; + used = st->os_files - st->os_ffree; + } else { + avail = st->os_bavail; + used = st->os_blocks - st->os_bfree; + } if (avail + used > 0) - ratio = used / (used + avail) * 100 + 0.5; + ratio = used / (used + avail) * 100; - return (int)ratio; + /* Round up to match df(1) usage percentage */ + return (ratio - (int)ratio) > 0 ? (int)(ratio + 1) : (int)ratio; } +/* This is to identify various problem states for "lfs df" if .osn_err = true, + * so only show flags reflecting those states by default. Informational states + * are only shown with "-v" and use lower-case names to distinguish them. + * UNUSED[12] were for "EROFS = 30" until 1.6 but are now available for use. + */ +static struct obd_statfs_state_names { + enum obd_statfs_state osn_state; + const char osn_name; + bool osn_err; +} oss_names[] = { + { .osn_state = OS_STATE_DEGRADED, .osn_name = 'D', .osn_err = true }, + { .osn_state = OS_STATE_READONLY, .osn_name = 'R', .osn_err = true }, + { .osn_state = OS_STATE_NOPRECREATE, .osn_name = 'N', .osn_err = true }, + { .osn_state = OS_STATE_UNUSED1, .osn_name = '?', .osn_err = true }, + { .osn_state = OS_STATE_UNUSED2, .osn_name = '?', .osn_err = true }, + { .osn_state = OS_STATE_ENOSPC, .osn_name = 'S', .osn_err = true }, + { .osn_state = OS_STATE_ENOINO, .osn_name = 'I', .osn_err = true }, + { .osn_state = OS_STATE_SUM, .osn_name = 'a', /* aggregate */ }, + { .osn_state = OS_STATE_NONROT, .osn_name = 'f', /* flash */ }, +}; + static int showdf(char *mntdir, struct obd_statfs *stat, char *uuid, enum mntdf_flags flags, char *type, int index, int rc) @@ -4445,7 +5355,7 @@ static int showdf(char *mntdir, struct obd_statfs *stat, total = (stat->os_blocks * stat->os_bsize) >> shift; } - ratio = obd_statfs_ratio(stat); + ratio = obd_statfs_ratio(stat, flags & MNTDF_INODES); if (flags & MNTDF_COOKED) { int i; @@ -4487,21 +5397,14 @@ static int showdf(char *mntdir, struct obd_statfs *stat, printf("[%s:%d]", type, index); if (stat->os_state) { - /* - * Each character represents the matching - * OS_STATE_* bit. - */ - const char state_names[] = "DRSI"; - __u32 state; - __u32 i; + uint32_t i; printf(" "); - for (i = 0, state = stat->os_state; - state && i < sizeof(state_names); i++) { - if (!(state & (1 << i))) - continue; - printf("%c", state_names[i]); - state ^= 1 << i; + for (i = 0; i < ARRAY_SIZE(oss_names); i++) { + if (oss_names[i].osn_state & stat->os_state && + (oss_names[i].osn_err || + flags & MNTDF_VERBOSE)) + printf("%c", oss_names[i].osn_name); } } @@ -4546,6 +5449,7 @@ static int mntdf(char *mntdir, char *fsname, char *pool, enum mntdf_flags flags, { .st_op = LL_STATFS_LOV, .st_name = "OST" }, { .st_name = NULL } }; struct ll_stat_type *tp; + __u64 ost_files = 0; __u64 ost_ffree = 0; __u32 index; __u32 type; @@ -4586,6 +5490,8 @@ static int mntdf(char *mntdir, char *fsname, char *pool, enum mntdf_flags flags, } for (tp = types; tp->st_name != NULL; tp++) { + bool have_ost = false; + if (!(tp->st_op & ops)) continue; @@ -4607,6 +5513,20 @@ static int mntdf(char *mntdir, char *fsname, char *pool, enum mntdf_flags flags, rc = rc2; } + /* If we have OSTs then don't report MDT block counts. + * For MDT-only filesystems the expectation is that all + * layouts have a DoM component. For filesystems with + * OSTs, files are not necessarily going to store data + * on MDTs, and MDT space is limited to a fraction of + * OST space, so don't include it in the summary. + */ + if (tp->st_op == LL_STATFS_LOV && !have_ost) { + have_ost = true; + sum.os_blocks = 0; + sum.os_bfree = 0; + sum.os_bavail = 0; + } + if (poolname && tp->st_op == LL_STATFS_LOV && llapi_search_ost(fsname, poolname, obd_uuid2str(&uuid_buf)) != 1) @@ -4630,30 +5550,33 @@ static int mntdf(char *mntdir, char *fsname, char *pool, enum mntdf_flags flags, obd_uuid2str(&uuid_buf), flags, tp->st_name, index, rc2); - if (rc2 == 0) { - if (tp->st_op == LL_STATFS_LMV) { - sum.os_ffree += stat_buf.os_ffree; - sum.os_files += stat_buf.os_files; - } else /* if (tp->st_op == LL_STATFS_LOV) */ { - sum.os_blocks += stat_buf.os_blocks * - stat_buf.os_bsize; - sum.os_bfree += stat_buf.os_bfree * - stat_buf.os_bsize; - sum.os_bavail += stat_buf.os_bavail * - stat_buf.os_bsize; - ost_ffree += stat_buf.os_ffree; - } - } + if (rc2) + continue; + + if (tp->st_op == LL_STATFS_LMV) { + sum.os_ffree += stat_buf.os_ffree; + sum.os_files += stat_buf.os_files; + } else /* if (tp->st_op == LL_STATFS_LOV) */ { + ost_files += stat_buf.os_files; + ost_ffree += stat_buf.os_ffree; + } + sum.os_blocks += stat_buf.os_blocks * + stat_buf.os_bsize; + sum.os_bfree += stat_buf.os_bfree * + stat_buf.os_bsize; + sum.os_bavail += stat_buf.os_bavail * + stat_buf.os_bsize; } } close(fd); - /* If we don't have as many objects free on the OST as inodes - * on the MDS, we reduce the total number of inodes to - * compensate, so that the "inodes in use" number is correct. - * Matches ll_statfs_internal() so the results are consistent. */ - if (ost_ffree < sum.os_ffree) { + /* If we have _some_ OSTs, but don't have as many free objects on the + * OST as inodes on the MDTs, reduce the reported number of inodes + * to compensate, so that the "inodes in use" number is correct. + * This should be kept in sync with ll_statfs_internal(). + */ + if (ost_files && ost_ffree < sum.os_ffree) { sum.os_files = (sum.os_files - sum.os_ffree) + ost_ffree; sum.os_ffree = ost_ffree; } @@ -4666,55 +5589,42 @@ static int mntdf(char *mntdir, char *fsname, char *pool, enum mntdf_flags flags, return rc; } -static int ll_statfs_data_comp(const void *sd1, const void *sd2) -{ - const struct obd_statfs *st1 = &((const struct ll_statfs_data *)sd1)-> - sd_st; - const struct obd_statfs *st2 = &((const struct ll_statfs_data *)sd2)-> - sd_st; - int r1 = obd_statfs_ratio(st1); - int r2 = obd_statfs_ratio(st2); - int64_t result = r1 - r2; - - /* if both space usage are above 90, compare free inodes */ - if (r1 > 90 && r2 > 90) - result = st2->os_ffree - st1->os_ffree; - - if (result < 0) - return -1; - else if (result == 0) - return 0; - else - return 1; -} - /* functions */ static int lfs_setdirstripe(int argc, char **argv) { - char *dname; - int result; - struct lfs_setstripe_args lsa = { 0 }; - struct llapi_stripe_param *param = NULL; - __u32 mdts[LMV_MAX_STRIPE_COUNT] = { 0 }; - char *end; - int c; - char *mode_opt = NULL; - bool default_stripe = false; - mode_t mode = S_IRWXU | S_IRWXG | S_IRWXO; - mode_t previous_mode = 0; - bool delete = false; - struct ll_statfs_buf *lsb = NULL; - char mntdir[PATH_MAX] = ""; - bool auto_distributed = false; - + char *dname; + struct lfs_setstripe_args lsa = { 0 }; + struct llapi_stripe_param *param = NULL; + __u32 mdts[LMV_MAX_STRIPE_COUNT] = { 0 }; + char *end; + int c; + char *mode_opt = NULL; + bool default_stripe = false; + bool delete = false; + bool foreign_mode = false; + mode_t mode = S_IRWXU | S_IRWXG | S_IRWXO; + mode_t previous_mode = 0; + char *xattr = NULL; + __u32 type = LU_FOREIGN_TYPE_DAOS, flags = 0; struct option long_opts[] = { { .val = 'c', .name = "count", .has_arg = required_argument }, { .val = 'c', .name = "mdt-count", .has_arg = required_argument }, { .val = 'd', .name = "delete", .has_arg = no_argument }, { .val = 'D', .name = "default", .has_arg = no_argument }, { .val = 'D', .name = "default_stripe", .has_arg = no_argument }, + { .val = LFS_LAYOUT_FLAGS_OPT, + .name = "flags", .has_arg = required_argument }, + { .val = LFS_LAYOUT_FOREIGN_OPT, + .name = "foreign", .has_arg = optional_argument}, { .val = 'H', .name = "mdt-hash", .has_arg = required_argument }, +#if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(2, 17, 53, 0) { .val = 'i', .name = "mdt-index", .has_arg = required_argument }, + { .val = 'i', .name = "mdt", .has_arg = required_argument }, +#else +/* find { .val = 'l', .name = "lazy", .has_arg = no_argument }, */ + { .val = 'm', .name = "mdt-index", .has_arg = required_argument }, + { .val = 'm', .name = "mdt", .has_arg = required_argument }, +#endif #if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(3, 0, 53, 0) { .val = 'i', .name = "index", .has_arg = required_argument }, #endif @@ -4724,12 +5634,14 @@ static int lfs_setdirstripe(int argc, char **argv) #endif { .val = 'T', .name = "mdt-count", .has_arg = required_argument }, /* setstripe { .val = 'y', .name = "yaml", .has_arg = no_argument }, */ + { .val = 'x', .name = "xattr", .has_arg = required_argument }, { .name = NULL } }; + int result = 0; setstripe_args_init(&lsa); - while ((c = getopt_long(argc, argv, "c:dDi:H:m:o:t:T:", long_opts, - NULL)) >= 0) { + while ((c = getopt_long(argc, argv, "c:dDi:H:m:o:t:T:x:", + long_opts, NULL)) >= 0) { switch (c) { case 0: /* Long options. */ @@ -4751,6 +5663,33 @@ static int lfs_setdirstripe(int argc, char **argv) case 'D': default_stripe = true; break; + case LFS_LAYOUT_FOREIGN_OPT: + if (optarg != NULL) { + /* check pure numeric */ + type = strtoul(optarg, &end, 0); + if (*end) { + /* check name */ + type = check_foreign_type_name(optarg); + if (type == LU_FOREIGN_TYPE_UNKNOWN) { + fprintf(stderr, + "%s %s: unknown foreign type '%s'\n", + progname, argv[0], + optarg); + return CMD_HELP; + } + } + } + foreign_mode = true; + break; + case LFS_LAYOUT_FLAGS_OPT: + flags = strtoul(optarg, &end, 16); + if (*end != '\0') { + fprintf(stderr, + "%s %s: bad flags '%s'\n", + progname, argv[0], optarg); + return CMD_HELP; + } + break; #if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(3, 0, 53, 0) case 't': fprintf(stderr, "warning: '--hash-type' and '-t' " @@ -4766,6 +5705,9 @@ static int lfs_setdirstripe(int argc, char **argv) } break; case 'i': +#if LUSTRE_VERSION_CODE >= OBD_OCD_VERSION(2, 17, 53, 0) + case 'm': +#endif #if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(3, 0, 53, 0) if (strcmp(argv[optind - 1], "--index") == 0) fprintf(stderr, @@ -4774,7 +5716,7 @@ static int lfs_setdirstripe(int argc, char **argv) #endif lsa.lsa_nr_tgts = parse_targets(mdts, sizeof(mdts) / sizeof(__u32), - lsa.lsa_nr_tgts, optarg); + lsa.lsa_nr_tgts, optarg, NULL); if (lsa.lsa_nr_tgts < 0) { fprintf(stderr, "%s %s: invalid MDT target(s) '%s'\n", @@ -4786,7 +5728,7 @@ static int lfs_setdirstripe(int argc, char **argv) if (lsa.lsa_stripe_off == LLAPI_LAYOUT_DEFAULT) lsa.lsa_stripe_off = mdts[0]; break; -#if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(2, 16, 53, 0) +#if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(2, 15, 53, 0) case 'm': fprintf(stderr, "warning: '-m' is deprecated, " "use '--mode' or '-o' instead\n"); @@ -4794,6 +5736,9 @@ static int lfs_setdirstripe(int argc, char **argv) case 'o': mode_opt = optarg; break; + case 'x': + xattr = optarg; + break; default: fprintf(stderr, "%s %s: unrecognized option '%s'\n", progname, argv[0], argv[optind - 1]); @@ -4807,8 +5752,30 @@ static int lfs_setdirstripe(int argc, char **argv) return CMD_HELP; } + if (xattr && !foreign_mode) { + /* only print a warning as this is armless and will be + * ignored + */ + fprintf(stderr, + "%s %s: xattr has been specified for non-foreign layout\n", + progname, argv[0]); + } else if (foreign_mode && !xattr) { + fprintf(stderr, + "%s %s: xattr must be provided in foreign mode\n", + progname, argv[0]); + return CMD_HELP; + } + + if (foreign_mode && (delete || default_stripe || lsa.lsa_nr_tgts || + lsa.lsa_tgts || setstripe_args_specified(&lsa))) { + fprintf(stderr, + "%s %s: only --xattr/--flags/--mode options are valid with --foreign\n", + progname, argv[0]); + return CMD_HELP; + } + if (!delete && lsa.lsa_stripe_off == LLAPI_LAYOUT_DEFAULT && - lsa.lsa_stripe_count == LLAPI_LAYOUT_DEFAULT) { + lsa.lsa_stripe_count == LLAPI_LAYOUT_DEFAULT && !foreign_mode) { fprintf(stderr, "%s %s: stripe offset and count must be specified\n", progname, argv[0]); @@ -4835,6 +5802,25 @@ static int lfs_setdirstripe(int argc, char **argv) previous_mode = umask(0); } + /* foreign LMV/dir case */ + if (foreign_mode) { + if (argc > optind + 1) { + fprintf(stderr, + "%s %s: cannot specify multiple foreign dirs\n", + progname, argv[0]); + return CMD_HELP; + } + + dname = argv[optind]; + result = llapi_dir_create_foreign(dname, mode, type, flags, + xattr); + if (result != 0) + fprintf(stderr, + "%s mkdir: can't create foreign dir '%s': %s\n", + progname, dname, strerror(-result)); + return result; + } + /* * initialize stripe parameters, in case param is converted to specific, * i.e, 'lfs mkdir -i -1 -c N', always allocate space for lsp_tgts. @@ -4858,16 +5844,17 @@ static int lfs_setdirstripe(int argc, char **argv) if (lsa.lsa_pattern != LLAPI_LAYOUT_RAID0) param->lsp_stripe_pattern = lsa.lsa_pattern; else - param->lsp_stripe_pattern = LMV_HASH_TYPE_FNV_1A_64; + param->lsp_stripe_pattern = LMV_HASH_TYPE_DEFAULT; param->lsp_pool = lsa.lsa_pool_name; param->lsp_is_specific = false; if (lsa.lsa_nr_tgts > 1) { if (lsa.lsa_stripe_count > 0 && lsa.lsa_stripe_count != LLAPI_LAYOUT_DEFAULT && lsa.lsa_stripe_count != lsa.lsa_nr_tgts) { - fprintf(stderr, "error: %s: stripe count %lld doesn't " - "match the number of MDTs: %d\n", - argv[0], lsa.lsa_stripe_count, lsa.lsa_nr_tgts); + fprintf(stderr, + "error: %s: stripe count %lld doesn't match the number of MDTs: %d\n", + argv[0], lsa.lsa_stripe_count, + lsa.lsa_nr_tgts); free(param); return CMD_HELP; } @@ -4881,114 +5868,23 @@ static int lfs_setdirstripe(int argc, char **argv) do { if (default_stripe) { result = llapi_dir_set_default_lmv(dname, param); - } else { - /* if current \a dname isn't under the same \a mntdir - * as the last one, and the last one was - * auto-distributed, restore \a param. - */ - if (mntdir[0] != '\0' && - strncmp(dname, mntdir, strlen(mntdir)) && - auto_distributed) { - param->lsp_is_specific = false; - param->lsp_stripe_offset = -1; - auto_distributed = false; - } - - if (!param->lsp_is_specific && - param->lsp_stripe_offset == -1) { - char path[PATH_MAX] = ""; - - if (!lsb) { - lsb = malloc(sizeof(*lsb)); - if (!lsb) { - result = -ENOMEM; - break; - } - } - lsb->sb_count = 0; - - /* use mntdir for dirname() temporarily */ - strncpy(mntdir, dname, sizeof(mntdir)); - if (!realpath(dirname(mntdir), path)) { - result = -errno; - fprintf(stderr, - "error: invalid path '%s': %s\n", - argv[optind], strerror(errno)); - break; - } - mntdir[0] = '\0'; - - result = llapi_search_mounts(path, 0, mntdir, - NULL); - if (result < 0 || mntdir[0] == '\0') { - fprintf(stderr, - "No suitable Lustre mount found\n"); - break; - } - - result = mntdf(mntdir, NULL, NULL, 0, - LL_STATFS_LMV, lsb); - if (result < 0) - break; - - if (param->lsp_stripe_count > lsb->sb_count) { - fprintf(stderr, - "error: stripe count %d is too big\n", - param->lsp_stripe_count); - result = -ERANGE; - break; - } - - qsort(lsb->sb_buf, lsb->sb_count, - sizeof(struct ll_statfs_data), - ll_statfs_data_comp); - - auto_distributed = true; - } - - if (auto_distributed) { - int r; - int nr = MAX(param->lsp_stripe_count, - lsb->sb_count / 2); - - /* don't use server whose usage is above 90% */ - while (nr != param->lsp_stripe_count && - obd_statfs_ratio(&lsb->sb_buf[nr].sd_st) - > 90) - nr = MAX(param->lsp_stripe_count, - nr / 2); - - /* get \a r between [0, nr) */ - r = rand() % nr; - - param->lsp_stripe_offset = - lsb->sb_buf[r].sd_index; - if (param->lsp_stripe_count > 1) { - int i = 0; - - param->lsp_is_specific = true; - for (; i < param->lsp_stripe_count; i++) - param->lsp_tgts[(i + r) % nr] = - lsb->sb_buf[i].sd_index; - } - } - - result = llapi_dir_create(dname, mode, param); + if (result) + fprintf(stderr, + "%s setdirstripe: cannot set default stripe on dir '%s': %s\n", + progname, dname, strerror(-result)); + continue; } - if (result) { + result = llapi_dir_create(dname, mode, param); + if (result) fprintf(stderr, - "%s setdirstripe: cannot create stripe dir '%s': %s\n", + "%s setdirstripe: cannot create dir '%s': %s\n", progname, dname, strerror(-result)); - break; - } - dname = argv[++optind]; - } while (dname != NULL); + } while (!result && (dname = argv[++optind])); if (mode_opt != NULL) umask(previous_mode); - free(lsb); free(param); return result; } @@ -5022,14 +5918,16 @@ static int lfs_rmentry(int argc, char **argv) static int lfs_mv(int argc, char **argv) { - struct find_param param = { + struct lmv_user_md lmu = { LMV_USER_MAGIC }; + struct find_param param = { .fp_max_depth = -1, .fp_mdt_index = -1, }; - char *end; - int c; - int rc = 0; + char *end; + int c; + int rc = 0; struct option long_opts[] = { + { .val = 'm', .name = "mdt", .has_arg = required_argument }, { .val = 'm', .name = "mdt-index", .has_arg = required_argument }, { .val = 'v', .name = "verbose", .has_arg = no_argument }, { .name = NULL } }; @@ -5042,7 +5940,7 @@ static int lfs_mv(int argc, char **argv) ", use '--mdt-index' or '-m' instead\n"); #endif case 'm': - param.fp_mdt_index = strtoul(optarg, &end, 0); + lmu.lum_stripe_offset = strtoul(optarg, &end, 0); if (*end != '\0') { fprintf(stderr, "%s mv: bad MDT index '%s'\n", progname, optarg); @@ -5059,7 +5957,7 @@ static int lfs_mv(int argc, char **argv) } } - if (param.fp_mdt_index == -1) { + if (lmu.lum_stripe_offset == LMV_OFFSET_DEFAULT) { fprintf(stderr, "%s mv: MDT index must be specified\n", progname); return CMD_HELP; @@ -5070,6 +5968,9 @@ static int lfs_mv(int argc, char **argv) return CMD_HELP; } + + /* initialize migrate mdt parameters */ + param.fp_lmv_md = &lmu; param.fp_migrate = 1; rc = llapi_migrate_mdt(argv[optind], ¶m); if (rc != 0) @@ -5148,53 +6049,115 @@ static int lfs_df(int argc, char **argv) return rc; } +static int print_instance(const char *mntdir, char *fsname, size_t fsnamelen, + bool opt_instance, bool opt_fsname, bool opt_mntdir) +{ + char *buf = fsname; + + /* llapi_search_mounts() fills "fsname", but that is not called if + * explicit paths are specified on the command-line + */ + if (opt_instance || (opt_fsname && fsname[0] == '\0')) { + int rc = llapi_getname(mntdir, fsname, fsnamelen); + + if (rc < 0) { + fprintf(stderr, "cannot get instance for '%s': %s\n", + mntdir, strerror(-rc)); + return rc; + } + buf = fsname; + if (!opt_instance) { + /* print only the fsname name */ + buf = strchr(fsname, '-'); + if (buf) + *buf = '\0'; + buf = fsname; + } else if (!opt_fsname) { + /* print only the instance name */ + buf = strchr(fsname, '-'); + if (buf) + buf++; + else + buf = fsname; + } + } else if (opt_fsname) { + /* print only the fsname */ + buf = fsname; + } + + printf("%s %s\n", buf, opt_mntdir ? mntdir : ""); + + return 0; +} + static int lfs_getname(int argc, char **argv) { - char mntdir[PATH_MAX] = "", path[PATH_MAX] = "", fsname[PATH_MAX] = ""; - int rc = 0, index = 0, c; - char buf[sizeof(struct obd_uuid)]; + struct option long_opts[] = { + { .val = 'h', .name = "help", .has_arg = no_argument }, + { .val = 'i', .name = "instance", .has_arg = no_argument }, + { .val = 'n', .name = "fsname", .has_arg = no_argument }, + { .name = NULL} }; + bool opt_instance = false, opt_fsname = false; + char fsname[PATH_MAX] = ""; + int rc = 0, rc2, c; - while ((c = getopt(argc, argv, "h")) != -1) - return CMD_HELP; + while ((c = getopt_long(argc, argv, "hin", long_opts, NULL)) != -1) { + switch (c) { + case 'i': + opt_instance = true; + break; + case 'n': + opt_fsname = true; + break; + case 'h': + default: + return CMD_HELP; + } + } - if (optind == argc) { /* no paths specified, get all paths. */ - while (!llapi_search_mounts(path, index++, mntdir, fsname)) { - rc = llapi_getname(mntdir, buf, sizeof(buf)); - if (rc < 0) { - fprintf(stderr, - "cannot get name for `%s': %s\n", - mntdir, strerror(-rc)); - break; - } + /* If neither option is given, print both instance and fsname */ + if (!opt_instance && !opt_fsname) + opt_instance = opt_fsname = true; - printf("%s %s\n", buf, mntdir); + if (optind == argc) { /* no paths specified, get all paths. */ + char mntdir[PATH_MAX] = "", path[PATH_MAX] = ""; + int index = 0; - path[0] = fsname[0] = mntdir[0] = 0; - } - } else { /* paths specified, only attempt to search these. */ - for (; optind < argc; optind++) { - rc = llapi_getname(argv[optind], buf, sizeof(buf)); - if (rc < 0) { - fprintf(stderr, - "cannot get name for `%s': %s\n", - argv[optind], strerror(-rc)); - break; - } + while (!llapi_search_mounts(path, index++, mntdir, fsname)) { + rc2 = print_instance(mntdir, fsname, sizeof(fsname), + opt_instance, opt_fsname, true); + if (!rc) + rc = rc2; + path[0] = fsname[0] = mntdir[0] = '\0'; + } + } else { /* paths specified, only attempt to search these. */ + bool opt_mntdir; - printf("%s %s\n", buf, argv[optind]); - } - } - return rc; + /* if only one path is given, print only requested info */ + opt_mntdir = argc - optind > 1 || (opt_instance == opt_fsname); + + for (; optind < argc; optind++) { + rc2 = print_instance(argv[optind], fsname, + sizeof(fsname), opt_instance, + opt_fsname, opt_mntdir); + if (!rc) + rc = rc2; + fsname[0] = '\0'; + } + } + + return rc; } static int lfs_check(int argc, char **argv) { - int rc; - char mntdir[PATH_MAX] = {'\0'}; - int num_types = 1; - char *obd_types[2]; - char obd_type1[4]; - char obd_type2[4]; + char mntdir[PATH_MAX] = {'\0'}; + int num_types = 1; + char *obd_types[3]; + char obd_type1[4]; + char obd_type2[4]; + char obd_type3[4]; + int rc; if (argc != 2) { fprintf(stderr, "%s check: server type must be specified\n", @@ -5202,17 +6165,23 @@ static int lfs_check(int argc, char **argv) return CMD_HELP; } - obd_types[0] = obd_type1; - obd_types[1] = obd_type2; - - if (strcmp(argv[1], "osts") == 0) { - strcpy(obd_types[0], "osc"); - } else if (strcmp(argv[1], "mds") == 0) { - strcpy(obd_types[0], "mdc"); - } else if (strcmp(argv[1], "servers") == 0) { - num_types = 2; - strcpy(obd_types[0], "osc"); - strcpy(obd_types[1], "mdc"); + obd_types[0] = obd_type1; + obd_types[1] = obd_type2; + obd_types[2] = obd_type3; + + if (strcmp(argv[1], "osts") == 0) { + strcpy(obd_types[0], "osc"); + } else if (strcmp(argv[1], "mdts") == 0 || + strcmp(argv[1], "mds") == 0) { + strcpy(obd_types[0], "mdc"); + } else if (strcmp(argv[1], "mgts") == 0) { + strcpy(obd_types[0], "mgc"); + } else if (strcmp(argv[1], "all") == 0 || + strcmp(argv[1], "servers") == 0) { + num_types = 3; + strcpy(obd_types[0], "osc"); + strcpy(obd_types[1], "mdc"); + strcpy(obd_types[2], "mgc"); } else { fprintf(stderr, "%s check: unrecognized option '%s'\n", progname, argv[1]); @@ -5535,7 +6504,8 @@ quota_type_def: fprintf(stderr, "%s setquota: warning: block softlimit '%llu' smaller than minimum qunit size\n" "See '%s help setquota' or Lustre manual for details\n", - progname, dqb->dqb_bsoftlimit, + progname, + (unsigned long long)dqb->dqb_bsoftlimit, progname); break; case 'B': @@ -5547,7 +6517,8 @@ quota_type_def: fprintf(stderr, "%s setquota: warning: block hardlimit '%llu' smaller than minimum qunit size\n" "See '%s help setquota' or Lustre manual for details\n", - progname, dqb->dqb_bhardlimit, + progname, + (unsigned long long)dqb->dqb_bhardlimit, progname); break; case 'i': @@ -5558,7 +6529,8 @@ quota_type_def: fprintf(stderr, "%s setquota: warning: inode softlimit '%llu' smaller than minimum qunit size\n" "See '%s help setquota' or Lustre manual for details\n", - progname, dqb->dqb_isoftlimit, + progname, + (unsigned long long)dqb->dqb_isoftlimit, progname); break; case 'I': @@ -5569,7 +6541,8 @@ quota_type_def: fprintf(stderr, "%s setquota: warning: inode hardlimit '%llu' smaller than minimum qunit size\n" "See '%s help setquota' or Lustre manual for details\n", - progname, dqb->dqb_ihardlimit, + progname, + (unsigned long long)dqb->dqb_ihardlimit, progname); break; default: @@ -5819,7 +6792,7 @@ static void print_quota(char *mnt, struct if_quotactl *qctl, int type, diff2str(dqb->dqb_btime, timebuf, now); else if (show_default) snprintf(timebuf, sizeof(timebuf), "%llu", - dqb->dqb_btime); + (unsigned long long)dqb->dqb_btime); kbytes2str(lustre_stoqb(dqb->dqb_curspace), strbuf, sizeof(strbuf), h); @@ -5852,7 +6825,7 @@ static void print_quota(char *mnt, struct if_quotactl *qctl, int type, diff2str(dqb->dqb_itime, timebuf, now); else if (show_default) snprintf(timebuf, sizeof(timebuf), "%llu", - dqb->dqb_itime); + (unsigned long long)dqb->dqb_itime); snprintf(numbuf[0], sizeof(numbuf), (dqb->dqb_valid & QIF_INODES) ? "%ju" : "[%ju]", @@ -6272,17 +7245,19 @@ quota_type: optind == argc - 1 && !show_default) { qctl.qc_cmd = LUSTRE_Q_GETQUOTA; - qctl.qc_valid = valid; qctl.qc_idx = idx; for (qtype = USRQUOTA; qtype <= GRPQUOTA; qtype++) { qctl.qc_type = qtype; + qctl.qc_valid = valid; if (qtype == USRQUOTA) { qctl.qc_id = geteuid(); rc = uid2name(&name, qctl.qc_id); } else { qctl.qc_id = getegid(); rc = gid2name(&name, qctl.qc_id); + memset(&qctl.qc_dqblk, 0, + sizeof(qctl.qc_dqblk)); } if (rc) name = ""; @@ -6416,20 +7391,6 @@ static int lfs_flushctx(int argc, char **argv) return rc; } -static int lfs_cp(int argc, char **argv) -{ - fprintf(stderr, "remote client copy file(s).\n" - "obsolete, does not support it anymore.\n"); - return 0; -} - -static int lfs_ls(int argc, char **argv) -{ - fprintf(stderr, "remote client lists directory contents.\n" - "obsolete, does not support it anymore.\n"); - return 0; -} - static int lfs_changelog(int argc, char **argv) { void *changelog_priv; @@ -6526,14 +7487,16 @@ static int lfs_changelog(int argc, char **argv) struct changelog_ext_extra_flags *ef = changelog_rec_extra_flags(rec); - printf(" ef=0x%llx", ef->cr_extra_flags); + printf(" ef=0x%llx", + (unsigned long long)ef->cr_extra_flags); if (ef->cr_extra_flags & CLFE_UIDGID) { struct changelog_ext_uidgid *uidgid = changelog_rec_uidgid(rec); printf(" u=%llu:%llu", - uidgid->cr_uid, uidgid->cr_gid); + (unsigned long long)uidgid->cr_uid, + (unsigned long long)uidgid->cr_gid); } if (ef->cr_extra_flags & CLFE_NID) { struct changelog_ext_nid *nid = @@ -6820,11 +7783,90 @@ static int lfs_path2fid(int argc, char **argv) return rc; } -static int lfs_data_version(int argc, char **argv) +#define MAX_ERRNO 4095 +#define IS_ERR_VALUE(x) ((unsigned long)(x) >= (unsigned long)-MAX_ERRNO) + +static int lfs_rmfid_and_show_errors(const char *device, struct fid_array *fa) { - char *path; - __u64 data_version; - int fd; + int rc, rc2 = 0, k; + + rc = llapi_rmfid(device, fa); + if (rc) { + fprintf(stderr, "rmfid(): rc = %d\n", rc); + return rc; + } + + for (k = 0; k < fa->fa_nr; k++) { + rc = (__s32)fa->fa_fids[k].f_ver; + if (!IS_ERR_VALUE(rc)) + continue; + if (!rc2 && rc) + rc2 = rc; + if (!rc) + continue; + fa->fa_fids[k].f_ver = 0; + fprintf(stderr, "rmfid("DFID"): rc = %d\n", + PFID(&fa->fa_fids[k]), rc); + } + + return rc2; +} + +static int lfs_rmfid(int argc, char **argv) +{ + char *fidstr, *device; + int rc = 0, rc2, nr; + struct fid_array *fa; + + if (optind > argc - 1) { + fprintf(stderr, "%s rmfid: missing dirname\n", progname); + return CMD_HELP; + } + + device = argv[optind++]; + + nr = argc - optind; + fa = malloc(offsetof(struct fid_array, fa_fids[nr + 1])); + if (fa == NULL) + return -ENOMEM; + + fa->fa_nr = 0; + rc = 0; + while (optind < argc) { + int found; + + fidstr = argv[optind++]; + while (*fidstr == '[') + fidstr++; + found = sscanf(fidstr, SFID, RFID(&fa->fa_fids[fa->fa_nr])); + if (found != 3) { + fprintf(stderr, "unrecognized FID: %s\n", + argv[optind - 1]); + exit(1); + } + fa->fa_nr++; + if (fa->fa_nr == OBD_MAX_FIDS_IN_ARRAY) { + /* start another batch */ + rc2 = lfs_rmfid_and_show_errors(device, fa); + if (rc2 && !rc) + rc = rc2; + fa->fa_nr = 0; + } + } + if (fa->fa_nr) { + rc2 = lfs_rmfid_and_show_errors(device, fa); + if (rc2 && !rc) + rc = rc2; + } + + return rc; +} + +static int lfs_data_version(int argc, char **argv) +{ + char *path; + __u64 data_version; + int fd; int rc; int c; int data_version_flags = LL_DV_RD_FLUSH; /* Read by default */ @@ -7628,6 +8670,128 @@ next: return rc; } +static const char *const heat_names[] = LU_HEAT_NAMES; + +static int lfs_heat_get(int argc, char **argv) +{ + struct lu_heat *heat; + int rc = 0, rc2; + char *path; + int fd; + int i; + + if (argc <= 1) + return CMD_HELP; + + heat = calloc(sizeof(*heat) + sizeof(__u64) * OBD_HEAT_COUNT, 1); + if (!heat) { + fprintf(stderr, "%s: memory allocation failed\n", argv[0]); + return -ENOMEM; + } + + optind = 1; + while (optind < argc) { + path = argv[optind++]; + + fd = open(path, O_RDONLY); + if (fd < 0) { + fprintf(stderr, "%s: cannot open file '%s': %s\n", + argv[0], path, strerror(errno)); + rc2 = -errno; + goto next; + } + + heat->lh_count = OBD_HEAT_COUNT; + rc2 = llapi_heat_get(fd, heat); + close(fd); + if (rc2 < 0) { + fprintf(stderr, "%s: cannot get heat of file '%s'" + ": %s\n", argv[0], path, strerror(errno)); + goto next; + } + + printf("flags: %x\n", heat->lh_flags); + for (i = 0; i < heat->lh_count; i++) + printf("%s: %llu\n", heat_names[i], + (unsigned long long)heat->lh_heat[i]); +next: + if (rc == 0 && rc2 < 0) + rc = rc2; + } + + free(heat); + return rc; +} + +static int lfs_heat_set(int argc, char **argv) +{ + struct option long_opts[] = { + { .val = 'c', .name = "clear", .has_arg = no_argument }, + { .val = 'o', .name = "off", .has_arg = no_argument }, + { .val = 'O', .name = "on", .has_arg = no_argument }, + { .name = NULL } }; + enum lu_heat_flag flags = 0; + int rc = 0, rc2; + char *path; + int fd; + int c; + + if (argc <= 1) + return CMD_HELP; + + optind = 0; + while ((c = getopt_long(argc, argv, "coO", long_opts, NULL)) != -1) { + switch (c) { + case 'c': + flags |= LU_HEAT_FLAG_CLEAR; + break; + case 'o': + flags |= LU_HEAT_FLAG_CLEAR; + flags |= LU_HEAT_FLAG_OFF; + break; + case 'O': + flags &= ~LU_HEAT_FLAG_OFF; + break; + case '?': + return CMD_HELP; + default: + fprintf(stderr, "%s: option '%s' unrecognized\n", + argv[0], argv[optind - 1]); + return CMD_HELP; + } + } + + if (argc <= optind) { + fprintf(stderr, "%s: please give one or more file names\n", + argv[0]); + return CMD_HELP; + } + + while (optind < argc) { + path = argv[optind++]; + + fd = open(path, O_RDONLY); + if (fd < 0) { + fprintf(stderr, "%s: cannot open file '%s': %s\n", + argv[0], path, strerror(errno)); + rc2 = -errno; + goto next; + } + + rc2 = llapi_heat_set(fd, flags); + close(fd); + if (rc2 < 0) { + fprintf(stderr, "%s: cannot setflags heat of file '%s'" + ": %s\n", argv[0], path, strerror(errno)); + goto next; + } +next: + if (rc == 0 && rc2 < 0) + rc = rc2; + } + return rc; +} + /** The input string contains a comma delimited list of component ids and * ranges, for example "1,2-4,7". */ @@ -7869,10 +9033,13 @@ int lfs_mirror_resync_file(const char *fname, struct ll_ioc_lease *ioc, struct llapi_layout *layout; struct stat stbuf; uint32_t flr_state; + uint64_t start; + uint64_t end; int comp_size = 0; int idx; int fd; int rc; + int rc2; if (stat(fname, &stbuf) < 0) { fprintf(stderr, "%s: cannot stat file '%s': %s.\n", @@ -7937,56 +9104,34 @@ int lfs_mirror_resync_file(const char *fname, struct ll_ioc_lease *ioc, else fprintf(stderr, "%s: '%s' llapi_lease_get_ext resync failed: %s.\n", - progname, fname, strerror(errno)); + progname, fname, strerror(-rc)); goto free_layout; } - idx = 0; - while (idx < comp_size) { - ssize_t result; - uint64_t end; - __u16 mirror_id; - int i; - - rc = llapi_lease_check(fd); - if (rc != LL_LEASE_WRLCK) { - fprintf(stderr, "%s: '%s' lost lease lock.\n", - progname, fname); - goto free_layout; - } - - mirror_id = comp_array[idx].lrc_mirror_id; - end = comp_array[idx].lrc_end; - - /* try to combine adjacent component */ - for (i = idx + 1; i < comp_size; i++) { - if (mirror_id != comp_array[i].lrc_mirror_id || - end != comp_array[i].lrc_start) - break; - end = comp_array[i].lrc_end; - } - - result = llapi_mirror_resync_one(fd, layout, mirror_id, - comp_array[idx].lrc_start, - end); - if (result < 0) { - fprintf(stderr, "%s: '%s' llapi_mirror_resync_one: " - "%ld.\n", progname, fname, result); - rc = result; - goto unlock; - } else if (result > 0) { - int j; - - /* mark synced components */ - for (j = idx; j < i; j++) - comp_array[j].lrc_synced = true; - } + /* get the read range [start, end) */ + start = comp_array[0].lrc_start; + end = comp_array[0].lrc_end; + for (idx = 1; idx < comp_size; idx++) { + if (comp_array[idx].lrc_start < start) + start = comp_array[idx].lrc_start; + if (end < comp_array[idx].lrc_end) + end = comp_array[idx].lrc_end; + } - idx = i; + rc = llapi_lease_check(fd); + if (rc != LL_LEASE_WRLCK) { + fprintf(stderr, "%s: '%s' lost lease lock.\n", + progname, fname); + goto free_layout; } -unlock: - /* prepare ioc for lease put */ + rc = llapi_mirror_resync_many(fd, layout, comp_array, comp_size, + start, end); + if (rc < 0) + fprintf(stderr, "%s: '%s' llapi_mirror_resync_many: %s.\n", + progname, fname, strerror(-rc)); + + /* need to do the lease unlock even resync fails */ ioc->lil_mode = LL_LEASE_UNLCK; ioc->lil_flags = LL_LEASE_RESYNC_DONE; ioc->lil_count = 0; @@ -7997,19 +9142,19 @@ unlock: } } - rc = llapi_lease_set(fd, ioc); - if (rc <= 0) { - if (rc == 0) /* lost lease lock */ - rc = -EBUSY; - fprintf(stderr, "%s: resync file '%s' failed: %s.\n", - progname, fname, strerror(errno)); - goto free_layout; - } + rc2 = llapi_lease_set(fd, ioc); /** * llapi_lease_set returns lease mode when it request to unlock - * the lease lock + * the lease lock. */ - rc = 0; + if (rc2 <= 0) { + /* rc2 == 0 means lost lease lock */ + if (rc2 == 0 && rc == 0) + rc = -EBUSY; + fprintf(stderr, "%s: resync file '%s' failed: %s.\n", + progname, fname, + rc2 == 0 ? "lost lease lock" : strerror(-rc2)); + } free_layout: llapi_layout_free(layout); @@ -8089,7 +9234,7 @@ static inline int lfs_mirror_resync(int argc, char **argv) /* ignore previous file's error, continue with next file */ /* reset ioc */ - memset(ioc, 0, sizeof(__u32) * 4096); + memset(ioc, 0, sizeof(*ioc) + sizeof(__u32) * 4096); } free(ioc); @@ -8097,690 +9242,1779 @@ error: return rc; } -/** - * struct verify_chunk - Mirror chunk to be verified. - * @chunk: [start, end) of the chunk. - * @mirror_count: Number of mirror ids in @mirror_id array. - * @mirror_id: Array of valid mirror ids that cover the chunk. - */ -struct verify_chunk { - struct lu_extent chunk; - unsigned int mirror_count; - __u16 mirror_id[LUSTRE_MIRROR_COUNT_MAX]; -}; - -/** - * print_chunks() - Print chunk information. - * @fname: Mirrored file name. - * @chunks: Array of chunks. - * @chunk_count: Number of chunks in @chunks array. - * - * This function prints [start, end) of each chunk in @chunks - * for mirrored file @fname, and also prints the valid mirror ids - * that cover the chunk. - * - * Return: void. - */ -static inline -void print_chunks(const char *fname, struct verify_chunk *chunks, - int chunk_count) +static inline int verify_mirror_id_by_fd(int fd, __u16 mirror_id) { - int i; - int j; + struct llapi_layout *layout; + int rc; - fprintf(stdout, "Chunks to be verified in %s:\n", fname); - for (i = 0; i < chunk_count; i++) { - fprintf(stdout, DEXT, PEXT(&chunks[i].chunk)); + layout = llapi_layout_get_by_fd(fd, 0); + if (layout == NULL) { + fprintf(stderr, "could not get layout.\n"); + return -EINVAL; + } - if (chunks[i].mirror_count == 0) - fprintf(stdout, "\t["); - else { - fprintf(stdout, "\t[%u", chunks[i].mirror_id[0]); - for (j = 1; j < chunks[i].mirror_count; j++) - fprintf(stdout, ", %u", chunks[i].mirror_id[j]); - } - fprintf(stdout, "]\t%u\n", chunks[i].mirror_count); + rc = llapi_layout_comp_iterate(layout, find_mirror_id, &mirror_id); + if (rc < 0) { + fprintf(stderr, "failed to iterate layout\n"); + llapi_layout_free(layout); + + return rc; + } else if (rc == LLAPI_LAYOUT_ITER_CONT) { + fprintf(stderr, "does not find mirror with ID %u\n", mirror_id); + llapi_layout_free(layout); + + return -EINVAL; } - fprintf(stdout, "\n"); + llapi_layout_free(layout); + + return 0; } /** - * print_checksums() - Print CRC-32 checksum values. - * @chunk: A chunk and its corresponding valid mirror ids. - * @crc: CRC-32 checksum values on the chunk for each valid mirror. - * - * This function prints CRC-32 checksum values on @chunk for - * each valid mirror that covers it. - * - * Return: void. + * Check whether two files are the same file + * \retval 0 same file + * \retval 1 not the same file + * \retval <0 error code */ -static inline -void print_checksums(struct verify_chunk *chunk, unsigned long *crc) +static inline int check_same_file(const char *f1, const char *f2) { - int i; + struct stat stbuf1; + struct stat stbuf2; - fprintf(stdout, - "CRC-32 checksum value for chunk "DEXT":\n", - PEXT(&chunk->chunk)); - for (i = 0; i < chunk->mirror_count; i++) - fprintf(stdout, "Mirror %u:\t%#lx\n", - chunk->mirror_id[i], crc[i]); - fprintf(stdout, "\n"); + if (stat(f1, &stbuf1) < 0) { + fprintf(stderr, "%s: cannot stat file '%s': %s\n", + progname, f1, strerror(errno)); + return -errno; + } + + if (stat(f2, &stbuf2) < 0) { + fprintf(stderr, "%s: cannot stat file '%s': %s\n", + progname, f2, strerror(errno)); + return -errno; + } + + if (stbuf1.st_rdev == stbuf2.st_rdev && + stbuf1.st_ino == stbuf2.st_ino) + return 0; + + return 1; } -/** - * filter_mirror_id() - Filter specified mirror ids. - * @chunks: Array of chunks. - * @chunk_count: Number of chunks in @chunks array. - * @mirror_ids: Specified mirror ids to be verified. - * @ids_nr: Number of specified mirror ids. - * - * This function scans valid mirror ids that cover each chunk in @chunks - * and filters specified mirror ids. - * +static inline int lfs_mirror_read(int argc, char **argv) +{ + int rc = CMD_HELP; + __u16 mirror_id = 0; + const char *outfile = NULL; + char *fname; + int fd = 0; + int outfd; + int c; + void *buf; + const size_t buflen = 4 << 20; + off_t pos; + struct option long_opts[] = { + { .val = 'N', .name = "mirror-id", .has_arg = required_argument }, + { .val = 'o', .name = "outfile", .has_arg = required_argument }, + { .name = NULL } }; + + while ((c = getopt_long(argc, argv, "N:o:", long_opts, NULL)) >= 0) { + char *end; + + switch (c) { + case 'N': + mirror_id = strtoul(optarg, &end, 0); + if (*end != '\0' || mirror_id == 0) { + fprintf(stderr, + "%s %s: invalid mirror ID '%s'\n", + progname, argv[0], optarg); + return rc; + } + break; + case 'o': + outfile = optarg; + break; + default: + fprintf(stderr, "%s: option '%s' unrecognized.\n", + progname, argv[optind - 1]); + return -EINVAL; + } + } + + if (argc == optind) { + fprintf(stderr, "%s %s: no mirrored file provided\n", + progname, argv[0]); + return rc; + } else if (argc > optind + 1) { + fprintf(stderr, "%s %s: too many files\n", progname, argv[0]); + return rc; + } + + if (mirror_id == 0) { + fprintf(stderr, "%s %s: no valid mirror ID is provided\n", + progname, argv[0]); + return rc; + } + + /* open mirror file */ + fname = argv[optind]; + + if (outfile) { + rc = check_same_file(fname, outfile); + if (rc == 0) { + fprintf(stderr, + "%s %s: output file cannot be the mirrored file\n", + progname, argv[0]); + return -EINVAL; + } + if (rc < 0) + return rc; + } + + fd = open(fname, O_DIRECT | O_RDONLY); + if (fd < 0) { + fprintf(stderr, "%s %s: cannot open '%s': %s\n", + progname, argv[0], fname, strerror(errno)); + return rc; + } + + /* verify mirror id */ + rc = verify_mirror_id_by_fd(fd, mirror_id); + if (rc) { + fprintf(stderr, + "%s %s: cannot find mirror with ID %u in '%s'\n", + progname, argv[0], mirror_id, fname); + goto close_fd; + } + + /* open output file */ + if (outfile) { + outfd = open(outfile, O_EXCL | O_WRONLY | O_CREAT, 0644); + if (outfd < 0) { + fprintf(stderr, "%s %s: cannot create file '%s': %s\n", + progname, argv[0], outfile, strerror(errno)); + rc = -errno; + goto close_fd; + } + } else { + outfd = STDOUT_FILENO; + } + + /* allocate buffer */ + rc = posix_memalign(&buf, sysconf(_SC_PAGESIZE), buflen); + if (rc) { + fprintf(stderr, "%s %s: posix_memalign returns %d\n", + progname, argv[0], rc); + goto close_outfd; + } + + pos = 0; + while (1) { + ssize_t bytes_read; + ssize_t written = 0; + + bytes_read = llapi_mirror_read(fd, mirror_id, buf, buflen, pos); + if (bytes_read < 0) { + rc = bytes_read; + fprintf(stderr, + "%s %s: fail to read data from mirror %u: %s\n", + progname, argv[0], mirror_id, strerror(-rc)); + goto free_buf; + } + + /* EOF reached */ + if (bytes_read == 0) + break; + + while (written < bytes_read) { + ssize_t written2; + + written2 = write(outfd, buf + written, + bytes_read - written); + if (written2 < 0) { + fprintf(stderr, + "%s %s: fail to write %s: %s\n", + progname, argv[0], outfile ? : "STDOUT", + strerror(errno)); + rc = -errno; + goto free_buf; + } + written += written2; + } + + if (written != bytes_read) { + fprintf(stderr, + "%s %s: written %ld bytes does not match with %ld read.\n", + progname, argv[0], written, bytes_read); + rc = -EIO; + goto free_buf; + } + + pos += bytes_read; + } + + fsync(outfd); + rc = 0; + +free_buf: + free(buf); +close_outfd: + if (outfile) + close(outfd); +close_fd: + close(fd); + + return rc; +} + +static inline int lfs_mirror_write(int argc, char **argv) +{ + int rc = CMD_HELP; + __u16 mirror_id = 0; + const char *inputfile = NULL; + char *fname; + int fd = 0; + int inputfd; + int c; + void *buf; + const size_t buflen = 4 << 20; + off_t pos; + size_t page_size = sysconf(_SC_PAGESIZE); + struct ll_ioc_lease_id ioc; + + struct option long_opts[] = { + { .val = 'N', .name = "mirror-id", .has_arg = required_argument }, + { .val = 'i', .name = "inputfile", .has_arg = required_argument }, + { .name = NULL } }; + + while ((c = getopt_long(argc, argv, "N:i:", long_opts, NULL)) >= 0) { + char *end; + + switch (c) { + case 'N': + mirror_id = strtoul(optarg, &end, 0); + if (*end != '\0' || mirror_id == 0) { + fprintf(stderr, + "%s %s: invalid mirror ID '%s'\n", + progname, argv[0], optarg); + return rc; + } + break; + case 'i': + inputfile = optarg; + break; + default: + fprintf(stderr, "%s: option '%s' unrecognized\n", + progname, argv[optind - 1]); + return -EINVAL; + } + } + + if (argc == optind) { + fprintf(stderr, "%s %s: no mirrored file provided\n", + progname, argv[0]); + return rc; + } else if (argc > optind + 1) { + fprintf(stderr, "%s %s: too many files\n", progname, argv[0]); + return rc; + } + + if (mirror_id == 0) { + fprintf(stderr, "%s %s: no valid mirror ID is provided\n", + progname, argv[0]); + return rc; + } + + /* open mirror file */ + fname = argv[optind]; + + if (inputfile) { + rc = check_same_file(fname, inputfile); + if (rc == 0) { + fprintf(stderr, + "%s %s: input file cannot be the mirrored file\n", + progname, argv[0]); + return -EINVAL; + } + if (rc < 0) + return rc; + } + + fd = open(fname, O_DIRECT | O_WRONLY); + if (fd < 0) { + fprintf(stderr, "%s %s: cannot open '%s': %s\n", + progname, argv[0], fname, strerror(errno)); + return rc; + } + + /* verify mirror id */ + rc = verify_mirror_id_by_fd(fd, mirror_id); + if (rc) { + fprintf(stderr, + "%s %s: cannot find mirror with ID %u in '%s'\n", + progname, argv[0], mirror_id, fname); + goto close_fd; + } + + /* open input file */ + if (inputfile) { + inputfd = open(inputfile, O_RDONLY, 0644); + if (inputfd < 0) { + fprintf(stderr, "%s %s: cannot open file '%s': %s\n", + progname, argv[0], inputfile, strerror(errno)); + rc = -errno; + goto close_fd; + } + } else { + inputfd = STDIN_FILENO; + } + + /* allocate buffer */ + rc = posix_memalign(&buf, page_size, buflen); + if (rc) { + fprintf(stderr, "%s %s: posix_memalign returns %d\n", + progname, argv[0], rc); + goto close_inputfd; + } + + /* prepare target mirror components instantiation */ + ioc.lil_mode = LL_LEASE_WRLCK; + ioc.lil_flags = LL_LEASE_RESYNC; + ioc.lil_mirror_id = mirror_id; + rc = llapi_lease_set(fd, (struct ll_ioc_lease *)&ioc); + if (rc < 0) { + fprintf(stderr, + "%s %s: '%s' llapi_lease_get_ext failed: %s\n", + progname, argv[0], fname, strerror(errno)); + goto free_buf; + } + + pos = 0; + while (1) { + ssize_t bytes_read; + ssize_t written; + size_t to_write; + + rc = llapi_lease_check(fd); + if (rc != LL_LEASE_WRLCK) { + fprintf(stderr, "%s %s: '%s' lost lease lock\n", + progname, argv[0], fname); + goto free_buf; + } + + bytes_read = read(inputfd, buf, buflen); + if (bytes_read < 0) { + rc = bytes_read; + fprintf(stderr, + "%s %s: fail to read data from '%s': %s\n", + progname, argv[0], inputfile ? : "STDIN", + strerror(errno)); + rc = -errno; + goto free_buf; + } + + /* EOF reached */ + if (bytes_read == 0) + break; + + /* round up to page align to make direct IO happy. */ + to_write = (bytes_read + page_size - 1) & ~(page_size - 1); + + written = llapi_mirror_write(fd, mirror_id, buf, to_write, + pos); + if (written < 0) { + rc = written; + fprintf(stderr, + "%s %s: fail to write to mirror %u: %s\n", + progname, argv[0], mirror_id, + strerror(-rc)); + goto free_buf; + } + + pos += bytes_read; + } + + if (pos & (page_size - 1)) { + rc = llapi_mirror_truncate(fd, mirror_id, pos); + if (rc < 0) + goto free_buf; + } + + ioc.lil_mode = LL_LEASE_UNLCK; + ioc.lil_flags = LL_LEASE_RESYNC_DONE; + ioc.lil_count = 0; + rc = llapi_lease_set(fd, (struct ll_ioc_lease *)&ioc); + if (rc <= 0) { + if (rc == 0) + rc = -EBUSY; + fprintf(stderr, + "%s %s: release lease lock of '%s' failed: %s\n", + progname, argv[0], fname, strerror(errno)); + goto free_buf; + } + + rc = 0; + +free_buf: + free(buf); +close_inputfd: + if (inputfile) + close(inputfd); +close_fd: + close(fd); + + return rc; +} + +static inline int get_other_mirror_ids(int fd, __u16 *ids, __u16 exclude_id) +{ + struct llapi_layout *layout; + struct collect_ids_data cid = { .cid_ids = ids, + .cid_count = 0, + .cid_exclude = exclude_id, }; + int rc; + + layout = llapi_layout_get_by_fd(fd, 0); + if (layout == NULL) { + fprintf(stderr, "could not get layout\n"); + return -EINVAL; + } + + rc = llapi_layout_comp_iterate(layout, collect_mirror_id, &cid); + if (rc < 0) { + fprintf(stderr, "failed to iterate layout\n"); + llapi_layout_free(layout); + + return rc; + } + llapi_layout_free(layout); + + return cid.cid_count; +} + +static inline int lfs_mirror_copy(int argc, char **argv) +{ + int rc = CMD_HELP; + __u16 read_mirror_id = 0; + __u16 ids[128] = { 0 }; + int count = 0; + struct llapi_layout *layout = NULL; + struct llapi_resync_comp comp_array[1024] = { { 0 } }; + int comp_size = 0; + char *fname; + int fd = 0; + int c; + int i; + ssize_t copied; + struct ll_ioc_lease *ioc = NULL; + struct ll_ioc_lease_id *resync_ioc; + + struct option long_opts[] = { + { .val = 'i', .name = "read-mirror", .has_arg = required_argument }, + { .val = 'o', .name = "write-mirror", .has_arg = required_argument }, + { .name = NULL } }; + + while ((c = getopt_long(argc, argv, "i:o:", long_opts, NULL)) >= 0) { + char *end; + + switch (c) { + case 'i': + read_mirror_id = strtoul(optarg, &end, 0); + if (*end != '\0' || read_mirror_id == 0) { + fprintf(stderr, + "%s %s: invalid read mirror ID '%s'\n", + progname, argv[0], optarg); + return rc; + } + break; + case 'o': + if (!strcmp(optarg, "-1")) { + /* specify all other mirrors */ + ids[0] = (__u16)-1; + count = 1; + } else { + count = parse_mirror_ids((__u16 *)ids, + ARRAY_SIZE(ids), + optarg); + if (count < 0) + return rc; + } + break; + default: + fprintf(stderr, "%s: option '%s' unrecognized\n", + progname, argv[optind - 1]); + return -EINVAL; + } + } + + if (argc == optind) { + fprintf(stderr, "%s %s: no mirrored file provided\n", + progname, argv[0]); + return rc; + } else if (argc > optind + 1) { + fprintf(stderr, "%s %s: too many files\n", progname, argv[0]); + return rc; + } + + if (read_mirror_id == 0) { + fprintf(stderr, + "%s %s: no valid read mirror ID %d is provided\n", + progname, argv[0], read_mirror_id); + return rc; + } + + if (count == 0) { + fprintf(stderr, + "%s %s: no write mirror ID is provided\n", + progname, argv[0]); + return rc; + } + + for (i = 0; i < count; i++) { + if (read_mirror_id == ids[i]) { + fprintf(stderr, + "%s %s: read and write mirror ID cannot be the same\n", + progname, argv[0]); + return rc; + } + } + + /* open mirror file */ + fname = argv[optind]; + + fd = open(fname, O_DIRECT | O_RDWR); + if (fd < 0) { + fprintf(stderr, "%s %s: cannot open '%s': %s\n", + progname, argv[0], fname, strerror(errno)); + return rc; + } + + /* write to all other mirrors */ + if (ids[0] == (__u16)-1) { + count = get_other_mirror_ids(fd, ids, read_mirror_id); + if (count <= 0) { + rc = count; + fprintf(stderr, + "%s %s: failed to get other mirror ids in '%s': %d\n", + progname, argv[0], fname, rc); + goto close_fd; + } + } + + /* verify mirror id */ + rc = verify_mirror_id_by_fd(fd, read_mirror_id); + if (rc) { + fprintf(stderr, + "%s %s: cannot find mirror with ID %u in '%s'\n", + progname, argv[0], read_mirror_id, fname); + goto close_fd; + } + + for (i = 0; i < count; i++) { + rc = verify_mirror_id_by_fd(fd, ids[i]); + if (rc) { + fprintf(stderr, + "%s %s: cannot find mirror with ID %u in '%s'\n", + progname, argv[0], ids[i], fname); + goto close_fd; + } + } + + ioc = calloc(sizeof(*ioc) + sizeof(__u32) * 4096, 1); + if (ioc == NULL) { + fprintf(stderr, + "%s %s: cannot alloc comp id array for ioc: %s\n", + progname, argv[0], strerror(errno)); + rc = -errno; + goto close_fd; + } + + /* get stale component info */ + layout = llapi_layout_get_by_fd(fd, 0); + if (layout == NULL) { + fprintf(stderr, "%s %s: failed to get layout of '%s': %s\n", + progname, argv[0], fname, strerror(errno)); + rc = -errno; + goto free_ioc; + } + comp_size = llapi_mirror_find_stale(layout, comp_array, + ARRAY_SIZE(comp_array), + ids, count); + llapi_layout_free(layout); + if (comp_size < 0) { + rc = comp_size; + goto free_ioc; + } + + /* prepare target mirror components instantiation */ + resync_ioc = (struct ll_ioc_lease_id *)ioc; + resync_ioc->lil_mode = LL_LEASE_WRLCK; + resync_ioc->lil_flags = LL_LEASE_RESYNC; + if (count == 1) + resync_ioc->lil_mirror_id = ids[0]; + else + resync_ioc->lil_mirror_id = read_mirror_id | MIRROR_ID_NEG; + rc = llapi_lease_set(fd, ioc); + if (rc < 0) { + fprintf(stderr, + "%s %s: '%s' llapi_lease_get_ext failed: %s\n", + progname, argv[0], fname, strerror(errno)); + goto free_ioc; + } + + copied = llapi_mirror_copy_many(fd, read_mirror_id, ids, count); + if (copied < 0) { + rc = copied; + fprintf(stderr, "%s %s: copy error: %d\n", + progname, argv[0], rc); + goto free_ioc; + } + + fprintf(stdout, "mirror copied successfully: "); + for (i = 0; i < copied; i++) + fprintf(stdout, "%d ", ids[i]); + fprintf(stdout, "\n"); + + ioc->lil_mode = LL_LEASE_UNLCK; + ioc->lil_flags = LL_LEASE_RESYNC_DONE; + ioc->lil_count = 0; + for (i = 0; i < comp_size; i++) { + int j; + + for (j = 0; j < copied; j++) { + if (comp_array[i].lrc_mirror_id != ids[j]) + continue; + + ioc->lil_ids[ioc->lil_count] = comp_array[i].lrc_id; + ioc->lil_count++; + } + } + rc = llapi_lease_set(fd, ioc); + if (rc <= 0) { + if (rc == 0) + rc = -EBUSY; + fprintf(stderr, + "%s %s: release lease lock of '%s' failed: %s\n", + progname, argv[0], fname, strerror(errno)); + goto free_ioc; + } + + rc = 0; + +free_ioc: + free(ioc); +close_fd: + close(fd); + + return rc; +} +/** + * struct verify_chunk - Mirror chunk to be verified. + * @chunk: [start, end) of the chunk. + * @mirror_count: Number of mirror ids in @mirror_id array. + * @mirror_id: Array of valid mirror ids that cover the chunk. + */ +struct verify_chunk { + struct lu_extent chunk; + unsigned int mirror_count; + __u16 mirror_id[LUSTRE_MIRROR_COUNT_MAX]; +}; + +/** + * print_chunks() - Print chunk information. + * @fname: Mirrored file name. + * @chunks: Array of chunks. + * @chunk_count: Number of chunks in @chunks array. + * + * This function prints [start, end) of each chunk in @chunks + * for mirrored file @fname, and also prints the valid mirror ids + * that cover the chunk. + * + * Return: void. + */ +static inline +void print_chunks(const char *fname, struct verify_chunk *chunks, + int chunk_count) +{ + int i; + int j; + + fprintf(stdout, "Chunks to be verified in %s:\n", fname); + for (i = 0; i < chunk_count; i++) { + fprintf(stdout, DEXT, PEXT(&chunks[i].chunk)); + + if (chunks[i].mirror_count == 0) + fprintf(stdout, "\t["); + else { + fprintf(stdout, "\t[%u", chunks[i].mirror_id[0]); + for (j = 1; j < chunks[i].mirror_count; j++) + fprintf(stdout, ", %u", chunks[i].mirror_id[j]); + } + fprintf(stdout, "]\t%u\n", chunks[i].mirror_count); + } + fprintf(stdout, "\n"); +} + +/** + * print_checksums() - Print CRC-32 checksum values. + * @chunk: A chunk and its corresponding valid mirror ids. + * @crc: CRC-32 checksum values on the chunk for each valid mirror. + * + * This function prints CRC-32 checksum values on @chunk for + * each valid mirror that covers it. + * + * Return: void. + */ +static inline +void print_checksums(struct verify_chunk *chunk, unsigned long *crc) +{ + int i; + + fprintf(stdout, + "CRC-32 checksum value for chunk "DEXT":\n", + PEXT(&chunk->chunk)); + for (i = 0; i < chunk->mirror_count; i++) + fprintf(stdout, "Mirror %u:\t%#lx\n", + chunk->mirror_id[i], crc[i]); + fprintf(stdout, "\n"); +} + +/** + * filter_mirror_id() - Filter specified mirror ids. + * @chunks: Array of chunks. + * @chunk_count: Number of chunks in @chunks array. + * @mirror_ids: Specified mirror ids to be verified. + * @ids_nr: Number of specified mirror ids. + * + * This function scans valid mirror ids that cover each chunk in @chunks + * and filters specified mirror ids. + * * Return: void. */ static inline -void filter_mirror_id(struct verify_chunk *chunks, int chunk_count, - __u16 *mirror_ids, int ids_nr) +void filter_mirror_id(struct verify_chunk *chunks, int chunk_count, + __u16 *mirror_ids, int ids_nr) +{ + int i; + int j; + int k; + __u16 valid_id[LUSTRE_MIRROR_COUNT_MAX] = { 0 }; + unsigned int valid_count = 0; + + for (i = 0; i < chunk_count; i++) { + if (chunks[i].mirror_count == 0) + continue; + + valid_count = 0; + for (j = 0; j < ids_nr; j++) { + for (k = 0; k < chunks[i].mirror_count; k++) { + if (chunks[i].mirror_id[k] == mirror_ids[j]) { + valid_id[valid_count] = mirror_ids[j]; + valid_count++; + break; + } + } + } + + memcpy(chunks[i].mirror_id, valid_id, + sizeof(__u16) * valid_count); + chunks[i].mirror_count = valid_count; + } +} + +/** + * lfs_mirror_prepare_chunk() - Find mirror chunks to be verified. + * @layout: Mirror component list. + * @chunks: Array of chunks. + * @chunks_size: Array size of @chunks. + * + * This function scans the components in @layout from offset 0 to LUSTRE_EOF + * to find out chunk segments and store them in @chunks array. + * + * The @mirror_id array in each element of @chunks will store the valid + * mirror ids that cover the chunk. If a mirror component covering the + * chunk has LCME_FL_STALE or LCME_FL_OFFLINE flag, then the mirror id + * will not be stored into the @mirror_id array, and the chunk for that + * mirror will not be verified. + * + * The @mirror_count in each element of @chunks will store the number of + * mirror ids in @mirror_id array. If @mirror_count is 0, it indicates the + * chunk is invalid in all of the mirrors. And if @mirror_count is 1, it + * indicates the chunk is valid in only one mirror. In both cases, the + * chunk will not be verified. + * + * Here is an example: + * + * 0 1M 2M 3M 4M EOF + * +------+-------------+--------------------+ + * | | | S | mirror1 + * +------+------+------+------+-------------+ + * | | S | S | | mirror2 + * +-------------+------+------+-------------+ + * + * prepared @chunks array will contain 5 elements: + * (([0, 1M), [1, 2], 2), + * ([1M, 2M), [1, 2], 2), + * ([2M, 3M), [1], 1), + * ([3M, 4M], [], 0), + * ([4M, EOF), [2], 1)) + * + * Return: the actual array size of @chunks on success + * or a negative error code on failure. + */ +static inline +int lfs_mirror_prepare_chunk(struct llapi_layout *layout, + struct verify_chunk *chunks, + size_t chunks_size) +{ + uint64_t start; + uint64_t end; + uint32_t mirror_id; + uint32_t flags; + int idx = 0; + int i = 0; + int rc = 0; + + memset(chunks, 0, sizeof(*chunks) * chunks_size); + + while (1) { + rc = llapi_layout_comp_use(layout, LLAPI_LAYOUT_COMP_USE_FIRST); + if (rc < 0) { + fprintf(stderr, + "%s: move to the first layout component: %s.\n", + progname, strerror(errno)); + goto error; + } + + i = 0; + rc = 0; + chunks[idx].chunk.e_end = LUSTRE_EOF; + while (rc == 0) { + rc = llapi_layout_comp_extent_get(layout, &start, &end); + if (rc < 0) { + fprintf(stderr, + "%s: llapi_layout_comp_extent_get failed: %s.\n", + progname, strerror(errno)); + goto error; + } + + if (start > chunks[idx].chunk.e_start || + end <= chunks[idx].chunk.e_start) + goto next; + + if (end < chunks[idx].chunk.e_end) + chunks[idx].chunk.e_end = end; + + rc = llapi_layout_comp_flags_get(layout, &flags); + if (rc < 0) { + fprintf(stderr, + "%s: llapi_layout_comp_flags_get failed: %s.\n", + progname, strerror(errno)); + goto error; + } + + if (flags & LCME_FL_STALE || flags & LCME_FL_OFFLINE) + goto next; + + rc = llapi_layout_mirror_id_get(layout, &mirror_id); + if (rc < 0) { + fprintf(stderr, + "%s: llapi_layout_mirror_id_get failed: %s.\n", + progname, strerror(errno)); + goto error; + } + + chunks[idx].mirror_id[i] = mirror_id; + i++; + if (i >= ARRAY_SIZE(chunks[idx].mirror_id)) { + fprintf(stderr, + "%s: mirror_id array is too small.\n", + progname); + rc = -EINVAL; + goto error; + } + + next: + rc = llapi_layout_comp_use(layout, + LLAPI_LAYOUT_COMP_USE_NEXT); + if (rc < 0) { + fprintf(stderr, + "%s: move to the next layout component: %s.\n", + progname, strerror(errno)); + goto error; + } + } /* loop through all components */ + + chunks[idx].mirror_count = i; + + if (chunks[idx].chunk.e_end == LUSTRE_EOF) + break; + + idx++; + if (idx >= chunks_size) { + fprintf(stderr, "%s: chunks array is too small.\n", + progname); + rc = -EINVAL; + goto error; + } + + chunks[idx].chunk.e_start = chunks[idx - 1].chunk.e_end; + } + +error: + return rc < 0 ? rc : idx + 1; +} + +/** + * lfs_mirror_verify_chunk() - Verify a chunk. + * @fd: File descriptor of the mirrored file. + * @file_size: Size of the mirrored file. + * @chunk: A chunk and its corresponding valid mirror ids. + * @verbose: Verbose mode. + * + * This function verifies a @chunk contains exactly the same data + * ammong the mirrors that cover it. + * + * If @verbose is specified, then the function will print where the + * differences are if the data do not match. Otherwise, it will + * just return an error in that case. + * + * Return: 0 on success or a negative error code on failure. + */ +static inline +int lfs_mirror_verify_chunk(int fd, size_t file_size, + struct verify_chunk *chunk, int verbose) { + const size_t buflen = 4 * 1024 * 1024; /* 4M */ + void *buf; + size_t page_size = sysconf(_SC_PAGESIZE); + ssize_t bytes_read; + ssize_t bytes_done; + size_t count; + off_t pos; + unsigned long crc; + unsigned long crc_array[LUSTRE_MIRROR_COUNT_MAX] = { 0 }; int i; - int j; - int k; - __u16 valid_id[LUSTRE_MIRROR_COUNT_MAX] = { 0 }; - unsigned int valid_count = 0; + int rc = 0; - for (i = 0; i < chunk_count; i++) { - if (chunks[i].mirror_count == 0) - continue; + if (file_size == 0) + return 0; - valid_count = 0; - for (j = 0; j < ids_nr; j++) { - for (k = 0; k < chunks[i].mirror_count; k++) { - if (chunks[i].mirror_id[k] == mirror_ids[j]) { - valid_id[valid_count] = mirror_ids[j]; - valid_count++; - break; - } + rc = posix_memalign(&buf, page_size, buflen); + if (rc) /* error code is returned directly */ + return -rc; + + if (verbose > 1) { + fprintf(stdout, "Verifying chunk "DEXT" on mirror:", + PEXT(&chunk->chunk)); + for (i = 0; i < chunk->mirror_count; i++) + fprintf(stdout, " %u", chunk->mirror_id[i]); + fprintf(stdout, "\n"); + } + + bytes_done = 0; + count = MIN(chunk->chunk.e_end, file_size) - chunk->chunk.e_start; + pos = chunk->chunk.e_start; + while (bytes_done < count) { + /* compute initial CRC-32 checksum */ + crc = crc32(0L, Z_NULL, 0); + memset(crc_array, 0, sizeof(crc_array)); + + bytes_read = 0; + for (i = 0; i < chunk->mirror_count; i++) { + bytes_read = llapi_mirror_read(fd, chunk->mirror_id[i], + buf, buflen, pos); + if (bytes_read < 0) { + rc = bytes_read; + fprintf(stderr, + "%s: failed to read data from mirror %u: %s.\n", + progname, chunk->mirror_id[i], + strerror(-rc)); + goto error; + } + + /* compute new CRC-32 checksum */ + crc_array[i] = crc32(crc, buf, bytes_read); + } + + if (verbose) + print_checksums(chunk, crc_array); + + /* compare CRC-32 checksum values */ + for (i = 1; i < chunk->mirror_count; i++) { + if (crc_array[i] != crc_array[0]) { + rc = -EINVAL; + + fprintf(stderr, + "%s: chunk "DEXT" has different checksum value on mirror %u and mirror %u.\n", + progname, PEXT(&chunk->chunk), + chunk->mirror_id[0], + chunk->mirror_id[i]); + } + } + + pos += bytes_read; + bytes_done += bytes_read; + } + + if (verbose > 1 && rc == 0) { + fprintf(stdout, "Verifying chunk "DEXT" on mirror:", + PEXT(&chunk->chunk)); + for (i = 0; i < chunk->mirror_count; i++) + fprintf(stdout, " %u", chunk->mirror_id[i]); + fprintf(stdout, " PASS\n\n"); + } + +error: + free(buf); + return rc; +} + +/** + * lfs_mirror_verify_file() - Verify a mirrored file. + * @fname: Mirrored file name. + * @mirror_ids: Specified mirror ids to be verified. + * @ids_nr: Number of specified mirror ids. + * @verbose: Verbose mode. + * + * This function verifies that each SYNC mirror of a mirrored file + * specified by @fname contains exactly the same data. + * + * If @mirror_ids is specified, then the function will verify the + * mirrors specified by @mirror_ids contain exactly the same data. + * + * If @verbose is specified, then the function will print where the + * differences are if the data do not match. Otherwise, it will + * just return an error in that case. + * + * Return: 0 on success or a negative error code on failure. + */ +static inline +int lfs_mirror_verify_file(const char *fname, __u16 *mirror_ids, int ids_nr, + int verbose) +{ + struct verify_chunk chunks_array[1024] = { }; + struct llapi_layout *layout = NULL; + struct stat stbuf; + uint32_t flr_state; + int fd; + int chunk_count = 0; + int idx = 0; + int rc = 0; + int rc1 = 0; + int rc2 = 0; + + if (stat(fname, &stbuf) < 0) { + fprintf(stderr, "%s: cannot stat file '%s': %s.\n", + progname, fname, strerror(errno)); + rc = -errno; + goto error; + } + + if (!S_ISREG(stbuf.st_mode)) { + fprintf(stderr, "%s: '%s' is not a regular file.\n", + progname, fname); + rc = -EINVAL; + goto error; + } + + if (stbuf.st_size == 0) { + if (verbose) + fprintf(stdout, "%s: '%s' file size is 0.\n", + progname, fname); + rc = 0; + goto error; + } + + fd = open(fname, O_DIRECT | O_RDONLY); + if (fd < 0) { + fprintf(stderr, "%s: cannot open '%s': %s.\n", + progname, fname, strerror(errno)); + rc = -errno; + goto error; + } + + rc = llapi_lease_acquire(fd, LL_LEASE_RDLCK); + if (rc < 0) { + fprintf(stderr, "%s: '%s' llapi_lease_acquire failed: %s.\n", + progname, fname, strerror(errno)); + goto close_fd; + } + + layout = llapi_layout_get_by_fd(fd, 0); + if (layout == NULL) { + fprintf(stderr, "%s: '%s' llapi_layout_get_by_fd failed: %s.\n", + progname, fname, strerror(errno)); + rc = -errno; + llapi_lease_release(fd); + goto close_fd; + } + + rc = llapi_layout_flags_get(layout, &flr_state); + if (rc < 0) { + fprintf(stderr, "%s: '%s' llapi_layout_flags_get failed: %s.\n", + progname, fname, strerror(errno)); + rc = -errno; + goto free_layout; + } + + flr_state &= LCM_FL_FLR_MASK; + switch (flr_state) { + case LCM_FL_NONE: + rc = -EINVAL; + fprintf(stderr, "%s: '%s' file state error: %s.\n", + progname, fname, llapi_layout_flags_string(flr_state)); + goto free_layout; + default: + break; + } + + /* find out mirror chunks to be verified */ + chunk_count = lfs_mirror_prepare_chunk(layout, chunks_array, + ARRAY_SIZE(chunks_array)); + if (chunk_count < 0) { + rc = chunk_count; + goto free_layout; + } + + if (ids_nr > 0) + /* filter specified mirror ids */ + filter_mirror_id(chunks_array, chunk_count, mirror_ids, ids_nr); + + if (verbose > 2) + print_chunks(fname, chunks_array, chunk_count); + + for (idx = 0; idx < chunk_count; idx++) { + if (chunks_array[idx].chunk.e_start >= stbuf.st_size) { + if (verbose) + fprintf(stdout, + "%s: '%s' chunk "DEXT" exceeds file size %#llx: skipped\n", + progname, fname, + PEXT(&chunks_array[idx].chunk), + (unsigned long long)stbuf.st_size); + break; + } + + if (chunks_array[idx].mirror_count == 0) { + fprintf(stderr, + "%s: '%s' chunk "DEXT" is invalid in all of the mirrors: ", + progname, fname, + PEXT(&chunks_array[idx].chunk)); + if (verbose) { + fprintf(stderr, "skipped\n"); + continue; } + rc = -EINVAL; + fprintf(stderr, "failed\n"); + goto free_layout; + } + + if (chunks_array[idx].mirror_count == 1) { + if (verbose) + fprintf(stdout, + "%s: '%s' chunk "DEXT" is only valid in mirror %u: skipped\n", + progname, fname, + PEXT(&chunks_array[idx].chunk), + chunks_array[idx].mirror_id[0]); + continue; + } + + rc = llapi_lease_check(fd); + if (rc != LL_LEASE_RDLCK) { + fprintf(stderr, "%s: '%s' lost lease lock.\n", + progname, fname); + goto free_layout; } - memcpy(chunks[i].mirror_id, valid_id, - sizeof(__u16) * valid_count); - chunks[i].mirror_count = valid_count; + /* verify one chunk */ + rc1 = lfs_mirror_verify_chunk(fd, stbuf.st_size, + &chunks_array[idx], verbose); + if (rc1 < 0) { + rc2 = rc1; + if (!verbose) { + rc = rc1; + goto free_layout; + } + } } + + if (rc2 < 0) + rc = rc2; + +free_layout: + llapi_layout_free(layout); + llapi_lease_release(fd); +close_fd: + close(fd); +error: + return rc; } /** - * lfs_mirror_prepare_chunk() - Find mirror chunks to be verified. - * @layout: Mirror component list. - * @chunks: Array of chunks. - * @chunks_size: Array size of @chunks. - * - * This function scans the components in @layout from offset 0 to LUSTRE_EOF - * to find out chunk segments and store them in @chunks array. - * - * The @mirror_id array in each element of @chunks will store the valid - * mirror ids that cover the chunk. If a mirror component covering the - * chunk has LCME_FL_STALE or LCME_FL_OFFLINE flag, then the mirror id - * will not be stored into the @mirror_id array, and the chunk for that - * mirror will not be verified. - * - * The @mirror_count in each element of @chunks will store the number of - * mirror ids in @mirror_id array. If @mirror_count is 0, it indicates the - * chunk is invalid in all of the mirrors. And if @mirror_count is 1, it - * indicates the chunk is valid in only one mirror. In both cases, the - * chunk will not be verified. - * - * Here is an example: - * - * 0 1M 2M 3M 4M EOF - * +------+-------------+--------------------+ - * | | | S | mirror1 - * +------+------+------+------+-------------+ - * | | S | S | | mirror2 - * +-------------+------+------+-------------+ + * lfs_mirror_verify() - Parse and execute lfs mirror verify command. + * @argc: The count of lfs mirror verify command line arguments. + * @argv: Array of strings for lfs mirror verify command line arguments. * - * prepared @chunks array will contain 5 elements: - * (([0, 1M), [1, 2], 2), - * ([1M, 2M), [1, 2], 2), - * ([2M, 3M), [1], 1), - * ([3M, 4M], [], 0), - * ([4M, EOF), [2], 1)) + * This function parses lfs mirror verify command and verifies the + * specified mirrored file(s). * - * Return: the actual array size of @chunks on success - * or a negative error code on failure. + * Return: 0 on success or a negative error code on failure. */ -static inline -int lfs_mirror_prepare_chunk(struct llapi_layout *layout, - struct verify_chunk *chunks, - size_t chunks_size) +static inline int lfs_mirror_verify(int argc, char **argv) { - uint64_t start; - uint64_t end; - uint32_t mirror_id; - uint32_t flags; - int idx = 0; - int i = 0; + __u16 mirror_ids[LUSTRE_MIRROR_COUNT_MAX] = { 0 }; + int ids_nr = 0; + int c; + int verbose = 0; int rc = 0; + int rc1 = 0; + char cmd[PATH_MAX]; - memset(chunks, 0, sizeof(*chunks) * chunks_size); - - while (1) { - rc = llapi_layout_comp_use(layout, LLAPI_LAYOUT_COMP_USE_FIRST); - if (rc < 0) { - fprintf(stderr, - "%s: move to the first layout component: %s.\n", - progname, strerror(errno)); - goto error; - } - - i = 0; - rc = 0; - chunks[idx].chunk.e_end = LUSTRE_EOF; - while (rc == 0) { - rc = llapi_layout_comp_extent_get(layout, &start, &end); - if (rc < 0) { - fprintf(stderr, - "%s: llapi_layout_comp_extent_get failed: %s.\n", - progname, strerror(errno)); - goto error; - } - - if (start > chunks[idx].chunk.e_start || - end <= chunks[idx].chunk.e_start) - goto next; - - if (end < chunks[idx].chunk.e_end) - chunks[idx].chunk.e_end = end; - - rc = llapi_layout_comp_flags_get(layout, &flags); - if (rc < 0) { - fprintf(stderr, - "%s: llapi_layout_comp_flags_get failed: %s.\n", - progname, strerror(errno)); - goto error; - } - - if (flags & LCME_FL_STALE || flags & LCME_FL_OFFLINE) - goto next; + struct option long_opts[] = { + { .val = 'o', .name = "only", .has_arg = required_argument }, + { .val = 'v', .name = "verbose", .has_arg = no_argument }, + { .name = NULL } }; - rc = llapi_layout_mirror_id_get(layout, &mirror_id); + snprintf(cmd, sizeof(cmd), "%s %s", progname, argv[0]); + progname = cmd; + while ((c = getopt_long(argc, argv, "o:v", long_opts, NULL)) >= 0) { + switch (c) { + case 'o': + rc = parse_mirror_ids(mirror_ids, + ARRAY_SIZE(mirror_ids), + optarg); if (rc < 0) { fprintf(stderr, - "%s: llapi_layout_mirror_id_get failed: %s.\n", - progname, strerror(errno)); + "%s: bad mirror ids '%s'.\n", + progname, optarg); goto error; } - - chunks[idx].mirror_id[i] = mirror_id; - i++; - if (i >= ARRAY_SIZE(chunks[idx].mirror_id)) { + ids_nr = rc; + if (ids_nr < 2) { fprintf(stderr, - "%s: mirror_id array is too small.\n", + "%s: at least 2 mirror ids needed with '--only' option.\n", progname); - rc = -EINVAL; - goto error; - } - - next: - rc = llapi_layout_comp_use(layout, - LLAPI_LAYOUT_COMP_USE_NEXT); - if (rc < 0) { - fprintf(stderr, - "%s: move to the next layout component: %s.\n", - progname, strerror(errno)); + rc = CMD_HELP; goto error; } - } /* loop through all components */ - - chunks[idx].mirror_count = i; - - if (chunks[idx].chunk.e_end == LUSTRE_EOF) break; - - idx++; - if (idx >= chunks_size) { - fprintf(stderr, "%s: chunks array is too small.\n", - progname); + case 'v': + verbose++; + break; + default: + fprintf(stderr, "%s: option '%s' unrecognized.\n", + progname, argv[optind - 1]); rc = -EINVAL; goto error; } + } - chunks[idx].chunk.e_start = chunks[idx - 1].chunk.e_end; + if (argc == optind) { + fprintf(stderr, "%s: no file name given.\n", progname); + rc = CMD_HELP; + goto error; + } + + if (ids_nr > 0 && argc > optind + 1) { + fprintf(stderr, + "%s: '--only' cannot be used upon multiple files.\n", + progname); + rc = CMD_HELP; + goto error; + + } + + if (ids_nr > 0) { + rc = verify_mirror_ids(argv[optind], mirror_ids, ids_nr); + if (rc < 0) + goto error; } + rc = 0; + for (; optind < argc; optind++) { + rc1 = lfs_mirror_verify_file(argv[optind], mirror_ids, ids_nr, + verbose); + if (rc1 < 0) + rc = rc1; + } error: - return rc < 0 ? rc : idx + 1; + return rc; } /** - * lfs_mirror_verify_chunk() - Verify a chunk. - * @fd: File descriptor of the mirrored file. - * @file_size: Size of the mirrored file. - * @chunk: A chunk and its corresponding valid mirror ids. - * @verbose: Verbose mode. - * - * This function verifies a @chunk contains exactly the same data - * ammong the mirrors that cover it. + * lfs_mirror() - Parse and execute lfs mirror commands. + * @argc: The count of lfs mirror command line arguments. + * @argv: Array of strings for lfs mirror command line arguments. * - * If @verbose is specified, then the function will print where the - * differences are if the data do not match. Otherwise, it will - * just return an error in that case. + * This function parses lfs mirror commands and performs the + * corresponding functions specified in mirror_cmdlist[]. * - * Return: 0 on success or a negative error code on failure. + * Return: 0 on success or an error code on failure. */ -static inline -int lfs_mirror_verify_chunk(int fd, size_t file_size, - struct verify_chunk *chunk, int verbose) +static int lfs_mirror(int argc, char **argv) { - const size_t buflen = 4 * 1024 * 1024; /* 4M */ - void *buf; - size_t page_size = sysconf(_SC_PAGESIZE); - ssize_t bytes_read; - ssize_t bytes_done; - size_t count; - off_t pos; - unsigned long crc; - unsigned long crc_array[LUSTRE_MIRROR_COUNT_MAX] = { 0 }; - int i; + char cmd[PATH_MAX]; int rc = 0; - if (file_size == 0) - return 0; + setlinebuf(stdout); + + Parser_init("lfs-mirror > ", mirror_cmdlist); + + snprintf(cmd, sizeof(cmd), "%s %s", progname, argv[0]); + progname = cmd; + program_invocation_short_name = cmd; + if (argc > 1) + rc = Parser_execarg(argc - 1, argv + 1, mirror_cmdlist); + else + rc = Parser_commands(); - rc = posix_memalign(&buf, page_size, buflen); - if (rc) /* error code is returned directly */ - return -rc; + return rc < 0 ? -rc : rc; +} - if (verbose > 1) { - fprintf(stdout, "Verifying chunk "DEXT" on mirror:", - PEXT(&chunk->chunk)); - for (i = 0; i < chunk->mirror_count; i++) - fprintf(stdout, " %u", chunk->mirror_id[i]); - fprintf(stdout, "\n"); - } +static void lustre_som_swab(struct lustre_som_attrs *attrs) +{ +#if __BYTE_ORDER == __BIG_ENDIAN + __swab16s(&attrs->lsa_valid); + __swab64s(&attrs->lsa_size); + __swab64s(&attrs->lsa_blocks); +#endif +} - bytes_done = 0; - count = MIN(chunk->chunk.e_end, file_size) - chunk->chunk.e_start; - pos = chunk->chunk.e_start; - while (bytes_done < count) { - /* compute initial CRC-32 checksum */ - crc = crc32(0L, Z_NULL, 0); - memset(crc_array, 0, sizeof(crc_array)); +enum lfs_som_type { + LFS_SOM_SIZE = 0x1, + LFS_SOM_BLOCKS = 0x2, + LFS_SOM_FLAGS = 0x4, + LFS_SOM_ATTR_ALL = LFS_SOM_SIZE | LFS_SOM_BLOCKS | + LFS_SOM_FLAGS, +}; - bytes_read = 0; - for (i = 0; i < chunk->mirror_count; i++) { - bytes_read = llapi_mirror_read(fd, chunk->mirror_id[i], - buf, buflen, pos); - if (bytes_read < 0) { - rc = bytes_read; - fprintf(stderr, - "%s: failed to read data from mirror %u: %s.\n", - progname, chunk->mirror_id[i], - strerror(-rc)); - goto error; - } +static int lfs_getsom(int argc, char **argv) +{ + const char *path; + struct lustre_som_attrs *attrs; + char buf[sizeof(*attrs) + 64]; + enum lfs_som_type type = LFS_SOM_ATTR_ALL; + int rc = 0, c; - /* compute new CRC-32 checksum */ - crc_array[i] = crc32(crc, buf, bytes_read); + while ((c = getopt(argc, argv, "sbf")) != -1) { + switch (c) { + case 's': + type = LFS_SOM_SIZE; + break; + case 'b': + type = LFS_SOM_BLOCKS; + break; + case 'f': + type = LFS_SOM_FLAGS; + break; + default: + fprintf(stderr, "%s: invalid option '%c'\n", + progname, optopt); + return CMD_HELP; } + } - if (verbose) - print_checksums(chunk, crc_array); - - /* compare CRC-32 checksum values */ - for (i = 1; i < chunk->mirror_count; i++) { - if (crc_array[i] != crc_array[0]) { - rc = -EINVAL; - if (!verbose) - goto error; + argc -= optind; + argv += optind; - fprintf(stderr, - "%s: chunk "DEXT" has different checksum value on mirror %u and mirror %u.\n", - progname, PEXT(&chunk->chunk), - chunk->mirror_id[0], - chunk->mirror_id[i]); - } - } + if (argc != 1) { + fprintf(stderr, "%s: %s\n", + progname, argc == 0 ? "miss file target" : + "input more than 2 files"); + return CMD_HELP; + } - pos += bytes_read; - bytes_done += bytes_read; + path = argv[0]; + attrs = (void *)buf; + rc = lgetxattr(path, "trusted.som", attrs, sizeof(buf)); + if (rc < 0) { + rc = -errno; + fprintf(stderr, "%s failed to get som xattr: %s (%d)\n", + argv[0], strerror(errno), errno); + return rc; } - if (verbose > 1 && rc == 0) { - fprintf(stdout, "Verifying chunk "DEXT" on mirror:", - PEXT(&chunk->chunk)); - for (i = 0; i < chunk->mirror_count; i++) - fprintf(stdout, " %u", chunk->mirror_id[i]); - fprintf(stdout, " PASS\n\n"); + lustre_som_swab(attrs); + + switch (type) { + case LFS_SOM_ATTR_ALL: + printf("file: %s size: %llu blocks: %llu flags: %x\n", + path, (unsigned long long)attrs->lsa_size, + (unsigned long long)attrs->lsa_blocks, + attrs->lsa_valid); + break; + case LFS_SOM_SIZE: + printf("%llu\n", (unsigned long long)attrs->lsa_size); + break; + case LFS_SOM_BLOCKS: + printf("%llu\n", (unsigned long long)attrs->lsa_blocks); + break; + case LFS_SOM_FLAGS: + printf("%x\n", attrs->lsa_valid); + break; + default: + fprintf(stderr, "%s: unknown option\n", progname); + return CMD_HELP; } -error: - free(buf); - return rc; + return 0; } /** - * lfs_mirror_verify_file() - Verify a mirrored file. - * @fname: Mirrored file name. - * @mirror_ids: Specified mirror ids to be verified. - * @ids_nr: Number of specified mirror ids. - * @verbose: Verbose mode. - * - * This function verifies that each SYNC mirror of a mirrored file - * specified by @fname contains exactly the same data. - * - * If @mirror_ids is specified, then the function will verify the - * mirrors specified by @mirror_ids contain exactly the same data. + * lfs_mirror_list_commands() - List lfs mirror commands. + * @argc: The count of command line arguments. + * @argv: Array of strings for command line arguments. * - * If @verbose is specified, then the function will print where the - * differences are if the data do not match. Otherwise, it will - * just return an error in that case. + * This function lists lfs mirror commands defined in mirror_cmdlist[]. * - * Return: 0 on success or a negative error code on failure. + * Return: 0 on success. */ -static inline -int lfs_mirror_verify_file(const char *fname, __u16 *mirror_ids, int ids_nr, - int verbose) +static int lfs_mirror_list_commands(int argc, char **argv) { - struct verify_chunk chunks_array[1024] = { }; - struct llapi_layout *layout = NULL; - struct stat stbuf; - uint32_t flr_state; - int fd; - int chunk_count = 0; - int idx = 0; + char buffer[81] = ""; + + Parser_list_commands(mirror_cmdlist, buffer, sizeof(buffer), + NULL, 0, 4); + + return 0; +} + +static int lfs_pcc_attach(int argc, char **argv) +{ + struct option long_opts[] = { + { .val = 'i', .name = "id", .has_arg = required_argument }, + { .name = NULL } }; + int c; int rc = 0; - int rc1 = 0; - int rc2 = 0; + __u32 archive_id = 0; + const char *path; + char *end; + char fullpath[PATH_MAX]; + enum lu_pcc_type type = LU_PCC_READWRITE; - if (stat(fname, &stbuf) < 0) { - fprintf(stderr, "%s: cannot stat file '%s': %s.\n", - progname, fname, strerror(errno)); - rc = -errno; - goto error; + optind = 0; + while ((c = getopt_long(argc, argv, "i:", + long_opts, NULL)) != -1) { + switch (c) { + case 'i': + archive_id = strtoul(optarg, &end, 0); + if (*end != '\0' || archive_id == 0) { + fprintf(stderr, "error: %s: bad archive ID " + "'%s'\n", argv[0], optarg); + return CMD_HELP; + } + break; + case '?': + return CMD_HELP; + default: + fprintf(stderr, "%s: option '%s' unrecognized\n", + argv[0], argv[optind - 1]); + return CMD_HELP; + } } - if (!S_ISREG(stbuf.st_mode)) { - fprintf(stderr, "%s: '%s' is not a regular file.\n", - progname, fname); - rc = -EINVAL; - goto error; + if (argc <= optind) { + fprintf(stderr, "%s: must specify one or more file names\n", + argv[0]); + return CMD_HELP; } - if (stbuf.st_size == 0) { - if (verbose) - fprintf(stdout, "%s: '%s' file size is 0.\n", - progname, fname); - rc = 0; - goto error; - } + while (optind < argc) { + int rc2; - fd = open(fname, O_DIRECT | O_RDONLY); - if (fd < 0) { - fprintf(stderr, "%s: cannot open '%s': %s.\n", - progname, fname, strerror(errno)); - rc = -errno; - goto error; - } + path = argv[optind++]; + if (realpath(path, fullpath) == NULL) { + fprintf(stderr, "%s: could not find path '%s': %s\n", + argv[0], path, strerror(errno)); + if (rc == 0) + rc = -EINVAL; + continue; + } - rc = llapi_lease_acquire(fd, LL_LEASE_RDLCK); - if (rc < 0) { - fprintf(stderr, "%s: '%s' llapi_lease_acquire failed: %s.\n", - progname, fname, strerror(errno)); - goto close_fd; + rc2 = llapi_pcc_attach(fullpath, archive_id, type); + if (rc2 < 0) { + fprintf(stderr, "%s: cannot attach '%s' to PCC " + "with archive ID '%u': %s\n", argv[0], + path, archive_id, strerror(-rc2)); + if (rc == 0) + rc = rc2; + } } + return rc; +} - layout = llapi_layout_get_by_fd(fd, 0); - if (layout == NULL) { - fprintf(stderr, "%s: '%s' llapi_layout_get_by_fd failed: %s.\n", - progname, fname, strerror(errno)); - rc = -errno; - llapi_lease_release(fd); - goto close_fd; +static int lfs_pcc_attach_fid(int argc, char **argv) +{ + struct option long_opts[] = { + { .val = 'i', .name = "id", .has_arg = required_argument }, + { .val = 'm', .name = "mnt", .has_arg = required_argument }, + { .name = NULL } }; + char short_opts[] = "i:m:"; + int c; + int rc = 0; + __u32 archive_id = 0; + char *end; + const char *mntpath = NULL; + const char *fidstr; + enum lu_pcc_type type = LU_PCC_READWRITE; + + optind = 0; + while ((c = getopt_long(argc, argv, short_opts, + long_opts, NULL)) != -1) { + switch (c) { + case 'i': + archive_id = strtoul(optarg, &end, 0); + if (*end != '\0') { + fprintf(stderr, "error: %s: bad archive ID " + "'%s'\n", argv[0], optarg); + return CMD_HELP; + } + break; + case 'm': + mntpath = optarg; + break; + case '?': + return CMD_HELP; + default: + fprintf(stderr, "%s: option '%s' unrecognized\n", + argv[0], argv[optind - 1]); + return CMD_HELP; + } } - rc = llapi_layout_flags_get(layout, &flr_state); - if (rc < 0) { - fprintf(stderr, "%s: '%s' llapi_layout_flags_get failed: %s.\n", - progname, fname, strerror(errno)); - rc = -errno; - goto free_layout; + if (archive_id == 0) { + fprintf(stderr, "%s: must specify an archive ID\n", argv[0]); + return CMD_HELP; } - flr_state &= LCM_FL_FLR_MASK; - switch (flr_state) { - case LCM_FL_NONE: - rc = -EINVAL; - fprintf(stderr, "%s: '%s' file state error: %s.\n", - progname, fname, llapi_layout_flags_string(flr_state)); - goto free_layout; - default: - break; + if (mntpath == NULL) { + fprintf(stderr, "%s: must specify Lustre mount point\n", + argv[0]); + return CMD_HELP; } - /* find out mirror chunks to be verified */ - chunk_count = lfs_mirror_prepare_chunk(layout, chunks_array, - ARRAY_SIZE(chunks_array)); - if (chunk_count < 0) { - rc = chunk_count; - goto free_layout; + if (argc <= optind) { + fprintf(stderr, "%s: must specify one or more fids\n", argv[0]); + return CMD_HELP; } - if (ids_nr > 0) - /* filter specified mirror ids */ - filter_mirror_id(chunks_array, chunk_count, mirror_ids, ids_nr); + while (optind < argc) { + int rc2; - if (verbose > 2) - print_chunks(fname, chunks_array, chunk_count); + fidstr = argv[optind++]; - for (idx = 0; idx < chunk_count; idx++) { - if (chunks_array[idx].chunk.e_start >= stbuf.st_size) { - if (verbose) - fprintf(stdout, - "%s: '%s' chunk "DEXT" exceeds file size %#llx: skipped\n", - progname, fname, - PEXT(&chunks_array[idx].chunk), - (unsigned long long)stbuf.st_size); - break; + rc2 = llapi_pcc_attach_fid_str(mntpath, fidstr, + archive_id, type); + if (rc2 < 0) { + fprintf(stderr, "%s: cannot attach '%s' on '%s' to PCC " + "with archive ID '%u': %s\n", argv[0], + fidstr, mntpath, archive_id, strerror(rc2)); } + if (rc == 0 && rc2 < 0) + rc = rc2; + } + return rc; +} - if (chunks_array[idx].mirror_count == 0) { - fprintf(stderr, - "%s: '%s' chunk "DEXT" is invalid in all of the mirrors: ", - progname, fname, - PEXT(&chunks_array[idx].chunk)); - if (verbose) { - fprintf(stderr, "skipped\n"); - continue; - } - rc = -EINVAL; - fprintf(stderr, "failed\n"); - goto free_layout; - } +static int lfs_pcc_detach(int argc, char **argv) +{ + struct option long_opts[] = { + { .val = 'k', .name = "keep", .has_arg = no_argument }, + { .name = NULL } }; + char short_opts[] = "k"; + int c; + int rc = 0; + const char *path; + char fullpath[PATH_MAX]; + __u32 detach_opt = PCC_DETACH_OPT_UNCACHE; - if (chunks_array[idx].mirror_count == 1) { - if (verbose) - fprintf(stdout, - "%s: '%s' chunk "DEXT" is only valid in mirror %u: skipped\n", - progname, fname, - PEXT(&chunks_array[idx].chunk), - chunks_array[idx].mirror_id[0]); - continue; + optind = 0; + while ((c = getopt_long(argc, argv, short_opts, + long_opts, NULL)) != -1) { + switch (c) { + case 'k': + detach_opt = PCC_DETACH_OPT_NONE; + break; + case '?': + return CMD_HELP; + default: + fprintf(stderr, "%s: option '%s' unrecognized\n", + argv[0], argv[optind - 1]); + return CMD_HELP; } + } - rc = llapi_lease_check(fd); - if (rc != LL_LEASE_RDLCK) { - fprintf(stderr, "%s: '%s' lost lease lock.\n", - progname, fname); - goto free_layout; + while (optind < argc) { + int rc2; + + path = argv[optind++]; + if (realpath(path, fullpath) == NULL) { + fprintf(stderr, "%s: could not find path '%s': %s\n", + argv[0], path, strerror(errno)); + if (rc == 0) + rc = -EINVAL; + continue; } - /* verify one chunk */ - rc1 = lfs_mirror_verify_chunk(fd, stbuf.st_size, - &chunks_array[idx], verbose); - if (rc1 < 0) { - rc2 = rc1; - if (!verbose) { - rc = rc1; - goto free_layout; - } + rc2 = llapi_pcc_detach_file(fullpath, detach_opt); + if (rc2 < 0) { + rc2 = -errno; + fprintf(stderr, "%s: cannot detach '%s' from PCC: " + "%s\n", argv[0], path, strerror(errno)); + if (rc == 0) + rc = rc2; } } - - if (rc2 < 0) - rc = rc2; - -free_layout: - llapi_layout_free(layout); - llapi_lease_release(fd); -close_fd: - close(fd); -error: return rc; } -/** - * lfs_mirror_verify() - Parse and execute lfs mirror verify command. - * @argc: The count of lfs mirror verify command line arguments. - * @argv: Array of strings for lfs mirror verify command line arguments. - * - * This function parses lfs mirror verify command and verifies the - * specified mirrored file(s). - * - * Return: 0 on success or a negative error code on failure. - */ -static inline int lfs_mirror_verify(int argc, char **argv) +static int lfs_pcc_detach_fid(int argc, char **argv) { - __u16 mirror_ids[LUSTRE_MIRROR_COUNT_MAX] = { 0 }; - int ids_nr = 0; - int c; - int verbose = 0; - int rc = 0; - int rc1 = 0; - char cmd[PATH_MAX]; - struct option long_opts[] = { - { .val = 'o', .name = "only", .has_arg = required_argument }, - { .val = 'v', .name = "verbose", .has_arg = no_argument }, + { .val = 'k', .name = "keep", .has_arg = no_argument }, { .name = NULL } }; + char short_opts[] = "k"; + int c; + int rc = 0; + const char *fid; + const char *mntpath; + __u32 detach_opt = PCC_DETACH_OPT_UNCACHE; - snprintf(cmd, sizeof(cmd), "%s %s", progname, argv[0]); - progname = cmd; - while ((c = getopt_long(argc, argv, "o:v", long_opts, NULL)) >= 0) { + optind = 0; + while ((c = getopt_long(argc, argv, short_opts, + long_opts, NULL)) != -1) { switch (c) { - case 'o': - rc = parse_mirror_ids(mirror_ids, - ARRAY_SIZE(mirror_ids), - optarg); - if (rc < 0) { - fprintf(stderr, - "%s: bad mirror ids '%s'.\n", - progname, optarg); - goto error; - } - ids_nr = rc; - if (ids_nr < 2) { - fprintf(stderr, - "%s: at least 2 mirror ids needed with '--only' option.\n", - progname); - rc = CMD_HELP; - goto error; - } - break; - case 'v': - verbose++; + case 'k': + detach_opt = PCC_DETACH_OPT_NONE; break; + case '?': + return CMD_HELP; default: - fprintf(stderr, "%s: options '%s' unrecognized.\n", - progname, argv[optind - 1]); - rc = -EINVAL; - goto error; + fprintf(stderr, "%s: option '%s' unrecognized\n", + argv[0], argv[optind - 1]); + return CMD_HELP; } } - if (argc == optind) { - fprintf(stderr, "%s: no file name given.\n", progname); - rc = CMD_HELP; - goto error; - } + mntpath = argv[optind++]; - if (ids_nr > 0 && argc > optind + 1) { - fprintf(stderr, - "%s: '--only' cannot be used upon multiple files.\n", - progname); - rc = CMD_HELP; - goto error; + while (optind < argc) { + int rc2; + fid = argv[optind++]; + + rc2 = llapi_pcc_detach_fid_str(mntpath, fid, detach_opt); + if (rc2 < 0) { + fprintf(stderr, "%s: cannot detach '%s' on '%s' " + "from PCC: %s\n", argv[0], fid, mntpath, + strerror(-rc2)); + if (rc == 0) + rc = rc2; + } } + return rc; +} - if (ids_nr > 0) { - rc = verify_mirror_ids(argv[optind], mirror_ids, ids_nr); - if (rc < 0) - goto error; +static int lfs_pcc_state(int argc, char **argv) +{ + int rc = 0; + const char *path; + char fullpath[PATH_MAX]; + struct lu_pcc_state state; + + optind = 1; + + if (argc <= 1) { + fprintf(stderr, "%s: must specify one or more file names\n", + argv[0]); + return CMD_HELP; } - rc = 0; - for (; optind < argc; optind++) { - rc1 = lfs_mirror_verify_file(argv[optind], mirror_ids, ids_nr, - verbose); - if (rc1 < 0) - rc = rc1; + while (optind < argc) { + int rc2; + + path = argv[optind++]; + if (realpath(path, fullpath) == NULL) { + fprintf(stderr, "%s: could not find path '%s': %s\n", + argv[0], path, strerror(errno)); + if (rc == 0) + rc = -EINVAL; + continue; + } + + rc2 = llapi_pcc_state_get(fullpath, &state); + if (rc2 < 0) { + if (rc == 0) + rc = rc2; + fprintf(stderr, "%s: cannot get PCC state of '%s': " + "%s\n", argv[0], path, strerror(-rc2)); + continue; + } + + printf("file: %s", path); + printf(", type: %s", pcc_type2string(state.pccs_type)); + if (state.pccs_type == LU_PCC_NONE && + state.pccs_open_count == 0) { + printf("\n"); + continue; + } + + printf(", PCC file: %s", state.pccs_path); + printf(", user number: %u", state.pccs_open_count); + printf(", flags: %x", state.pccs_flags); + printf("\n"); } -error: return rc; } /** - * lfs_mirror() - Parse and execute lfs mirror commands. - * @argc: The count of lfs mirror command line arguments. - * @argv: Array of strings for lfs mirror command line arguments. + * lfs_pcc_list_commands() - List lfs pcc commands. + * @argc: The count of command line arguments. + * @argv: Array of strings for command line arguments. * - * This function parses lfs mirror commands and performs the - * corresponding functions specified in mirror_cmdlist[]. + * This function lists lfs pcc commands defined in pcc_cmdlist[]. + * + * Return: 0 on success. + */ +static int lfs_pcc_list_commands(int argc, char **argv) +{ + char buffer[81] = ""; + + Parser_list_commands(pcc_cmdlist, buffer, sizeof(buffer), + NULL, 0, 4); + + return 0; +} + +/** + * lfs_pcc() - Parse and execute lfs pcc commands. + * @argc: The count of lfs pcc command line arguments. + * @argv: Array of strings for lfs pcc command line arguments. + * + * This function parses lfs pcc commands and performs the + * corresponding functions specified in pcc_cmdlist[]. * * Return: 0 on success or an error code on failure. */ -static int lfs_mirror(int argc, char **argv) +static int lfs_pcc(int argc, char **argv) { char cmd[PATH_MAX]; int rc = 0; setlinebuf(stdout); - Parser_init("lfs-mirror > ", mirror_cmdlist); + Parser_init("lfs-pcc > ", pcc_cmdlist); snprintf(cmd, sizeof(cmd), "%s %s", progname, argv[0]); progname = cmd; program_invocation_short_name = cmd; if (argc > 1) - rc = Parser_execarg(argc - 1, argv + 1, mirror_cmdlist); + rc = Parser_execarg(argc - 1, argv + 1, pcc_cmdlist); else rc = Parser_commands(); return rc < 0 ? -rc : rc; } -/** - * lfs_mirror_list_commands() - List lfs mirror commands. - * @argc: The count of command line arguments. - * @argv: Array of strings for command line arguments. - * - * This function lists lfs mirror commands defined in mirror_cmdlist[]. - * - * Return: 0 on success. - */ -static int lfs_mirror_list_commands(int argc, char **argv) -{ - char buffer[81] = ""; - - Parser_list_commands(mirror_cmdlist, buffer, sizeof(buffer), - NULL, 0, 4); - - return 0; -} - static int lfs_list_commands(int argc, char **argv) { char buffer[81] = ""; /* 80 printable chars + terminating NUL */