cmd_fsck: -k, run fsck in kernel

This adds a new option to cmd_fsck for using the kernel implementation
of fsck instead of userspace, via the BCH_IOCTL_FSCK_OFFLINE ioctl.

This isn't intended for normal usage - mainly for testing and debugging
purposes, and for when the kernel version of bcachefs better matches the
on disk format version.

Signed-off-by: Kent Overstreet <kent.overstreet@linux.dev>

diff --git a/cmd_fsck.c b/cmd_fsck.c
index 3ce129f9f0dcb098a5da08df0f52ef73385d9e97..81e589b465a7c4d157e772f1f60d9ba3a5e46b8c 100644 (file)
--- a/cmd_fsck.c
+++ b/cmd_fsck.c
@@ -8,7 +8,7 @@
 #include "libbcachefs/super.h"
 #include "tools-util.h"
 
-static void usage(void)
+static void fsck_usage(void)
 {
        puts("bcachefs fsck - filesystem check and repair\n"
             "Usage: bcachefs fsck [OPTION]... <devices>\n"
@@ -20,6 +20,7 @@ static void usage(void)
             "  -f                      Force checking even if filesystem is marked clean\n"
             "  -r, --ratelimit_errors  Don't display more than 10 errors of a given type\n"
             "  -R, --reconstruct_alloc Reconstruct the alloc btree\n"
+            "  -k, --kernel            Use the in-kernel fsck implementation\n"
             "  -v                      Be verbose\n"
             "  -h, --help              Display this help and exit\n"
             "Report bugs to <linux-bcachefs@vger.kernel.org>");
@@ -48,86 +49,101 @@ static int do_splice(int rfd, int wfd)
        return 0;
 }
 
-static int fsck_online(const char *dev_path)
+static int splice_fd_to_stdinout(int fd)
 {
-       int dev_idx;
-       struct bchfs_handle fs = bchu_fs_open_by_dev(dev_path, &dev_idx);
-
-       struct bch_ioctl_fsck_online fsck = { 0 };
-
-       int fsck_fd = ioctl(fs.ioctl_fd, BCH_IOCTL_FSCK_ONLINE, &fsck);
-       if (fsck_fd < 0)
-               die("BCH_IOCTL_FSCK_ONLINE error: %s", bch2_err_str(fsck_fd));
-
        setnonblocking(STDIN_FILENO);
-       setnonblocking(fsck_fd);
+       setnonblocking(fd);
 
        while (true) {
                fd_set fds;
 
                FD_ZERO(&fds);
                FD_SET(STDIN_FILENO, &fds);
-               FD_SET(fsck_fd, &fds);
+               FD_SET(fd, &fds);
 
-               select(fsck_fd + 1, &fds, NULL, NULL, NULL);
+               select(fd + 1, &fds, NULL, NULL, NULL);
 
-               int r = do_splice(fsck_fd, STDOUT_FILENO) ?:
-                       do_splice(STDIN_FILENO, fsck_fd);
+               int r = do_splice(fd, STDOUT_FILENO) ?:
+                       do_splice(STDIN_FILENO, fd);
                if (r)
                        return r < 0 ? r : 0;
        }
 
-       pr_info("done");
        return 0;
 }
 
