Skip to contentSkip to conversation

self healing: inode <-> dirent checks

PATCH New Kent Overstreet 1 participant 5 messages Mar 20, 2025

lore
Share & tools
lore
#0 lore raw

cover self healing: inode <-> dirent checks

there have been some sporadic reports of "dirent points to inode that does not point back" errors.

the reports I've seen look harmless after repair; no deeper corruption involved, the inode backpointer field is off and nothing else. we haven't caught it in the act yet - i.e. found the transaction in the journal that did it - but this is something self healing can cope with fine until we get it root caused.

this series takes the fsck code and adds it to the lookup path - the general strategy of self healing is "any time we've already lookup up multiple keys, check the relationships between them whenever it doesn't cost to do so".

note that self healing hasn't actually been flipped on yet; i.e. we won't be repairing outside of fsck, just running the same checks fsck does (and going ERO if they fire).

once this has been out there for a bit, we'll flip on self healing.

Kent Overstreet (4):
bcachefs: fs-common.c -> namei.c
bcachefs: Move bch2_check_dirent_target() to namei.c
bcachefs: Refactor bch2_check_dirent_target()
bcachefs: Run bch2_check_dirent_target() at lookup time

 fs/bcachefs/Makefile                 |   2 +-
 fs/bcachefs/dirent.c                 |  51 ++++++
 fs/bcachefs/dirent.h                 |   2 +
 fs/bcachefs/error.c                  |   2 +-
 fs/bcachefs/fs-ioctl.c               |   2 +-
 fs/bcachefs/fs.c                     |  34 ++--
 fs/bcachefs/fsck.c                   | 231 +--------------------------
 fs/bcachefs/inode.h                  |   1 +
 fs/bcachefs/{fs-common.c => namei.c} | 180 ++++++++++++++++++++-
 fs/bcachefs/{fs-common.h => namei.h} |  31 +++-
 fs/bcachefs/recovery.c               |   2 +-
 11 files changed, 289 insertions(+), 249 deletions(-)
 rename fs/bcachefs/{fs-common.c => namei.c} (75%)
 rename fs/bcachefs/{fs-common.h => namei.h} (61%)
Signature · 1 line
2.49.0
#1 lore raw

PATCH 1/4 bcachefs: fs-common.c -> namei.c

name <-> inode, code for managing the relationships between inodes and dirents.

---
 fs/bcachefs/Makefile                 | 2 +-
 fs/bcachefs/error.c                  | 2 +-
 fs/bcachefs/fs-ioctl.c               | 2 +-
 fs/bcachefs/fs.c                     | 2 +-
 fs/bcachefs/fsck.c                   | 2 +-
 fs/bcachefs/{fs-common.c => namei.c} | 2 +-
 fs/bcachefs/{fs-common.h => namei.h} | 6 +++---
 fs/bcachefs/recovery.c               | 2 +-
 8 files changed, 10 insertions(+), 10 deletions(-)
 rename fs/bcachefs/{fs-common.c => namei.c} (99%)
 rename fs/bcachefs/{fs-common.h => namei.h} (93%)
fs/bcachefs/Makefile +1 -1
index 1cf17a16af9f..9af65079374f 100644
@@ -41,7 +41,6 @@ bcachefs-y		:=	\
 	extent_update.o		\
 	eytzinger.o		\
 	fs.o			\
-	fs-common.o		\
 	fs-ioctl.o		\
 	fs-io.o			\
 	fs-io-buffered.o	\
@@ -64,6 +63,7 @@ bcachefs-y		:=	\
 	migrate.o		\
 	move.o			\
 	movinggc.o		\
+	namei.o			\
 	nocow_locking.o		\
 	opts.o			\
 	printbuf.o		\
fs/bcachefs/error.c +1 -1
index 6d68c89a49b2..207f35d3cce2 100644
@@ -3,8 +3,8 @@
 #include "btree_cache.h"
 #include "btree_iter.h"
 #include "error.h"
-#include "fs-common.h"
 #include "journal.h"
+#include "namei.h"
 #include "recovery_passes.h"
 #include "super.h"
 #include "thread_with_file.h"
fs/bcachefs/fs-ioctl.c +1 -1
index 5b47b94fe1ea..e3a3230fc652 100644
@@ -5,8 +5,8 @@
 #include "chardev.h"
 #include "dirent.h"
 #include "fs.h"
-#include "fs-common.h"
 #include "fs-ioctl.h"
+#include "namei.h"
 #include "quota.h"
 
 #include <linux/compat.h>
fs/bcachefs/fs.c +1 -1
index 4453dd2f888e..273078ceb4df 100644
@@ -11,7 +11,6 @@
 #include "errcode.h"
 #include "extents.h"
 #include "fs.h"
-#include "fs-common.h"
 #include "fs-io.h"
 #include "fs-ioctl.h"
 #include "fs-io-buffered.h"
