bcachefs: x-macro-ify inode flags enum

This lets us use bch2_prt_bitflags to print them out.

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

diff --git a/fs/bcachefs/bcachefs_format.h b/fs/bcachefs/bcachefs_format.h
index a191baa..0a75095 100644 (file)
--- a/fs/bcachefs/bcachefs_format.h
+++ b/fs/bcachefs/bcachefs_format.h
@@ -824,34 +824,30 @@ enum inode_opt_id {
        Inode_opt_nr,
 };
 
-enum {
-       /*
-        * User flags (get/settable with FS_IOC_*FLAGS, correspond to FS_*_FL
-        * flags)
-        */
-       __BCH_INODE_SYNC                = 0,
-       __BCH_INODE_IMMUTABLE           = 1,
-       __BCH_INODE_APPEND              = 2,
-       __BCH_INODE_NODUMP              = 3,
-       __BCH_INODE_NOATIME             = 4,
-
-       __BCH_INODE_I_SIZE_DIRTY        = 5, /* obsolete */
-       __BCH_INODE_I_SECTORS_DIRTY     = 6, /* obsolete */
-       __BCH_INODE_UNLINKED            = 7,
-       __BCH_INODE_BACKPTR_UNTRUSTED   = 8,
-
-       /* bits 20+ reserved for packed fields below: */
-};
-
-#define BCH_INODE_SYNC         (1 << __BCH_INODE_SYNC)
-#define BCH_INODE_IMMUTABLE    (1 << __BCH_INODE_IMMUTABLE)
-#define BCH_INODE_APPEND       (1 << __BCH_INODE_APPEND)
-#define BCH_INODE_NODUMP       (1 << __BCH_INODE_NODUMP)
-#define BCH_INODE_NOATIME      (1 << __BCH_INODE_NOATIME)
-#define BCH_INODE_I_SIZE_DIRTY (1 << __BCH_INODE_I_SIZE_DIRTY)
-#define BCH_INODE_I_SECTORS_DIRTY (1 << __BCH_INODE_I_SECTORS_DIRTY)
-#define BCH_INODE_UNLINKED     (1 << __BCH_INODE_UNLINKED)
-#define BCH_INODE_BACKPTR_UNTRUSTED (1 << __BCH_INODE_BACKPTR_UNTRUSTED)
+#define BCH_INODE_FLAGS()                      \
+       x(sync,                         0)      \
+       x(immutable,                    1)      \
+       x(append,                       2)      \
+       x(nodump,                       3)      \
+       x(noatime,                      4)      \
+       x(i_size_dirty,                 5)      \
+       x(i_sectors_dirty,              6)      \
+       x(unlinked,                     7)      \
+       x(backptr_untrusted,            8)
+
+/* bits 20+ reserved for packed fields below: */
+
+enum bch_inode_flags {
+#define x(t, n)        BCH_INODE_##t = 1U << n,
+       BCH_INODE_FLAGS()
+#undef x
+};
+
+enum __bch_inode_flags {
+#define x(t, n)        __BCH_INODE_##t = n,
+       BCH_INODE_FLAGS()
+#undef x
+};
 
 LE32_BITMASK(INODE_STR_HASH,   struct bch_inode, bi_flags, 20, 24);
 LE32_BITMASK(INODE_NR_FIELDS,  struct bch_inode, bi_flags, 24, 31);

