bcachefs: bch2_inode_find_by_inum_snapshot()

Move a fsck.c helper into inode.c, eliminate some duplicate and organize
the inode lookup helpers.

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

diff --git a/fs/bcachefs/fsck.c b/fs/bcachefs/fsck.c
index 9d94d31cfec9aa2259b93508b0d7076b2dec63d5..5402c40e3697cf8ff91daf81d1ac08460668d54e 100644 (file)
--- a/fs/bcachefs/fsck.c
+++ b/fs/bcachefs/fsck.c
@@ -109,27 +109,6 @@ static int subvol_lookup(struct btree_trans *trans, u32 subvol,
        return ret;
 }
 
-static int lookup_inode(struct btree_trans *trans, u64 inode_nr, u32 snapshot,
-                       struct bch_inode_unpacked *inode)
-{
-       struct btree_iter iter;
-       struct bkey_s_c k;
-       int ret;
-
-       k = bch2_bkey_get_iter(trans, &iter, BTREE_ID_inodes,
-                              SPOS(0, inode_nr, snapshot), 0);
-       ret = bkey_err(k);
-       if (ret)
-               goto err;
-
-       ret = bkey_is_inode(k.k)
-               ? bch2_inode_unpack(k, inode)
-               : -BCH_ERR_ENOENT_inode;
-err:
-       bch2_trans_iter_exit(trans, &iter);
-       return ret;
-}
-
 static int lookup_dirent_in_snapshot(struct btree_trans *trans,
                           struct bch_hash_info hash_info,
                           subvol_inum dir, struct qstr *name,
@@ -231,7 +210,7 @@ static int lookup_lostfound(struct btree_trans *trans, u32 snapshot,
 
        struct bch_inode_unpacked root_inode;
        struct bch_hash_info root_hash_info;
-       ret = lookup_inode(trans, root_inum.inum, snapshot, &root_inode);
+       ret = bch2_inode_find_by_inum_snapshot(trans, root_inum.inum, snapshot, &root_inode, 0);
        bch_err_msg(c, ret, "looking up root inode %llu for subvol %u",
                    root_inum.inum, subvolid);
        if (ret)
@@ -257,7 +236,7 @@ static int lookup_lostfound(struct btree_trans *trans, u32 snapshot,
         * The bch2_check_dirents pass has already run, dangling dirents
         * shouldn't exist here:
         */
-       ret = lookup_inode(trans, inum, snapshot, lostfound);
+       ret = bch2_inode_find_by_inum_snapshot(trans, inum, snapshot, lostfound, 0);
        bch_err_msg(c, ret, "looking up lost+found %llu:%u in (root inode %llu, snapshot root %u)",
                    inum, snapshot, root_inum.inum, bch2_snapshot_root(c, snapshot));
        return ret;
@@ -2117,7 +2096,8 @@ static int check_dirent_to_subvol(struct btree_trans *trans, struct btree_iter *
        u64 target_inum = le64_to_cpu(s.v->inode);
        u32 target_snapshot = le32_to_cpu(s.v->snapshot);
 
-       ret = lookup_inode(trans, target_inum, target_snapshot, &subvol_root);
+       ret = bch2_inode_find_by_inum_snapshot(trans, target_inum, target_snapshot,
+                                              &subvol_root, 0);
        if (ret && !bch2_err_matches(ret, ENOENT))
                goto err;
 
@@ -2434,7 +2414,8 @@ static int check_root_trans(struct btree_trans *trans)
                        goto err;
        }
 
-       ret = lookup_inode(trans, BCACHEFS_ROOT_INO, snapshot, &root_inode);
+       ret = bch2_inode_find_by_inum_snapshot(trans, BCACHEFS_ROOT_INO, snapshot,
+                                              &root_inode, 0);
        if (ret && !bch2_err_matches(ret, ENOENT))
                return ret;
 

diff --git a/fs/bcachefs/inode.c b/fs/bcachefs/inode.c
index ee00805078558362c5872e11c3a1edf3262b371f..13c1e9df252a14c11afc772095cb72a92a22ff19 100644 (file)
--- a/fs/bcachefs/inode.c
+++ b/fs/bcachefs/inode.c
@@ -367,6 +367,82 @@ err:
        return ret;
 }
 
+int bch2_inode_find_by_inum_snapshot(struct btree_trans *trans,
+                                           u64 inode_nr, u32 snapshot,
+                                           struct bch_inode_unpacked *inode,
+                                           unsigned flags)
+{
+       struct btree_iter iter;
+       struct bkey_s_c k = bch2_bkey_get_iter(trans, &iter, BTREE_ID_inodes,
+                                              SPOS(0, inode_nr, snapshot), flags);
+       int ret = bkey_err(k);
+       if (ret)
+               goto err;
+
+       ret = bkey_is_inode(k.k)
+               ? bch2_inode_unpack(k, inode)
+               : -BCH_ERR_ENOENT_inode;
+err:
+       bch2_trans_iter_exit(trans, &iter);
+       return ret;
+}
+
+int bch2_inode_find_by_inum_nowarn_trans(struct btree_trans *trans,
+                                 subvol_inum inum,
+                                 struct bch_inode_unpacked *inode)
+{
+       struct btree_iter iter;
+       int ret;
+
+       ret = bch2_inode_peek_nowarn(trans, &iter, inode, inum, 0);
+       if (!ret)
+               bch2_trans_iter_exit(trans, &iter);
+       return ret;
+}
+
+int bch2_inode_find_by_inum_trans(struct btree_trans *trans,
+                                 subvol_inum inum,
+                                 struct bch_inode_unpacked *inode)
+{
+       struct btree_iter iter;
+       int ret;
+
+       ret = bch2_inode_peek(trans, &iter, inode, inum, 0);
+       if (!ret)
+               bch2_trans_iter_exit(trans, &iter);
+       return ret;
+}
+
+int bch2_inode_find_by_inum(struct bch_fs *c, subvol_inum inum,
+                           struct bch_inode_unpacked *inode)
+{
+       return bch2_trans_do(c, bch2_inode_find_by_inum_trans(trans, inum, inode));
+}
+
+int bch2_inode_find_snapshot_root(struct btree_trans *trans, u64 inum,
+                                 struct bch_inode_unpacked *root)
+{
+       struct btree_iter iter;
+       struct bkey_s_c k;
+       int ret = 0;
+
+       for_each_btree_key_reverse_norestart(trans, iter, BTREE_ID_inodes,
+                                            SPOS(0, inum, U32_MAX),
+                                            BTREE_ITER_all_snapshots, k, ret) {
+               if (k.k->p.offset != inum)
+                       break;
+               if (bkey_is_inode(k.k)) {
+                       ret = bch2_inode_unpack(k, root);
+                       goto out;
+               }
+       }
+       /* We're only called when we know we have an inode for @inum */
+       BUG_ON(!ret);
+out:
+       bch2_trans_iter_exit(trans, &iter);
+       return ret;
+}
+
 int bch2_inode_write_flags(struct btree_trans *trans,
                     struct btree_iter *iter,
                     struct bch_inode_unpacked *inode,
@@ -1102,62 +1178,6 @@ err2:
        return ret;
 }
 
-int bch2_inode_find_by_inum_nowarn_trans(struct btree_trans *trans,
-                                 subvol_inum inum,
-                                 struct bch_inode_unpacked *inode)
-{
-       struct btree_iter iter;
-       int ret;
-
-       ret = bch2_inode_peek_nowarn(trans, &iter, inode, inum, 0);
-       if (!ret)
-               bch2_trans_iter_exit(trans, &iter);
-       return ret;
-}
-
-int bch2_inode_find_by_inum_trans(struct btree_trans *trans,
-                                 subvol_inum inum,
-                                 struct bch_inode_unpacked *inode)
-{
-       struct btree_iter iter;
-       int ret;
-
-       ret = bch2_inode_peek(trans, &iter, inode, inum, 0);
-       if (!ret)
-               bch2_trans_iter_exit(trans, &iter);
-       return ret;
-}
-
-int bch2_inode_find_by_inum(struct bch_fs *c, subvol_inum inum,
-                           struct bch_inode_unpacked *inode)
-{
-       return bch2_trans_do(c, bch2_inode_find_by_inum_trans(trans, inum, inode));
-}
-
-int bch2_inode_find_snapshot_root(struct btree_trans *trans, u64 inum,
-                                 struct bch_inode_unpacked *root)
-{
-       struct btree_iter iter;
-       struct bkey_s_c k;
-       int ret = 0;
-
-       for_each_btree_key_reverse_norestart(trans, iter, BTREE_ID_inodes,
-                                            SPOS(0, inum, U32_MAX),
-                                            BTREE_ITER_all_snapshots, k, ret) {
-               if (k.k->p.offset != inum)
-                       break;
-               if (bkey_is_inode(k.k)) {
-                       ret = bch2_inode_unpack(k, root);
-                       goto out;
-               }
-       }
-       /* We're only called when we know we have an inode for @inum */
-       BUG_ON(!ret);
-out:
-       bch2_trans_iter_exit(trans, &iter);
-       return ret;
-}
-
 int bch2_inode_nlink_inc(struct bch_inode_unpacked *bi)
 {
        if (bi->bi_flags & BCH_INODE_unlinked)

diff --git a/fs/bcachefs/inode.h b/fs/bcachefs/inode.h
index bf6624aadc56a6809def979772552e5fb9726937..c31567c09b8a356b7b7fa857702ed3f9c81add31 100644 (file)
--- a/fs/bcachefs/inode.h
+++ b/fs/bcachefs/inode.h
@@ -134,10 +134,21 @@ static inline int bch2_inode_peek(struct btree_trans *trans,
                                  subvol_inum inum, unsigned flags)
 {
        return __bch2_inode_peek(trans, iter, inode, inum, flags, true);
-       int ret = bch2_inode_peek_nowarn(trans, iter, inode, inum, flags);
-       return ret;
 }
 
+int bch2_inode_find_by_inum_snapshot(struct btree_trans *, u64, u32,
+                                    struct bch_inode_unpacked *, unsigned);
+int bch2_inode_find_by_inum_nowarn_trans(struct btree_trans *,
+                                 subvol_inum,
+                                 struct bch_inode_unpacked *);
+int bch2_inode_find_by_inum_trans(struct btree_trans *, subvol_inum,
+                                 struct bch_inode_unpacked *);
+int bch2_inode_find_by_inum(struct bch_fs *, subvol_inum,
+                           struct bch_inode_unpacked *);
+
+int bch2_inode_find_snapshot_root(struct btree_trans *trans, u64 inum,
+                                 struct bch_inode_unpacked *root);
+
 int bch2_inode_write_flags(struct btree_trans *, struct btree_iter *,
                     struct bch_inode_unpacked *, enum btree_iter_update_trigger_flags);
 
@@ -165,17 +176,6 @@ int bch2_inode_create(struct btree_trans *, struct btree_iter *,
 
 int bch2_inode_rm(struct bch_fs *, subvol_inum);
 
-int bch2_inode_find_by_inum_nowarn_trans(struct btree_trans *,
-                                 subvol_inum,
-                                 struct bch_inode_unpacked *);
-int bch2_inode_find_by_inum_trans(struct btree_trans *, subvol_inum,
-                                 struct bch_inode_unpacked *);
-int bch2_inode_find_by_inum(struct bch_fs *, subvol_inum,
-                           struct bch_inode_unpacked *);
-
-int bch2_inode_find_snapshot_root(struct btree_trans *trans, u64 inum,
-                                 struct bch_inode_unpacked *root);
-
 #define inode_opt_get(_c, _inode, _name)                       \
        ((_inode)->bi_##_name ? (_inode)->bi_##_name - 1 : (_c)->opts._name)
 
@@ -248,7 +248,7 @@ static inline unsigned bkey_inode_mode(struct bkey_s_c k)
 
 static inline bool bch2_inode_casefold(struct bch_fs *c, const struct bch_inode_unpacked *bi)
 {
-       /* inode apts are stored with a +1 bias: 0 means "unset, use fs opt" */
+       /* inode opts are stored with a +1 bias: 0 means "unset, use fs opt" */
        return bi->bi_casefold
                ? bi->bi_casefold - 1
                : c->opts.casefold;