@@ -22,6 +21,7 @@
 #include "io_read.h"
 #include "journal.h"
 #include "keylist.h"
+#include "namei.h"
 #include "quota.h"
 #include "rebalance.h"
 #include "snapshot.h"
fs/bcachefs/fsck.c +1 -1
index 0e85131d0af8..4271ce4a4c8c 100644
@@ -10,10 +10,10 @@
 #include "dirent.h"
 #include "error.h"
 #include "fs.h"
-#include "fs-common.h"
 #include "fsck.h"
 #include "inode.h"
 #include "keylist.h"
+#include "namei.h"
 #include "recovery_passes.h"
 #include "snapshot.h"
 #include "super.h"
fs/bcachefs/namei.c renamed from fs/bcachefs/fs-common.c +1 -1
similarity index 99%
rename from fs/bcachefs/fs-common.c
rename to fs/bcachefs/namei.c
index fbc3da59536c..bc83acbf5414 100644
@@ -4,8 +4,8 @@
 #include "acl.h"
 #include "btree_update.h"
 #include "dirent.h"
-#include "fs-common.h"
 #include "inode.h"
+#include "namei.h"
 #include "subvolume.h"
 #include "xattr.h"
 
fs/bcachefs/namei.h renamed from fs/bcachefs/fs-common.h +3 -3
similarity index 93%
rename from fs/bcachefs/fs-common.h
rename to fs/bcachefs/namei.h
index 2b59210bb5e8..7383b76270e9 100644
@@ -1,6 +1,6 @@
 /* SPDX-License-Identifier: GPL-2.0 */
-#ifndef _BCACHEFS_FS_COMMON_H
-#define _BCACHEFS_FS_COMMON_H
+#ifndef _BCACHEFS_NAMEI_H
+#define _BCACHEFS_NAMEI_H
 
 #include "dirent.h"
 
@@ -44,4 +44,4 @@ bool bch2_reinherit_attrs(struct bch_inode_unpacked *,
 
 int bch2_inum_to_path(struct btree_trans *, subvol_inum, struct printbuf *);
 
-#endif /* _BCACHEFS_FS_COMMON_H */
+#endif /* _BCACHEFS_NAMEI_H */
fs/bcachefs/recovery.c +1 -1
index a6e26733854d..266c5770c824 100644
@@ -13,12 +13,12 @@
 #include "disk_accounting.h"
 #include "errcode.h"
 #include "error.h"
-#include "fs-common.h"
 #include "journal_io.h"
 #include "journal_reclaim.h"
 #include "journal_seq_blacklist.h"
 #include "logged_ops.h"
 #include "move.h"
+#include "namei.h"
 #include "quota.h"
 #include "rebalance.h"
 #include "recovery.h"
Signature · 1 line
2.49.0
#2 lore raw

PATCH 2/4 bcachefs: Move bch2_check_dirent_target() to namei.c

In reply to Kent Overstreet

We're gradually running more and more fsck.c checks at runtime, whereever applicable; when we do so they get moved out of fsck.c.

Next patch will call bch2_check_dirent_target() from bch2_lookup().

---
 fs/bcachefs/dirent.c |  51 ++++++++++
 fs/bcachefs/dirent.h |   2 +
 fs/bcachefs/fsck.c   | 229 +------------------------------------------
 fs/bcachefs/namei.c  | 173 ++++++++++++++++++++++++++++++++
 fs/bcachefs/namei.h  |   5 +
 5 files changed, 236 insertions(+), 224 deletions(-)
fs/bcachefs/dirent.c +51 -0
index f4c283d1e86a..d7f9f79318a2 100644
@@ -729,3 +729,54 @@ int bch2_readdir(struct bch_fs *c, subvol_inum inum, struct dir_context *ctx)
 
 	return ret < 0 ? ret : 0;
 }
