X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=cmds-filesystem.c;h=30a50bf55e38f7a6a9cda8864bb6eb28209b9096;hb=HEAD;hp=b93bb33028f2e360abd53a657eb9f579f6937dda;hpb=7ab0bdd7125c098670a6c2bb9d6bb95c1aaa78ed;p=platform%2Fupstream%2Fbtrfs-progs.git diff --git a/cmds-filesystem.c b/cmds-filesystem.c index b93bb33..30a50bf 100644 --- a/cmds-filesystem.c +++ b/cmds-filesystem.c @@ -28,118 +28,40 @@ #include #include +#include + #include "kerncompat.h" #include "ctree.h" -#include "ioctl.h" #include "utils.h" #include "volumes.h" #include "commands.h" #include "cmds-fi-usage.h" #include "list_sort.h" #include "disk-io.h" - +#include "help.h" /* * for btrfs fi show, we maintain a hash of fsids we've already printed. * This way we don't print dups if a given FS is mounted more than once. */ -#define SEEN_FSID_HASH_SIZE 256 - -struct seen_fsid { - u8 fsid[BTRFS_FSID_SIZE]; - struct seen_fsid *next; -}; - static struct seen_fsid *seen_fsid_hash[SEEN_FSID_HASH_SIZE] = {NULL,}; -static int is_seen_fsid(u8 *fsid) -{ - u8 hash = fsid[0]; - int slot = hash % SEEN_FSID_HASH_SIZE; - struct seen_fsid *seen = seen_fsid_hash[slot]; - - return seen ? 1 : 0; -} - -static int add_seen_fsid(u8 *fsid) -{ - u8 hash = fsid[0]; - int slot = hash % SEEN_FSID_HASH_SIZE; - struct seen_fsid *seen = seen_fsid_hash[slot]; - struct seen_fsid *alloc; - - if (!seen) - goto insert; - - while (1) { - if (memcmp(seen->fsid, fsid, BTRFS_FSID_SIZE) == 0) - return -EEXIST; - - if (!seen->next) - break; - - seen = seen->next; - } - -insert: - - alloc = malloc(sizeof(*alloc)); - if (!alloc) - return -ENOMEM; - - alloc->next = NULL; - memcpy(alloc->fsid, fsid, BTRFS_FSID_SIZE); - - if (seen) - seen->next = alloc; - else - seen_fsid_hash[slot] = alloc; - - return 0; -} - -static void free_seen_fsid(void) -{ - int slot; - struct seen_fsid *seen; - struct seen_fsid *next; - - for (slot = 0; slot < SEEN_FSID_HASH_SIZE; slot++) { - seen = seen_fsid_hash[slot]; - while (seen) { - next = seen->next; - free(seen); - seen = next; - } - seen_fsid_hash[slot] = NULL; - } -} - static const char * const filesystem_cmd_group_usage[] = { "btrfs filesystem [] []", NULL }; static const char * const cmd_filesystem_df_usage[] = { - "btrfs filesystem df [options] ", - "Show space usage information for a mount point", - "-b|--raw raw numbers in bytes", - "-h|--human-readable", - " human friendly numbers, base 1024 (default)", - "-H human friendly numbers, base 1000", - "--iec use 1024 as a base (KiB, MiB, GiB, TiB)", - "--si use 1000 as a base (kB, MB, GB, TB)", - "-k|--kbytes show sizes in KiB, or kB with --si", - "-m|--mbytes show sizes in MiB, or MB with --si", - "-g|--gbytes show sizes in GiB, or GB with --si", - "-t|--tbytes show sizes in TiB, or TB with --si", - NULL + "btrfs filesystem df [options] ", + "Show space usage information for a mount point", + HELPINFO_UNITS_SHORT_LONG, + NULL }; static int get_df(int fd, struct btrfs_ioctl_space_args **sargs_ret) { u64 count = 0; - int ret, e; + int ret; struct btrfs_ioctl_space_args *sargs; sargs = malloc(sizeof(struct btrfs_ioctl_space_args)); @@ -150,12 +72,10 @@ static int get_df(int fd, struct btrfs_ioctl_space_args **sargs_ret) sargs->total_spaces = 0; ret = ioctl(fd, BTRFS_IOC_SPACE_INFO, sargs); - e = errno; - if (ret) { - fprintf(stderr, "ERROR: couldn't get space info - %s\n", - strerror(e)); + if (ret < 0) { + error("cannot get space info: %m"); free(sargs); - return -e; + return -errno; } /* This really should never happen */ if (!sargs->total_spaces) { @@ -173,12 +93,11 @@ static int get_df(int fd, struct btrfs_ioctl_space_args **sargs_ret) sargs->space_slots = count; sargs->total_spaces = 0; ret = ioctl(fd, BTRFS_IOC_SPACE_INFO, sargs); - e = errno; - if (ret) { - fprintf(stderr, "ERROR: get space info count %llu - %s\n", - count, strerror(e)); + if (ret < 0) { + error("cannot get space info with %llu slots: %m", + count); free(sargs); - return -e; + return -errno; } *sargs_ret = sargs; return 0; @@ -205,84 +124,35 @@ static int cmd_filesystem_df(int argc, char **argv) int fd; char *path; DIR *dirstream = NULL; - unsigned unit_mode = UNITS_DEFAULT; + unsigned unit_mode; - while (1) { - int c; - static const struct option long_options[] = { - { "raw", no_argument, NULL, 'b'}, - { "kbytes", no_argument, NULL, 'k'}, - { "mbytes", no_argument, NULL, 'm'}, - { "gbytes", no_argument, NULL, 'g'}, - { "tbytes", no_argument, NULL, 't'}, - { "si", no_argument, NULL, GETOPT_VAL_SI}, - { "iec", no_argument, NULL, GETOPT_VAL_IEC}, - { "human-readable", no_argument, NULL, - GETOPT_VAL_HUMAN_READABLE}, - { NULL, 0, NULL, 0 } - }; + unit_mode = get_unit_mode_from_arg(&argc, argv, 1); - c = getopt_long(argc, argv, "bhHkmgt", long_options, NULL); - if (c < 0) - break; - switch (c) { - case 'b': - unit_mode = UNITS_RAW; - break; - case 'k': - units_set_base(&unit_mode, UNITS_KBYTES); - break; - case 'm': - units_set_base(&unit_mode, UNITS_MBYTES); - break; - case 'g': - units_set_base(&unit_mode, UNITS_GBYTES); - break; - case 't': - units_set_base(&unit_mode, UNITS_TBYTES); - break; - case GETOPT_VAL_HUMAN_READABLE: - case 'h': - unit_mode = UNITS_HUMAN_BINARY; - break; - case 'H': - unit_mode = UNITS_HUMAN_DECIMAL; - break; - case GETOPT_VAL_SI: - units_set_mode(&unit_mode, UNITS_DECIMAL); - break; - case GETOPT_VAL_IEC: - units_set_mode(&unit_mode, UNITS_BINARY); - break; - default: - usage(cmd_filesystem_df_usage); - } - } + clean_args_no_options(argc, argv, cmd_filesystem_df_usage); - if (check_argc_exact(argc, optind + 1)) + if (check_argc_exact(argc - optind, 1)) usage(cmd_filesystem_df_usage); path = argv[optind]; - 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 = get_df(fd, &sargs); if (ret == 0) { print_df(sargs, unit_mode); free(sargs); } else { - fprintf(stderr, "ERROR: get_df failed %s\n", strerror(-ret)); + error("get_df failed %s", strerror(-ret)); } close_file_or_dir(fd, dirstream); return !!ret; } -static int match_search_item_kernel(__u8 *fsid, char *mnt, char *label, +static int match_search_item_kernel(u8 *fsid, char *mnt, char *label, char *search) { char uuidbuf[BTRFS_UUID_UNPARSED_SIZE]; @@ -293,7 +163,7 @@ static int match_search_item_kernel(__u8 *fsid, char *mnt, char *label, if (!strncmp(uuidbuf, search, search_len)) return 1; - if (strlen(label) && strcmp(label, search) == 0) + if (*label && strcmp(label, search) == 0) return 1; if (strcmp(mnt, search) == 0) @@ -302,10 +172,9 @@ static int match_search_item_kernel(__u8 *fsid, char *mnt, char *label, return 0; } -static int uuid_search(struct btrfs_fs_devices *fs_devices, char *search) +static int uuid_search(struct btrfs_fs_devices *fs_devices, const char *search) { char uuidbuf[BTRFS_UUID_UNPARSED_SIZE]; - struct list_head *cur; struct btrfs_device *device; int search_len = strlen(search); @@ -314,8 +183,7 @@ static int uuid_search(struct btrfs_fs_devices *fs_devices, char *search) if (!strncmp(uuidbuf, search, search_len)) return 1; - list_for_each(cur, &fs_devices->devices) { - device = list_entry(cur, struct btrfs_device, dev_list); + list_for_each_entry(device, &fs_devices->devices, dev_list) { if ((device->label && strcmp(device->label, search) == 0) || strcmp(device->name, search) == 0) return 1; @@ -375,7 +243,7 @@ static void splice_device_list(struct list_head *seed_devices, } static void print_devices(struct btrfs_fs_devices *fs_devices, - u64 *devs_found) + u64 *devs_found, unsigned unit_mode) { struct btrfs_device *device; struct btrfs_fs_devices *cur_fs; @@ -393,21 +261,23 @@ static void print_devices(struct btrfs_fs_devices *fs_devices, list_for_each_entry(device, all_devices, dev_list) { printf("\tdevid %4llu size %s used %s path %s\n", (unsigned long long)device->devid, - pretty_size(device->total_bytes), - pretty_size(device->bytes_used), device->name); + pretty_size_mode(device->total_bytes, unit_mode), + pretty_size_mode(device->bytes_used, unit_mode), + device->name); (*devs_found)++; } } -static void print_one_uuid(struct btrfs_fs_devices *fs_devices) +static void print_one_uuid(struct btrfs_fs_devices *fs_devices, + unsigned unit_mode) { char uuidbuf[BTRFS_UUID_UNPARSED_SIZE]; struct btrfs_device *device; u64 devs_found = 0; u64 total; - if (add_seen_fsid(fs_devices->fsid)) + if (add_seen_fsid(fs_devices->fsid, seen_fsid_hash, -1, NULL)) return; uuid_unparse(fs_devices->fsid, uuidbuf); @@ -421,9 +291,9 @@ static void print_one_uuid(struct btrfs_fs_devices *fs_devices) total = device->total_devs; printf(" uuid: %s\n\tTotal devices %llu FS bytes used %s\n", uuidbuf, (unsigned long long)total, - pretty_size(device->super_bytes_used)); + pretty_size_mode(device->super_bytes_used, unit_mode)); - print_devices(fs_devices, &devs_found); + print_devices(fs_devices, &devs_found, unit_mode); if (devs_found < total) { printf("\t*** Some devices missing\n"); @@ -445,7 +315,7 @@ static u64 calc_used_bytes(struct btrfs_ioctl_space_args *si) static int print_one_fs(struct btrfs_ioctl_fs_info_args *fs_info, struct btrfs_ioctl_dev_info_args *dev_info, struct btrfs_ioctl_space_args *space_info, - char *label, char *path) + char *label, unsigned unit_mode) { int i; int fd; @@ -454,21 +324,22 @@ static int print_one_fs(struct btrfs_ioctl_fs_info_args *fs_info, struct btrfs_ioctl_dev_info_args *tmp_dev_info; int ret; - ret = add_seen_fsid(fs_info->fsid); + ret = add_seen_fsid(fs_info->fsid, seen_fsid_hash, -1, NULL); if (ret == -EEXIST) return 0; else if (ret) return ret; uuid_unparse(fs_info->fsid, uuidbuf); - if (label && strlen(label)) + if (label && *label) printf("Label: '%s' ", label); else printf("Label: none "); printf(" uuid: %s\n\tTotal devices %llu FS bytes used %s\n", uuidbuf, fs_info->num_devices, - pretty_size(calc_used_bytes(space_info))); + pretty_size_mode(calc_used_bytes(space_info), + unit_mode)); for (i = 0; i < fs_info->num_devices; i++) { char *canonical_path; @@ -485,8 +356,8 @@ static int print_one_fs(struct btrfs_ioctl_fs_info_args *fs_info, canonical_path = canonicalize_path((char *)tmp_dev_info->path); printf("\tdevid %4llu size %s used %s path %s\n", tmp_dev_info->devid, - pretty_size(tmp_dev_info->total_bytes), - pretty_size(tmp_dev_info->bytes_used), + pretty_size_mode(tmp_dev_info->total_bytes, unit_mode), + pretty_size_mode(tmp_dev_info->bytes_used, unit_mode), canonical_path); free(canonical_path); @@ -498,7 +369,7 @@ static int print_one_fs(struct btrfs_ioctl_fs_info_args *fs_info, return 0; } -static int btrfs_scan_kernel(void *search) +static int btrfs_scan_kernel(void *search, unsigned unit_mode) { int ret = 0, fd; int found = 0; @@ -515,76 +386,51 @@ static int btrfs_scan_kernel(void *search) memset(label, 0, sizeof(label)); while ((mnt = getmntent(f)) != NULL) { + free(dev_info_arg); + dev_info_arg = NULL; if (strcmp(mnt->mnt_type, "btrfs")) continue; ret = get_fs_info(mnt->mnt_dir, &fs_info_arg, &dev_info_arg); - if (ret) { - kfree(dev_info_arg); + if (ret) goto out; - } - if (get_label_mounted(mnt->mnt_dir, label)) { - kfree(dev_info_arg); + /* skip all fs already shown as mounted fs */ + if (is_seen_fsid(fs_info_arg.fsid, seen_fsid_hash)) + continue; + + ret = get_label_mounted(mnt->mnt_dir, label); + /* provide backward kernel compatibility */ + if (ret == -ENOTTY) + ret = get_label_unmounted( + (const char *)dev_info_arg->path, label); + + if (ret) goto out; - } + if (search && !match_search_item_kernel(fs_info_arg.fsid, mnt->mnt_dir, label, search)) { - kfree(dev_info_arg); continue; } fd = open(mnt->mnt_dir, O_RDONLY); if ((fd != -1) && !get_df(fd, &space_info_arg)) { print_one_fs(&fs_info_arg, dev_info_arg, - space_info_arg, label, mnt->mnt_dir); - kfree(space_info_arg); + space_info_arg, label, unit_mode); + free(space_info_arg); memset(label, 0, sizeof(label)); found = 1; } if (fd != -1) close(fd); - kfree(dev_info_arg); } out: + free(dev_info_arg); endmntent(f); return !found; } -static int dev_to_fsid(char *dev, __u8 *fsid) -{ - struct btrfs_super_block *disk_super; - char *buf; - int ret; - int fd; - - buf = malloc(4096); - if (!buf) - return -ENOMEM; - - fd = open(dev, O_RDONLY); - if (fd < 0) { - ret = -errno; - free(buf); - return ret; - } - - disk_super = (struct btrfs_super_block *)buf; - ret = btrfs_read_dev_super(fd, disk_super, - BTRFS_SUPER_INFO_OFFSET, 0); - if (ret) - goto out; - - memcpy(fsid, disk_super->fsid, BTRFS_FSID_SIZE); - ret = 0; - -out: - close(fd); - free(buf); - return ret; -} - static void free_fs_devices(struct btrfs_fs_devices *fs_devices) { struct btrfs_fs_devices *cur_seed, *next_seed; @@ -725,10 +571,10 @@ static int search_umounted_fs_uuids(struct list_head *all_uuids, } /* skip all fs already shown as mounted fs */ - if (is_seen_fsid(cur_fs->fsid)) + if (is_seen_fsid(cur_fs->fsid, seen_fsid_hash)) continue; - fs_copy = malloc(sizeof(*fs_copy)); + fs_copy = calloc(1, sizeof(*fs_copy)); if (!fs_copy) { ret = -ENOMEM; goto out; @@ -772,7 +618,7 @@ static int map_seed_devices(struct list_head *all_uuids) /* * open_ctree_* detects seed/sprout mapping */ - fs_info = open_ctree_fs_info(device->name, 0, 0, + fs_info = open_ctree_fs_info(device->name, 0, 0, 0, OPEN_CTREE_PARTIAL); if (!fs_info) continue; @@ -811,16 +657,17 @@ fail_out: goto out; } -static const char * const cmd_show_usage[] = { +static const char * const cmd_filesystem_show_usage[] = { "btrfs filesystem show [options] [|||label]", "Show the structure of a filesystem", "-d|--all-devices show only disks under /dev containing btrfs filesystem", "-m|--mounted show only mounted btrfs", + HELPINFO_UNITS_LONG, "If no argument is given, structure of all present filesystems is shown.", 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; @@ -829,12 +676,15 @@ static int cmd_show(int argc, char **argv) /* default, search both kernel and udev */ int where = -1; int type = 0; - char mp[BTRFS_PATH_NAME_MAX + 1]; + char mp[PATH_MAX]; char path[PATH_MAX]; - __u8 fsid[BTRFS_FSID_SIZE]; + u8 fsid[BTRFS_FSID_SIZE]; char uuid_buf[BTRFS_UUID_UNPARSED_SIZE]; + unsigned unit_mode; int found = 0; + unit_mode = get_unit_mode_from_arg(&argc, argv, 0); + while (1) { int c; static const struct option long_options[] = { @@ -854,17 +704,17 @@ static int cmd_show(int argc, char **argv) where = BTRFS_SCAN_MOUNTED; 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); + if (*search == 0) + usage(cmd_filesystem_show_usage); type = check_arg_type(search); /* @@ -891,9 +741,7 @@ static int cmd_show(int argc, char **argv) } else { ret = dev_to_fsid(search, fsid); if (ret) { - fprintf(stderr, - "ERROR: No btrfs on %s\n", - search); + error("no btrfs on %s", search); return 1; } uuid_unparse(fsid, uuid_buf); @@ -908,7 +756,7 @@ static int cmd_show(int argc, char **argv) goto devs_only; /* show mounted btrfs */ - ret = btrfs_scan_kernel(search); + ret = btrfs_scan_kernel(search, unit_mode); if (search && !ret) { /* since search is found we are done */ goto out; @@ -919,17 +767,16 @@ static int cmd_show(int argc, char **argv) goto out; devs_only: - ret = btrfs_scan_lblkid(); + ret = btrfs_scan_devices(); if (ret) { - fprintf(stderr, "ERROR: %d while scanning\n", ret); + error("blkid device scan returned %d", ret); return 1; } ret = search_umounted_fs_uuids(&all_uuids, search, &found); if (ret < 0) { - fprintf(stderr, - "ERROR: %d while searching target device\n", ret); + error("searching target device returned error %d", ret); return 1; } @@ -939,58 +786,45 @@ devs_only: */ ret = map_seed_devices(&all_uuids); if (ret) { - fprintf(stderr, - "ERROR: %d while mapping seed devices\n", ret); + error("mapping seed devices returned error %d", ret); return 1; } list_for_each_entry(fs_devices, &all_uuids, list) - print_one_uuid(fs_devices); + print_one_uuid(fs_devices, unit_mode); - if (search && !found) + if (search && !found) { + error("not a valid btrfs filesystem: %s", search); ret = 1; - + } while (!list_empty(&all_uuids)) { fs_devices = list_entry(all_uuids.next, struct btrfs_fs_devices, list); free_fs_devices(fs_devices); } out: - printf("%s\n", PACKAGE_STRING); - free_seen_fsid(); + free_seen_fsid(seen_fsid_hash); return ret; } -static const char * const cmd_sync_usage[] = { +static const char * const cmd_filesystem_sync_usage[] = { "btrfs filesystem sync ", "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; + enum btrfs_util_error err; - if (check_argc_exact(argc, 2)) - usage(cmd_sync_usage); + clean_args_no_options(argc, argv, cmd_filesystem_sync_usage); - path = argv[1]; - - fd = open_file_or_dir(path, &dirstream); - if (fd < 0) { - fprintf(stderr, "ERROR: can't access '%s'\n", path); - return 1; - } + if (check_argc_exact(argc - optind, 1)) + usage(cmd_filesystem_sync_usage); - printf("FSSync '%s'\n", path); - res = ioctl(fd, BTRFS_IOC_SYNC); - e = errno; - close_file_or_dir(fd, dirstream); - if( res < 0 ){ - fprintf(stderr, "ERROR: unable to fs-syncing '%s' - %s\n", - path, strerror(e)); + err = btrfs_util_sync(argv[optind]); + if (err) { + error_btrfs_util(err); return 1; } @@ -1003,40 +837,33 @@ static int parse_compress_type(char *s) return BTRFS_COMPRESS_ZLIB; else if (strcmp(optarg, "lzo") == 0) return BTRFS_COMPRESS_LZO; + else if (strcmp(optarg, "zstd") == 0) + return BTRFS_COMPRESS_ZSTD; else { - fprintf(stderr, "Unknown compress type %s\n", s); + error("unknown compression type %s", s); exit(1); }; } -static const char * const cmd_defrag_usage[] = { +static const char * const cmd_filesystem_defrag_usage[] = { "btrfs filesystem defragment [options] | [|...]", "Defragment a file or a directory", "", - "-v be verbose", - "-r defragment files recursively", - "-c[zlib,lzo] compress the file while defragmenting", - "-f flush data to disk immediately after defragmenting", - "-s start defragment only from byte onward", - "-l len defragment only up to len bytes", - "-t size minimal size of file to be considered for defragmenting", + "-v be verbose", + "-r defragment files recursively", + "-c[zlib,lzo,zstd] compress the file while defragmenting", + "-f flush data to disk immediately after defragmenting", + "-s start defragment only from byte onward", + "-l len defragment only up to len bytes", + "-t size target extent size hint (default: 32M)", + "", + "Warning: most Linux kernels will break up the ref-links of COW data", + "(e.g., files copied with 'cp --reflink', snapshots) which may cause", + "considerable increase of space usage. See btrfs-filesystem(8) for", + "more information.", NULL }; -static int do_defrag(int fd, int fancy_ioctl, - struct btrfs_ioctl_defrag_range_args *range) -{ - int ret; - - if (!fancy_ioctl) - ret = ioctl(fd, BTRFS_IOC_DEFRAG, NULL); - else - ret = ioctl(fd, BTRFS_IOC_DEFRAG_RANGE, range); - - return ret; -} - -static int defrag_global_fancy_ioctl; static struct btrfs_ioctl_defrag_range_args defrag_global_range; static int defrag_global_verbose; static int defrag_global_errors; @@ -1044,57 +871,59 @@ static int defrag_callback(const char *fpath, const struct stat *sb, int typeflag, struct FTW *ftwbuf) { int ret = 0; - int e = 0; int fd = 0; if ((typeflag == FTW_F) && S_ISREG(sb->st_mode)) { if (defrag_global_verbose) printf("%s\n", fpath); fd = open(fpath, O_RDWR); - e = errno; - if (fd < 0) + if (fd < 0) { goto error; - ret = do_defrag(fd, defrag_global_fancy_ioctl, &defrag_global_range); - e = errno; + } + ret = ioctl(fd, BTRFS_IOC_DEFRAG_RANGE, &defrag_global_range); close(fd); - if (ret && e == ENOTTY && defrag_global_fancy_ioctl) { - fprintf(stderr, "ERROR: defrag range ioctl not " - "supported in this kernel, please try " - "without any options.\n"); + if (ret && errno == ENOTTY) { + error( +"defrag range ioctl not supported in this kernel version, 2.6.33 and newer is required"); defrag_global_errors++; return ENOTTY; } - if (ret) + if (ret) { goto error; + } } return 0; error: - fprintf(stderr, "ERROR: defrag failed on %s - %s\n", fpath, strerror(e)); + error("defrag failed on %s: %m", fpath); defrag_global_errors++; return 0; } -static int cmd_defrag(int argc, char **argv) +static int cmd_filesystem_defrag(int argc, char **argv) { int fd; int flush = 0; u64 start = 0; u64 len = (u64)-1; - u32 thresh = 0; + u64 thresh; int i; int recursive = 0; int ret = 0; - struct btrfs_ioctl_defrag_range_args range; - int e = 0; int compress_type = BTRFS_COMPRESS_NONE; DIR *dirstream; + /* + * Kernel has a different default (256K) that is supposed to be safe, + * but it does not defragment very well. The 32M will likely lead to + * better results and is independent of the kernel default. We have to + * use the v2 defrag ioctl. + */ + thresh = SZ_32M; + defrag_global_errors = 0; defrag_global_verbose = 0; defrag_global_errors = 0; - defrag_global_fancy_ioctl = 0; - optind = 1; while(1) { int c = getopt(argc, argv, "vrc::fs:l:t:"); if (c < 0) @@ -1105,42 +934,43 @@ static int cmd_defrag(int argc, char **argv) compress_type = BTRFS_COMPRESS_ZLIB; if (optarg) compress_type = parse_compress_type(optarg); - defrag_global_fancy_ioctl = 1; break; case 'f': flush = 1; - defrag_global_fancy_ioctl = 1; break; case 'v': defrag_global_verbose = 1; break; case 's': start = parse_size(optarg); - defrag_global_fancy_ioctl = 1; break; case 'l': len = parse_size(optarg); - defrag_global_fancy_ioctl = 1; break; case 't': thresh = parse_size(optarg); - defrag_global_fancy_ioctl = 1; + if (thresh > (u32)-1) { + warning( + "target extent size %llu too big, trimmed to %u", + thresh, (u32)-1); + thresh = (u32)-1; + } break; case 'r': 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)); + memset(&defrag_global_range, 0, sizeof(defrag_global_range)); defrag_global_range.start = start; defrag_global_range.len = len; - defrag_global_range.extent_thresh = thresh; + defrag_global_range.extent_thresh = (u32)thresh; if (compress_type) { defrag_global_range.flags |= BTRFS_DEFRAG_RANGE_COMPRESS; defrag_global_range.compress_type = compress_type; @@ -1148,78 +978,98 @@ static int cmd_defrag(int argc, char **argv) if (flush) defrag_global_range.flags |= BTRFS_DEFRAG_RANGE_START_IO; + /* + * Look for directory arguments and warn if the recursive mode is not + * requested, as this is not implemented as recursive defragmentation + * in kernel. The stat errors are silent here as we check them below. + */ + if (!recursive) { + int found = 0; + + for (i = optind; i < argc; i++) { + struct stat st; + + if (stat(argv[i], &st)) + continue; + + if (S_ISDIR(st.st_mode)) { + warning( + "directory specified but recursive mode not requested: %s", + argv[i]); + found = 1; + } + } + if (found) { + warning( +"a directory passed to the defrag ioctl will not process the files\n" +"recursively but will defragment the subvolume tree and the extent tree.\n" +"If this is not intended, please use option -r ."); + } + } + for (i = optind; i < argc; i++) { struct stat st; + int defrag_err = 0; dirstream = NULL; fd = open_file_or_dir(argv[i], &dirstream); if (fd < 0) { - fprintf(stderr, "ERROR: failed to open %s - %s\n", argv[i], - strerror(errno)); - defrag_global_errors++; - close_file_or_dir(fd, dirstream); - continue; + error("cannot open %s: %m", argv[i]); + ret = -errno; + goto next; } - if (fstat(fd, &st)) { - fprintf(stderr, "ERROR: failed to stat %s - %s\n", - argv[i], strerror(errno)); - defrag_global_errors++; - close_file_or_dir(fd, dirstream); - continue; + + ret = fstat(fd, &st); + if (ret) { + error("failed to stat %s: %m", argv[i]); + ret = -errno; + goto next; } if (!(S_ISDIR(st.st_mode) || S_ISREG(st.st_mode))) { - fprintf(stderr, - "ERROR: %s is not a directory or a regular file\n", - argv[i]); - defrag_global_errors++; - close_file_or_dir(fd, dirstream); - continue; + error("%s is not a directory or a regular file", + argv[i]); + ret = -EINVAL; + goto next; } - if (recursive) { - if (S_ISDIR(st.st_mode)) { - ret = nftw(argv[i], defrag_callback, 10, + if (recursive && S_ISDIR(st.st_mode)) { + ret = nftw(argv[i], defrag_callback, 10, FTW_MOUNT | FTW_PHYS); - if (ret == ENOTTY) - exit(1); - /* errors are handled in the callback */ - ret = 0; - } else { - if (defrag_global_verbose) - printf("%s\n", argv[i]); - ret = do_defrag(fd, defrag_global_fancy_ioctl, - &defrag_global_range); - e = errno; - } + if (ret == ENOTTY) + exit(1); + /* errors are handled in the callback */ + ret = 0; } else { if (defrag_global_verbose) printf("%s\n", argv[i]); - ret = do_defrag(fd, defrag_global_fancy_ioctl, + ret = ioctl(fd, BTRFS_IOC_DEFRAG_RANGE, &defrag_global_range); - e = errno; - } - close_file_or_dir(fd, dirstream); - if (ret && e == ENOTTY && defrag_global_fancy_ioctl) { - fprintf(stderr, "ERROR: defrag range ioctl not " - "supported in this kernel, please try " - "without any options.\n"); - defrag_global_errors++; - break; + defrag_err = errno; + if (ret && defrag_err == ENOTTY) { + error( +"defrag range ioctl not supported in this kernel version, 2.6.33 and newer is required"); + defrag_global_errors++; + close_file_or_dir(fd, dirstream); + break; + } + if (ret) { + error("defrag failed on %s: %s", argv[i], + strerror(defrag_err)); + goto next; + } } - if (ret) { - fprintf(stderr, "ERROR: defrag failed on %s - %s\n", - argv[i], strerror(e)); +next: + if (ret) defrag_global_errors++; - } + close_file_or_dir(fd, dirstream); } - if (defrag_global_verbose) - printf("%s\n", PACKAGE_STRING); + if (defrag_global_errors) fprintf(stderr, "total %d failures\n", defrag_global_errors); return !!defrag_global_errors; } -static const char * const cmd_resize_usage[] = { +static const char * const cmd_filesystem_resize_usage[] = { "btrfs filesystem resize [devid:][+/-][kKmMgGtTpPeE]|[devid:]max ", "Resize a filesystem", "If 'max' is passed, the filesystem will occupy all available space", @@ -1228,7 +1078,7 @@ static const char * const cmd_resize_usage[] = { 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; @@ -1236,57 +1086,60 @@ static int cmd_resize(int argc, char **argv) DIR *dirstream = NULL; struct stat st; - if (check_argc_exact(argc, 3)) - usage(cmd_resize_usage); + clean_args_no_options_relaxed(argc, argv); + + if (check_argc_exact(argc - optind, 2)) + usage(cmd_filesystem_resize_usage); - amount = argv[1]; - path = argv[2]; + amount = argv[optind]; + path = argv[optind + 1]; len = strlen(amount); if (len == 0 || len >= BTRFS_VOL_NAME_MAX) { - fprintf(stderr, "ERROR: size value too long ('%s)\n", - amount); + error("resize value too long (%s)", amount); return 1; } res = stat(path, &st); if (res < 0) { - fprintf(stderr, "ERROR: resize: cannot stat %s: %s\n", - path, strerror(errno)); + error("resize: cannot stat %s: %m", path); return 1; } if (!S_ISDIR(st.st_mode)) { - fprintf(stderr, - "ERROR: resize works on mounted filesystems and accepts only\n" + error("resize works on mounted filesystems and accepts only\n" "directories as argument. Passing file containing a btrfs image\n" "would resize the underlying filesystem instead of the image.\n"); 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; - } printf("Resize '%s' of '%s'\n", path, amount); + memset(&args, 0, sizeof(args)); strncpy_null(args.name, amount); res = ioctl(fd, BTRFS_IOC_RESIZE, &args); e = errno; close_file_or_dir(fd, dirstream); if( res < 0 ){ - fprintf(stderr, "ERROR: unable to resize '%s' - %s\n", - path, strerror(e)); + switch (e) { + case EFBIG: + error("unable to resize '%s': no enough free space", + path); + break; + default: + error("unable to resize '%s': %m", path); + break; + } return 1; } else if (res > 0) { const char *err_str = btrfs_err_str(res); if (err_str) { - fprintf(stderr, "ERROR: btrfs error resizing '%s' - %s\n", - path, err_str); + error("resizing of '%s' failed: %s", path, err_str); } else { - fprintf(stderr, - "ERROR: btrfs error resizing '%s' - unknown btrfs_err_code %d\n", + error("resizing of '%s' failed: unknown error %d", path, res); } return 1; @@ -1294,7 +1147,7 @@ static int cmd_resize(int argc, char **argv) return 0; } -static const char * const cmd_label_usage[] = { +static const char * const cmd_filesystem_label_usage[] = { "btrfs filesystem label [|] []", "Get or change the label of a filesystem", "With one argument, get the label of filesystem on .", @@ -1302,18 +1155,21 @@ static const char * const cmd_label_usage[] = { 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); + clean_args_no_options(argc, argv, cmd_filesystem_label_usage); - if (argc > 2) { - return set_label(argv[1], argv[2]); + if (check_argc_min(argc - optind, 1) || + check_argc_max(argc - optind, 2)) + usage(cmd_filesystem_label_usage); + + if (argc - optind > 1) { + return set_label(argv[optind], argv[optind + 1]); } else { char label[BTRFS_LABEL_SIZE]; int ret; - ret = get_label(argv[1], label); + ret = get_label(argv[optind], label); if (!ret) fprintf(stdout, "%s\n", label); @@ -1321,15 +1177,25 @@ static int cmd_label(int argc, char **argv) } } +static const char filesystem_cmd_group_info[] = +"overall filesystem tasks and information"; + const struct cmd_group filesystem_cmd_group = { - filesystem_cmd_group_usage, NULL, { + 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, 1 }, - { "resize", cmd_resize, cmd_resize_usage, NULL, 0 }, - { "label", cmd_label, cmd_label_usage, NULL, 0 }, + { "du", cmd_filesystem_du, cmd_filesystem_du_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 },