Use cmd_ + group + command schema.
Signed-off-by: David Sterba <dsterba@suse.com>
NULL
};
-static const char * const cmd_add_dev_usage[] = {
+static const char * const cmd_device_add_usage[] = {
"btrfs device add [options] <device> [<device>...] <path>",
"Add a device to a filesystem",
"-K|--nodiscard do not perform whole device TRIM",
NULL
};
-static int cmd_add_dev(int argc, char **argv)
+static int cmd_device_add(int argc, char **argv)
{
char *mntpnt;
int i, fdmnt, ret=0, e;
force = 1;
break;
default:
- usage(cmd_add_dev_usage);
+ usage(cmd_device_add_usage);
}
}
argc = argc - optind;
if (check_argc_min(argc, 2))
- usage(cmd_add_dev_usage);
+ usage(cmd_device_add_usage);
mntpnt = argv[optind + argc - 1];
return !!ret;
}
-static int _cmd_rm_dev(int argc, char **argv, const char * const *usagestr)
+static int _cmd_device_remove(int argc, char **argv,
+ const char * const *usagestr)
{
char *mntpnt;
int i, fdmnt, ret=0, e;
return !!ret;
}
-static const char * const cmd_rm_dev_usage[] = {
+static const char * const cmd_device_remove_usage[] = {
"btrfs device remove <device> [<device>...] <path>",
"Remove a device from a filesystem",
NULL
};
-static int cmd_rm_dev(int argc, char **argv)
+static int cmd_device_remove(int argc, char **argv)
{
- return _cmd_rm_dev(argc, argv, cmd_rm_dev_usage);
+ return _cmd_device_remove(argc, argv, cmd_device_remove_usage);
}
-static const char * const cmd_del_dev_usage[] = {
+static const char * const cmd_device_delete_usage[] = {
"btrfs device delete <device> [<device>...] <path>",
"Remove a device from a filesystem",
NULL
};
-static int cmd_del_dev(int argc, char **argv)
+static int cmd_device_delete(int argc, char **argv)
{
- return _cmd_rm_dev(argc, argv, cmd_del_dev_usage);
+ return _cmd_device_remove(argc, argv, cmd_device_delete_usage);
}
-static const char * const cmd_scan_dev_usage[] = {
+static const char * const cmd_device_scan_usage[] = {
"btrfs device scan [(-d|--all-devices)|<device> [<device>...]]",
"Scan devices for a btrfs filesystem",
" -d|--all-devices (deprecated)",
NULL
};
-static int cmd_scan_dev(int argc, char **argv)
+static int cmd_device_scan(int argc, char **argv)
{
int i;
int devstart = 1;
all = 1;
break;
default:
- usage(cmd_scan_dev_usage);
+ usage(cmd_device_scan_usage);
}
}
if (all && check_argc_max(argc, 2))
- usage(cmd_scan_dev_usage);
+ usage(cmd_device_scan_usage);
if (all || argc == 1) {
printf("Scanning for Btrfs filesystems\n");
return !!ret;
}
-static const char * const cmd_ready_dev_usage[] = {
+static const char * const cmd_device_ready_usage[] = {
"btrfs device ready <device>",
"Check device to see if it has all of its devices in cache for mounting",
NULL
};
-static int cmd_ready_dev(int argc, char **argv)
+static int cmd_device_ready(int argc, char **argv)
{
struct btrfs_ioctl_vol_args args;
int fd;
char *path;
if (check_argc_min(argc, 2))
- usage(cmd_ready_dev_usage);
+ usage(cmd_device_ready_usage);
fd = open("/dev/btrfs-control", O_RDWR);
if (fd < 0) {
return ret;
}
-static const char * const cmd_dev_stats_usage[] = {
+static const char * const cmd_device_stats_usage[] = {
"btrfs device stats [-z] <path>|<device>",
"Show current device IO stats. -z to reset stats afterwards.",
NULL
};
-static int cmd_dev_stats(int argc, char **argv)
+static int cmd_device_stats(int argc, char **argv)
{
char *dev_path;
struct btrfs_ioctl_fs_info_args fi_args;
break;
case '?':
default:
- usage(cmd_dev_stats_usage);
+ usage(cmd_device_stats_usage);
}
}
argc = argc - optind;
if (check_argc_exact(argc, 1))
- usage(cmd_dev_stats_usage);
+ usage(cmd_device_stats_usage);
dev_path = argv[optind];
const struct cmd_group device_cmd_group = {
device_cmd_group_usage, device_cmd_group_info, {
- { "add", cmd_add_dev, cmd_add_dev_usage, NULL, 0 },
- { "delete", cmd_del_dev, cmd_del_dev_usage, NULL, CMD_ALIAS },
- { "remove", cmd_rm_dev, cmd_rm_dev_usage, NULL, 0 },
- { "scan", cmd_scan_dev, cmd_scan_dev_usage, NULL, 0 },
- { "ready", cmd_ready_dev, cmd_ready_dev_usage, NULL, 0 },
- { "stats", cmd_dev_stats, cmd_dev_stats_usage, NULL, 0 },
+ { "add", cmd_device_add, cmd_device_add_usage, NULL, 0 },
+ { "delete", cmd_device_delete, cmd_device_delete_usage, NULL,
+ CMD_ALIAS },
+ { "remove", cmd_device_remove, cmd_device_remove_usage, NULL, 0 },
+ { "scan", cmd_device_scan, cmd_device_scan_usage, NULL, 0 },
+ { "ready", cmd_device_ready, cmd_device_ready_usage, NULL, 0 },
+ { "stats", cmd_device_stats, cmd_device_stats_usage, NULL, 0 },
{ "usage", cmd_device_usage,
cmd_device_usage_usage, NULL, 0 },
NULL_CMD_STRUCT
goto out;
}
-static const char * const cmd_show_usage[] = {
+static const char * const cmd_filesystem_show_usage[] = {
"btrfs filesystem show [options] [<path>|<uuid>|<device>|label]",
"Show the structure of a filesystem",
"-d|--all-devices show only disks under /dev containing btrfs filesystem",
NULL
};
-static int cmd_show(int argc, char **argv)
+static int cmd_filesystem_show(int argc, char **argv)
{
LIST_HEAD(all_uuids);
struct btrfs_fs_devices *fs_devices;
units_set_mode(&unit_mode, UNITS_HUMAN_BINARY);
break;
default:
- usage(cmd_show_usage);
+ usage(cmd_filesystem_show_usage);
}
}
if (check_argc_max(argc, optind + 1))
- usage(cmd_show_usage);
+ usage(cmd_filesystem_show_usage);
if (argc > optind) {
search = argv[optind];
if (strlen(search) == 0)
- usage(cmd_show_usage);
+ usage(cmd_filesystem_show_usage);
type = check_arg_type(search);
/*
return ret;
}
-static const char * const cmd_sync_usage[] = {
+static const char * const cmd_filesystem_sync_usage[] = {
"btrfs filesystem sync <path>",
"Force a sync on a filesystem",
NULL
};
-static int cmd_sync(int argc, char **argv)
+static int cmd_filesystem_sync(int argc, char **argv)
{
int fd, res, e;
char *path;
DIR *dirstream = NULL;
if (check_argc_exact(argc, 2))
- usage(cmd_sync_usage);
+ usage(cmd_filesystem_sync_usage);
path = argv[1];
};
}
-static const char * const cmd_defrag_usage[] = {
+static const char * const cmd_filesystem_defrag_usage[] = {
"btrfs filesystem defragment [options] <file>|<dir> [<file>|<dir>...]",
"Defragment a file or a directory",
"",
return 0;
}
-static int cmd_defrag(int argc, char **argv)
+static int cmd_filesystem_defrag(int argc, char **argv)
{
int fd;
int flush = 0;
recursive = 1;
break;
default:
- usage(cmd_defrag_usage);
+ usage(cmd_filesystem_defrag_usage);
}
}
if (check_argc_min(argc - optind, 1))
- usage(cmd_defrag_usage);
+ usage(cmd_filesystem_defrag_usage);
memset(&defrag_global_range, 0, sizeof(range));
defrag_global_range.start = start;
return !!defrag_global_errors;
}
-static const char * const cmd_resize_usage[] = {
+static const char * const cmd_filesystem_resize_usage[] = {
"btrfs filesystem resize [devid:][+/-]<newsize>[kKmMgGtTpPeE]|[devid:]max <path>",
"Resize a filesystem",
"If 'max' is passed, the filesystem will occupy all available space",
NULL
};
-static int cmd_resize(int argc, char **argv)
+static int cmd_filesystem_resize(int argc, char **argv)
{
struct btrfs_ioctl_vol_args args;
int fd, res, len, e;
struct stat st;
if (check_argc_exact(argc, 3))
- usage(cmd_resize_usage);
+ usage(cmd_filesystem_resize_usage);
amount = argv[1];
path = argv[2];
return 0;
}
-static const char * const cmd_label_usage[] = {
+static const char * const cmd_filesystem_label_usage[] = {
"btrfs filesystem label [<device>|<mount_point>] [<newlabel>]",
"Get or change the label of a filesystem",
"With one argument, get the label of filesystem on <device>.",
NULL
};
-static int cmd_label(int argc, char **argv)
+static int cmd_filesystem_label(int argc, char **argv)
{
if (check_argc_min(argc, 2) || check_argc_max(argc, 3))
- usage(cmd_label_usage);
+ usage(cmd_filesystem_label_usage);
if (argc > 2) {
return set_label(argv[1], argv[2]);
const struct cmd_group filesystem_cmd_group = {
filesystem_cmd_group_usage, filesystem_cmd_group_info, {
{ "df", cmd_filesystem_df, cmd_filesystem_df_usage, NULL, 0 },
- { "show", cmd_show, cmd_show_usage, NULL, 0 },
- { "sync", cmd_sync, cmd_sync_usage, NULL, 0 },
- { "defragment", cmd_defrag, cmd_defrag_usage, NULL, 0 },
- { "balance", cmd_balance, NULL, &balance_cmd_group, CMD_HIDDEN },
- { "resize", cmd_resize, cmd_resize_usage, NULL, 0 },
- { "label", cmd_label, cmd_label_usage, NULL, 0 },
+ { "show", cmd_filesystem_show, cmd_filesystem_show_usage, NULL,
+ 0 },
+ { "sync", cmd_filesystem_sync, cmd_filesystem_sync_usage, NULL,
+ 0 },
+ { "defragment", cmd_filesystem_defrag,
+ cmd_filesystem_defrag_usage, NULL, 0 },
+ { "balance", cmd_balance, NULL, &balance_cmd_group,
+ CMD_HIDDEN },
+ { "resize", cmd_filesystem_resize, cmd_filesystem_resize_usage,
+ NULL, 0 },
+ { "label", cmd_filesystem_label, cmd_filesystem_label_usage,
+ NULL, 0 },
{ "usage", cmd_filesystem_usage,
cmd_filesystem_usage_usage, NULL, 0 },
return !!ret;
}
-static const char * const cmd_inode_resolve_usage[] = {
+static const char * const cmd_inspect_inode_resolve_usage[] = {
"btrfs inspect-internal inode-resolve [-v] <inode> <path>",
"Get file system paths for the given inode",
"",
NULL
};
-static int cmd_inode_resolve(int argc, char **argv)
+static int cmd_inspect_inode_resolve(int argc, char **argv)
{
int fd;
int verbose = 0;
verbose = 1;
break;
default:
- usage(cmd_inode_resolve_usage);
+ usage(cmd_inspect_inode_resolve_usage);
}
}
if (check_argc_exact(argc - optind, 2))
- usage(cmd_inode_resolve_usage);
+ usage(cmd_inspect_inode_resolve_usage);
fd = open_file_or_dir(argv[optind+1], &dirstream);
if (fd < 0) {
}
-static const char * const cmd_logical_resolve_usage[] = {
+static const char * const cmd_inspect_logical_resolve_usage[] = {
"btrfs inspect-internal logical-resolve [-Pv] [-s bufsize] <logical> <path>",
"Get file system paths for the given logical address",
"-P skip the path resolving and print the inodes instead",
NULL
};
-static int cmd_logical_resolve(int argc, char **argv)
+static int cmd_inspect_logical_resolve(int argc, char **argv)
{
int ret;
int fd;
size = arg_strtou64(optarg);
break;
default:
- usage(cmd_logical_resolve_usage);
+ usage(cmd_inspect_logical_resolve_usage);
}
}
if (check_argc_exact(argc - optind, 2))
- usage(cmd_logical_resolve_usage);
+ usage(cmd_inspect_logical_resolve_usage);
size = min(size, (u64)64 * 1024);
inodes = malloc(size);
return !!ret;
}
-static const char * const cmd_subvolid_resolve_usage[] = {
+static const char * const cmd_inspect_subvolid_resolve_usage[] = {
"btrfs inspect-internal subvolid-resolve <subvolid> <path>",
"Get file system paths for the given subvolume ID.",
NULL
};
-static int cmd_subvolid_resolve(int argc, char **argv)
+static int cmd_inspect_subvolid_resolve(int argc, char **argv)
{
int ret;
int fd = -1;
DIR *dirstream = NULL;
if (check_argc_exact(argc, 3))
- usage(cmd_subvolid_resolve_usage);
+ usage(cmd_inspect_subvolid_resolve_usage);
fd = open_file_or_dir(argv[2], &dirstream);
if (fd < 0) {
return ret ? 1 : 0;
}
-static const char* const cmd_rootid_usage[] = {
+static const char* const cmd_inspect_rootid_usage[] = {
"btrfs inspect-internal rootid <path>",
"Get tree ID of the containing subvolume of path.",
NULL
};
-static int cmd_rootid(int argc, char **argv)
+static int cmd_inspect_rootid(int argc, char **argv)
{
int ret;
int fd = -1;
DIR *dirstream = NULL;
if (check_argc_exact(argc, 2))
- usage(cmd_rootid_usage);
+ usage(cmd_inspect_rootid_usage);
fd = open_file_or_dir(argv[1], &dirstream);
if (fd < 0) {
const struct cmd_group inspect_cmd_group = {
inspect_cmd_group_usage, inspect_cmd_group_info, {
- { "inode-resolve", cmd_inode_resolve, cmd_inode_resolve_usage,
- NULL, 0 },
- { "logical-resolve", cmd_logical_resolve,
- cmd_logical_resolve_usage, NULL, 0 },
- { "subvolid-resolve", cmd_subvolid_resolve,
- cmd_subvolid_resolve_usage, NULL, 0 },
- { "rootid", cmd_rootid, cmd_rootid_usage, NULL, 0 },
+ { "inode-resolve", cmd_inspect_inode_resolve,
+ cmd_inspect_inode_resolve_usage, NULL, 0 },
+ { "logical-resolve", cmd_inspect_logical_resolve,
+ cmd_inspect_logical_resolve_usage, NULL, 0 },
+ { "subvolid-resolve", cmd_inspect_subvolid_resolve,
+ cmd_inspect_subvolid_resolve_usage, NULL, 0 },
+ { "rootid", cmd_inspect_rootid, cmd_inspect_rootid_usage, NULL,
+ 0 },
{ "min-dev-size", cmd_inspect_min_dev_size,
cmd_inspect_min_dev_size_usage, NULL, 0 },
NULL_CMD_STRUCT
NULL
};
-static const char * const cmd_get_usage[] = {
+static const char * const cmd_property_get_usage[] = {
"btrfs property get [-t <type>] <object> [<name>]",
"Gets a property from a btrfs object.",
"If no name is specified, all properties for the given object are",
NULL
};
-static const char * const cmd_set_usage[] = {
+static const char * const cmd_property_set_usage[] = {
"btrfs property set [-t <type>] <object> <name> <value>",
"Sets a property on a btrfs object.",
"Please see the help of 'btrfs property get' for a description of",
NULL
};
-static const char * const cmd_list_usage[] = {
+static const char * const cmd_property_list_usage[] = {
"btrfs property list [-t <type>] <object>",
"Lists available properties with their descriptions for the given object.",
"Please see the help of 'btrfs property get' for a description of",
}
}
-static int cmd_get(int argc, char **argv)
+static int cmd_property_get(int argc, char **argv)
{
int ret;
char *object = NULL;
int types = 0;
if (check_argc_min(argc, 2) || check_argc_max(argc, 5))
- usage(cmd_get_usage);
+ usage(cmd_property_get_usage);
- parse_args(argc, argv, cmd_get_usage, &types, &object, &name, NULL);
+ parse_args(argc, argv, cmd_property_get_usage, &types, &object, &name,
+ NULL);
if (!object) {
fprintf(stderr, "ERROR: invalid arguments.\n");
- usage(cmd_set_usage);
+ usage(cmd_property_set_usage);
}
if (name)
return ret;
}
-static int cmd_set(int argc, char **argv)
+static int cmd_property_set(int argc, char **argv)
{
int ret;
char *object = NULL;
int types = 0;
if (check_argc_min(argc, 4) || check_argc_max(argc, 6))
- usage(cmd_set_usage);
+ usage(cmd_property_set_usage);
- parse_args(argc, argv, cmd_set_usage, &types, &object, &name, &value);
+ parse_args(argc, argv, cmd_property_set_usage, &types,
+ &object, &name, &value);
if (!object || !name || !value) {
fprintf(stderr, "ERROR: invalid arguments.\n");
- usage(cmd_set_usage);
+ usage(cmd_property_set_usage);
}
ret = setget_prop(types, object, name, value);
return ret;
}
-static int cmd_list(int argc, char **argv)
+static int cmd_property_list(int argc, char **argv)
{
int ret;
char *object = NULL;
int types = 0;
if (check_argc_min(argc, 2) || check_argc_max(argc, 4))
- usage(cmd_list_usage);
+ usage(cmd_property_list_usage);
- parse_args(argc, argv, cmd_list_usage, &types, &object, NULL, NULL);
+ parse_args(argc, argv, cmd_property_list_usage,
+ &types, &object, NULL, NULL);
if (!object) {
fprintf(stderr, "ERROR: invalid arguments.\n");
- usage(cmd_set_usage);
+ usage(cmd_property_set_usage);
}
ret = dump_props(types, object, 1);
const struct cmd_group property_cmd_group = {
property_cmd_group_usage, property_cmd_group_info, {
- { "get", cmd_get, cmd_get_usage, NULL, 0 },
- { "set", cmd_set, cmd_set_usage, NULL, 0 },
- { "list", cmd_list, cmd_list_usage, NULL, 0 },
+ { "get", cmd_property_get,
+ cmd_property_get_usage, NULL, 0 },
+ { "set", cmd_property_set,
+ cmd_property_set_usage, NULL, 0 },
+ { "list", cmd_property_list,
+ cmd_property_list_usage, NULL, 0 },
{ 0, 0, 0, 0, 0 },
}
};
return sigaction(SIGINT, &sa, NULL);
}
-static const char *const cmd_start_replace_usage[] = {
+static const char *const cmd_replace_start_usage[] = {
"btrfs replace start [-Bfr] <srcdev>|<devid> <targetdev> <mount_point>",
"Replace device of a btrfs filesystem.",
"On a live filesystem, duplicate the data to the target device which",
NULL
};
-static int cmd_start_replace(int argc, char **argv)
+static int cmd_replace_start(int argc, char **argv)
{
struct btrfs_ioctl_dev_replace_args start_args = {0};
struct btrfs_ioctl_dev_replace_args status_args = {0};
break;
case '?':
default:
- usage(cmd_start_replace_usage);
+ usage(cmd_replace_start_usage);
}
}
BTRFS_IOCTL_DEV_REPLACE_CONT_READING_FROM_SRCDEV_MODE_AVOID :
BTRFS_IOCTL_DEV_REPLACE_CONT_READING_FROM_SRCDEV_MODE_ALWAYS;
if (check_argc_exact(argc - optind, 3))
- usage(cmd_start_replace_usage);
+ usage(cmd_replace_start_usage);
path = argv[optind + 2];
fdmnt = open_path_or_dev_mnt(path, &dirstream);
return 1;
}
-static const char *const cmd_status_replace_usage[] = {
+static const char *const cmd_replace_status_usage[] = {
"btrfs replace status [-1] <mount_point>",
"Print status and progress information of a running device replace",
"operation",
NULL
};
-static int cmd_status_replace(int argc, char **argv)
+static int cmd_replace_status(int argc, char **argv)
{
int fd;
int e;
break;
case '?':
default:
- usage(cmd_status_replace_usage);
+ usage(cmd_replace_status_usage);
}
}
if (check_argc_exact(argc - optind, 1))
- usage(cmd_status_replace_usage);
+ usage(cmd_replace_status_usage);
path = argv[optind];
fd = open_file_or_dir(path, &dirstream);
return buf;
}
-static const char *const cmd_cancel_replace_usage[] = {
+static const char *const cmd_replace_cancel_usage[] = {
"btrfs replace cancel <mount_point>",
"Cancel a running device replace operation.",
NULL
};
-static int cmd_cancel_replace(int argc, char **argv)
+static int cmd_replace_cancel(int argc, char **argv)
{
struct btrfs_ioctl_dev_replace_args args = {0};
int ret;
switch (c) {
case '?':
default:
- usage(cmd_cancel_replace_usage);
+ usage(cmd_replace_cancel_usage);
}
}
if (check_argc_exact(argc - optind, 1))
- usage(cmd_cancel_replace_usage);
+ usage(cmd_replace_cancel_usage);
path = argv[optind];
fd = open_file_or_dir(path, &dirstream);
const struct cmd_group replace_cmd_group = {
replace_cmd_group_usage, replace_cmd_group_info, {
- { "start", cmd_start_replace, cmd_start_replace_usage, NULL,
+ { "start", cmd_replace_start, cmd_replace_start_usage, NULL,
0 },
- { "status", cmd_status_replace, cmd_status_replace_usage, NULL,
+ { "status", cmd_replace_status, cmd_replace_status_usage, NULL,
0 },
- { "cancel", cmd_cancel_replace, cmd_cancel_replace_usage, NULL,
+ { "cancel", cmd_replace_cancel, cmd_replace_cancel_usage, NULL,
0 },
NULL_CMD_STRUCT
}
int btrfs_recover_chunk_tree(char *path, int verbose, int yes);
int btrfs_recover_superblocks(char *path, int verbose, int yes);
-const char * const cmd_chunk_recover_usage[] = {
+const char * const cmd_rescue_chunk_recover_usage[] = {
"btrfs rescue chunk-recover [options] <device>",
"Recover the chunk tree by scanning the devices one by one.",
"",
NULL
};
-const char * const cmd_super_recover_usage[] = {
+const char * const cmd_rescue_super_recover_usage[] = {
"btrfs rescue super-recover [options] <device>",
"Recover bad superblocks from good copies",
"",
NULL
};
-int cmd_chunk_recover(int argc, char *argv[])
+int cmd_rescue_chunk_recover(int argc, char *argv[])
{
int ret = 0;
char *file;
break;
case 'h':
default:
- usage(cmd_chunk_recover_usage);
+ usage(cmd_rescue_chunk_recover_usage);
}
}
argc = argc - optind;
if (check_argc_exact(argc, 1))
- usage(cmd_chunk_recover_usage);
+ usage(cmd_rescue_chunk_recover_usage);
file = argv[optind];
* 3 : Fail to Recover bad supeblocks
* 4 : Abort to recover bad superblocks
*/
-int cmd_super_recover(int argc, char **argv)
+int cmd_rescue_super_recover(int argc, char **argv)
{
int ret;
int verbose = 0;
yes = 1;
break;
default:
- usage(cmd_super_recover_usage);
+ usage(cmd_rescue_super_recover_usage);
}
}
argc = argc - optind;
if (check_argc_exact(argc, 1))
- usage(cmd_super_recover_usage);
+ usage(cmd_rescue_super_recover_usage);
dname = argv[optind];
ret = check_mounted(dname);
const struct cmd_group rescue_cmd_group = {
rescue_cmd_group_usage, rescue_cmd_group_info, {
- { "chunk-recover", cmd_chunk_recover, cmd_chunk_recover_usage, NULL, 0},
- { "super-recover", cmd_super_recover, cmd_super_recover_usage, NULL, 0},
+ { "chunk-recover", cmd_rescue_chunk_recover,
+ cmd_rescue_chunk_recover_usage, NULL, 0},
+ { "super-recover", cmd_rescue_super_recover,
+ cmd_rescue_super_recover_usage, NULL, 0},
{ "zero-log", cmd_rescue_zero_log, cmd_rescue_zero_log_usage, NULL, 0},
NULL_CMD_STRUCT
}
return !!ret;
}
-static const char * const cmd_snapshot_usage[] = {
+static const char * const cmd_subvol_snapshot_usage[] = {
"btrfs subvolume snapshot [-r] [-i <qgroupid>] <source> <dest>|[<dest>/]<name>",
"Create a snapshot of the subvolume",
"Create a writable/readonly snapshot of the subvolume <source> with",
NULL
};
-static int cmd_snapshot(int argc, char **argv)
+static int cmd_subvol_snapshot(int argc, char **argv)
{
char *subvol, *dst;
int res, retval;
}
break;
default:
- usage(cmd_snapshot_usage);
+ usage(cmd_subvol_snapshot_usage);
}
}
if (check_argc_exact(argc - optind, 2))
- usage(cmd_snapshot_usage);
+ usage(cmd_subvol_snapshot_usage);
subvol = argv[optind];
dst = argv[optind + 1];
return 0;
}
-static const char * const cmd_find_new_usage[] = {
+static const char * const cmd_subvol_find_new_usage[] = {
"btrfs subvolume find-new <path> <lastgen>",
"List the recently modified files in a filesystem",
NULL
};
-static int cmd_find_new(int argc, char **argv)
+static int cmd_subvol_find_new(int argc, char **argv)
{
int fd;
int ret;
DIR *dirstream = NULL;
if (check_argc_exact(argc, 3))
- usage(cmd_find_new_usage);
+ usage(cmd_subvol_find_new_usage);
subvol = argv[1];
last_gen = arg_strtou64(argv[2]);
{ "create", cmd_subvol_create, cmd_subvol_create_usage, NULL, 0 },
{ "delete", cmd_subvol_delete, cmd_subvol_delete_usage, NULL, 0 },
{ "list", cmd_subvol_list, cmd_subvol_list_usage, NULL, 0 },
- { "snapshot", cmd_snapshot, cmd_snapshot_usage, NULL, 0 },
+ { "snapshot", cmd_subvol_snapshot, cmd_subvol_snapshot_usage,
+ NULL, 0 },
{ "get-default", cmd_subvol_get_default,
cmd_subvol_get_default_usage, NULL, 0 },
{ "set-default", cmd_subvol_set_default,
cmd_subvol_set_default_usage, NULL, 0 },
- { "find-new", cmd_find_new, cmd_find_new_usage, NULL, 0 },
+ { "find-new", cmd_subvol_find_new, cmd_subvol_find_new_usage,
+ NULL, 0 },
{ "show", cmd_subvol_show, cmd_subvol_show_usage, NULL, 0 },
{ "sync", cmd_subvol_sync, cmd_subvol_sync_usage, NULL, 0 },
NULL_CMD_STRUCT
projects / platform / upstream / btrfs-progs.git / commitdiff