+
+/* fsck */
+
+static int lookup_first_inode(struct btree_trans *trans, u64 inode_nr,
+			      struct bch_inode_unpacked *inode)
+{
+	struct btree_iter iter;
+	struct bkey_s_c k;
+	int ret;
+
+	for_each_btree_key_norestart(trans, iter, BTREE_ID_inodes, POS(0, inode_nr),
+				     BTREE_ITER_all_snapshots, k, ret) {
+		if (k.k->p.offset != inode_nr)
+			break;
+		if (!bkey_is_inode(k.k))
+			continue;
+		ret = bch2_inode_unpack(k, inode);
+		goto found;
+	}
+	ret = -BCH_ERR_ENOENT_inode;
+found:
+	bch_err_msg(trans->c, ret, "fetching inode %llu", inode_nr);
+	bch2_trans_iter_exit(trans, &iter);
+	return ret;
+}
+
+int bch2_fsck_remove_dirent(struct btree_trans *trans, struct bpos pos)
+{
+	struct bch_fs *c = trans->c;
+	struct btree_iter iter;
+	struct bch_inode_unpacked dir_inode;
+	struct bch_hash_info dir_hash_info;
+	int ret;
+
+	ret = lookup_first_inode(trans, pos.inode, &dir_inode);
+	if (ret)
+		goto err;
+
+	dir_hash_info = bch2_hash_info_init(c, &dir_inode);
+
+	bch2_trans_iter_init(trans, &iter, BTREE_ID_dirents, pos, BTREE_ITER_intent);
+
+	ret =   bch2_btree_iter_traverse(&iter) ?:
+		bch2_hash_delete_at(trans, bch2_dirent_hash_desc,
+				    &dir_hash_info, &iter,
+				    BTREE_UPDATE_internal_snapshot_node);
+	bch2_trans_iter_exit(trans, &iter);
+err:
+	bch_err_fn(c, ret);
+	return ret;
+}
fs/bcachefs/dirent.h +2 -0
index a6e15a012936..0880772b80a9 100644
@@ -82,4 +82,6 @@ int bch2_empty_dir_snapshot(struct btree_trans *, u64, u32, u32);
 int bch2_empty_dir_trans(struct btree_trans *, subvol_inum);
 int bch2_readdir(struct bch_fs *, subvol_inum, struct dir_context *);
 
+int bch2_fsck_remove_dirent(struct btree_trans *, struct bpos);
+
 #endif /* _BCACHEFS_DIRENT_H */
fs/bcachefs/fsck.c +5 -224

282 lines not on this page · raw message

fs/bcachefs/namei.c +173 -0

182 lines not on this page · raw message

