Update bcachefs sources to 33a60d9b05 bcachefs: Assorted fixes for clang

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

diff --git a/libbcachefs/super-io.c b/libbcachefs/super-io.c
index b4aec5b6aef661cb5b1b669734ef6c80ae295918..c9a5a7cb97cf842f3afacdc1846464bc444fdd7c 100644 (file)
--- a/libbcachefs/super-io.c
+++ b/libbcachefs/super-io.c
@@ -4,6 +4,7 @@
 #include "btree_update_interior.h"
 #include "buckets.h"
 #include "checksum.h"
+#include "counters.h"
 #include "disk_groups.h"
 #include "ec.h"
 #include "error.h"
@@ -12,24 +13,29 @@
 #include "journal_io.h"
 #include "journal_sb.h"
 #include "journal_seq_blacklist.h"
+#include "recovery.h"
 #include "replicas.h"
 #include "quota.h"
 #include "super-io.h"
 #include "super.h"
 #include "trace.h"
 #include "vstructs.h"
-#include "counters.h"
 
 #include <linux/backing-dev.h>
 #include <linux/sort.h>
 
-struct bch2_metadata_version_str {
+struct bch2_metadata_version {
        u16             version;
        const char      *name;
+       u64             recovery_passes;
 };
 
-static const struct bch2_metadata_version_str bch2_metadata_versions[] = {
-#define x(n, v) { .version = v, .name = #n },
+static const struct bch2_metadata_version bch2_metadata_versions[] = {
+#define x(n, v, _recovery_passes) {            \
+       .version = v,                           \
+       .name = #n,                             \
+       .recovery_passes = _recovery_passes,    \
+},
        BCH_METADATA_VERSIONS()
 #undef x
 };
@@ -61,6 +67,24 @@ unsigned bch2_latest_compatible_version(unsigned v)
        return v;
 }
 
