X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;ds=sidebyside;f=cmds-qgroup.c;h=93206900693de5a43472f6c6c6ff6f63b6d3230c;hb=7cdd58b2e92863f055c70ef7134d3a70760473c7;hp=4fe776c031601abe55684604af935b7442e8ec8e;hpb=8ac2ddf588d0f8b9d7f055459355c801d1fd04ed;p=platform%2Fupstream%2Fbtrfs-progs.git diff --git a/cmds-qgroup.c b/cmds-qgroup.c index 4fe776c..9320690 100644 --- a/cmds-qgroup.c +++ b/cmds-qgroup.c @@ -20,87 +20,139 @@ #include #include +#include + #include "ctree.h" #include "ioctl.h" #include "commands.h" #include "qgroup.h" #include "utils.h" +#include "help.h" static const char * const qgroup_cmd_group_usage[] = { "btrfs qgroup [options] ", NULL }; -static int qgroup_assign(int assign, int argc, char **argv) +static int _cmd_qgroup_assign(int assign, int argc, char **argv, + const char * const *usage_str) { int ret = 0; int fd; - int e; - char *path = argv[3]; + int rescan = 0; + char *path; struct btrfs_ioctl_qgroup_assign_args args; DIR *dirstream = NULL; - if (check_argc_exact(argc, 4)) - return -1; + if (assign) { + while (1) { + enum { GETOPT_VAL_RESCAN = 256, GETOPT_VAL_NO_RESCAN }; + static const struct option long_options[] = { + { "rescan", no_argument, NULL, + GETOPT_VAL_RESCAN }, + { "no-rescan", no_argument, NULL, + GETOPT_VAL_NO_RESCAN }, + { NULL, 0, NULL, 0 } + }; + int c = getopt_long(argc, argv, "", long_options, NULL); + + if (c < 0) + break; + switch (c) { + case GETOPT_VAL_RESCAN: + rescan = 1; + break; + case GETOPT_VAL_NO_RESCAN: + rescan = 0; + break; + default: + /* Usage printed by the caller */ + return -1; + } + } + } else { + clean_args_no_options(argc, argv, usage_str); + } + + if (check_argc_exact(argc - optind, 3)) + usage(usage_str); memset(&args, 0, sizeof(args)); args.assign = assign; - args.src = parse_qgroupid(argv[1]); - args.dst = parse_qgroupid(argv[2]); + args.src = parse_qgroupid(argv[optind]); + args.dst = parse_qgroupid(argv[optind + 1]); + + path = argv[optind + 2]; /* * FIXME src should accept subvol path */ - if ((args.src >> 48) >= (args.dst >> 48)) { - fprintf(stderr, "ERROR: bad relation requested '%s'\n", path); + if (btrfs_qgroup_level(args.src) >= btrfs_qgroup_level(args.dst)) { + error("bad relation requested: %s", path); return 1; } - fd = open_file_or_dir(path, &dirstream); - if (fd < 0) { - fprintf(stderr, "ERROR: can't access '%s'\n", path); + fd = btrfs_open_dir(path, &dirstream, 1); + if (fd < 0) return 1; - } ret = ioctl(fd, BTRFS_IOC_QGROUP_ASSIGN, &args); - e = errno; - close_file_or_dir(fd, dirstream); if (ret < 0) { - fprintf(stderr, "ERROR: unable to assign quota group: %s\n", - strerror(e)); + error("unable to assign quota group: %m"); + close_file_or_dir(fd, dirstream); return 1; } - return 0; + + /* + * If ret > 0, it means assign caused qgroup data inconsistent state. + * Schedule a quota rescan if requested. + * + * The return value change only happens in newer kernel. But will not + * cause problem since old kernel has a bug that will never clear + * INCONSISTENT bit. + */ + if (ret > 0) { + if (rescan) { + struct btrfs_ioctl_quota_rescan_args qargs; + + printf("Quota data changed, rescan scheduled\n"); + memset(&qargs, 0, sizeof(qargs)); + ret = ioctl(fd, BTRFS_IOC_QUOTA_RESCAN, &qargs); + if (ret < 0) + error("quota rescan failed: %m"); + } else { + warning("quotas may be inconsistent, rescan needed"); + } + } + close_file_or_dir(fd, dirstream); + return ret; } -static int qgroup_create(int create, int argc, char **argv) +static int _cmd_qgroup_create(int create, int argc, char **argv) { int ret = 0; int fd; - int e; - char *path = argv[2]; + char *path; struct btrfs_ioctl_qgroup_create_args args; DIR *dirstream = NULL; - if (check_argc_exact(argc, 3)) + if (check_argc_exact(argc - optind, 2)) return -1; memset(&args, 0, sizeof(args)); args.create = create; - args.qgroupid = parse_qgroupid(argv[1]); + args.qgroupid = parse_qgroupid(argv[optind]); + path = argv[optind + 1]; - fd = open_file_or_dir(path, &dirstream); - if (fd < 0) { - fprintf(stderr, "ERROR: can't access '%s'\n", path); + fd = btrfs_open_dir(path, &dirstream, 1); + if (fd < 0) return 1; - } ret = ioctl(fd, BTRFS_IOC_QGROUP_CREATE, &args); - e = errno; close_file_or_dir(fd, dirstream); if (ret < 0) { - fprintf(stderr, "ERROR: unable to create quota group: %s\n", - strerror(e)); + error("unable to %s quota group: %m", + create ? "create":"destroy"); return 1; } return 0; @@ -110,22 +162,33 @@ static int parse_limit(const char *p, unsigned long long *s) { char *endptr; unsigned long long size; + unsigned long long CLEAR_VALUE = -1; if (strcasecmp(p, "none") == 0) { - *s = 0; + *s = CLEAR_VALUE; return 1; } + + if (p[0] == '-') + return 0; + size = strtoull(p, &endptr, 10); + if (p == endptr) + return 0; + switch (*endptr) { case 'T': case 't': size *= 1024; + /* fallthrough */ case 'G': case 'g': size *= 1024; + /* fallthrough */ case 'M': case 'm': size *= 1024; + /* fallthrough */ case 'K': case 'k': size *= 1024; @@ -146,31 +209,28 @@ static int parse_limit(const char *p, unsigned long long *s) } static const char * const cmd_qgroup_assign_usage[] = { - "btrfs qgroup assign ", - "Enable subvolume qgroup support for a filesystem.", + "btrfs qgroup assign [options] ", + "Assign SRC as the child qgroup of DST", + "", + "--rescan schedule qutoa rescan if needed", + "--no-rescan don't schedule quota rescan", NULL }; static int cmd_qgroup_assign(int argc, char **argv) { - int ret = qgroup_assign(1, argc, argv); - if (ret < 0) - usage(cmd_qgroup_assign_usage); - return ret; + return _cmd_qgroup_assign(1, argc, argv, cmd_qgroup_assign_usage); } static const char * const cmd_qgroup_remove_usage[] = { "btrfs qgroup remove ", - "Remove a subvol from a quota group.", + "Remove a child qgroup SRC from DST.", NULL }; static int cmd_qgroup_remove(int argc, char **argv) { - int ret = qgroup_assign(0, argc, argv); - if (ret < 0) - usage(cmd_qgroup_remove_usage); - return ret; + return _cmd_qgroup_assign(0, argc, argv, cmd_qgroup_remove_usage); } static const char * const cmd_qgroup_create_usage[] = { @@ -181,7 +241,12 @@ static const char * const cmd_qgroup_create_usage[] = { static int cmd_qgroup_create(int argc, char **argv) { - int ret = qgroup_create(1, argc, argv); + int ret; + + clean_args_no_options(argc, argv, cmd_qgroup_create_usage); + + ret = _cmd_qgroup_create(1, argc, argv); + if (ret < 0) usage(cmd_qgroup_create_usage); return ret; @@ -189,35 +254,40 @@ static int cmd_qgroup_create(int argc, char **argv) static const char * const cmd_qgroup_destroy_usage[] = { "btrfs qgroup destroy ", - "Destroy a subvolume quota group.", + "Destroy a quota group.", NULL }; static int cmd_qgroup_destroy(int argc, char **argv) { - int ret = qgroup_create(0, argc, argv); + int ret; + + clean_args_no_options(argc, argv, cmd_qgroup_destroy_usage); + + ret = _cmd_qgroup_create(0, argc, argv); + if (ret < 0) usage(cmd_qgroup_destroy_usage); return ret; } static const char * const cmd_qgroup_show_usage[] = { - "btrfs qgroup show -pcreFf " - "[--sort=qgroupid,rfer,excl,max_rfer,max_excl] ", + "btrfs qgroup show [options] ", "Show subvolume quota groups.", - "-p print parent qgroup id", - "-c print child qgroup id", - "-r print max referenced size of qgroup", - "-e print max exclusive size of qgroup", - "-F list all qgroups which impact the given path" - "(include ancestral qgroups)", - "-f list all qgroups which impact the given path" - "(exclude ancestral qgroups)", + "-p print parent qgroup id", + "-c print child qgroup id", + "-r print limit of referenced size of qgroup", + "-e print limit of exclusive size of qgroup", + "-F list all qgroups which impact the given path", + " (including ancestral qgroups)", + "-f list all qgroups which impact the given path", + " (excluding ancestral qgroups)", + HELPINFO_UNITS_LONG, "--sort=qgroupid,rfer,excl,max_rfer,max_excl", - " list qgroups in order of qgroupid," - "rfer,max_rfer or max_excl", - " you can use '+' or '-' in front of each item.", - " (+:ascending, -:descending, ascending default)", + " list qgroups sorted by specified items", + " you can use '+' or '-' in front of each item.", + " (+:ascending, -:descending, ascending default)", + "--sync force sync of the filesystem before getting info", NULL }; @@ -226,25 +296,33 @@ static int cmd_qgroup_show(int argc, char **argv) char *path; int ret = 0; int fd; - int e; DIR *dirstream = NULL; - int c; u64 qgroupid; int filter_flag = 0; + unsigned unit_mode; + int sync = 0; + enum btrfs_util_error err; struct btrfs_qgroup_comparer_set *comparer_set; struct btrfs_qgroup_filter_set *filter_set; filter_set = btrfs_qgroup_alloc_filter_set(); comparer_set = btrfs_qgroup_alloc_comparer_set(); - struct option long_options[] = { - {"sort", 1, NULL, 'S'}, - {0, 0, 0, 0} - }; - optind = 1; + unit_mode = get_unit_mode_from_arg(&argc, argv, 0); + while (1) { - c = getopt_long(argc, argv, "pcreFf", - long_options, NULL); + int c; + enum { + GETOPT_VAL_SORT = 256, + GETOPT_VAL_SYNC + }; + static const struct option long_options[] = { + {"sort", required_argument, NULL, GETOPT_VAL_SORT}, + {"sync", no_argument, NULL, GETOPT_VAL_SYNC}, + { NULL, 0, NULL, 0 } + }; + + c = getopt_long(argc, argv, "pcreFf", long_options, NULL); if (c < 0) break; switch (c) { @@ -270,28 +348,47 @@ static int cmd_qgroup_show(int argc, char **argv) case 'f': filter_flag |= 0x2; break; - case 'S': + case GETOPT_VAL_SORT: ret = btrfs_qgroup_parse_sort_string(optarg, &comparer_set); if (ret) usage(cmd_qgroup_show_usage); break; + case GETOPT_VAL_SYNC: + sync = 1; + break; default: usage(cmd_qgroup_show_usage); } } + btrfs_qgroup_setup_units(unit_mode); + if (check_argc_exact(argc - optind, 1)) usage(cmd_qgroup_show_usage); path = argv[optind]; - fd = open_file_or_dir(path, &dirstream); + fd = btrfs_open_dir(path, &dirstream, 1); if (fd < 0) { - fprintf(stderr, "ERROR: can't access '%s'\n", path); + free(filter_set); + free(comparer_set); return 1; } + if (sync) { + err = btrfs_util_sync_fd(fd); + if (err) + warning("sync ioctl failed on '%s': %s", path, + strerror(errno)); + } + if (filter_flag) { - qgroupid = btrfs_get_path_rootid(fd); + ret = lookup_path_rootid(fd, &qgroupid); + if (ret < 0) { + error("cannot resolve rootid for %s: %s", + path, strerror(-ret)); + close_file_or_dir(fd, dirstream); + goto out; + } if (filter_flag & 0x1) btrfs_qgroup_setup_filter(&filter_set, BTRFS_QGROUP_FILTER_ALL_PARENT, @@ -302,18 +399,17 @@ static int cmd_qgroup_show(int argc, char **argv) qgroupid); } ret = btrfs_show_qgroups(fd, filter_set, comparer_set); - e = errno; close_file_or_dir(fd, dirstream); - if (ret < 0) - fprintf(stderr, "ERROR: can't list qgroups: %s\n", - strerror(e)); + free(filter_set); + free(comparer_set); +out: return !!ret; } static const char * const cmd_qgroup_limit_usage[] = { "btrfs qgroup limit [options] |none [] ", - "Limit the size of a subvolume quota group.", + "Set the limits a subvolume quota group.", "", "-c limit amount of data after compression. This is the default,", " it is currently not possible to turn off this option.", @@ -325,15 +421,14 @@ static int cmd_qgroup_limit(int argc, char **argv) { int ret = 0; int fd; - int e; char *path = NULL; struct btrfs_ioctl_qgroup_limit_args args; unsigned long long size; int compressed = 0; int exclusive = 0; DIR *dirstream = NULL; + enum btrfs_util_error err; - optind = 1; while (1) { int c = getopt(argc, argv, "ce"); if (c < 0) @@ -354,35 +449,28 @@ static int cmd_qgroup_limit(int argc, char **argv) usage(cmd_qgroup_limit_usage); if (!parse_limit(argv[optind], &size)) { - fprintf(stderr, "Invalid size argument given\n"); + error("invalid size argument: %s", argv[optind]); return 1; } memset(&args, 0, sizeof(args)); - if (size) { - if (compressed) - args.lim.flags |= BTRFS_QGROUP_LIMIT_RFER_CMPR | - BTRFS_QGROUP_LIMIT_EXCL_CMPR; - if (exclusive) { - args.lim.flags |= BTRFS_QGROUP_LIMIT_MAX_EXCL; - args.lim.max_exclusive = size; - } else { - args.lim.flags |= BTRFS_QGROUP_LIMIT_MAX_RFER; - args.lim.max_referenced = size; - } + if (compressed) + args.lim.flags |= BTRFS_QGROUP_LIMIT_RFER_CMPR | + BTRFS_QGROUP_LIMIT_EXCL_CMPR; + if (exclusive) { + args.lim.flags |= BTRFS_QGROUP_LIMIT_MAX_EXCL; + args.lim.max_exclusive = size; + } else { + args.lim.flags |= BTRFS_QGROUP_LIMIT_MAX_RFER; + args.lim.max_referenced = size; } if (argc - optind == 2) { args.qgroupid = 0; path = argv[optind + 1]; - ret = test_issubvolume(path); - if (ret < 0) { - fprintf(stderr, "ERROR: error accessing '%s'\n", path); - return 1; - } - if (!ret) { - fprintf(stderr, "ERROR: '%s' is not a subvolume\n", - path); + err = btrfs_util_is_subvolume(path); + if (err) { + error_btrfs_util(err); return 1; } /* @@ -395,25 +483,24 @@ static int cmd_qgroup_limit(int argc, char **argv) } else usage(cmd_qgroup_limit_usage); - fd = open_file_or_dir(path, &dirstream); - if (fd < 0) { - fprintf(stderr, "ERROR: can't access '%s'\n", path); + fd = btrfs_open_dir(path, &dirstream, 1); + if (fd < 0) return 1; - } ret = ioctl(fd, BTRFS_IOC_QGROUP_LIMIT, &args); - e = errno; close_file_or_dir(fd, dirstream); if (ret < 0) { - fprintf(stderr, "ERROR: unable to limit requested quota group: " - "%s\n", strerror(e)); + error("unable to limit requested quota group: %m"); return 1; } return 0; } +static const char qgroup_cmd_group_info[] = +"manage quota groups"; + const struct cmd_group qgroup_cmd_group = { - qgroup_cmd_group_usage, NULL, { + qgroup_cmd_group_usage, qgroup_cmd_group_info, { { "assign", cmd_qgroup_assign, cmd_qgroup_assign_usage, NULL, 0 }, { "remove", cmd_qgroup_remove, cmd_qgroup_remove_usage,