+static int fsck_online(const char *dev_path)
+{
+       int dev_idx;
+       struct bchfs_handle fs = bchu_fs_open_by_dev(dev_path, &dev_idx);
+
+       struct bch_ioctl_fsck_online fsck = { 0 };
+
+       int fsck_fd = ioctl(fs.ioctl_fd, BCH_IOCTL_FSCK_ONLINE, &fsck);
+       if (fsck_fd < 0)
+               die("BCH_IOCTL_FSCK_ONLINE error: %s", bch2_err_str(fsck_fd));
+
+       return splice_fd_to_stdinout(fsck_fd);
+}
+
+static void append_opt(struct printbuf *out, const char *opt)
+{
+       if (out->pos)
+               prt_char(out, ',');
+       prt_str(out, opt);
+}
+
 int cmd_fsck(int argc, char *argv[])
 {
        static const struct option longopts[] = {
                { "ratelimit_errors",   no_argument,            NULL, 'r' },
                { "reconstruct_alloc",  no_argument,            NULL, 'R' },
+               { "kernel",             no_argument,            NULL, 'k' },
                { "help",               no_argument,            NULL, 'h' },
                { NULL }
        };
-       struct bch_opts opts = bch2_opts_empty();
+       bool kernel = false;
        int opt, ret = 0;
+       struct printbuf opts_str = PRINTBUF;
 
-       opt_set(opts, degraded, true);
-       opt_set(opts, fsck, true);
-       opt_set(opts, fix_errors, FSCK_FIX_ask);
+       append_opt(&opts_str, "degraded");
+       append_opt(&opts_str, "fsck");
+       append_opt(&opts_str, "fix_errors=ask");
+       append_opt(&opts_str, "read_only");
 
        while ((opt = getopt_long(argc, argv,
-                                 "apynfo:rvh",
+                                 "apynfo:rRkvh",
                                  longopts, NULL)) != -1)
                switch (opt) {
                case 'a': /* outdated alias for -p */
                case 'p':
                case 'y':
-                       opt_set(opts, fix_errors, FSCK_FIX_yes);
+                       append_opt(&opts_str, "fix_errors=yes");
                        break;
                case 'n':
-                       opt_set(opts, nochanges, true);
-                       opt_set(opts, fix_errors, FSCK_FIX_no);
+                       append_opt(&opts_str, "nochanges");
+                       append_opt(&opts_str, "fix_errors=no");
                        break;
                case 'f':
                        /* force check, even if filesystem marked clean: */
                        break;
                case 'o':
-                       ret = bch2_parse_mount_opts(NULL, &opts, optarg);
-                       if (ret)
-                               return ret;
+                       append_opt(&opts_str, optarg);
                        break;
                case 'r':
-                       opt_set(opts, ratelimit_errors, true);
+                       append_opt(&opts_str, "ratelimit_errors");
                        break;
                case 'R':
-                       opt_set(opts, reconstruct_alloc, true);
+                       append_opt(&opts_str, "reconstruct_alloc");
+                       break;
+               case 'k':
+                       kernel = true;
                        break;
                case 'v':
-                       opt_set(opts, verbose, true);
+                       append_opt(&opts_str, "verbose");
                        break;
                case 'h':
-                       usage();
+                       fsck_usage();
                        exit(16);
                }
        args_shift(optind);
@@ -139,23 +155,49 @@ int cmd_fsck(int argc, char *argv[])
 
        darray_str devs = get_or_split_cmdline_devs(argc, argv);
 
-       darray_for_each(devs, i)
-               if (dev_mounted(*i))
-                       return fsck_online(*i);
+       if (!kernel) {
+               struct bch_opts opts = bch2_opts_empty();
+               ret = bch2_parse_mount_opts(NULL, &opts, opts_str.buf);
+               if (ret)
+                       return ret;
 
-       struct bch_fs *c = bch2_fs_open(devs.data, devs.nr, opts);
-       if (IS_ERR(c))
-               exit(8);
+               darray_for_each(devs, i)
+                       if (dev_mounted(*i))
+                               return fsck_online(*i);
 
-       if (test_bit(BCH_FS_errors_fixed, &c->flags)) {
-               fprintf(stderr, "%s: errors fixed\n", c->name);
-               ret |= 1;
-       }
-       if (test_bit(BCH_FS_error, &c->flags)) {
-               fprintf(stderr, "%s: still has errors\n", c->name);
-               ret |= 4;
+               struct bch_fs *c = bch2_fs_open(devs.data, devs.nr, opts);
+               if (IS_ERR(c))
+                       exit(8);
+
+               if (test_bit(BCH_FS_errors_fixed, &c->flags)) {
+                       fprintf(stderr, "%s: errors fixed\n", c->name);
+                       ret |= 1;
+               }
+               if (test_bit(BCH_FS_error, &c->flags)) {
+                       fprintf(stderr, "%s: still has errors\n", c->name);
+                       ret |= 4;
+               }
+
+               bch2_fs_stop(c);
+       } else {
+               struct bch_ioctl_fsck_offline *fsck = calloc(sizeof(*fsck) +
+                                                            sizeof(u64) * devs.nr, 1);
+
+               fsck->opts = (unsigned long)opts_str.buf;
+               darray_for_each(devs, i)
+                       fsck->devs[i - devs.data] = (unsigned long) *i;
+               fsck->nr_devs = devs.nr;
+
+               int ctl_fd = bcachectl_open();
+
+               int fsck_fd = ioctl(ctl_fd, BCH_IOCTL_FSCK_OFFLINE, fsck);
+               if (fsck_fd < 0)
+                       die("BCH_IOCTL_FSCK_OFFLINE error: %s", bch2_err_str(fsck_fd));
+
+               ret = splice_fd_to_stdinout(fsck_fd);
+               free(fsck);
        }
 
-       bch2_fs_stop(c);
+       printbuf_exit(&opts_str);
        return ret;
 }

diff --git a/libbcachefs.c b/libbcachefs.c
index a3b9c30c555bf7c7c1a392ee04f0f3fc774d9119..68b750a389bc59324baa12236fe6318b87f90828 100644 (file)
--- a/libbcachefs.c
+++ b/libbcachefs.c
@@ -449,16 +449,17 @@ struct bchfs_handle bchu_fs_open_by_dev(const char *path, int *idx)
 
        struct stat stat = xstat(path);
 
-       if (!S_ISBLK(stat.st_mode))
-               die("%s is not a block device", path);
+       if (S_ISBLK(stat.st_mode)) {
+               char *sysfs = mprintf("/sys/dev/block/%u:%u/bcachefs",
+                                     major(stat.st_dev),
+                                     minor(stat.st_dev));
 
-       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);
+               ssize_t len = readlink(sysfs, buf, sizeof(buf));
+               free(sysfs);
+
+               if (len <= 0)
+                       goto read_super;
 
-       if (len > 0) {
                char *p = strrchr(buf, '/');
                if (!p || sscanf(p + 1, "dev-%u", idx) != 1)
                        die("error parsing sysfs");
@@ -467,6 +468,7 @@ struct bchfs_handle bchu_fs_open_by_dev(const char *path, int *idx)
                p = strrchr(buf, '/');
                uuid_str = p + 1;
        } else {
+read_super:
                struct bch_opts opts = bch2_opts_empty();
 
                opt_set(opts, noexcl,   true);