Update bcachefs sources to e7f6215768 bcachefs: Fix snapshot_skiplist_good()

[bcachefs-tools-debian] / libbcachefs / super.c

diff --git a/libbcachefs/super.c b/libbcachefs/super.c
index 6fa805cb4bc51cb08147fd90d477e54e9b30d53f..e7dbc31be36d84f9b91f77cf348e072bf60932f1 100644 (file)
--- a/libbcachefs/super.c
+++ b/libbcachefs/super.c
@@ -13,6 +13,7 @@
 #include "bkey_sort.h"
 #include "btree_cache.h"
 #include "btree_gc.h"
+#include "btree_journal_iter.h"
 #include "btree_key_cache.h"
 #include "btree_update_interior.h"
 #include "btree_io.h"
@@ -30,6 +31,8 @@
 #include "error.h"
 #include "fs.h"
 #include "fs-io.h"
+#include "fs-io-buffered.h"
+#include "fs-io-direct.h"
 #include "fsck.h"
 #include "inode.h"
 #include "io.h"
@@ -44,6 +47,8 @@
 #include "rebalance.h"
 #include "recovery.h"
 #include "replicas.h"
+#include "sb-clean.h"
+#include "snapshot.h"
 #include "subvolume.h"
 #include "super.h"
 #include "super-io.h"