diff --git a/fs/bcachefs/fs-common.c b/fs/bcachefs/fs-common.c
index bb53054..4496cf9 100644 (file)
--- a/fs/bcachefs/fs-common.c
+++ b/fs/bcachefs/fs-common.c
@@ -51,7 +51,7 @@ int bch2_create_trans(struct btree_trans *trans,
                bch2_inode_init_late(new_inode, now, uid, gid, mode, rdev, dir_u);
 
                if (flags & BCH_CREATE_TMPFILE)
-                       new_inode->bi_flags |= BCH_INODE_UNLINKED;
+                       new_inode->bi_flags |= BCH_INODE_unlinked;
 
                ret = bch2_inode_create(trans, &inode_iter, new_inode, snapshot, cpu);
                if (ret)

diff --git a/fs/bcachefs/fs-ioctl.c b/fs/bcachefs/fs-ioctl.c
index 6040bd3..5a39bcb 100644 (file)
--- a/fs/bcachefs/fs-ioctl.c
+++ b/fs/bcachefs/fs-ioctl.c
@@ -45,13 +45,13 @@ static int bch2_inode_flags_set(struct btree_trans *trans,
        unsigned newflags = s->flags;
        unsigned oldflags = bi->bi_flags & s->mask;
 
-       if (((newflags ^ oldflags) & (BCH_INODE_APPEND|BCH_INODE_IMMUTABLE)) &&
+       if (((newflags ^ oldflags) & (BCH_INODE_append|BCH_INODE_immutable)) &&
            !capable(CAP_LINUX_IMMUTABLE))
                return -EPERM;
 
        if (!S_ISREG(bi->bi_mode) &&
            !S_ISDIR(bi->bi_mode) &&
-           (newflags & (BCH_INODE_NODUMP|BCH_INODE_NOATIME)) != newflags)
+           (newflags & (BCH_INODE_nodump|BCH_INODE_noatime)) != newflags)
                return -EINVAL;
 
        if (s->set_projinherit) {

diff --git a/fs/bcachefs/fs-ioctl.h b/fs/bcachefs/fs-ioctl.h
index 54a9c21..d30f9bb 100644 (file)
--- a/fs/bcachefs/fs-ioctl.h
+++ b/fs/bcachefs/fs-ioctl.h
@@ -6,28 +6,28 @@
 
 /* bcachefs inode flags -> vfs inode flags: */
 static const __maybe_unused unsigned bch_flags_to_vfs[] = {
-       [__BCH_INODE_SYNC]      = S_SYNC,
-       [__BCH_INODE_IMMUTABLE] = S_IMMUTABLE,
-       [__BCH_INODE_APPEND]    = S_APPEND,
-       [__BCH_INODE_NOATIME]   = S_NOATIME,
+       [__BCH_INODE_sync]      = S_SYNC,
+       [__BCH_INODE_immutable] = S_IMMUTABLE,
+       [__BCH_INODE_append]    = S_APPEND,
+       [__BCH_INODE_noatime]   = S_NOATIME,
 };
 
 /* bcachefs inode flags -> FS_IOC_GETFLAGS: */
 static const __maybe_unused unsigned bch_flags_to_uflags[] = {
-       [__BCH_INODE_SYNC]      = FS_SYNC_FL,
-       [__BCH_INODE_IMMUTABLE] = FS_IMMUTABLE_FL,
-       [__BCH_INODE_APPEND]    = FS_APPEND_FL,
-       [__BCH_INODE_NODUMP]    = FS_NODUMP_FL,
-       [__BCH_INODE_NOATIME]   = FS_NOATIME_FL,
+       [__BCH_INODE_sync]      = FS_SYNC_FL,
+       [__BCH_INODE_immutable] = FS_IMMUTABLE_FL,
+       [__BCH_INODE_append]    = FS_APPEND_FL,
+       [__BCH_INODE_nodump]    = FS_NODUMP_FL,
+       [__BCH_INODE_noatime]   = FS_NOATIME_FL,
 };
 
 /* bcachefs inode flags -> FS_IOC_FSGETXATTR: */
 static const __maybe_unused unsigned bch_flags_to_xflags[] = {
-       [__BCH_INODE_SYNC]      = FS_XFLAG_SYNC,
-       [__BCH_INODE_IMMUTABLE] = FS_XFLAG_IMMUTABLE,
-       [__BCH_INODE_APPEND]    = FS_XFLAG_APPEND,
-       [__BCH_INODE_NODUMP]    = FS_XFLAG_NODUMP,
-       [__BCH_INODE_NOATIME]   = FS_XFLAG_NOATIME,
+       [__BCH_INODE_sync]      = FS_XFLAG_SYNC,
+       [__BCH_INODE_immutable] = FS_XFLAG_IMMUTABLE,
+       [__BCH_INODE_append]    = FS_XFLAG_APPEND,
+       [__BCH_INODE_nodump]    = FS_XFLAG_NODUMP,
+       [__BCH_INODE_noatime]   = FS_XFLAG_NOATIME,
        //[__BCH_INODE_PROJINHERIT] = FS_XFLAG_PROJINHERIT;
 };
 

diff --git a/fs/bcachefs/fs.c b/fs/bcachefs/fs.c
index a425c77..8dbc848 100644 (file)
--- a/fs/bcachefs/fs.c
+++ b/fs/bcachefs/fs.c
@@ -764,15 +764,15 @@ static int bch2_getattr(struct mnt_idmap *idmap,
                stat->btime = bch2_time_to_timespec(c, inode->ei_inode.bi_otime);
        }
 
-       if (inode->ei_inode.bi_flags & BCH_INODE_IMMUTABLE)
+       if (inode->ei_inode.bi_flags & BCH_INODE_immutable)
                stat->attributes |= STATX_ATTR_IMMUTABLE;
        stat->attributes_mask    |= STATX_ATTR_IMMUTABLE;
 
-       if (inode->ei_inode.bi_flags & BCH_INODE_APPEND)
+       if (inode->ei_inode.bi_flags & BCH_INODE_append)
                stat->attributes |= STATX_ATTR_APPEND;
        stat->attributes_mask    |= STATX_ATTR_APPEND;
 
-       if (inode->ei_inode.bi_flags & BCH_INODE_NODUMP)
+       if (inode->ei_inode.bi_flags & BCH_INODE_nodump)
                stat->attributes |= STATX_ATTR_NODUMP;
        stat->attributes_mask    |= STATX_ATTR_NODUMP;
 

diff --git a/fs/bcachefs/fsck.c b/fs/bcachefs/fsck.c
index 0e470eb..9f3e9bd 100644 (file)
--- a/fs/bcachefs/fsck.c
+++ b/fs/bcachefs/fsck.c
@@ -854,9 +854,9 @@ static int check_inode(struct btree_trans *trans,
        BUG_ON(bch2_inode_unpack(k, &u));
 
        if (!full &&
-           !(u.bi_flags & (BCH_INODE_I_SIZE_DIRTY|
-                           BCH_INODE_I_SECTORS_DIRTY|
-                           BCH_INODE_UNLINKED)))
+           !(u.bi_flags & (BCH_INODE_i_size_dirty|
+                           BCH_INODE_i_sectors_dirty|
+                           BCH_INODE_unlinked)))
                return 0;
 
        if (prev->bi_inum != u.bi_inum)
@@ -870,7 +870,7 @@ static int check_inode(struct btree_trans *trans,
                return -EINVAL;
        }
 
-       if ((u.bi_flags & (BCH_INODE_I_SIZE_DIRTY|BCH_INODE_UNLINKED)) &&
+       if ((u.bi_flags & (BCH_INODE_i_size_dirty|BCH_INODE_unlinked)) &&
            bch2_key_has_snapshot_overwrites(trans, BTREE_ID_inodes, k.k->p)) {
                struct bpos new_min_pos;
 
@@ -878,7 +878,7 @@ static int check_inode(struct btree_trans *trans,
                if (ret)
                        goto err;
 
-               u.bi_flags &= ~BCH_INODE_I_SIZE_DIRTY|BCH_INODE_UNLINKED;
+               u.bi_flags &= ~BCH_INODE_i_size_dirty|BCH_INODE_unlinked;
 
                ret = __write_inode(trans, &u, iter->pos.snapshot);
                bch_err_msg(c, ret, "in fsck updating inode");
@@ -890,7 +890,7 @@ static int check_inode(struct btree_trans *trans,
                return 0;
        }
 
-       if (u.bi_flags & BCH_INODE_UNLINKED &&
+       if (u.bi_flags & BCH_INODE_unlinked &&
            (!c->sb.clean ||
             fsck_err(c, inode_unlinked_but_clean,
                      "filesystem marked clean, but inode %llu unlinked",
@@ -903,7 +903,7 @@ static int check_inode(struct btree_trans *trans,
                return ret;
        }
 
-       if (u.bi_flags & BCH_INODE_I_SIZE_DIRTY &&
+       if (u.bi_flags & BCH_INODE_i_size_dirty &&
            (!c->sb.clean ||
             fsck_err(c, inode_i_size_dirty_but_clean,
                      "filesystem marked clean, but inode %llu has i_size dirty",
@@ -930,13 +930,13 @@ static int check_inode(struct btree_trans *trans,
                 * We truncated without our normal sector accounting hook, just
                 * make sure we recalculate it:
                 */
-               u.bi_flags |= BCH_INODE_I_SECTORS_DIRTY;
+               u.bi_flags |= BCH_INODE_i_sectors_dirty;
 
-               u.bi_flags &= ~BCH_INODE_I_SIZE_DIRTY;
+               u.bi_flags &= ~BCH_INODE_i_size_dirty;
                do_update = true;
        }
 
-       if (u.bi_flags & BCH_INODE_I_SECTORS_DIRTY &&
+       if (u.bi_flags & BCH_INODE_i_sectors_dirty &&
            (!c->sb.clean ||
             fsck_err(c, inode_i_sectors_dirty_but_clean,
                      "filesystem marked clean, but inode %llu has i_sectors dirty",
@@ -953,14 +953,14 @@ static int check_inode(struct btree_trans *trans,
                }
 
                u.bi_sectors = sectors;
-               u.bi_flags &= ~BCH_INODE_I_SECTORS_DIRTY;
+               u.bi_flags &= ~BCH_INODE_i_sectors_dirty;
                do_update = true;
        }
 
-       if (u.bi_flags & BCH_INODE_BACKPTR_UNTRUSTED) {
+       if (u.bi_flags & BCH_INODE_backptr_untrusted) {
                u.bi_dir = 0;
                u.bi_dir_offset = 0;
-               u.bi_flags &= ~BCH_INODE_BACKPTR_UNTRUSTED;
+               u.bi_flags &= ~BCH_INODE_backptr_untrusted;
                do_update = true;
        }
 
@@ -1065,7 +1065,7 @@ static int check_i_sectors(struct btree_trans *trans, struct inode_walker *w)
                        return -BCH_ERR_internal_fsck_err;
                }
 
-               if (fsck_err_on(!(i->inode.bi_flags & BCH_INODE_I_SECTORS_DIRTY),
+               if (fsck_err_on(!(i->inode.bi_flags & BCH_INODE_i_sectors_dirty),
                                c, inode_i_sectors_wrong,
                                "inode %llu:%u has incorrect i_sectors: got %llu, should be %llu",
                                w->last_pos.inode, i->snapshot,
@@ -1405,7 +1405,7 @@ static int check_extent(struct btree_trans *trans, struct btree_iter *iter,
                        continue;
 
                if (k.k->type != KEY_TYPE_whiteout) {
-                       if (fsck_err_on(!(i->inode.bi_flags & BCH_INODE_I_SIZE_DIRTY) &&
+                       if (fsck_err_on(!(i->inode.bi_flags & BCH_INODE_i_size_dirty) &&
                                        k.k->p.offset > round_up(i->inode.bi_size, block_bytes(c)) >> 9 &&
                                        !bkey_extent_is_reservation(k),
                                        c, extent_past_end_of_inode,
@@ -1588,7 +1588,7 @@ static int check_dirent_target(struct btree_trans *trans,
                                "inode %llu type %s has multiple links but i_nlink 0",
                                target->bi_inum, bch2_d_types[d.v->d_type])) {
                        target->bi_nlink++;
-                       target->bi_flags &= ~BCH_INODE_UNLINKED;
+                       target->bi_flags &= ~BCH_INODE_unlinked;
 
                        ret = __write_inode(trans, target, target_snapshot);
                        if (ret)
@@ -2160,7 +2160,7 @@ int bch2_check_directory_structure(struct bch_fs *c)
                        break;
                }
 
-               if (u.bi_flags & BCH_INODE_UNLINKED)
+               if (u.bi_flags & BCH_INODE_unlinked)
                        continue;
 
                ret = check_path(trans, &path, &u, iter.pos.snapshot);

diff --git a/fs/bcachefs/inode.c b/fs/bcachefs/inode.c
index 789f895..def77f2 100644 (file)
--- a/fs/bcachefs/inode.c
+++ b/fs/bcachefs/inode.c
@@ -20,13 +20,18 @@
 
 #include <asm/unaligned.h>
 
-const char * const bch2_inode_opts[] = {
 #define x(name, ...)   #name,
+const char * const bch2_inode_opts[] = {
        BCH_INODE_OPTS()
-#undef  x
        NULL,
 };
 
+static const char * const bch2_inode_flag_strs[] = {
+       BCH_INODE_FLAGS()
+       NULL
+};
+#undef  x
+
 static const u8 byte_table[8] = { 1, 2, 3, 4, 6, 8, 10, 13 };
 
 static int inode_decode_field(const u8 *in, const u8 *end,
@@ -426,7 +431,7 @@ static int __bch2_inode_invalid(struct bch_fs *c, struct bkey_s_c k, struct prin
                         inode_compression_type_invalid,
                         "invalid compression opt %u", unpacked.bi_compression - 1);
 
-       bkey_fsck_err_on((unpacked.bi_flags & BCH_INODE_UNLINKED) &&
+       bkey_fsck_err_on((unpacked.bi_flags & BCH_INODE_unlinked) &&
                         unpacked.bi_nlink != 0, c, err,
                         inode_unlinked_but_nlink_nonzero,
                         "flagged as unlinked but bi_nlink != 0");
@@ -500,15 +505,20 @@ fsck_err:
 static void __bch2_inode_unpacked_to_text(struct printbuf *out,
                                          struct bch_inode_unpacked *inode)
 {
-       prt_printf(out, "mode %o flags %x journal_seq %llu bi_size %llu bi_sectors %llu bi_version %llu",
-              inode->bi_mode, inode->bi_flags,
+       prt_printf(out, "mode=%o ", inode->bi_mode);
+
+       prt_str(out, "flags=");
+       prt_bitflags(out, bch2_inode_flag_strs, inode->bi_flags & ((1U << 20) - 1));
+       prt_printf(out, " (%x)", inode->bi_flags);
+
+       prt_printf(out, " journal_seq=%llu bi_size=%llu bi_sectors=%llu bi_version=%llu",
               inode->bi_journal_seq,
               inode->bi_size,
               inode->bi_sectors,
               inode->bi_version);
 
 #define x(_name, _bits)                                                \
-       prt_printf(out, " "#_name " %llu", (u64) inode->_name);
+       prt_printf(out, " "#_name "=%llu", (u64) inode->_name);
        BCH_INODE_FIELDS_v3()
 #undef  x
 }
@@ -547,7 +557,7 @@ static inline u64 bkey_inode_flags(struct bkey_s_c k)
 
 static inline bool bkey_is_deleted_inode(struct bkey_s_c k)
 {
-       return bkey_inode_flags(k) & BCH_INODE_UNLINKED;
+       return bkey_inode_flags(k) & BCH_INODE_unlinked;
 }
 
 int bch2_trans_mark_inode(struct btree_trans *trans,
@@ -928,8 +938,8 @@ int bch2_inode_find_by_inum(struct bch_fs *c, subvol_inum inum,
 
 int bch2_inode_nlink_inc(struct bch_inode_unpacked *bi)
 {
-       if (bi->bi_flags & BCH_INODE_UNLINKED)
-               bi->bi_flags &= ~BCH_INODE_UNLINKED;
+       if (bi->bi_flags & BCH_INODE_unlinked)
+               bi->bi_flags &= ~BCH_INODE_unlinked;
        else {
                if (bi->bi_nlink == U32_MAX)
                        return -EINVAL;
@@ -942,13 +952,13 @@ int bch2_inode_nlink_inc(struct bch_inode_unpacked *bi)
 
 void bch2_inode_nlink_dec(struct btree_trans *trans, struct bch_inode_unpacked *bi)
 {
-       if (bi->bi_nlink && (bi->bi_flags & BCH_INODE_UNLINKED)) {
+       if (bi->bi_nlink && (bi->bi_flags & BCH_INODE_unlinked)) {
                bch2_trans_inconsistent(trans, "inode %llu unlinked but link count nonzero",
                                        bi->bi_inum);
                return;
        }
 
-       if (bi->bi_flags & BCH_INODE_UNLINKED) {
+       if (bi->bi_flags & BCH_INODE_unlinked) {
                bch2_trans_inconsistent(trans, "inode %llu link count underflow", bi->bi_inum);
                return;
        }
@@ -956,7 +966,7 @@ void bch2_inode_nlink_dec(struct btree_trans *trans, struct bch_inode_unpacked *
        if (bi->bi_nlink)
                bi->bi_nlink--;
        else
-               bi->bi_flags |= BCH_INODE_UNLINKED;
+               bi->bi_flags |= BCH_INODE_unlinked;
 }
 
 struct bch_opts bch2_inode_opts_to_opts(struct bch_inode_unpacked *inode)
@@ -1089,7 +1099,7 @@ static int may_delete_deleted_inode(struct btree_trans *trans,
                        pos.offset, pos.snapshot))
                goto delete;
 
-       if (fsck_err_on(!(inode.bi_flags & BCH_INODE_UNLINKED), c,
+       if (fsck_err_on(!(inode.bi_flags & BCH_INODE_unlinked), c,
                        deleted_inode_not_unlinked,
                        "non-deleted inode %llu:%u in deleted_inodes btree",
                        pos.offset, pos.snapshot))
@@ -1111,7 +1121,7 @@ static int may_delete_deleted_inode(struct btree_trans *trans,
                if (ret)
                        goto out;
 
-               inode.bi_flags &= ~BCH_INODE_UNLINKED;
+               inode.bi_flags &= ~BCH_INODE_unlinked;
 
                ret = bch2_inode_write_flags(trans, &inode_iter, &inode,
                                             BTREE_UPDATE_INTERNAL_SNAPSHOT_NODE);

diff --git a/fs/bcachefs/inode.h b/fs/bcachefs/inode.h
index b09fda4..88818a3 100644 (file)
--- a/fs/bcachefs/inode.h
+++ b/fs/bcachefs/inode.h
@@ -186,7 +186,7 @@ static inline unsigned nlink_bias(umode_t mode)
 
 static inline unsigned bch2_inode_nlink_get(struct bch_inode_unpacked *bi)
 {
-       return bi->bi_flags & BCH_INODE_UNLINKED
+       return bi->bi_flags & BCH_INODE_unlinked
                  ? 0
                  : bi->bi_nlink + nlink_bias(bi->bi_mode);
 }
@@ -196,10 +196,10 @@ static inline void bch2_inode_nlink_set(struct bch_inode_unpacked *bi,
 {
        if (nlink) {
                bi->bi_nlink = nlink - nlink_bias(bi->bi_mode);
-               bi->bi_flags &= ~BCH_INODE_UNLINKED;
+               bi->bi_flags &= ~BCH_INODE_unlinked;
        } else {
                bi->bi_nlink = 0;
-               bi->bi_flags |= BCH_INODE_UNLINKED;
+               bi->bi_flags |= BCH_INODE_unlinked;
        }
 }
 

diff --git a/fs/bcachefs/io_write.c b/fs/bcachefs/io_write.c
index 4eb0eda..f02b3f7 100644 (file)
--- a/fs/bcachefs/io_write.c
+++ b/fs/bcachefs/io_write.c
@@ -234,7 +234,7 @@ static inline int bch2_extent_update_i_size_sectors(struct btree_trans *trans,
 
        inode = bkey_i_to_inode_v3(k);
 
-       if (!(le64_to_cpu(inode->v.bi_flags) & BCH_INODE_I_SIZE_DIRTY) &&
+       if (!(le64_to_cpu(inode->v.bi_flags) & BCH_INODE_i_size_dirty) &&
            new_i_size > le64_to_cpu(inode->v.bi_size)) {
                inode->v.bi_size = cpu_to_le64(new_i_size);
                inode_update_flags = 0;