From 7875b82630f6431971175e2f4205bb65c2c43488 Mon Sep 17 00:00:00 2001 From: Kent Overstreet Date: Thu, 8 Feb 2018 15:30:19 -0500 Subject: [PATCH] New data rereplicate command --- bcachefs.c | 17 ++++ cmd_data.c | 48 ++++++++++ cmd_debug.c | 20 ++-- cmd_device.c | 261 ++++++++++++++------------------------------------ cmd_format.c | 4 + cmd_fs.c | 9 +- cmd_fsck.c | 7 +- cmds.h | 2 + libbcachefs.c | 90 ++++++++++++++++- libbcachefs.h | 42 ++++++-- tools-util.c | 8 ++ tools-util.h | 6 +- 12 files changed, 296 insertions(+), 218 deletions(-) create mode 100644 cmd_data.c diff --git a/bcachefs.c b/bcachefs.c index 7b940ace..53806f39 100644 --- a/bcachefs.c +++ b/bcachefs.c @@ -53,6 +53,9 @@ static void usage(void) " device set-state Mark a device as failed\n" " device resize Resize filesystem on a device\n" "\n" + "Commands for managing filesystem data:\n" + " data rereplicate Rereplicate degraded data\n" + "\n" "Encryption:\n" " unlock Unlock an encrypted filesystem prior to running/mounting\n" " set-passphrase Change passphrase on an existing (unmounted) filesystem\n" @@ -120,6 +123,17 @@ static int device_cmds(int argc, char *argv[]) return 0; } +static int data_cmds(int argc, char *argv[]) +{ + char *cmd = pop_cmd(&argc, argv); + + if (!strcmp(cmd, "rereplicate")) + return cmd_data_rereplicate(argc, argv); + + usage(); + return 0; +} + int main(int argc, char *argv[]) { full_cmd = argv[0]; @@ -151,6 +165,9 @@ int main(int argc, char *argv[]) if (!strcmp(cmd, "device")) return device_cmds(argc, argv); + if (!strcmp(cmd, "data")) + return data_cmds(argc, argv); + if (!strcmp(cmd, "unlock")) return cmd_unlock(argc, argv); if (!strcmp(cmd, "set-passphrase")) diff --git a/cmd_data.c b/cmd_data.c new file mode 100644 index 00000000..f495b6c0 --- /dev/null +++ b/cmd_data.c @@ -0,0 +1,48 @@ + + +#include +#include + +#include "libbcachefs/bcachefs_ioctl.h" + +#include "cmds.h" +#include "libbcachefs.h" + +static void data_rereplicate_usage(void) +{ + puts("bcachefs data rereplicate\n" + "Usage: bcachefs data rereplicate filesystem\n" + "\n" + "Walks existing data in a filesystem, writing additional copies\n" + "of any degraded data\n" + "\n" + "Options:\n" + " -h, --help display this help and exit\n" + "Report bugs to "); + exit(EXIT_SUCCESS); +} + +int cmd_data_rereplicate(int argc, char *argv[]) +{ + int opt; + + while ((opt = getopt(argc, argv, "h")) != -1) + switch (opt) { + case 'h': + data_rereplicate_usage(); + } + args_shift(optind); + + char *fs_path = arg_pop(); + if (!fs_path) + die("Please supply a filesystem"); + + if (argc) + die("too many arguments"); + + return bchu_data(bcache_fs_open(fs_path), (struct bch_ioctl_data) { + .op = BCH_DATA_OP_REREPLICATE, + .start = POS_MIN, + .end = POS_MAX, + }); +} diff --git a/cmd_debug.c b/cmd_debug.c index 6e395bab..b622cd39 100644 --- a/cmd_debug.c +++ b/cmd_debug.c @@ -103,16 +103,17 @@ int cmd_dump(int argc, char *argv[]) dump_usage(); exit(EXIT_SUCCESS); } - - if (optind >= argc) - die("Please supply device(s) to check"); + args_shift(optind); if (!out) die("Please supply output filename"); - struct bch_fs *c = bch2_fs_open(argv + optind, argc - optind, opts); + if (!argc) + die("Please supply device(s) to check"); + + struct bch_fs *c = bch2_fs_open(argv, argc, opts); if (IS_ERR(c)) - die("error opening %s: %s", argv[optind], strerror(-PTR_ERR(c))); + die("error opening %s: %s", argv[0], strerror(-PTR_ERR(c))); down_read(&c->gc_lock); @@ -299,13 +300,14 @@ int cmd_list(int argc, char *argv[]) list_keys_usage(); exit(EXIT_SUCCESS); } + args_shift(optind); - if (optind >= argc) - die("Please supply device(s) to check"); + if (!argc) + die("Please supply device(s)"); - struct bch_fs *c = bch2_fs_open(argv + optind, argc - optind, opts); + struct bch_fs *c = bch2_fs_open(argv, argc, opts); if (IS_ERR(c)) - die("error opening %s: %s", argv[optind], strerror(-PTR_ERR(c))); + die("error opening %s: %s", argv[0], strerror(-PTR_ERR(c))); switch (mode) { case 0: diff --git a/cmd_device.c b/cmd_device.c index 390c48ad..5628faec 100644 --- a/cmd_device.c +++ b/cmd_device.c @@ -19,165 +19,6 @@ #include "libbcachefs/opts.h" #include "tools-util.h" -/* This code belongs under show_fs */ -#if 0 - -struct bcache_dev { - unsigned nr; - const char *name; - - unsigned has_metadata; - unsigned has_data; - const char *state; - unsigned tier; - - u64 bucket_size; - u64 first_bucket; - u64 nbuckets; - - /* XXX: dirty != used, it doesn't count metadata */ - u64 bytes_dirty; -}; - -static struct bcache_dev fill_dev(const char *dev_name, unsigned nr, int dir) -{ - return (struct bcache_dev) { - .nr = nr, - .name = dev_name, - - .has_metadata = read_file_u64(dir, "has_metadata"), - .has_data = read_file_u64(dir, "has_data"), - .state = read_file_str(dir, "state"), - .tier = read_file_u64(dir, "tier"), - - .bucket_size = read_file_u64(dir, "bucket_size_bytes"), - .first_bucket = read_file_u64(dir, "first_bucket"), - .nbuckets = read_file_u64(dir, "nbuckets"), - .bytes_dirty = read_file_u64(dir, "dirty_bytes"), - }; -} - -static void show_dev(struct bcache_dev *dev) -{ - u64 capacity = (dev->nbuckets - dev->first_bucket) * - dev->bucket_size; - /* - * XXX: show fragmentation information, cached/dirty information - */ - - printf("Device %u (/dev/%s):\n" - " Has metadata:\t%u\n" - " Has dirty data:\t%u\n" - " State:\t\t%s\n" - " Tier:\t\t%u\n" - " Size:\t\t%llu\n" - " Used:\t\t%llu\n" - " Free:\t\t%llu\n" - " Use%%:\t\t%llu\n", - dev->nr, dev->name, - dev->has_metadata, - dev->has_data, - dev->state, - dev->tier, - capacity, - dev->bytes_dirty, - capacity - dev->bytes_dirty, - (dev->bytes_dirty * 100) / capacity); -} - -int cmd_device_show(int argc, char *argv[]) -{ - int human_readable = 0; - NihOption opts[] = { - // { int shortoption, char *longoption, char *help, NihOptionGroup, char *argname, void *value, NihOptionSetter} - - { 'h', "human-readable", N_("print sizes in powers of 1024 (e.g., 1023M)"), - NULL, NULL, &human_readable, NULL}, - NIH_OPTION_LAST - }; - char **args = bch_nih_init(argc, argv, opts); - - if (argc != 2) - die("Please supply a single device"); - - struct bchfs_handle fs = bcache_fs_open(argv[1]); - struct dirent *entry; - - struct bcache_dev devices[256]; - unsigned i, j, nr_devices = 0, nr_active_tiers = 0; - - unsigned tiers[BCH_TIER_MAX]; /* number of devices in each tier */ - memset(tiers, 0, sizeof(tiers)); - - while ((entry = readdir(fs.sysfs))) { - unsigned nr; - int pos = 0; - - sscanf(entry->d_name, "cache%u%n", &nr, &pos); - if (pos != strlen(entry->d_name)) - continue; - - char link[PATH_MAX]; - if (readlinkat(dirfd(fs.sysfs), entry->d_name, - link, sizeof(link)) < 0) - die("readlink error: %m\n"); - - char *dev_name = basename(dirname(link)); - - int fd = xopenat(dirfd(fs.sysfs), entry->d_name, O_RDONLY); - - devices[nr_devices] = fill_dev(strdup(dev_name), nr, fd); - tiers[devices[nr_devices].tier]++; - nr_devices++; - - close(fd); - } - - for (i = 0; i < BCH_TIER_MAX; i++) - if (tiers[i]) - nr_active_tiers++; - - /* Print out devices sorted by tier: */ - bool first = true; - - for (i = 0; i < BCH_TIER_MAX; i++) { - if (!tiers[i]) - continue; - - if (nr_active_tiers > 1) { - if (!first) - printf("\n"); - first = false; - printf("Tier %u:\n\n", i); - } - - for (j = 0; j < nr_devices; j++) { - if (devices[j].tier != i) - continue; - - if (!first) - printf("\n"); - first = false; - show_dev(&devices[j]); - } - } - - return 0; -} -#endif - -static void disk_ioctl(const char *fs, const char *dev, int cmd, int flags) -{ - struct bch_ioctl_disk i = { .flags = flags, }; - - if (!kstrtoull(dev, 10, &i.dev)) - i.flags |= BCH_BY_INDEX; - else - i.dev = (u64) dev; - - xioctl(bcache_fs_open(fs).ioctl_fd, cmd, &i); -} - static void device_add_usage(void) { puts("bcachefs device add - add a device to an existing filesystem\n" @@ -239,12 +80,20 @@ int cmd_device_add(int argc, char *argv[]) } args_shift(optind); - if (argc != 2) - die("Please supply a filesystem and a device to add"); + char *fs_path = arg_pop(); + if (!fs_path) + die("Please supply a filesystem"); - struct bchfs_handle fs = bcache_fs_open(arg_pop()); + char *dev_path = arg_pop(); + if (!dev_path) + die("Please supply a device"); - dev_opts.path = arg_pop(); + if (argc) + die("too many arguments"); + + struct bchfs_handle fs = bcache_fs_open(fs_path); + + dev_opts.path = dev_path; dev_opts.fd = open_for_format(dev_opts.path, force); format_opts.block_size = @@ -264,7 +113,7 @@ int cmd_device_add(int argc, char *argv[]) static void device_remove_usage(void) { puts("bcachefs device_remove - remove a device from a filesystem\n" - "Usage: bcachefs device remove filesystem device\n" + "Usage: bcachefs device remove device\n" "\n" "Options:\n" " -f, --force Force removal, even if some data\n" @@ -299,10 +148,6 @@ int cmd_device_remove(int argc, char *argv[]) } args_shift(optind); - char *fs = arg_pop(); - if (!fs) - die("Please supply a filesystem"); - char *dev = arg_pop(); if (!dev) die("Please supply a device to remove"); @@ -310,14 +155,16 @@ int cmd_device_remove(int argc, char *argv[]) if (argc) die("too many arguments"); - disk_ioctl(fs, dev, BCH_IOCTL_DISK_REMOVE, flags); + unsigned dev_idx; + struct bchfs_handle fs = bchu_fs_open_by_dev(dev, &dev_idx); + bchu_disk_remove(fs, dev_idx, flags); return 0; } static void device_online_usage(void) { puts("bcachefs device online - readd a device to a running filesystem\n" - "Usage: bcachefs device online [OPTION]... filesystem device\n" + "Usage: bcachefs device online [OPTION]... device\n" "\n" "Options:\n" " -h, --help Display this help and exit\n" @@ -335,18 +182,25 @@ int cmd_device_online(int argc, char *argv[]) device_online_usage(); exit(EXIT_SUCCESS); } + args_shift(optind); - if (argc - optind != 2) - die("Please supply a filesystem and a device"); + char *dev = arg_pop(); + if (!dev) + die("Please supply a device"); - disk_ioctl(argv[optind], argv[optind + 1], BCH_IOCTL_DISK_ONLINE, 0); + if (argc) + die("too many arguments"); + + unsigned dev_idx; + struct bchfs_handle fs = bchu_fs_open_by_dev(dev, &dev_idx); + bchu_disk_online(fs, dev); return 0; } static void device_offline_usage(void) { puts("bcachefs device offline - take a device offline, without removing it\n" - "Usage: bcachefs device offline [OPTION]... filesystem device\n" + "Usage: bcachefs device offline [OPTION]... device\n" "\n" "Options:\n" " -f, --force Force, if data redundancy will be degraded\n" @@ -373,19 +227,25 @@ int cmd_device_offline(int argc, char *argv[]) device_offline_usage(); exit(EXIT_SUCCESS); } + args_shift(optind); - if (argc - optind != 2) - die("Please supply a filesystem and a device"); + char *dev = arg_pop(); + if (!dev) + die("Please supply a device"); - disk_ioctl(argv[optind], argv[optind + 1], - BCH_IOCTL_DISK_OFFLINE, flags); + if (argc) + die("too many arguments"); + + unsigned dev_idx; + struct bchfs_handle fs = bchu_fs_open_by_dev(dev, &dev_idx); + bchu_disk_offline(fs, dev_idx, flags); return 0; } static void device_evacuate_usage(void) { puts("bcachefs device evacuate - move data off of a given device\n" - "Usage: bcachefs device evacuate [OPTION]... filesystem device\n" + "Usage: bcachefs device evacuate [OPTION]... device\n" "\n" "Options:\n" " -h, --help Display this help and exit\n" @@ -403,18 +263,30 @@ int cmd_device_evacuate(int argc, char *argv[]) device_evacuate_usage(); exit(EXIT_SUCCESS); } + args_shift(optind); - if (argc - optind != 2) - die("Please supply a filesystem and a device"); + char *dev_path = arg_pop(); + if (!dev_path) + die("Please supply a device"); - disk_ioctl(argv[optind], argv[optind + 1], BCH_IOCTL_DISK_EVACUATE, 0); - return 0; + if (argc) + die("too many arguments"); + + unsigned dev_idx; + struct bchfs_handle fs = bchu_fs_open_by_dev(dev_path, &dev_idx); + + return bchu_data(fs, (struct bch_ioctl_data) { + .op = BCH_DATA_OP_MIGRATE, + .start = POS_MIN, + .end = POS_MAX, + .migrate.dev = dev_idx, + }); } static void device_set_state_usage(void) { puts("bcachefs device set-state\n" - "Usage: bcachefs device set-state filesystem device new-state\n" + "Usage: bcachefs device set-state device new-state\n" "\n" "Options:\n" " -f, --force Force, if data redundancy will be degraded\n" @@ -440,16 +312,23 @@ int cmd_device_set_state(int argc, char *argv[]) case 'h': device_set_state_usage(); } + args_shift(optind); - if (argc - optind != 3) - die("Please supply a filesystem, device and state"); + char *dev_path = arg_pop(); + if (!dev_path) + die("Please supply a device"); - struct bchfs_handle fs = bcache_fs_open(argv[optind]); + char *new_state_str = arg_pop(); + if (!new_state_str) + die("Please supply a device state"); - bchu_disk_set_state(fs, argv[optind + 1], - read_string_list_or_die(argv[optind + 2], - bch2_dev_state, "device state"), - flags); + unsigned new_state = read_string_list_or_die(new_state_str, + bch2_dev_state, "device state"); + + unsigned dev_idx; + struct bchfs_handle fs = bchu_fs_open_by_dev(dev_path, &dev_idx); + + bchu_disk_set_state(fs, dev_idx, new_state, flags); return 0; } diff --git a/cmd_format.c b/cmd_format.c index 42e8d1a6..85b7e655 100644 --- a/cmd_format.c +++ b/cmd_format.c @@ -329,6 +329,10 @@ int cmd_show_super(int argc, char *argv[]) die("too many arguments"); struct bch_opts opts = bch2_opts_empty(); + + opt_set(opts, noexcl, true); + opt_set(opts, nochanges, true); + struct bch_sb_handle sb; int ret = bch2_read_super(dev, &opts, &sb); if (ret) diff --git a/cmd_fs.c b/cmd_fs.c index 964d1b04..967ac7a7 100644 --- a/cmd_fs.c +++ b/cmd_fs.c @@ -80,7 +80,7 @@ static void print_fs_usage(const char *path, enum units units) int cmd_fs_usage(int argc, char *argv[]) { enum units units = BYTES; - unsigned i; + char *fs; int opt; while ((opt = getopt(argc, argv, "h")) != -1) @@ -89,12 +89,13 @@ int cmd_fs_usage(int argc, char *argv[]) units = HUMAN_READABLE; break; } + args_shift(optind); - if (argc - optind < 1) { + if (!argc) { print_fs_usage(".", units); } else { - for (i = optind; i < argc; i++) - print_fs_usage(argv[i], units); + while ((fs = arg_pop())) + print_fs_usage(fs, units); } return 0; diff --git a/cmd_fsck.c b/cmd_fsck.c index 6f873b1f..4e19080a 100644 --- a/cmd_fsck.c +++ b/cmd_fsck.c @@ -50,13 +50,14 @@ int cmd_fsck(int argc, char *argv[]) usage(); exit(EXIT_SUCCESS); } + args_shift(optind); - if (optind >= argc) + if (!argc) die("Please supply device(s) to check"); - struct bch_fs *c = bch2_fs_open(argv + optind, argc - optind, opts); + struct bch_fs *c = bch2_fs_open(argv, argc, opts); if (IS_ERR(c)) - die("error opening %s: %s", argv[optind], strerror(-PTR_ERR(c))); + die("error opening %s: %s", argv[0], strerror(-PTR_ERR(c))); bch2_fs_stop(c); return 0; diff --git a/cmds.h b/cmds.h index e28a5045..6d21db6f 100644 --- a/cmds.h +++ b/cmds.h @@ -27,6 +27,8 @@ int cmd_device_evacuate(int argc, char *argv[]); int cmd_device_set_state(int argc, char *argv[]); int cmd_device_resize(int argc, char *argv[]); +int cmd_data_rereplicate(int argc, char *argv[]); + int cmd_unlock(int argc, char *argv[]); int cmd_set_passphrase(int argc, char *argv[]); int cmd_remove_passphrase(int argc, char *argv[]); diff --git a/libbcachefs.c b/libbcachefs.c index 238cca99..bdf2924f 100644 --- a/libbcachefs.c +++ b/libbcachefs.c @@ -7,6 +7,7 @@ #include #include #include +#include #include #include #include @@ -17,6 +18,7 @@ #include "libbcachefs/checksum.h" #include "crypto.h" #include "libbcachefs.h" +#include "libbcachefs/btree_cache.h" #include "libbcachefs/opts.h" #include "libbcachefs/super-io.h" @@ -640,7 +642,7 @@ struct bchfs_handle bcache_fs_open(const char *path) if (!uuid_parse(path, ret.uuid.b)) { /* It's a UUID, look it up in sysfs: */ - char *sysfs = mprintf("%s%s", SYSFS_BASE, path); + char *sysfs = mprintf(SYSFS_BASE "%s", path); ret.sysfs_fd = xopen(sysfs, O_RDONLY); char *minor = read_file_str(ret.sysfs_fd, "minor"); @@ -662,10 +664,94 @@ struct bchfs_handle bcache_fs_open(const char *path) char uuid_str[40]; uuid_unparse(uuid.uuid.b, uuid_str); - char *sysfs = mprintf("%s%s", SYSFS_BASE, uuid_str); + char *sysfs = mprintf(SYSFS_BASE "%s", uuid_str); ret.sysfs_fd = xopen(sysfs, O_RDONLY); free(sysfs); } return ret; } + +/* + * Given a path to a block device, open the filesystem it belongs to; also + * return the device's idx: + */ +struct bchfs_handle bchu_fs_open_by_dev(const char *path, unsigned *idx) +{ + char buf[1024], *uuid_str; + + struct stat stat = xstat(path); + + if (!S_ISBLK(stat.st_mode)) + die("%s is not a block device", path); + + char *sysfs = mprintf("/sys/dev/block/%u:%u/bcachefs", + major(stat.st_dev), + minor(stat.st_dev)); + ssize_t len = readlink(sysfs, buf, sizeof(buf)); + free(sysfs); + + if (len > 0) { + char *p = strrchr(buf, '/'); + if (!p || sscanf(p + 1, "dev-%u", idx) != 1) + die("error parsing sysfs"); + + *p = '\0'; + p = strrchr(buf, '/'); + uuid_str = p + 1; + } else { + struct bch_opts opts = bch2_opts_empty(); + + opt_set(opts, noexcl, true); + opt_set(opts, nochanges, true); + + struct bch_sb_handle sb; + int ret = bch2_read_super(path, &opts, &sb); + if (ret) + die("Error opening %s: %s", path, strerror(-ret)); + + *idx = sb.sb->dev_idx; + uuid_str = buf; + uuid_unparse(sb.sb->user_uuid.b, uuid_str); + + bch2_free_super(&sb); + } + + return bcache_fs_open(uuid_str); +} + +int bchu_data(struct bchfs_handle fs, struct bch_ioctl_data cmd) +{ + int progress_fd = xioctl(fs.ioctl_fd, BCH_IOCTL_DATA, &cmd); + + while (1) { + struct bch_ioctl_data_progress p; + + if (read(progress_fd, &p, sizeof(p)) != sizeof(p)) + die("error reading from progress fd"); + + if (p.data_type == U8_MAX) + break; + + printf("\33[2K\r"); + + printf("%llu%% complete: current position %s", + p.sectors_done * 100 / p.sectors_total, + bch2_data_types[p.data_type]); + + switch (p.data_type) { + case BCH_DATA_BTREE: + case BCH_DATA_USER: + printf(" %s:%llu:%llu", + bch2_btree_ids[p.btree_id], + p.pos.inode, + p.pos.offset); + } + + sleep(1); + } + printf("\nDone\n"); + + close(progress_fd); + return 0; +} diff --git a/libbcachefs.h b/libbcachefs.h index dc509833..c7c31dd2 100644 --- a/libbcachefs.h +++ b/libbcachefs.h @@ -89,6 +89,7 @@ struct bchfs_handle { void bcache_fs_close(struct bchfs_handle); struct bchfs_handle bcache_fs_open(const char *); +struct bchfs_handle bchu_fs_open_by_dev(const char *, unsigned *); static inline void bchu_disk_add(struct bchfs_handle fs, char *dev) { @@ -97,19 +98,44 @@ static inline void bchu_disk_add(struct bchfs_handle fs, char *dev) xioctl(fs.ioctl_fd, BCH_IOCTL_DISK_ADD, &i); } -static inline void bchu_disk_set_state(struct bchfs_handle fs, const char *dev, +static inline void bchu_disk_remove(struct bchfs_handle fs, unsigned dev_idx, + unsigned flags) +{ + struct bch_ioctl_disk i = { + .flags = flags|BCH_BY_INDEX, + .dev = dev_idx, + }; + + xioctl(fs.ioctl_fd, BCH_IOCTL_DISK_REMOVE, &i); +} + +static inline void bchu_disk_online(struct bchfs_handle fs, char *dev) +{ + struct bch_ioctl_disk i = { .dev = (__u64) dev, }; + + xioctl(fs.ioctl_fd, BCH_IOCTL_DISK_ONLINE, &i); +} + +static inline void bchu_disk_offline(struct bchfs_handle fs, unsigned dev_idx, + unsigned flags) +{ + struct bch_ioctl_disk i = { + .flags = flags|BCH_BY_INDEX, + .dev = dev_idx, + }; + + xioctl(fs.ioctl_fd, BCH_IOCTL_DISK_OFFLINE, &i); +} + +static inline void bchu_disk_set_state(struct bchfs_handle fs, unsigned dev, unsigned new_state, unsigned flags) { struct bch_ioctl_disk_set_state i = { - .flags = flags, + .flags = flags|BCH_BY_INDEX, .new_state = new_state, + .dev = dev, }; - if (!kstrtoull(dev, 10, &i.dev)) - i.flags |= BCH_BY_INDEX; - else - i.dev = (u64) dev; - xioctl(fs.ioctl_fd, BCH_IOCTL_DISK_SET_STATE, &i); } @@ -176,4 +202,6 @@ static inline void bchu_disk_resize(struct bchfs_handle fs, xioctl(fs.ioctl_fd, BCH_IOCTL_DISK_RESIZE, &i); } +int bchu_data(struct bchfs_handle, struct bch_ioctl_data); + #endif /* _LIBBCACHE_H */ diff --git a/tools-util.c b/tools-util.c index b06f36d3..f2ff97d2 100644 --- a/tools-util.c +++ b/tools-util.c @@ -118,6 +118,14 @@ struct stat xfstat(int fd) return stat; } +struct stat xstat(const char *path) +{ + struct stat statbuf; + if (stat(path, &statbuf)) + die("stat error: %m"); + return statbuf; +} + /* Formatting: */ int printf_pad(unsigned pad, const char * fmt, ...) diff --git a/tools-util.h b/tools-util.h index dca9be29..e5edf98c 100644 --- a/tools-util.h +++ b/tools-util.h @@ -28,6 +28,7 @@ void xpread(int, void *, size_t, off_t); void xpwrite(int, const void *, size_t, off_t); struct stat xfstatat(int, const char *, int); struct stat xfstat(int); +struct stat xstat(const char *); #define xopenat(_dirfd, _path, ...) \ ({ \ @@ -155,8 +156,9 @@ char *dev_to_mount(char *); #define args_shift(_nr) \ do { \ - argc -= (_nr); \ - argv += (_nr); \ + unsigned _n = min((_nr), argc); \ + argc -= _n; \ + argv += _n; \ } while (0) #define arg_pop() \