@@ -344,6 +349,19 @@ static int bch2_fs_read_write_late(struct bch_fs *c)
 {
        int ret;
 
+       /*
+        * Data move operations can't run until after check_snapshots has
+        * completed, and bch2_snapshot_is_ancestor() is available.
+        *
+        * Ideally we'd start copygc/rebalance earlier instead of waiting for
+        * all of recovery/fsck to complete:
+        */
+       ret = bch2_copygc_start(c);
+       if (ret) {
+               bch_err(c, "error starting copygc thread");
+               return ret;
+       }
+
        ret = bch2_rebalance_start(c);
        if (ret) {
                bch_err(c, "error starting rebalance thread");
@@ -361,20 +379,21 @@ static int __bch2_fs_read_write(struct bch_fs *c, bool early)
 
        if (test_bit(BCH_FS_INITIAL_GC_UNFIXED, &c->flags)) {
                bch_err(c, "cannot go rw, unfixed btree errors");
-               return -EROFS;
+               return -BCH_ERR_erofs_unfixed_errors;
        }
 
        if (test_bit(BCH_FS_RW, &c->flags))
                return 0;
 
+       if (c->opts.norecovery)
+               return -BCH_ERR_erofs_norecovery;
+
        /*
         * nochanges is used for fsck -n mode - we have to allow going rw
         * during recovery for that to work:
         */
-       if (c->opts.norecovery ||
-           (c->opts.nochanges &&
-            (!early || c->opts.read_only)))
-               return -EROFS;
+       if (c->opts.nochanges && (!early || c->opts.read_only))
+               return -BCH_ERR_erofs_nochanges;
 
        bch_info(c, "going read-write");
 
@@ -402,12 +421,6 @@ static int __bch2_fs_read_write(struct bch_fs *c, bool early)
                return ret;
        }
 
-       ret = bch2_copygc_start(c);
-       if (ret) {
-               bch_err(c, "error starting copygc thread");
-               return ret;
-       }
-
        if (!early) {
                ret = bch2_fs_read_write_late(c);
                if (ret)
@@ -461,6 +474,8 @@ static void __bch2_fs_free(struct bch_fs *c)
        bch2_fs_counters_exit(c);
        bch2_fs_snapshots_exit(c);
        bch2_fs_quota_exit(c);
+       bch2_fs_fs_io_direct_exit(c);
+       bch2_fs_fs_io_buffered_exit(c);
        bch2_fs_fsio_exit(c);
        bch2_fs_ec_exit(c);
        bch2_fs_encryption_exit(c);
@@ -560,19 +575,14 @@ void __bch2_fs_stop(struct bch_fs *c)
                cancel_work_sync(&ca->io_error_work);
 
        cancel_work_sync(&c->read_only_work);
-
-       for (i = 0; i < c->sb.nr_devices; i++) {
-               struct bch_dev *ca = rcu_dereference_protected(c->devs[i], true);
-
-               if (ca)
-                       bch2_free_super(&ca->disk_sb);
-       }
 }
 
 void bch2_fs_free(struct bch_fs *c)
 {
        unsigned i;
 
+       BUG_ON(!test_bit(BCH_FS_STOPPING, &c->flags));
+
        mutex_lock(&bch_fs_list_lock);
        list_del(&c->list);
        mutex_unlock(&bch_fs_list_lock);
@@ -580,9 +590,14 @@ void bch2_fs_free(struct bch_fs *c)
        closure_sync(&c->cl);
        closure_debug_destroy(&c->cl);
 
-       for (i = 0; i < c->sb.nr_devices; i++)
-               if (c->devs[i])
-                       bch2_dev_free(rcu_dereference_protected(c->devs[i], 1));
+       for (i = 0; i < c->sb.nr_devices; i++) {
+               struct bch_dev *ca = rcu_dereference_protected(c->devs[i], true);
+
+               if (ca) {
+                       bch2_free_super(&ca->disk_sb);
+                       bch2_dev_free(ca);
+               }
+       }
 
        bch_verbose(c, "shutdown complete");
 
@@ -653,8 +668,6 @@ static struct bch_fs *bch2_fs_alloc(struct bch_sb *sb, struct bch_opts opts)
        unsigned i, iter_size;
        int ret = 0;
 
-       pr_verbose_init(opts, "");
-
        c = kvpmalloc(sizeof(struct bch_fs), GFP_KERNEL|__GFP_ZERO);
        if (!c) {
                c = ERR_PTR(-BCH_ERR_ENOMEM_fs_alloc);
@@ -838,7 +851,9 @@ static struct bch_fs *bch2_fs_alloc(struct bch_sb *sb, struct bch_opts opts)
            bch2_fs_encryption_init(c) ?:
            bch2_fs_compress_init(c) ?:
            bch2_fs_ec_init(c) ?:
-           bch2_fs_fsio_init(c);
+           bch2_fs_fsio_init(c) ?:
+           bch2_fs_fs_io_buffered_init(c);
+           bch2_fs_fs_io_direct_init(c);
        if (ret)
                goto err;
 
@@ -865,7 +880,6 @@ static struct bch_fs *bch2_fs_alloc(struct bch_sb *sb, struct bch_opts opts)
        if (ret)
                goto err;
 out:
-       pr_verbose_init(opts, "ret %i", PTR_ERR_OR_ZERO(c));
        return c;
 err:
        bch2_fs_free(c);
@@ -880,7 +894,7 @@ static void print_mount_opts(struct bch_fs *c)
        struct printbuf p = PRINTBUF;
        bool first = true;
 
-       prt_str(&p, "mounted version ");
+       prt_str(&p, "mounting version ");
        bch2_version_to_text(&p, c->sb.version);
 
        if (c->opts.read_only) {
@@ -916,6 +930,8 @@ int bch2_fs_start(struct bch_fs *c)
        unsigned i;
        int ret;
 
+       print_mount_opts(c);
+
        down_write(&c->state_lock);
 
        BUG_ON(test_bit(BCH_FS_STARTED, &c->flags));
@@ -969,7 +985,6 @@ int bch2_fs_start(struct bch_fs *c)
                        goto err;
        }
 
-       print_mount_opts(c);
        ret = 0;
 out:
        up_write(&c->state_lock);
@@ -1181,8 +1196,6 @@ static int bch2_dev_alloc(struct bch_fs *c, unsigned dev_idx)
        struct bch_dev *ca = NULL;
        int ret = 0;
 
-       pr_verbose_init(c->opts, "");
-
        if (bch2_fs_init_fault("dev_alloc"))
                goto err;
 
@@ -1193,14 +1206,11 @@ static int bch2_dev_alloc(struct bch_fs *c, unsigned dev_idx)
        ca->fs = c;
 
        bch2_dev_attach(c, ca, dev_idx);
-out:
-       pr_verbose_init(c->opts, "ret %i", ret);
        return ret;
 err:
        if (ca)
                bch2_dev_free(ca);
-       ret = -BCH_ERR_ENOMEM_dev_alloc;
-       goto out;
+       return -BCH_ERR_ENOMEM_dev_alloc;
 }
 
 static int __bch2_dev_attach_bdev(struct bch_dev *ca, struct bch_sb_handle *sb)
@@ -1878,8 +1888,6 @@ struct bch_fs *bch2_fs_open(char * const *devices, unsigned nr_devices,
        if (!try_module_get(THIS_MODULE))
                return ERR_PTR(-ENODEV);
 
-       pr_verbose_init(opts, "");
-
        if (!nr_devices) {
                ret = -EINVAL;
                goto err;
@@ -1951,8 +1959,6 @@ out:
        kfree(sb);
        printbuf_exit(&errbuf);
        module_put(THIS_MODULE);
-       pr_verbose_init(opts, "ret %s (%i)", bch2_err_str(PTR_ERR_OR_ZERO(c)),
-                       PTR_ERR_OR_ZERO(c));
        return c;
 err_print:
        pr_err("bch_fs_open err opening %s: %s",
@@ -2003,6 +2009,7 @@ err:
 BCH_DEBUG_PARAMS()
 #undef BCH_DEBUG_PARAM
 
+__maybe_unused
 static unsigned bch2_metadata_version = bcachefs_metadata_version_current;
 module_param_named(version, bch2_metadata_version, uint, 0400);