+u64 bch2_upgrade_recovery_passes(struct bch_fs *c,
+                                unsigned old_version,
+                                unsigned new_version)
+{
+       u64 ret = 0;
+
+       for (const struct bch2_metadata_version *i = bch2_metadata_versions;
+            i < bch2_metadata_versions + ARRAY_SIZE(bch2_metadata_versions);
+            i++)
+               if (i->version > old_version && i->version <= new_version) {
+                       if (i->recovery_passes & RECOVERY_PASS_ALL_FSCK)
+                               ret |= bch2_fsck_recovery_passes();
+                       ret |= i->recovery_passes;
+               }
+
+       return ret &= ~RECOVERY_PASS_ALL_FSCK;
+}
+
 const char * const bch2_sb_fields[] = {
 #define x(name, nr)    #name,
        BCH_SB_FIELDS()
@@ -237,16 +261,13 @@ struct bch_sb_field *bch2_sb_field_resize(struct bch_sb_handle *sb,
 
 /* Superblock validate: */
 
-static inline void __bch2_sb_layout_size_assert(void)
-{
-       BUILD_BUG_ON(sizeof(struct bch_sb_layout) != 512);
-}
-
 static int validate_sb_layout(struct bch_sb_layout *layout, struct printbuf *out)
 {
        u64 offset, prev_offset, max_sectors;
        unsigned i;
 
+       BUILD_BUG_ON(sizeof(struct bch_sb_layout) != 512);
+
        if (!uuid_equal(&layout->magic, &BCACHE_MAGIC) &&
            !uuid_equal(&layout->magic, &BCHFS_MAGIC)) {
                prt_printf(out, "Not a bcachefs superblock layout");
@@ -394,6 +415,9 @@ static int bch2_sb_validate(struct bch_sb_handle *disk_sb, struct printbuf *out,
                        SET_BCH_SB_JOURNAL_FLUSH_DELAY(sb, 1000);
                if (!BCH_SB_JOURNAL_RECLAIM_DELAY(sb))
                        SET_BCH_SB_JOURNAL_RECLAIM_DELAY(sb, 1000);
+
+               if (!BCH_SB_VERSION_UPGRADE_COMPLETE(sb))
+                       SET_BCH_SB_VERSION_UPGRADE_COMPLETE(sb, le16_to_cpu(sb->version));
        }
 
        for (opt_id = 0; opt_id < bch2_opts_nr; opt_id++) {
@@ -468,7 +492,7 @@ static void bch2_sb_update(struct bch_fs *c)
        c->sb.user_uuid         = src->user_uuid;
        c->sb.version           = le16_to_cpu(src->version);
        c->sb.version_min       = le16_to_cpu(src->version_min);
-       c->sb.version_upgrade_complete = BCH_SB_VERSION_UPGRADE_COMPLETE(src) ?: c->sb.version;
+       c->sb.version_upgrade_complete = BCH_SB_VERSION_UPGRADE_COMPLETE(src);
        c->sb.nr_devices        = src->nr_devices;
        c->sb.clean             = BCH_SB_CLEAN(src);
        c->sb.encryption_type   = BCH_SB_ENCRYPTION_TYPE(src);
@@ -634,11 +658,18 @@ int bch2_read_super(const char *path, struct bch_opts *opts,
        struct printbuf err = PRINTBUF;
        __le64 *i;
        int ret;
-
+#ifndef __KERNEL__
+retry:
+#endif
        memset(sb, 0, sizeof(*sb));
        sb->mode        = FMODE_READ;
        sb->have_bio    = true;
 
+#ifndef __KERNEL__
+       if (opt_get(*opts, direct_io) == false)
+               sb->mode |= FMODE_BUFFERED;
+#endif
+
        if (!opt_get(*opts, noexcl))
                sb->mode |= FMODE_EXCL;
 
@@ -723,7 +754,13 @@ int bch2_read_super(const char *path, struct bch_opts *opts,
 
 got_super:
        if (le16_to_cpu(sb->sb->block_size) << 9 <
-           bdev_logical_block_size(sb->bdev)) {
+           bdev_logical_block_size(sb->bdev) &&
+           opt_get(*opts, direct_io)) {
+#ifndef __KERNEL__
+               opt_set(*opts, direct_io, false);
+               bch2_free_super(sb);
+               goto retry;
+#endif
                prt_printf(&err, "block size (%u) smaller than device block size (%u)",
                       le16_to_cpu(sb->sb->block_size) << 9,
                       bdev_logical_block_size(sb->bdev));
@@ -1197,17 +1234,10 @@ int bch2_sb_clean_validate_late(struct bch_fs *c, struct bch_sb_field_clean *cle
        return 0;
 }
 
-int bch2_fs_mark_dirty(struct bch_fs *c)
+/* Downgrade if superblock is at a higher version than currently supported: */
+void bch2_sb_maybe_downgrade(struct bch_fs *c)
 {
-       int ret;
-
-       /*
-        * Unconditionally write superblock, to verify it hasn't changed before
-        * we go rw:
-        */
-
-       mutex_lock(&c->sb_lock);
-       SET_BCH_SB_CLEAN(c->disk_sb.sb, false);
+       lockdep_assert_held(&c->sb_lock);
 
        /*
         * Downgrade, if superblock is at a higher version than currently
@@ -1220,8 +1250,31 @@ int bch2_fs_mark_dirty(struct bch_fs *c)
        if (c->sb.version_min > bcachefs_metadata_version_current)
                c->disk_sb.sb->version_min = cpu_to_le16(bcachefs_metadata_version_current);
        c->disk_sb.sb->compat[0] &= cpu_to_le64((1ULL << BCH_COMPAT_NR) - 1);
+}
+
+void bch2_sb_upgrade(struct bch_fs *c, unsigned new_version)
+{
+       lockdep_assert_held(&c->sb_lock);
+
+       c->disk_sb.sb->version = cpu_to_le16(new_version);
+       c->disk_sb.sb->features[0] |= cpu_to_le64(BCH_SB_FEATURES_ALL);
+}
+
+int bch2_fs_mark_dirty(struct bch_fs *c)
+{
+       int ret;
+
+       /*
+        * Unconditionally write superblock, to verify it hasn't changed before
+        * we go rw:
+        */
 
+       mutex_lock(&c->sb_lock);
+       SET_BCH_SB_CLEAN(c->disk_sb.sb, false);
+
+       bch2_sb_maybe_downgrade(c);
        c->disk_sb.sb->features[0] |= cpu_to_le64(BCH_SB_FEATURES_ALWAYS);
+
        ret = bch2_write_super(c);
        mutex_unlock(&c->sb_lock);
 
@@ -1440,9 +1493,7 @@ static const struct bch_sb_field_ops *bch2_sb_field_ops[] = {
 #undef x
 };
 
-static const struct bch_sb_field_ops bch2_sb_field_null_ops = {
-       NULL
-};
+static const struct bch_sb_field_ops bch2_sb_field_null_ops;
 
 static const struct bch_sb_field_ops *bch2_sb_field_type_ops(unsigned type)
 {