fs/bcachefs/namei.h +5 -0
index 7383b76270e9..48a2c8cb5fa9 100644
@@ -44,4 +44,9 @@ bool bch2_reinherit_attrs(struct bch_inode_unpacked *,
 
 int bch2_inum_to_path(struct btree_trans *, subvol_inum, struct printbuf *);
 
+int bch2_check_dirent_target(struct btree_trans *,
+			     struct btree_iter *,
+			     struct bkey_s_c_dirent,
+			     struct bch_inode_unpacked *);
+
 #endif /* _BCACHEFS_NAMEI_H */
Signature · 1 line
2.49.0
#3 lore raw

PATCH 3/4 bcachefs: Refactor bch2_check_dirent_target()

In reply to Kent Overstreet

Prep work for calling bch2_check_dirent_target() from bch2_lookup().

- Add an inline wrapper, if the target and backpointer match we can skip the function call.

- We don't (yet?) want to remove the dirent we did the lookup from (when we find a directory or subvol with multiple valid dirents pointing to it), we can defer on that until later. For now, add an "are we in fsck?" parameter.

---
 fs/bcachefs/fsck.c  |   4 +-
 fs/bcachefs/inode.h |   1 +
 fs/bcachefs/namei.c | 129 +++++++++++++++++++++++---------------------
 fs/bcachefs/namei.h |  28 ++++++++--
 4 files changed, 94 insertions(+), 68 deletions(-)
fs/bcachefs/fsck.c +2 -2
index f3853b741937..091057023fc5 100644
@@ -2072,7 +2072,7 @@ static int check_dirent_to_subvol(struct btree_trans *trans, struct btree_iter *
 			goto err;
 	}
 
-	ret = bch2_check_dirent_target(trans, iter, d, &subvol_root);
+	ret = bch2_check_dirent_target(trans, iter, d, &subvol_root, true);
 	if (ret)
 		goto err;
 out:
@@ -2165,7 +2165,7 @@ static int check_dirent(struct btree_trans *trans, struct btree_iter *iter,
 		}
 
 		darray_for_each(target->inodes, i) {
-			ret = bch2_check_dirent_target(trans, iter, d, &i->inode);
+			ret = bch2_check_dirent_target(trans, iter, d, &i->inode, true);
 			if (ret)
 				goto err;
 		}
fs/bcachefs/inode.h +1 -0
index 428b9be6af34..f82cfbf460d0 100644
@@ -277,6 +277,7 @@ static inline bool bch2_inode_should_have_single_bp(struct bch_inode_unpacked *i
 	bool inode_has_bp = inode->bi_dir || inode->bi_dir_offset;
 
 	return S_ISDIR(inode->bi_mode) ||
+		inode->bi_subvol ||
 		(!inode->bi_nlink && inode_has_bp);
 }
 
fs/bcachefs/namei.c +67 -62

163 lines not on this page · raw message

fs/bcachefs/namei.h +24 -4
index 48a2c8cb5fa9..2e6f6364767f 100644
@@ -44,9 +44,29 @@ bool bch2_reinherit_attrs(struct bch_inode_unpacked *,
 
 int bch2_inum_to_path(struct btree_trans *, subvol_inum, struct printbuf *);
 
-int bch2_check_dirent_target(struct btree_trans *,
-			     struct btree_iter *,
-			     struct bkey_s_c_dirent,
-			     struct bch_inode_unpacked *);
+int __bch2_check_dirent_target(struct btree_trans *,
+			       struct btree_iter *,
+			       struct bkey_s_c_dirent,
+			       struct bch_inode_unpacked *, bool);
+
+static inline bool inode_points_to_dirent(struct bch_inode_unpacked *inode,
+					  struct bkey_s_c_dirent d)
+{
+	return  inode->bi_dir		== d.k->p.inode &&
+		inode->bi_dir_offset	== d.k->p.offset;
+}
+
+static inline int bch2_check_dirent_target(struct btree_trans *trans,
+					   struct btree_iter *dirent_iter,
+					   struct bkey_s_c_dirent d,
+					   struct bch_inode_unpacked *target,
+					   bool in_fsck)
+{
+	if (likely(inode_points_to_dirent(target, d) &&
+		   d.v->d_type == inode_d_type(target)))
+		return 0;
+
+	return __bch2_check_dirent_target(trans, dirent_iter, d, target, in_fsck);
+}
 
 #endif /* _BCACHEFS_NAMEI_H */
Signature · 1 line
2.49.0
#4 lore raw

PATCH 4/4 bcachefs: Run bch2_check_dirent_target() at lookup time

In reply to Kent Overstreet

More on the "full online self healing" project:

We now run most of the dirent <-> inode consistency checks, with repair code, at runtime - the exact same check and repair code that fsck runs.

This will allow us to repair the "dirent points to inode that does not point back" inconsistencies that have been popping up at runtime.

---
 fs/bcachefs/fs.c | 32 +++++++++++++++++---------------
 1 file changed, 17 insertions(+), 15 deletions(-)
fs/bcachefs/fs.c +17 -15
index 273078ceb4df..fbca200f7636 100644
@@ -641,7 +641,9 @@ static struct bch_inode_info *bch2_lookup_trans(struct btree_trans *trans,
 	if (ret)
 		return ERR_PTR(ret);
 
-	ret = bch2_dirent_read_target(trans, dir, bkey_s_c_to_dirent(k), &inum);
+	struct bkey_s_c_dirent d = bkey_s_c_to_dirent(k);
+
+	ret = bch2_dirent_read_target(trans, dir, d, &inum);
 	if (ret > 0)
 		ret = -ENOENT;
 	if (ret)
@@ -651,30 +653,30 @@ static struct bch_inode_info *bch2_lookup_trans(struct btree_trans *trans,
 	if (inode)
 		goto out;
 
+	/*
+	 * Note: if check/repair needs it, we commit before
+	 * bch2_inode_hash_init_insert(), as after that point we can't take a
+	 * restart - not in the top level loop with a commit_do(), like we
+	 * usually do:
+	 */
+
 	struct bch_subvolume subvol;
 	struct bch_inode_unpacked inode_u;
 	ret =   bch2_subvolume_get(trans, inum.subvol, true, &subvol) ?:
 		bch2_inode_find_by_inum_nowarn_trans(trans, inum, &inode_u) ?:
+		bch2_check_dirent_target(trans, &dirent_iter, d, &inode_u, false) ?:
+		bch2_trans_commit(trans, NULL, NULL, BCH_TRANS_COMMIT_no_enospc) ?:
 		PTR_ERR_OR_ZERO(inode = bch2_inode_hash_init_insert(trans, inum, &inode_u, &subvol));
 
+	/*
+	 * don't remove it: check_inodes might find another inode that points
+	 * back to this dirent
+	 */
 	bch2_fs_inconsistent_on(bch2_err_matches(ret, ENOENT),
 				c, "dirent to missing inode:\n  %s",
-				(bch2_bkey_val_to_text(&buf, c, k), buf.buf));
+				(bch2_bkey_val_to_text(&buf, c, d.s_c), buf.buf));
 	if (ret)
 		goto err;
-
-	/* regular files may have hardlinks: */
-	if (bch2_fs_inconsistent_on(bch2_inode_should_have_single_bp(&inode_u) &&
-				    !bkey_eq(k.k->p, POS(inode_u.bi_dir, inode_u.bi_dir_offset)),
-				    c,
-				    "dirent points to inode that does not point back:\n  %s",
-				    (bch2_bkey_val_to_text(&buf, c, k),
-				     prt_printf(&buf, "\n  "),
-				     bch2_inode_unpacked_to_text(&buf, &inode_u),
-				     buf.buf))) {
-		ret = -ENOENT;
-		goto err;
-	}
 out:
 	bch2_trans_iter_exit(trans, &dirent_iter);
 	printbuf_exit(&buf);
Signature · 1 line
2.49.0