X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=tools-util.c;h=5f0b9ba4fd5f7c279763c3f7df9a9da1d0ca0f59;hb=ba4c17c12ba5a66f24b4beee0f5791eee46333b0;hp=f48b015b1d32febe2728446139a94e651455b139;hpb=5c7454176ef1914d723a62c3d424be1913b51a97;p=bcachefs-tools-debian diff --git a/tools-util.c b/tools-util.c index f48b015..5f0b9ba 100644 --- a/tools-util.c +++ b/tools-util.c @@ -10,54 +10,106 @@ #include #include #include +#include #include #include #include #include -#include "ccan/crc/crc.h" - -#include "bcachefs_ioctl.h" +#include "libbcachefs.h" +#include "libbcachefs/bcachefs_ioctl.h" #include "linux/sort.h" #include "tools-util.h" -#include "util.h" - -/* Integer stuff: */ - -struct units_buf __pr_units(u64 v, enum units units) -{ - struct units_buf ret; - - switch (units) { - case BYTES: - snprintf(ret.b, sizeof(ret.b), "%llu", v << 9); - break; - case SECTORS: - snprintf(ret.b, sizeof(ret.b), "%llu", v); - break; - case HUMAN_READABLE: - v <<= 9; - - if (v >= 1024) { - int exp = log(v) / log(1024); - snprintf(ret.b, sizeof(ret.b), "%.1f%c", - v / pow(1024, exp), - "KMGTPE"[exp-1]); - } else { - snprintf(ret.b, sizeof(ret.b), "%llu", v); - } +#include "libbcachefs/util.h" + +void die(const char *fmt, ...) +{ + va_list args; + + va_start(args, fmt); + vfprintf(stderr, fmt, args); + va_end(args); + fputc('\n', stderr); + + _exit(EXIT_FAILURE); +} + +char *mprintf(const char *fmt, ...) +{ + va_list args; + char *str; + int ret; + + va_start(args, fmt); + ret = vasprintf(&str, fmt, args); + va_end(args); - break; + if (ret < 0) + die("insufficient memory"); + + return str; +} + +void xpread(int fd, void *buf, size_t count, off_t offset) +{ + while (count) { + ssize_t r = pread(fd, buf, count, offset); + + if (r < 0) + die("read error: %m"); + if (!r) + die("pread error: unexpected eof"); + count -= r; + offset += r; } +} - return ret; +void xpwrite(int fd, const void *buf, size_t count, off_t offset, const char *msg) +{ + ssize_t r = pwrite(fd, buf, count, offset); + + if (r != count) + die("error writing %s (ret %zi err %m)", msg, r); } -/* Argument parsing stuff: */ +struct stat xfstatat(int dirfd, const char *path, int flags) +{ + struct stat stat; + if (fstatat(dirfd, path, &stat, flags)) + die("stat error: %m"); + return stat; +} + +struct stat xfstat(int fd) +{ + struct stat stat; + if (fstat(fd, &stat)) + die("stat error: %m"); + return stat; +} + +struct stat xstat(const char *path) +{ + struct stat statbuf; + if (stat(path, &statbuf)) + die("stat error statting %s: %m", path); + return statbuf; +} /* File parsing (i.e. sysfs) */ +void write_file_str(int dirfd, const char *path, const char *str) +{ + int fd = xopenat(dirfd, path, O_WRONLY); + ssize_t wrote, len = strlen(str); + + wrote = write(fd, str, len); + if (wrote != len) + die("read error: %m"); + close(fd); +} + char *read_file_str(int dirfd, const char *path) { int fd = xopenat(dirfd, path, O_RDONLY); @@ -72,6 +124,10 @@ char *read_file_str(int dirfd, const char *path) buf[len] = '\0'; if (len && buf[len - 1] == '\n') buf[len - 1] = '\0'; + if (!strlen(buf)) { + free(buf); + buf = NULL; + } close(fd); @@ -82,7 +138,7 @@ u64 read_file_u64(int dirfd, const char *path) { char *buf = read_file_str(dirfd, path); u64 v; - if (kstrtou64(buf, 10, &v)) + if (bch2_strtou64_h(buf, &v)) die("read_file_u64: error parsing %s (got %s)", path, buf); free(buf); return v; @@ -93,7 +149,7 @@ u64 read_file_u64(int dirfd, const char *path) ssize_t read_string_list_or_die(const char *opt, const char * const list[], const char *msg) { - ssize_t v = bch2_read_string_list(opt, list); + ssize_t v = match_string(list, -1, opt); if (v < 0) die("Bad %s %s", msg, opt); @@ -101,7 +157,7 @@ ssize_t read_string_list_or_die(const char *opt, const char * const list[], } /* Returns size of file or block device: */ -u64 get_size(const char *path, int fd) +u64 get_size(int fd) { struct stat statbuf = xfstat(fd); @@ -113,36 +169,40 @@ u64 get_size(const char *path, int fd) return ret; } -/* Returns blocksize in units of 512 byte sectors: */ -unsigned get_blocksize(const char *path, int fd) +/* Returns blocksize, in bytes: */ +unsigned get_blocksize(int fd) { struct stat statbuf = xfstat(fd); if (!S_ISBLK(statbuf.st_mode)) - return statbuf.st_blksize >> 9; + return statbuf.st_blksize; unsigned ret; xioctl(fd, BLKPBSZGET, &ret); - return ret >> 9; + return ret; } /* Open a block device, do magic blkid stuff to probe for existing filesystems: */ -int open_for_format(const char *dev, bool force) +int open_for_format(struct dev_opts *dev, bool force) { blkid_probe pr; const char *fs_type = NULL, *fs_label = NULL; size_t fs_type_len, fs_label_len; - int fd = xopen(dev, O_RDWR|O_EXCL); - - if (force) - return fd; + dev->bdev = blkdev_get_by_path(dev->path, BLK_OPEN_READ|BLK_OPEN_WRITE|BLK_OPEN_EXCL, + dev, NULL); + int ret = PTR_ERR_OR_ZERO(dev->bdev); + if (ret < 0) + die("Error opening device to format %s: %s", dev->path, strerror(-ret)); if (!(pr = blkid_new_probe())) die("blkid error 1"); - if (blkid_probe_set_device(pr, fd, 0, 0)) + if (blkid_probe_set_device(pr, dev->bdev->bd_buffered_fd, 0, 0)) die("blkid error 2"); - if (blkid_probe_enable_partitions(pr, true)) + if (blkid_probe_enable_partitions(pr, true) || + blkid_probe_enable_superblocks(pr, true) || + blkid_probe_set_superblocks_flags(pr, + BLKID_SUBLKS_LABEL|BLKID_SUBLKS_TYPE|BLKID_SUBLKS_MAGIC)) die("blkid error 3"); if (blkid_do_fullprobe(pr) < 0) die("blkid error 4"); @@ -153,61 +213,22 @@ int open_for_format(const char *dev, bool force) if (fs_type) { if (fs_label) printf("%s contains a %s filesystem labelled '%s'\n", - dev, fs_type, fs_label); + dev->path, fs_type, fs_label); else printf("%s contains a %s filesystem\n", - dev, fs_type); - fputs("Proceed anyway?", stdout); - if (!ask_yn()) - exit(EXIT_FAILURE); + dev->path, fs_type); + if (!force) { + fputs("Proceed anyway?", stdout); + if (!ask_yn()) + exit(EXIT_FAILURE); + } + while (blkid_do_probe(pr) == 0) { + if (blkid_do_wipe(pr, 0)) + die("Failed to wipe preexisting metadata."); + } } blkid_free_probe(pr); - return fd; -} - -/* Global control device: */ -int bcachectl_open(void) -{ - return xopen("/dev/bcachefs-ctl", O_RDWR); -} - -/* Filesystem handles (ioctl, sysfs dir): */ - -#define SYSFS_BASE "/sys/fs/bcachefs/" - -struct bcache_handle bcache_fs_open(const char *path) -{ - struct bcache_handle ret; - uuid_t tmp; - - if (!uuid_parse(path, tmp)) { - /* It's a UUID, look it up in sysfs: */ - char *sysfs = mprintf("%s%s", SYSFS_BASE, path); - ret.sysfs_fd = xopen(sysfs, O_RDONLY); - - char *minor = read_file_str(ret.sysfs_fd, "minor"); - char *ctl = mprintf("/dev/bcachefs%s-ctl", minor); - ret.ioctl_fd = xopen(ctl, O_RDWR); - - free(sysfs); - free(minor); - free(ctl); - } else { - /* It's a path: */ - ret.ioctl_fd = xopen(path, O_RDONLY); - - struct bch_ioctl_query_uuid uuid; - xioctl(ret.ioctl_fd, BCH_IOCTL_QUERY_UUID, &uuid); - - char uuid_str[40]; - uuid_unparse(uuid.uuid.b, uuid_str); - - char *sysfs = mprintf("%s%s", SYSFS_BASE, uuid_str); - ret.sysfs_fd = xopen(sysfs, O_RDONLY); - free(sysfs); - } - return ret; } @@ -242,31 +263,27 @@ static int range_cmp(const void *_l, const void *_r) void ranges_sort_merge(ranges *r) { - struct range *t, *i; - ranges tmp = { NULL }; + ranges tmp = { 0 }; - sort(&darray_item(*r, 0), darray_size(*r), - sizeof(darray_item(*r, 0)), range_cmp, NULL); + sort(r->data, r->nr, sizeof(r->data[0]), range_cmp, NULL); /* Merge contiguous ranges: */ - darray_foreach(i, *r) { - t = tmp.size ? &tmp.item[tmp.size - 1] : NULL; + darray_for_each(*r, i) { + struct range *t = tmp.nr ? &tmp.data[tmp.nr - 1] : NULL; if (t && t->end >= i->start) t->end = max(t->end, i->end); else - darray_append(tmp, *i); + darray_push(&tmp, *i); } - darray_free(*r); + darray_exit(r); *r = tmp; } void ranges_roundup(ranges *r, unsigned block_size) { - struct range *i; - - darray_foreach(i, *r) { + darray_for_each(*r, i) { i->start = round_down(i->start, block_size); i->end = round_up(i->end, block_size); } @@ -274,9 +291,7 @@ void ranges_roundup(ranges *r, unsigned block_size) void ranges_rounddown(ranges *r, unsigned block_size) { - struct range *i; - - darray_foreach(i, *r) { + darray_for_each(*r, i) { i->start = round_up(i->start, block_size); i->end = round_down(i->end, block_size); i->end = max(i->end, i->start); @@ -287,26 +302,26 @@ struct fiemap_extent fiemap_iter_next(struct fiemap_iter *iter) { struct fiemap_extent e; - BUG_ON(iter->idx > iter->f.fm_mapped_extents); + BUG_ON(iter->idx > iter->f->fm_mapped_extents); - if (iter->idx == iter->f.fm_mapped_extents) { - xioctl(iter->fd, FS_IOC_FIEMAP, &iter->f); + if (iter->idx == iter->f->fm_mapped_extents) { + xioctl(iter->fd, FS_IOC_FIEMAP, iter->f); - if (!iter->f.fm_mapped_extents) + if (!iter->f->fm_mapped_extents) return (struct fiemap_extent) { .fe_length = 0 }; iter->idx = 0; } - e = iter->f.fm_extents[iter->idx++]; + e = iter->f->fm_extents[iter->idx++]; BUG_ON(!e.fe_length); - iter->f.fm_start = e.fe_logical + e.fe_length; + iter->f->fm_start = e.fe_logical + e.fe_length; return e; } -const char *strcmp_prefix(const char *a, const char *a_prefix) +char *strcmp_prefix(char *a, const char *a_prefix) { while (*a_prefix && *a == *a_prefix) { a++; @@ -315,23 +330,337 @@ const char *strcmp_prefix(const char *a, const char *a_prefix) return *a_prefix ? NULL : a; } -unsigned hatoi_validate(const char *s, const char *msg) +/* crc32c */ + +static u32 crc32c_default(u32 crc, const void *buf, size_t size) { - u64 v; + static const u32 crc32c_tab[] = { + 0x00000000, 0xF26B8303, 0xE13B70F7, 0x1350F3F4, + 0xC79A971F, 0x35F1141C, 0x26A1E7E8, 0xD4CA64EB, + 0x8AD958CF, 0x78B2DBCC, 0x6BE22838, 0x9989AB3B, + 0x4D43CFD0, 0xBF284CD3, 0xAC78BF27, 0x5E133C24, + 0x105EC76F, 0xE235446C, 0xF165B798, 0x030E349B, + 0xD7C45070, 0x25AFD373, 0x36FF2087, 0xC494A384, + 0x9A879FA0, 0x68EC1CA3, 0x7BBCEF57, 0x89D76C54, + 0x5D1D08BF, 0xAF768BBC, 0xBC267848, 0x4E4DFB4B, + 0x20BD8EDE, 0xD2D60DDD, 0xC186FE29, 0x33ED7D2A, + 0xE72719C1, 0x154C9AC2, 0x061C6936, 0xF477EA35, + 0xAA64D611, 0x580F5512, 0x4B5FA6E6, 0xB93425E5, + 0x6DFE410E, 0x9F95C20D, 0x8CC531F9, 0x7EAEB2FA, + 0x30E349B1, 0xC288CAB2, 0xD1D83946, 0x23B3BA45, + 0xF779DEAE, 0x05125DAD, 0x1642AE59, 0xE4292D5A, + 0xBA3A117E, 0x4851927D, 0x5B016189, 0xA96AE28A, + 0x7DA08661, 0x8FCB0562, 0x9C9BF696, 0x6EF07595, + 0x417B1DBC, 0xB3109EBF, 0xA0406D4B, 0x522BEE48, + 0x86E18AA3, 0x748A09A0, 0x67DAFA54, 0x95B17957, + 0xCBA24573, 0x39C9C670, 0x2A993584, 0xD8F2B687, + 0x0C38D26C, 0xFE53516F, 0xED03A29B, 0x1F682198, + 0x5125DAD3, 0xA34E59D0, 0xB01EAA24, 0x42752927, + 0x96BF4DCC, 0x64D4CECF, 0x77843D3B, 0x85EFBE38, + 0xDBFC821C, 0x2997011F, 0x3AC7F2EB, 0xC8AC71E8, + 0x1C661503, 0xEE0D9600, 0xFD5D65F4, 0x0F36E6F7, + 0x61C69362, 0x93AD1061, 0x80FDE395, 0x72966096, + 0xA65C047D, 0x5437877E, 0x4767748A, 0xB50CF789, + 0xEB1FCBAD, 0x197448AE, 0x0A24BB5A, 0xF84F3859, + 0x2C855CB2, 0xDEEEDFB1, 0xCDBE2C45, 0x3FD5AF46, + 0x7198540D, 0x83F3D70E, 0x90A324FA, 0x62C8A7F9, + 0xB602C312, 0x44694011, 0x5739B3E5, 0xA55230E6, + 0xFB410CC2, 0x092A8FC1, 0x1A7A7C35, 0xE811FF36, + 0x3CDB9BDD, 0xCEB018DE, 0xDDE0EB2A, 0x2F8B6829, + 0x82F63B78, 0x709DB87B, 0x63CD4B8F, 0x91A6C88C, + 0x456CAC67, 0xB7072F64, 0xA457DC90, 0x563C5F93, + 0x082F63B7, 0xFA44E0B4, 0xE9141340, 0x1B7F9043, + 0xCFB5F4A8, 0x3DDE77AB, 0x2E8E845F, 0xDCE5075C, + 0x92A8FC17, 0x60C37F14, 0x73938CE0, 0x81F80FE3, + 0x55326B08, 0xA759E80B, 0xB4091BFF, 0x466298FC, + 0x1871A4D8, 0xEA1A27DB, 0xF94AD42F, 0x0B21572C, + 0xDFEB33C7, 0x2D80B0C4, 0x3ED04330, 0xCCBBC033, + 0xA24BB5A6, 0x502036A5, 0x4370C551, 0xB11B4652, + 0x65D122B9, 0x97BAA1BA, 0x84EA524E, 0x7681D14D, + 0x2892ED69, 0xDAF96E6A, 0xC9A99D9E, 0x3BC21E9D, + 0xEF087A76, 0x1D63F975, 0x0E330A81, 0xFC588982, + 0xB21572C9, 0x407EF1CA, 0x532E023E, 0xA145813D, + 0x758FE5D6, 0x87E466D5, 0x94B49521, 0x66DF1622, + 0x38CC2A06, 0xCAA7A905, 0xD9F75AF1, 0x2B9CD9F2, + 0xFF56BD19, 0x0D3D3E1A, 0x1E6DCDEE, 0xEC064EED, + 0xC38D26C4, 0x31E6A5C7, 0x22B65633, 0xD0DDD530, + 0x0417B1DB, 0xF67C32D8, 0xE52CC12C, 0x1747422F, + 0x49547E0B, 0xBB3FFD08, 0xA86F0EFC, 0x5A048DFF, + 0x8ECEE914, 0x7CA56A17, 0x6FF599E3, 0x9D9E1AE0, + 0xD3D3E1AB, 0x21B862A8, 0x32E8915C, 0xC083125F, + 0x144976B4, 0xE622F5B7, 0xF5720643, 0x07198540, + 0x590AB964, 0xAB613A67, 0xB831C993, 0x4A5A4A90, + 0x9E902E7B, 0x6CFBAD78, 0x7FAB5E8C, 0x8DC0DD8F, + 0xE330A81A, 0x115B2B19, 0x020BD8ED, 0xF0605BEE, + 0x24AA3F05, 0xD6C1BC06, 0xC5914FF2, 0x37FACCF1, + 0x69E9F0D5, 0x9B8273D6, 0x88D28022, 0x7AB90321, + 0xAE7367CA, 0x5C18E4C9, 0x4F48173D, 0xBD23943E, + 0xF36E6F75, 0x0105EC76, 0x12551F82, 0xE03E9C81, + 0x34F4F86A, 0xC69F7B69, 0xD5CF889D, 0x27A40B9E, + 0x79B737BA, 0x8BDCB4B9, 0x988C474D, 0x6AE7C44E, + 0xBE2DA0A5, 0x4C4623A6, 0x5F16D052, 0xAD7D5351 + }; + const u8 *p = buf; + + while (size--) + crc = crc32c_tab[(crc ^ *p++) & 0xFFL] ^ (crc >> 8); + + return crc; +} - if (bch2_strtoull_h(s, &v)) - die("bad %s %s", msg, s); +#include - if (v & (v - 1)) - die("%s must be a power of two", msg); +#ifdef __x86_64__ - v /= 512; +#ifdef CONFIG_X86_64 +#define REX_PRE "0x48, " +#else +#define REX_PRE +#endif - if (v > USHRT_MAX) - die("%s too large\n", msg); +static u32 crc32c_sse42(u32 crc, const void *buf, size_t size) +{ + while (size >= sizeof(long)) { + const unsigned long *d = buf; + + __asm__ __volatile__( + ".byte 0xf2, " REX_PRE "0xf, 0x38, 0xf1, 0xf1;" + :"=S"(crc) + :"0"(crc), "c"(*d) + ); + buf += sizeof(long); + size -= sizeof(long); + } - if (!v) - die("%s too small\n", msg); + while (size) { + const u8 *d = buf; - return v; + __asm__ __volatile__( + ".byte 0xf2, 0xf, 0x38, 0xf0, 0xf1" + :"=S"(crc) + :"0"(crc), "c"(*d) + ); + buf += 1; + size -= 1; + } + + return crc; +} + +#endif + +static void *resolve_crc32c(void) +{ +#ifdef __x86_64__ + if (__builtin_cpu_supports("sse4.2")) + return crc32c_sse42; +#endif + return crc32c_default; +} + +/* + * ifunc is buggy and I don't know what breaks it (LTO?) + */ +#ifdef HAVE_WORKING_IFUNC + +static void *ifunc_resolve_crc32c(void) +{ + __builtin_cpu_init(); + + return resolve_crc32c +} + +u32 crc32c(u32, const void *, size_t) + __attribute__((ifunc("ifunc_resolve_crc32c"))); + +#else + +u32 crc32c(u32 crc, const void *buf, size_t size) +{ + static u32 (*real_crc32c)(u32, const void *, size_t); + + if (unlikely(!real_crc32c)) + real_crc32c = resolve_crc32c(); + + return real_crc32c(crc, buf, size); +} + +#endif /* HAVE_WORKING_IFUNC */ + +char *dev_to_name(dev_t dev) +{ + char *line = NULL, *name = NULL; + size_t n = 0; + + FILE *f = fopen("/proc/partitions", "r"); + if (!f) + die("error opening /proc/partitions: %m"); + + while (getline(&line, &n, f) != -1) { + unsigned ma, mi; + u64 sectors; + + name = realloc(name, n + 1); + + if (sscanf(line, " %u %u %llu %s", &ma, &mi, §ors, name) == 4 && + ma == major(dev) && mi == minor(dev)) + goto found; + } + + free(name); + name = NULL; +found: + fclose(f); + free(line); + return name; +} + +char *dev_to_path(dev_t dev) +{ + char *name = dev_to_name(dev); + if (!name) + return NULL; + + char *path = mprintf("/dev/%s", name); + + free(name); + return path; +} + +struct mntent *dev_to_mount(char *dev) +{ + struct mntent *mnt, *ret = NULL; + FILE *f = setmntent("/proc/mounts", "r"); + if (!f) + die("error opening /proc/mounts: %m"); + + struct stat d1 = xstat(dev); + + while ((mnt = getmntent(f))) { + char *d, *p = mnt->mnt_fsname; + + while ((d = strsep(&p, ":"))) { + struct stat d2; + + if (stat(d, &d2)) + continue; + + if (S_ISBLK(d1.st_mode) != S_ISBLK(d2.st_mode)) + continue; + + if (S_ISBLK(d1.st_mode)) { + if (d1.st_rdev != d2.st_rdev) + continue; + } else { + if (d1.st_dev != d2.st_dev || + d1.st_ino != d2.st_ino) + continue; + } + + ret = mnt; + goto found; + } + } +found: + fclose(f); + return ret; +} + +int dev_mounted(char *dev) +{ + struct mntent *mnt = dev_to_mount(dev); + + if (!mnt) + return 0; + if (hasmntopt(mnt, "ro")) + return 1; + return 2; +} + +static int kstrtoull_symbolic(const char *s, unsigned int base, unsigned long long *res) +{ + if (!strcmp(s, "U64_MAX")) { + *res = U64_MAX; + return 0; + } + + if (!strcmp(s, "U32_MAX")) { + *res = U32_MAX; + return 0; + } + + return kstrtoull(s, base, res); +} + +static int kstrtouint_symbolic(const char *s, unsigned int base, unsigned *res) +{ + unsigned long long tmp; + int rv; + + rv = kstrtoull_symbolic(s, base, &tmp); + if (rv < 0) + return rv; + if (tmp != (unsigned long long)(unsigned int)tmp) + return -ERANGE; + *res = tmp; + return 0; +} + +struct bpos bpos_parse(char *buf) +{ + char *orig = strdup(buf); + char *s = buf; + + char *inode_s = strsep(&s, ":"); + char *offset_s = strsep(&s, ":"); + char *snapshot_s = strsep(&s, ":"); + + if (!inode_s || !offset_s || s) + die("invalid bpos %s", orig); + free(orig); + + u64 inode_v = 0, offset_v = 0; + u32 snapshot_v = 0; + if (kstrtoull_symbolic(inode_s, 10, &inode_v)) + die("invalid bpos.inode %s", inode_s); + + if (kstrtoull_symbolic(offset_s, 10, &offset_v)) + die("invalid bpos.offset %s", offset_s); + + if (snapshot_s && + kstrtouint_symbolic(snapshot_s, 10, &snapshot_v)) + die("invalid bpos.snapshot %s", snapshot_s); + + return (struct bpos) { .inode = inode_v, .offset = offset_v, .snapshot = snapshot_v }; +} + +struct bbpos bbpos_parse(char *buf) +{ + char *s = buf, *field; + struct bbpos ret; + + if (!(field = strsep(&s, ":"))) + die("invalid bbpos %s", buf); + + ret.btree = read_string_list_or_die(field, __bch2_btree_ids, "btree id"); + + if (!s) + die("invalid bbpos %s", buf); + + ret.pos = bpos_parse(s); + return ret; +} + +darray_str get_or_split_cmdline_devs(int argc, char *argv[]) +{ + darray_str ret = {}; + + if (argc == 1) { + bch2_split_devs(argv[0], &ret); + } else { + for (unsigned i = 0; i < argc; i++) + darray_push(&ret, strdup(argv[i])); + } + + return ret; }