xfs: the rest of online repair part 1
Subsystems (3)
PATCH 1/4 xfs: the rest of online repair part 1
Hi everyone,
In last year's NYE deluges, I mentioned that I wanted to get online repair merged for the 2023 LTS kernel. That goal was not attained, so now I want to get this merged in time for the 2024 LTS kernel.
(Big thanks to Dave earlier for helping to get all 120 scrub fixes merged; and Christoph more recently for doing the same for the first 30 patches of repair and a bunch of rt refactorings from the modernization series.)
But seriously, folks, this is dragging on unnecessarily. Either you all need to step up and actually review the 55 patchsets and 458 patches needed to get online repair done, or decide to let me merge it and deal with the consequences, which I will. The only part of this deluge that changes the ondisk format are the swapext patches that add a new log intent item type. Everything else is guarded by Kconfig options and won't destabilize the rest of the filesystem. I haven't changed the swapext log intent item format since 2021. 2+ years to get feedback is dysfunctional.
In the meantime, lack of upstream merging means that I cannot start wider testing of this code with the people who run (b)leading edge XFS code; I cannot solicit user and customer feedback because they don't have the code; and there's no way I can meaningfully prioritize improvements to the code because **I cannot get feedback**.
Fuzz and stress testing of online repairs have been running well for two years now. As of this writing, online repair can fix more things than offline repair, and the fsstress+repair long soak test has passed 300 million repairs with zero problems observed.
(For comparison, the long soak fsx test recently passed 110 billion file operations, so online fsck has a ways to go...)
--D
PATCH 1/28 xfs: live inode scans for online fsck
Hi all,
The design document discusses the need for a specialized inode scan cursor to manage walking every file on a live filesystem to build replacement metadata objects while receiving updates about the files already scanned. This series adds three pieces of infrastructure -- the scan cursor, live hooks to deliver information about updates going on in other parts of the filesystem, and then adds a batching mechanism to amortize AGI lookups over a batch of inodes to improve performance.
If you're going to start using this code, I strongly recommend pulling from my git trees, which are linked below.
This has been running on the djcloud for months with no problems. Enjoy! Comments and questions are, as always, welcome.
--D
kernel git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfs-linux.git/log/?h=scrub-iscan
--- fs/xfs/Kconfig | 36 ++ fs/xfs/Makefile | 2 fs/xfs/scrub/iscan.c | 738 ++++++++++++++++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/iscan.h | 81 +++++ fs/xfs/scrub/trace.c | 1 fs/xfs/scrub/trace.h | 145 ++++++++++ fs/xfs/xfs_hooks.c | 94 ++++++ fs/xfs/xfs_hooks.h | 72 +++++ fs/xfs/xfs_iwalk.c | 13 - fs/xfs/xfs_linux.h | 1 10 files changed, 1172 insertions(+), 11 deletions(-) create mode 100644 fs/xfs/scrub/iscan.c create mode 100644 fs/xfs/scrub/iscan.h create mode 100644 fs/xfs/xfs_hooks.c create mode 100644 fs/xfs/xfs_hooks.h
PATCH 1/7 xfs: speed up xfs_iwalk_adjust_start a little bit
From: Darrick J. Wong <[email protected]>
Replace the open-coded loop that recomputes freecount with a single call to a bit weight function.
--- fs/xfs/xfs_iwalk.c | 13 ++----------- 1 file changed, 2 insertions(+), 11 deletions(-)
fs/xfs/xfs_iwalk.c +2 -11
@@ -22,6 +22,7 @@#include "xfs_trans.h" #include "xfs_pwork.h" #include "xfs_ag.h" +#include "xfs_bit.h" /* * Walking Inodes in the Filesystem
@@ -131,21 +132,11 @@ xfs_iwalk_adjust_start( struct xfs_inobt_rec_incore *irec) /* btree record */ {int idx;/* index into inode chunk */ -int i; idx = agino - irec->ir_startino; -/* -* We got a right chunk with some left inodes allocated at it. Grab -* the chunk record. Mark all the uninteresting inodes free because -* they're before our start point. -*/ -for (i =0 ; i < idx; i++) { -if (XFS_INOBT_MASK (i) & ~irec->ir_free) - irec->ir_freecount++; - } - irec->ir_free |=xfs_inobt_maskn (0 , idx); + irec->ir_freecount =hweight64 (irec->ir_free); }/* Allocate memory for a walk. */
Re: [PATCH 1/7] xfs: speed up xfs_iwalk_adjust_start a little bit
Quoted 4 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Replace the open-coded loop that recomputes freecount with a single call to a bit weight function.
Looks good:
PATCH 2/7 xfs: implement live inode scan for scrub
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
This patch implements a live file scanner for online fsck functions that require the ability to walk a filesystem to gather metadata records and stay informed about metadata changes to files that have already been visited.
The iscan structure consists of two inode number cursors: one to track which inode we want to visit next, and a second one to track which inodes have already been visited. This second cursor is key to capturing live updates to files previously scanned while the main thread continues scanning -- any inode greater than this value hasn't been scanned and can go on its way; any other update must be incorporated into the collected data. It is critical for the scanning thraad to hold exclusive access on the inode until after marking the inode visited.
This new code is a separate patch from the patchsets adding callers for the sake of enabling the author to move patches around his tree with ease. The intended usage model for this code is roughly:
xchk_iscan_start(iscan, 0, 0);
while ((error = xchk_iscan_iter(sc, iscan, &ip)) == 1) {
xfs_ilock(ip, ...);
/* capture inode metadata */
xchk_iscan_mark_visited(iscan, ip);
xfs_iunlock(ip, ...);
xfs_irele(ip);
}
xchk_iscan_stop(iscan);
if (error)
return error;Hook functions for live updates can then do:
if (xchk_iscan_want_live_update(...)) /* update the captured inode metadata */
--- fs/xfs/Makefile | 1 fs/xfs/scrub/iscan.c | 485 ++++++++++++++++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/iscan.h | 63 ++++++ fs/xfs/scrub/trace.c | 1 fs/xfs/scrub/trace.h | 106 +++++++++++ 5 files changed, 656 insertions(+) create mode 100644 fs/xfs/scrub/iscan.c create mode 100644 fs/xfs/scrub/iscan.h
fs/xfs/Makefile +1 -0
@@ -159,6 +159,7 @@ xfs-y += $(addprefix scrub/, \ health.o \ ialloc.o \ inode.o \ + iscan.o \ parent.o \ readdir.o \ refcount.o \
fs/xfs/scrub/iscan.c new file +485 -0
485 lines not on this page · raw message
fs/xfs/scrub/iscan.h new file +63 -0
63 lines not on this page · raw message
fs/xfs/scrub/trace.c +1 -0
@@ -20,6 +20,7 @@#include "scrub/xfile.h" #include "scrub/xfarray.h" #include "scrub/quota.h" +#include "scrub/iscan.h" /* Figure out which block the btree cursor was pointing to. */ static inline xfs_fsblock_t
fs/xfs/scrub/trace.h +106 -0
122 lines not on this page · raw message
Re: [PATCH 2/7] xfs: implement live inode scan for scrub
fs/xfs/scrub/iscan.c line 342
Quoted 4 lines
fs/xfs/scrub/iscan.c new file +4
-0+trace_xchk_iscan_iget (iscan, error); + +if (error == -ENOENT || error == -EAGAIN ) { +/*¬
This has a weird character on the opening comment line.
Otherwise looks good:
PATCH 3/7 xfs: allow scrub to hook metadata updates in other writers
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Certain types of filesystem metadata can only be checked by scanning every file in the entire filesystem. Specific examples of this include quota counts, file link counts, and reverse mappings of file extents. Directory and parent pointer reconstruction may also fall into this category. File scanning is much trickier than scanning AG metadata because we have to take inode locks in the same order as the rest of [VX]FS, we can't be holding buffer locks when we do that, and scanning the whole filesystem takes time.
Earlier versions of the online repair patchset relied heavily on fsfreeze as a means to quiesce the filesystem so that we could take locks in the proper order without worrying about concurrent updates from other writers. Reviewers of those patches opined that freezing the entire fs to check and repair something was not sufficiently better than unmounting to run fsck offline. I don't agree with that 100%, but the message was clear: find a way to repair things that minimizes the quiet period where nobody can write to the filesystem.
Generally, building btree indexes online can be split into two phases: a collection phase where we compute the records that will be put into the new btree; and a construction phase, where we construct the physical btree blocks and persist them. While it's simple to hold resource locks for the entirety of the two phases to ensure that the new index is consistent with the rest of the system, we don't need to hold resource locks during the collection phase if we have a means to receive live updates of other work going on elsewhere in the system.
The goal of this patch, then, is to enable online fsck to learn about metadata updates going on in other threads while it constructs a shadow copy of the metadata records to verify or correct the real metadata. To minimize the overhead when online fsck isn't running, we use srcu notifiers because they prioritize fast access to the notifier call chain (particularly when the chain is empty) at a cost to configuring notifiers. Online fsck should be relatively infrequent, so this is acceptable.
The intended usage model is fairly simple. Code that modifies a metadata structure of interest should declare a xfs_hook_chain structure in some well defined place, and call xfs_hook_call whenever an update happens. Online fsck code should define a struct notifier_block and use xfs_hook_add to attach the block to the chain, along with a function to be called. This function should synchronize with the fsck scanner to update whatever in-memory data the scanner is collecting. When finished, xfs_hook_del removes the notifier from the list and waits for them all to complete.
On the author's computer, calling an empty srcu notifier chain was observed to have an overhead averaging ~40ns with a maximum of 60ns. Adding a no-op notifier function increased the average to ~58ns and 66ns. When the quotacheck live update notifier is attached, the average increases to ~322ns with a max of 372ns to update scrub's in-memory observation data, assuming no lock contention.
With jump labels enabled, calls to empty srcu notifier chains are elided from the call sites when there are no hooks registered, which means that the overhead is 0.36ns when fsck is not running. For compilers that do not support jump labels (all major architectures do), the overhead of a no-op notifier call is less bad (on a many-cpu system) than the atomic counter ops, so we make the hook switch itself a nop.
Note: This new code is also split out as a separate patch from its initial user so that the author can move patches around his tree with ease.
--- fs/xfs/Kconfig | 5 ++++ fs/xfs/Makefile | 1 + fs/xfs/xfs_hooks.c | 53 +++++++++++++++++++++++++++++++++++++++++ fs/xfs/xfs_hooks.h | 68 ++++++++++++++++++++++++++++++++++++++++++++++++++++ fs/xfs/xfs_linux.h | 1 + 5 files changed, 128 insertions(+) create mode 100644 fs/xfs/xfs_hooks.c create mode 100644 fs/xfs/xfs_hooks.h
fs/xfs/Kconfig +5 -0
@@ -124,11 +124,16 @@ config XFS_DRAIN_INTENTS bool select JUMP_LABEL if HAVE_ARCH_JUMP_LABEL +config XFS_LIVE_HOOKS + bool + select JUMP_LABEL if HAVE_ARCH_JUMP_LABEL + config XFS_ONLINE_SCRUB bool "XFS online metadata check support" default n depends on XFS_FS depends on TMPFS && SHMEM + select XFS_LIVE_HOOKS select XFS_DRAIN_INTENTS help If you say Y here you will be able to check metadata on a
fs/xfs/Makefile +1 -0
@@ -137,6 +137,7 @@ xfs-$(CONFIG_FS_DAX) += xfs_notify_failure.o endif xfs-$(CONFIG_XFS_DRAIN_INTENTS) += xfs_drain.o +xfs-$(CONFIG_XFS_LIVE_HOOKS) += xfs_hooks.o # online scrub/repair ifeq ($(CONFIG_XFS_ONLINE_SCRUB),y)
fs/xfs/xfs_hooks.c new file +53 -0
53 lines not on this page · raw message
fs/xfs/xfs_hooks.h new file +68 -0
68 lines not on this page · raw message
fs/xfs/xfs_linux.h +1 -0
@@ -82,6 +82,7 @@ typedef __u32 xfs_nlink_t;#include "xfs_buf.h" #include "xfs_message.h" #include "xfs_drain.h" +#include "xfs_hooks.h" #ifdef __BIG_ENDIAN#define XFS_NATIVE_HOST 1
Re: [PATCH 3/7] xfs: allow scrub to hook metadata updates in other writers
Quoted 7 lines · Darrick J. Wong
On the author's computer, calling an empty srcu notifier chain was observed to have an overhead averaging ~40ns with a maximum of 60ns. Adding a no-op notifier function increased the average to ~58ns and 66ns. When the quotacheck live update notifier is attached, the average increases to ~322ns with a max of 372ns to update scrub's in-memory observation data, assuming no lock contention.
Quoted 6 lines
With jump labels enabled, calls to empty srcu notifier chains are elided from the call sites when there are no hooks registered, which means that the overhead is 0.36ns when fsck is not running. For compilers that do not support jump labels (all major architectures do), the overhead of a no-op notifier call is less bad (on a many-cpu system) than the atomic counter ops, so we make the hook switch itself a nop.
Based on the next patch it seems like blocking notifier are the way to go and thus this patch should switch to using them and the above needs updates.
Quoted 3 lines
Note: This new code is also split out as a separate patch from its initial user so that the author can move patches around his tree with ease.
For the final merge candidate at least this comment should go away, and maybe also the split..
fs/xfs/Kconfig config XFS_DRAIN_INTENTS · line 137
Quoted 11 lines
fs/xfs/Kconfig +5
-0+config XFS_LIVE_HOOKS + bool + select JUMP_LABEL if HAVE_ARCH_JUMP_LABEL + config XFS_ONLINE_SCRUB bool "XFS online metadata check support" default n depends on XFS_FS depends on TMPFS && SHMEM + select XFS_LIVE_HOOKS select XFS_DRAIN_INTENTS
I'm a bit confused by all the extra Kconfig options here. Why do we need XFS_LIVE_HOOKS, or the existing XFS_DRAIN_INTENTS instead of just switching the ifdefs to XFS_ONLINE_SCRUB and selecting JUMP_LABEL if HAVE_ARCH_JUMP_LABEL from XFS_ONLINE_SCRUB?
Also while I'm at random Kconfig critique, n is the default default and the default n here can be dropped. I might just send a patch for that instead of bothering you once this series is in, though.
Otherwise this looks good except for the choice of which notifier type to use.
Re: [PATCH 3/7] xfs: allow scrub to hook metadata updates in other writers
Quoted 15 lines · Christoph Hellwig
Quoted 7 lines · Darrick J. Wong
On the author's computer, calling an empty srcu notifier chain was observed to have an overhead averaging ~40ns with a maximum of 60ns. Adding a no-op notifier function increased the average to ~58ns and 66ns. When the quotacheck live update notifier is attached, the average increases to ~322ns with a max of 372ns to update scrub's in-memory observation data, assuming no lock contention.
Quoted 6 lines
With jump labels enabled, calls to empty srcu notifier chains are elided from the call sites when there are no hooks registered, which means that the overhead is 0.36ns when fsck is not running. For compilers that do not support jump labels (all major architectures do), the overhead of a no-op notifier call is less bad (on a many-cpu system) than the atomic counter ops, so we make the hook switch itself a nop.
Quoted 3 lines
Based on the next patch it seems like blocking notifier are the way to go and thus this patch should switch to using them and the above needs updates.
I'll address the srcu vs. blocking choice in the thread for the next patch.
Quoted 16 lines
Quoted 3 lines
Note: This new code is also split out as a separate patch from its initial user so that the author can move patches around his tree with ease.
For the final merge candidate at least this comment should go away, and maybe also the split..
Quoted 9 lines
fs/xfs/Kconfig +4
-0+config XFS_LIVE_HOOKS + bool + select JUMP_LABEL if HAVE_ARCH_JUMP_LABEL + config XFS_ONLINE_SCRUB bool "XFS online metadata check support" default n depends on XFS_FS depends on TMPFS && SHMEM
Quoted 8 lines
fs/xfs/Kconfig config XFS_DRAIN_INTENTS · line 137
Quoted 2 lines
fs/xfs/Kconfig +1
-0+ select XFS_LIVE_HOOKS select XFS_DRAIN_INTENTSI'm a bit confused by all the extra
Kconfigoptions here. Why do we needXFS_LIVE_HOOKS, or the existingXFS_DRAIN_INTENTSinstead of just switching the ifdefs toXFS_ONLINE_SCRUBand selectingJUMP_LABELifHAVE_ARCH_JUMP_LABELfromXFS_ONLINE_SCRUB?
I have plans to use the live hooks for more than just online scrub. If we ever get around to reimplementing xfs_reno (see patchriver #4 for a somewhat racy userspace version) in the kernel, it would be helpful for reno to be able to keep an eye on any other directory link changes while we're trying to renumber things.
As for DRAIN_INTENTS, userspace takes advantage of some of the XFS_ONLINE_SCRUB code but doesn't need the intent drain because libxfs isn't properly multithreaded.
Quoted 3 lines
Also while I'm at random
Kconfigcritique, n is the default default and the default n here can be dropped. I might just send a patch for that instead of bothering you once this series is in, though.
You could even send it now; I don't think there's much chance that Chandan will merge this patchset for 6.8, whereas I think the kconfig cleanup would be fine for the merge window.
Quoted 2 lines
Otherwise this looks good except for the choice of which notifier type to use.
<nod>
--D
PATCH 4/7 xfs: allow blocking notifier chains with filesystem hooks
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Make it so that we can switch between notifier chain implementations for testing purposes. On the author's test system, calling an empty srcu notifier chain cost about 19ns per call, vs. 4ns for a blocking notifier chain. Hm. Might we actually want regular blocking notifiers?
--- fs/xfs/Kconfig | 31 +++++++++++++++++++++++++++++++ fs/xfs/xfs_hooks.c | 41 +++++++++++++++++++++++++++++++++++++++++ fs/xfs/xfs_hooks.h | 6 +++++- 3 files changed, 77 insertions(+), 1 deletion(-)
fs/xfs/Kconfig +31 -0
@@ -165,6 +165,37 @@ config XFS_ONLINE_SCRUB_STATS If unsure, say N. +choice + prompt "XFS hook implementation" + depends on XFS_FS && XFS_LIVE_HOOKS && XFS_ONLINE_SCRUB + default XFS_LIVE_HOOKS_BLOCKING if HAVE_ARCH_JUMP_LABEL + default XFS_LIVE_HOOKS_SRCU if !HAVE_ARCH_JUMP_LABEL + help + Pick one + +config XFS_LIVE_HOOKS_SRCU + bool "SRCU notifier chains" + help + Use SRCU notifier chains for filesystem hooks. These have very low + overhead for event initiators (the main filesystem) and higher + overhead for chain modifiers (scrub waits for RCU grace). This is + the best option when jump labels are not supported or there are many + CPUs in the system. + + This may cause problems with CPU hotplug invoking reclaim invoking + XFS. + +config XFS_LIVE_HOOKS_BLOCKING + bool "Blocking notifier chains" + help + Use blocking notifier chains for filesystem hooks. These have medium + overhead for event initiators (the main fs) and chain modifiers + (scrub) due to their use of rwsems. This is the best option when + jump labels can be used to eliminate overhead for the filesystem when + scrub is not running. + +endchoice + config XFS_ONLINE_REPAIR bool "XFS online metadata repair support" default n
fs/xfs/xfs_hooks.c +41 -0
50 lines not on this page · raw message
fs/xfs/xfs_hooks.h +5 -1
@@ -6,10 +6,14 @@#ifndef XFS_HOOKS_H_ #define XFS_HOOKS_H_ -#ifdef CONFIG_XFS_LIVE_HOOKS +#if defined(CONFIG_XFS_LIVE_HOOKS_SRCU )struct xfs_hooks {struct srcu_notifier_head head; }; +#elif defined(CONFIG_XFS_LIVE_HOOKS_BLOCKING ) +struct xfs_hooks { +struct blocking_notifier_head head; +};#else struct xfs_hooks {/* empty */ };#endif
Re: [PATCH 4/7] xfs: allow blocking notifier chains with filesystem hooks
Quoted 6 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Make it so that we can switch between notifier chain implementations for testing purposes. On the author's test system, calling an empty srcu notifier chain cost about 19ns per call, vs. 4ns for a blocking notifier chain. Hm. Might we actually want regular blocking notifiers?
Sounds like it. But what is important is that we really shouldn't provide both and punt the decision to the user..
Re: [PATCH 4/7] xfs: allow blocking notifier chains with filesystem hooks
Quoted 10 lines · Christoph Hellwig
Quoted 6 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Make it so that we can switch between notifier chain implementations for testing purposes. On the author's test system, calling an empty srcu notifier chain cost about 19ns per call, vs. 4ns for a blocking notifier chain. Hm. Might we actually want regular blocking notifiers?
Sounds like it. But what is important is that we really shouldn't provide both and punt the decision to the user..
How about this for a commit message:
"Originally, I selected srcu notifiers to implement live hooks because they seemed to have fewer impacts to scalability. The per-call cost of srcu_notifier_call_chain is lower (19ns) than blocking_notifier_ (4ns), but the latter takes an rwsem. IIRC, rwsems have scalability problems when the cpu count gets high due to all the cacheline bouncing and atomic operations. I didn't want regular xfs operations to suffer memory contention on the blocking notifiers for the sake of something that won't be running most of the time.
"Therefore, I stuck with srcu notifiers, despite trading off single threaded performance for multithreaded performance. I wasn't thrilled with the very high teardown time for srcu notifiers, since the caller has to wait for the next rcu grace period.
"Then I discovered static branches.
"Now suddenly I had a tool to reduce the pain of a high-contention rwsem to zero except in the case where scrub is running. This seemed a lot better to me -- zero runtime overhead when scrub is not running; low setup and teardown overhead for scrub; and cacheline bouncing problems only when there are a lot of threads running through the notifier call code *and* scrub is running.
"This seems perfect, but static branches aren't supported on all the architectures that Linux supports. Further, I haven't really tested the impacts of scrub on big iron. This makes me hesitant to get rid of the SRCU notifier implementation while online fsck is still experimental.
"Note that Kconfig automatically selects the best option for a particular architecture. Kernel builders should take the defaults."
I dunno. Do you want me to rip out the srcu implementation and only provide the blocking notifiers? That's easy to do, though hard to undo once I've done it.
Hmm. How many arches support static branches today?
$ grep HAVE_ARCH_JUMP_LABEL arch/ arch/arc/Kconfig:52: select HAVE_ARCH_JUMP_LABEL if ISA_ARCV2 && !CPU_ENDIAN_BE32 arch/arm/Kconfig:77: select HAVE_ARCH_JUMP_LABEL if !XIP_KERNEL && !CPU_ENDIAN_BE32 && MMU arch/arm64/Kconfig:163: select HAVE_ARCH_JUMP_LABEL arch/arm64/Kconfig:164: select HAVE_ARCH_JUMP_LABEL_RELATIVE arch/csky/Kconfig:71: select HAVE_ARCH_JUMP_LABEL if !CPU_CK610 arch/csky/Kconfig:72: select HAVE_ARCH_JUMP_LABEL_RELATIVE arch/mips/Kconfig:53: select HAVE_ARCH_JUMP_LABEL arch/parisc/Kconfig:60: select HAVE_ARCH_JUMP_LABEL arch/parisc/Kconfig:61: select HAVE_ARCH_JUMP_LABEL_RELATIVE arch/powerpc/Kconfig:212: select HAVE_ARCH_JUMP_LABEL arch/powerpc/Kconfig:213: select HAVE_ARCH_JUMP_LABEL_RELATIVE arch/riscv/Kconfig:96: select HAVE_ARCH_JUMP_LABEL if !XIP_KERNEL arch/riscv/Kconfig:97: select HAVE_ARCH_JUMP_LABEL_RELATIVE if !XIP_KERNEL arch/s390/Kconfig:151: select HAVE_ARCH_JUMP_LABEL arch/s390/Kconfig:152: select HAVE_ARCH_JUMP_LABEL_RELATIVE arch/sparc/Kconfig:31: select HAVE_ARCH_JUMP_LABEL if SPARC64 arch/x86/Kconfig:176: select HAVE_ARCH_JUMP_LABEL arch/x86/Kconfig:177: select HAVE_ARCH_JUMP_LABEL_RELATIVE arch/xtensa/Kconfig:33: select HAVE_ARCH_JUMP_LABEL if !XIP_KERNEL arch/loongarch/Kconfig:94: select HAVE_ARCH_JUMP_LABEL arch/loongarch/Kconfig:95: select HAVE_ARCH_JUMP_LABEL_RELATIVE
The main arches that xfs really cares about are arm64, ppc64, riscv, s390x, and x86_64, right? Perhaps there's a stronger case for only providing blocking notifiers and jump labels since there aren't many m68k xfs users, right?
--D
Re: [PATCH 4/7] xfs: allow blocking notifier chains with filesystem hooks
Quoted 4 lines · Darrick J. Wong
The main arches that xfs really cares about are arm64, ppc64, riscv, s390x, and
x86_64, right? Perhaps there's a stronger case for only providing blocking notifiers and jump labels since there aren't many m68k xfs users, right?
Yes. And if there are m68k xfs users, they are even more unlikely to run with online repair enabled as they'd be very memory constrained.
So I suspect always using blocking notifiers would be best to keep the complexity down. In fact I suspect we should simply make online repair depend on jump labels instead of selecting it when available to remove anoher rarely tested build combination.
Re: [PATCH 4/7] xfs: allow blocking notifier chains with filesystem hooks
Quoted 6 lines · Christoph Hellwig
Quoted 4 lines · Darrick J. Wong
The main arches that xfs really cares about are arm64, ppc64, riscv, s390x, and
x86_64, right? Perhaps there's a stronger case for only providing blocking notifiers and jump labels since there aren't many m68k xfs users, right?
Quoted 7 lines
Yes. And if there are m68k xfs users, they are even more unlikely to run with online repair enabled as they'd be very memory constrained.
So I suspect always using blocking notifiers would be best to keep the complexity down. In fact I suspect we should simply make online repair depend on jump labels instead of selecting it when available to remove anoher rarely tested build combination.
Later on in the online fsck patch series, scrub will start using LIVE_HOOKS for some of its scanning functionality. I don't know that anyone will really want to use online fsck on weird old systems like you said, but while it's EXPERIMENTAL I don't want to lose the option entirely.
That said, static branches do have a fallback for !HAVE_ARCH_JUMP_LABEL case, which is raw_atomic_read.
I'll get rid of the srcu notifier chain xfs_hook implementation to reduce the complexity within xfs. Online fsck will always use static branches + blocking rwsem notifiers. For modern arches like x64 there will be almost zero runtime cost due to the nop sled. For m68k and friends, they can kick the tires on xfs_scrub, but if the performance sucks due to the READ_ONCE then oh well.
--D
PATCH 5/7 xfs: stagger the starting AG of scrub iscans to reduce contention
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Online directory and parent repairs on parent-pointer equipped filesystems have shown that starting a large number of parallel iscans causes a lot of AGI buffer contention. Try to reduce this by making it so that iscans scan wrap around the end of the filesystem, and using a rotor to stagger where each scanner begins. Surprisingly, this boosts CPU utilization (on the author's test machines) from effectively single-threaded to 160%. Not great, but see the next patch.
--- fs/xfs/scrub/iscan.c | 87 ++++++++++++++++++++++++++++++++++++++++++++------ fs/xfs/scrub/iscan.h | 7 ++++ fs/xfs/scrub/trace.h | 7 +++- 3 files changed, 89 insertions(+), 12 deletions(-)
fs/xfs/scrub/iscan.c +77 -10
@@ -170,10 +170,24 @@ xchk_iscan_move_cursor( {struct xfs_scrub *sc = iscan->sc;struct xfs_mount *mp = sc->mp; +xfs_ino_t cursor, visited; + +BUILD_BUG_ON (XFS_MAXINUMBER ==NULLFSINO ); + +/* +* Special-case ino == 0 here so that we never set visited_ino to +* NULLFSINO when wrapping around EOFS, for that will let through all +* live updates. +*/ + cursor =XFS_AGINO_TO_INO (mp, agno, agino); +if (cursor ==0 ) + visited =XFS_MAXINUMBER ; +else + visited = cursor -1 ;mutex_lock (&iscan->lock); - iscan->cursor_ino =XFS_AGINO_TO_INO (mp, agno, agino); - iscan->__visited_ino = iscan->cursor_ino -1 ; + iscan->cursor_ino = cursor; + iscan->__visited_ino = visited;trace_xchk_iscan_move_cursor (iscan);mutex_unlock (&iscan->lock); }
@@ -257,12 +271,13 @@ xchk_iscan_advance(* Did not find any more inodes in this AG, move on to the next * AG. */ -xchk_iscan_move_cursor (iscan, ++agno,0 ); + agno = (agno +1 ) % mp->m_sb.sb_agcount; +xchk_iscan_move_cursor (iscan, agno,0 );xfs_trans_brelse (sc->tp, agi_bp);xfs_perag_put (pag);trace_xchk_iscan_advance_ag (iscan); - }while (agno < mp->m_sb.sb_agcount); + }while (iscan->cursor_ino != iscan->scan_start_ino);xchk_iscan_finish (iscan);return 0 ;
@@ -420,6 +435,23 @@ xchk_iscan_teardown(mutex_destroy (&iscan->lock); } +/* Pick an AG from which to start a scan. */ +static inline xfs_ino_t +xchk_iscan_rotor ( +struct xfs_mount *mp) +{ +static atomic_t agi_rotor; +unsigned int r =atomic_inc_return (&agi_rotor) -1 ; + +/* +* Rotoring *backwards* through the AGs, so we add one here before +* subtracting from the agcount to arrive at an AG number. +*/ + r = (r % mp->m_sb.sb_agcount) +1 ; + +return XFS_AGINO_TO_INO (mp, mp->m_sb.sb_agcount - r,0 ); +} +/* * Set ourselves up to start an inode scan. If the @iget_timeout and * @iget_retry_delay parameters are set, the scan will try to iget each inode
@@ -434,15 +466,20 @@ xchk_iscan_start(unsigned int iget_retry_delay, struct xchk_iscan *iscan) { + xfs_ino_t start_ino; + + start_ino =xchk_iscan_rotor (sc->mp); + iscan->sc = sc;clear_bit (XCHK_ISCAN_OPSTATE_ABORTED , &iscan->__opstate); iscan->iget_timeout = iget_timeout; iscan->iget_retry_delay = iget_retry_delay; - iscan->__visited_ino =0 ; - iscan->cursor_ino =0 ; + iscan->__visited_ino = start_ino; + iscan->cursor_ino = start_ino; + iscan->scan_start_ino = start_ino;mutex_init (&iscan->lock); -trace_xchk_iscan_start (iscan); +trace_xchk_iscan_start (iscan, start_ino); }/*
@@ -471,15 +508,45 @@ xchk_iscan_want_live_update(struct xchk_iscan *iscan, xfs_ino_t ino) { - bool ret; + bool ret = false;if (xchk_iscan_aborted (iscan))return false;mutex_lock (&iscan->lock); +trace_xchk_iscan_want_live_update (iscan, ino); - ret = iscan->__visited_ino >= ino; + +/* Scan is finished, caller should receive all updates. */ +if (iscan->__visited_ino ==NULLFSINO ) { + ret = true; + goto unlock; + } + +/* +* The visited cursor hasn't yet wrapped around the end of the FS. If +* @ino is inside the starred range, the caller should receive updates: +* +* 0 ------------ S ************ V ------------ EOFS +*/ +if (iscan->scan_start_ino <= iscan->__visited_ino) { +if (ino >= iscan->scan_start_ino && + ino <= iscan->__visited_ino) + ret = true; + + goto unlock; + } + +/* +* The visited cursor wrapped around the end of the FS. If @ino is +* inside the starred range, the caller should receive updates: +* +* 0 ************ V ------------ S ************ EOFS +*/ +if (ino >= iscan->scan_start_ino || ino <= iscan->__visited_ino) + ret = true; + +unlock:mutex_unlock (&iscan->lock); -return ret; }
fs/xfs/scrub/iscan.h +7 -0
@@ -12,6 +12,13 @@ struct xchk_iscan {/* Lock to protect the scan cursor. */ struct mutex lock; +/* +* This is the first inode in the inumber address space that we +* examined. When the scan wraps around back to here, the scan is +* finished. +*/ +xfs_ino_t scan_start_ino; +/* This is the inode that will be examined next. */ xfs_ino_t cursor_ino;
fs/xfs/scrub/trace.h +5 -2
@@ -1146,25 +1146,27 @@ DEFINE_EVENT(xchk_iscan_class, name, \DEFINE_ISCAN_EVENT (xchk_iscan_move_cursor);DEFINE_ISCAN_EVENT (xchk_iscan_visit);DEFINE_ISCAN_EVENT (xchk_iscan_advance_ag); -DEFINE_ISCAN_EVENT (xchk_iscan_start);DECLARE_EVENT_CLASS (xchk_iscan_ino_class, TP_PROTO(struct xchk_iscan *iscan, xfs_ino_t ino),TP_ARGS (iscan, ino),TP_STRUCT__entry ( __field(dev_t, dev) + __field(xfs_ino_t, startino) __field(xfs_ino_t, cursor) __field(xfs_ino_t, visited)__field (xfs_ino_t, ino) ),TP_fast_assign ( __entry->dev = iscan->sc->mp->m_super->s_dev; + __entry->startino = iscan->scan_start_ino; __entry->cursor = iscan->cursor_ino; __entry->visited = iscan->__visited_ino; __entry->ino = ino; ), -TP_printk ("dev %d:%d iscan cursor 0x%llx visited 0x%llx ino 0x%llx" , +TP_printk ("dev %d:%d iscan start 0x%llx cursor 0x%llx visited 0x%llx ino 0x%llx" ,MAJOR (__entry->dev),MINOR (__entry->dev), + __entry->startino, __entry->cursor, __entry->visited, __entry->ino)
@@ -1174,6 +1176,7 @@ DEFINE_EVENT(xchk_iscan_ino_class, name, \ TP_PROTO(struct xchk_iscan *iscan, xfs_ino_t ino), \ TP_ARGS(iscan, ino)) DEFINE_ISCAN_INO_EVENT(xchk_iscan_want_live_update); +DEFINE_ISCAN_INO_EVENT (xchk_iscan_start); TRACE_EVENT(xchk_iscan_iget, TP_PROTO(struct xchk_iscan *iscan, int error),
Re: [PATCH 5/7] xfs: stagger the starting AG of scrub iscans to reduce contention
Looks good:
PATCH 6/7 xfs: cache a bunch of inodes for repair scans
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
After observing xfs_scrub taking forever to rebuild parent pointers on a pptrs enabled filesystem, I decided to profile what the system was doing. It turns out that when there are a lot of threads trying to scan the filesystem, most of our time is spent contending on AGI buffer locks. Given that we're walking the inobt records anyway, we can often tell ahead of time when there's a bunch of (up to 64) consecutive inodes that we could grab all at once.
Do this to amortize the cost of taking the AGI lock across as many inodes as we possibly can. On the author's system this seems to improve parallel throughput from barely one and a half cores to slightly sublinear scaling. The obvious antipattern here of course is where the freemask has every other bit set (e.g. all 0xA's)
--- fs/xfs/scrub/iscan.c | 159 +++++++++++++++++++++++++++++++++++++++++--------- fs/xfs/scrub/iscan.h | 7 ++ fs/xfs/scrub/trace.h | 23 +++++++ 3 files changed, 159 insertions(+), 30 deletions(-)
fs/xfs/scrub/iscan.c +129 -30
@@ -60,6 +60,7 @@ xchk_iscan_find_next(struct xchk_iscan *iscan, struct xfs_buf *agi_bp, struct xfs_perag *pag, + xfs_inofree_t *allocmaskp, xfs_agino_t *cursor) { struct xfs_scrub *sc = iscan->sc;
@@ -145,6 +146,7 @@ xchk_iscan_find_next(ASSERT (next >=0 ); *cursor = rec.ir_startino + next; + *allocmaskp = allocmask >> next;break ; } }
@@ -225,7 +227,8 @@ STATIC intxchk_iscan_advance ( struct xchk_iscan *iscan, struct xfs_perag **pagp, - struct xfs_buf **agi_bpp) + struct xfs_buf **agi_bpp, + xfs_inofree_t *allocmaskp) { struct xfs_scrub *sc = iscan->sc;struct xfs_mount *mp = sc->mp;
@@ -251,7 +254,8 @@ xchk_iscan_advance( goto out_pag; agino =XFS_INO_TO_AGINO (mp, iscan->cursor_ino); - ret =xchk_iscan_find_next (iscan, agi_bp, pag, &agino); + ret =xchk_iscan_find_next (iscan, agi_bp, pag, allocmaskp, + &agino);if (ret) goto out_buf;
@@ -331,29 +335,35 @@ xchk_iscan_iget_retry(* caller must ensure that no other threads can modify the inode until a call * to xchk_iscan_visit succeeds. * -* Returns 0 and an incore inode; -EAGAIN if the caller should call again -* xchk_iscan_advance; -EBUSY if we couldn't grab an inode; -ECANCELED if -* there's a fatal signal pending; or some other negative errno. +* Returns the number of incore inodes grabbed; -EAGAIN if the caller should +* call again xchk_iscan_advance; -EBUSY if we couldn't grab an inode; +* -ECANCELED if there's a fatal signal pending; or some other negative errno. */ STATIC intxchk_iscan_iget (struct xchk_iscan *iscan,struct xfs_perag *pag,struct xfs_buf *agi_bp, -struct xfs_inode **ipp) +xfs_inofree_t allocmask) {struct xfs_scrub *sc = iscan->sc;struct xfs_mount *mp = sc->mp; +xfs_ino_t ino = iscan->cursor_ino; +unsigned int idx =0 ;int error; - error =xfs_iget (sc->mp, sc->tp, iscan->cursor_ino,XFS_IGET_NORETRY , -0 , ipp); -xfs_trans_brelse (sc->tp, agi_bp); -xfs_perag_put (pag); +ASSERT (iscan->__inodes[0 ] ==NULL ); + +/* Fill the first slot in the inode array. */ + error =xfs_iget (sc->mp, sc->tp, ino,XFS_IGET_NORETRY ,0 , + &iscan->__inodes[idx]);trace_xchk_iscan_iget (iscan, error);if (error == -ENOENT || error == -EAGAIN ) { +xfs_trans_brelse (sc->tp, agi_bp); +xfs_perag_put (pag); +/*¬ * It's possible that this inode has lost all of its links but * hasn't yet been inactivated. If we don't have a transaction
@@ -364,6 +374,9 @@ xchk_iscan_iget( }if (error == -EINVAL ) { +xfs_trans_brelse (sc->tp, agi_bp); +xfs_perag_put (pag); +/* * We thought the inode was allocated, but the inode btree * lookup failed, which means that it was freed since the last
@@ -374,25 +387,47 @@ xchk_iscan_iget(return xchk_iscan_iget_retry (iscan, false); } -return error; +if (error) { +xfs_trans_brelse (sc->tp, agi_bp); +xfs_perag_put (pag); +return error; + } + idx++; + ino++; + allocmask >>=1 ; + +/* +* Now that we've filled the first slot in __inodes, try to fill the +* rest of the batch with consecutively ordered inodes. to reduce the +* number of _iter calls. If we can't get an inode, we stop and return +* what we have. +*/ +for (; allocmask &1 ; allocmask >>=1 , ino++, idx++) { +ASSERT (iscan->__inodes[idx] ==NULL ); + + error =xfs_iget (sc->mp, sc->tp, ino,XFS_IGET_NORETRY ,0 , + &iscan->__inodes[idx]); +if (error) +break ; + +mutex_lock (&iscan->lock); + iscan->cursor_ino = ino; +mutex_unlock (&iscan->lock); + } + +trace_xchk_iscan_iget_batch (sc->mp, iscan, idx); +xfs_trans_brelse (sc->tp, agi_bp); +xfs_perag_put (pag); +return idx; }/* -* Advance the inode scan cursor to the next allocated inode and return the -* incore inode structure associated with it. -* -* Returns 1 if there's a new inode to examine, 0 if we've run out of inodes, -* -ECANCELED if the live scan aborted, -EBUSY if the incore inode could not be -* grabbed, or the usual negative errno. -* -* If the function returns -EBUSY and the caller can handle skipping an inode, -* it may call this function again to continue the scan with the next allocated -* inode. +* Advance the inode scan cursor to the next allocated inode and return up to +* 64 consecutive allocated inodes starting with the cursor position. */ -int -xchk_iscan_iter ( -struct xchk_iscan *iscan, -struct xfs_inode **ipp) +STATIC int +xchk_iscan_iter_batch ( +struct xchk_iscan *iscan) {struct xfs_scrub *sc = iscan->sc;int ret;
@@ -404,8 +439,9 @@ xchk_iscan_iter( do { struct xfs_buf *agi_bp = NULL; struct xfs_perag *pag = NULL; + xfs_inofree_t allocmask = 0; - ret = xchk_iscan_advance(iscan, &pag, &agi_bp); + ret = xchk_iscan_advance(iscan, &pag, &agi_bp, &allocmask); if (ret != 1) return ret;
@@ -416,21 +452,74 @@ xchk_iscan_iter(break ; } - ret =xchk_iscan_iget (iscan, pag, agi_bp, ipp); + ret =xchk_iscan_iget (iscan, pag, agi_bp, allocmask); }while (ret == -EAGAIN ); -if (!ret) -return 1 ; -return ret; } +/* +* Advance the inode scan cursor to the next allocated inode and return the +* incore inode structure associated with it. +* +* Returns 1 if there's a new inode to examine, 0 if we've run out of inodes, +* -ECANCELED if the live scan aborted, -EBUSY if the incore inode could not be +* grabbed, or the usual negative errno. +* +* If the function returns -EBUSY and the caller can handle skipping an inode, +* it may call this function again to continue the scan with the next allocated +* inode. +*/ +int +xchk_iscan_iter ( +struct xchk_iscan *iscan, +struct xfs_inode **ipp) +{ +unsigned int i; +int error; + +/* Find a cached inode, or go get another batch. */ +for (i =0 ; i <XFS_INODES_PER_CHUNK ; i++) { +if (iscan->__inodes[i]) + goto foundit; + } + + error =xchk_iscan_iter_batch (iscan); +if (error <=0 ) +return error; + +ASSERT (iscan->__inodes[0 ] !=NULL ); + i =0 ; + +foundit: +/* Give the caller our reference. */ + *ipp = iscan->__inodes[i]; + iscan->__inodes[i] =NULL ; +return 1 ; +} + +/* Clean up an xfs_iscan_iter call by dropping any inodes that we still hold. */ +void +xchk_iscan_iter_finish ( +struct xchk_iscan *iscan) +{ +struct xfs_scrub *sc = iscan->sc; +unsigned int i; + +for (i =0 ; i <XFS_INODES_PER_CHUNK ; i++) { +if (iscan->__inodes[i]) { +xchk_irele (sc, iscan->__inodes[i]); + iscan->__inodes[i] =NULL ; + } + } +}/* Mark this inode scan finished and release resources. */ void xchk_iscan_teardown (struct xchk_iscan *iscan) { +xchk_iscan_iter_finish (iscan);xchk_iscan_finish (iscan);mutex_destroy (&iscan->lock); }
@@ -478,6 +567,7 @@ xchk_iscan_start( iscan->cursor_ino = start_ino; iscan->scan_start_ino = start_ino;mutex_init (&iscan->lock); +memset (iscan->__inodes,0 ,sizeof (iscan->__inodes));trace_xchk_iscan_start (iscan, start_ino); }
@@ -523,6 +613,15 @@ xchk_iscan_want_live_update( goto unlock; } +/* +* No inodes have been visited yet, so the visited cursor points at the +* start of the scan range. The caller should not receive any updates. +*/ +if (iscan->scan_start_ino == iscan->__visited_ino) { + ret = false; + goto unlock; + } +/* * The visited cursor hasn't yet wrapped around the end of the FS. If * @ino is inside the starred range, the caller should receive updates:
fs/xfs/scrub/iscan.h +7 -0
@@ -41,6 +41,12 @@ struct xchk_iscan {/* Wait this many ms to retry an iget. */ unsigned int iget_retry_delay; + +/* +* The scan grabs batches of inodes and stashes them here before +* handing them out with _iter. +*/ +struct xfs_inode *__inodes[XFS_INODES_PER_CHUNK ]; };/* Set if the scan has been aborted due to some event in the fs. */
@@ -63,6 +69,7 @@ void xchk_iscan_start(struct xfs_scrub *sc, unsigned int iget_timeout,void xchk_iscan_teardown (struct xchk_iscan *iscan);int xchk_iscan_iter (struct xchk_iscan *iscan,struct xfs_inode **ipp); +void xchk_iscan_iter_finish (struct xchk_iscan *iscan);void xchk_iscan_mark_visited (struct xchk_iscan *iscan,struct xfs_inode *ip);bool xchk_iscan_want_live_update (struct xchk_iscan *iscan,xfs_ino_t ino);
fs/xfs/scrub/trace.h +23 -0
@@ -1200,6 +1200,29 @@ TRACE_EVENT(xchk_iscan_iget, __entry->error) ); +TRACE_EVENT (xchk_iscan_iget_batch, + TP_PROTO(struct xfs_mount *mp, struct xchk_iscan *iscan, + unsigned int nr), +TP_ARGS (mp, iscan, nr), +TP_STRUCT__entry ( + __field(dev_t, dev) + __field(xfs_ino_t, cursor) + __field(xfs_ino_t, visited) + __field(unsigned int, nr) + ), +TP_fast_assign ( + __entry->dev = mp->m_super->s_dev; + __entry->cursor = iscan->cursor_ino; + __entry->visited = iscan->__visited_ino; + __entry->nr = nr; + ), +TP_printk ("dev %d:%d iscan cursor 0x%llx visited 0x%llx nr %d" , +MAJOR (__entry->dev),MINOR (__entry->dev), + __entry->cursor, + __entry->visited, + __entry->nr) +); + TRACE_EVENT(xchk_iscan_iget_retry_wait, TP_PROTO(struct xchk_iscan *iscan), TP_ARGS(iscan),
Re: [PATCH 6/7] xfs: cache a bunch of inodes for repair scans
Looks good:
PATCH 7/7 xfs: iscan batching should handle unallocated inodes too
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
The inode scanner tries to reduce contention on the AGI header buffer lock by grabbing references to consecutive allocated inodes. Batching stops as soon as we encounter an unallocated inode. This is unfortunate because in the worst case performance collapses to the old "one at a time" behavior if every other inode is free.
This is correct behavior, but we could do better. Unallocated inodes by definition have nothing to scan, which means the iscan can ignore them as long as someone ensures that the scan data will reflect another thread allocating the inode and adding interesting metadata to that inode. That mechanism is, of course, the live update hooks.
Therefore, extend the batching mechanism to track unallocated inodes adjacent to the scan cursor. The _want_live_update predicate can tell the caller's live update hook to incorporate all live updates to what the scanner thinks is an unallocated inode if (after dropping the AGI) some other thread allocates one of those inodes and begins using it.
Note that we cannot just copy the ir_free bitmap into the scan cursor because the batching stops if iget says the inode is in an intermediate state (e.g. on the inactivation list) and cannot be igrabbed.
--- fs/xfs/scrub/iscan.c | 107 +++++++++++++++++++++++++++++++++++++++++++++----- fs/xfs/scrub/iscan.h | 6 ++- fs/xfs/scrub/trace.h | 21 ++++++++-- 3 files changed, 119 insertions(+), 15 deletions(-)
fs/xfs/scrub/iscan.c +97 -10
@@ -61,7 +61,8 @@ xchk_iscan_find_next(struct xfs_buf *agi_bp, struct xfs_perag *pag, xfs_inofree_t *allocmaskp, - xfs_agino_t *cursor) + xfs_agino_t *cursor, + uint8_t *nr_inodesp) { struct xfs_scrub *sc = iscan->sc;struct xfs_inobt_rec_incore rec;
@@ -147,6 +148,7 @@ xchk_iscan_find_next(ASSERT (next >=0 ); *cursor = rec.ir_startino + next; *allocmaskp = allocmask >> next; + *nr_inodesp =XFS_INODES_PER_CHUNK - next;break ; } }
@@ -228,7 +230,8 @@ xchk_iscan_advance(struct xchk_iscan *iscan, struct xfs_perag **pagp, struct xfs_buf **agi_bpp, - xfs_inofree_t *allocmaskp) + xfs_inofree_t *allocmaskp, + uint8_t *nr_inodesp) { struct xfs_scrub *sc = iscan->sc;struct xfs_mount *mp = sc->mp;
@@ -255,7 +258,7 @@ xchk_iscan_advance( agino =XFS_INO_TO_AGINO (mp, iscan->cursor_ino); ret =xchk_iscan_find_next (iscan, agi_bp, pag, allocmaskp, - &agino); + &agino, nr_inodesp);if (ret) goto out_buf;
@@ -344,12 +347,14 @@ xchk_iscan_iget(struct xchk_iscan *iscan, struct xfs_perag *pag, struct xfs_buf *agi_bp, - xfs_inofree_t allocmask) + xfs_inofree_t allocmask, + uint8_t nr_inodes) { struct xfs_scrub *sc = iscan->sc;struct xfs_mount *mp = sc->mp;xfs_ino_t ino = iscan->cursor_ino;unsigned int idx =0 ; +unsigned int i;int error;ASSERT (iscan->__inodes[0 ] ==NULL );
@@ -399,10 +404,28 @@ xchk_iscan_iget(/* * Now that we've filled the first slot in __inodes, try to fill the * rest of the batch with consecutively ordered inodes. to reduce the -* number of _iter calls. If we can't get an inode, we stop and return -* what we have. +* number of _iter calls. Make a bitmap of unallocated inodes from the +* zeroes in the inuse bitmap; these inodes will not be scanned, but +* the _want_live_update predicate will pass through all live updates. +* +* If we can't iget an allocated inode, stop and return what we have. */ -for (; allocmask &1 ; allocmask >>=1 , ino++, idx++) { +mutex_lock (&iscan->lock); + iscan->__batch_ino = ino -1 ; + iscan->__skipped_inomask =0 ; +mutex_unlock (&iscan->lock); + +for (i =1 ; i < nr_inodes; i++, ino++, allocmask >>=1 ) { +if (!(allocmask &1 )) { +ASSERT (!(iscan->__skipped_inomask & (1ULL << i))); + +mutex_lock (&iscan->lock); + iscan->cursor_ino = ino; + iscan->__skipped_inomask |= (1ULL << i); +mutex_unlock (&iscan->lock); +continue ; + } +ASSERT (iscan->__inodes[idx] ==NULL ); error = xfs_iget(sc->mp, sc->tp, ino, XFS_IGET_NORETRY, 0,
@@ -413,14 +436,42 @@ xchk_iscan_iget(mutex_lock (&iscan->lock); iscan->cursor_ino = ino;mutex_unlock (&iscan->lock); + idx++; } -trace_xchk_iscan_iget_batch (sc->mp, iscan, idx); +trace_xchk_iscan_iget_batch (sc->mp, iscan, nr_inodes, idx);xfs_trans_brelse (sc->tp, agi_bp);xfs_perag_put (pag);return idx; } +/* +* Advance the visit cursor to reflect skipped inodes beyond whatever we +* scanned. +*/ +STATIC void +xchk_iscan_finish_batch ( +struct xchk_iscan *iscan) +{ +xfs_ino_t highest_skipped; + +mutex_lock (&iscan->lock); + +if (iscan->__batch_ino !=NULLFSINO ) { + highest_skipped = iscan->__batch_ino + +xfs_highbit64 (iscan->__skipped_inomask); + iscan->__visited_ino =max (iscan->__visited_ino, + highest_skipped); + +trace_xchk_iscan_skip (iscan); + } + + iscan->__batch_ino =NULLFSINO ; + iscan->__skipped_inomask =0 ; + +mutex_unlock (&iscan->lock); +} +/* * Advance the inode scan cursor to the next allocated inode and return up to * 64 consecutive allocated inodes starting with the cursor position.
@@ -432,6 +483,8 @@ xchk_iscan_iter_batch(struct xfs_scrub *sc = iscan->sc;int ret; +xchk_iscan_finish_batch (iscan); +if (iscan->iget_timeout) iscan->__iget_deadline = jiffies +msecs_to_jiffies (iscan->iget_timeout);
@@ -440,8 +493,10 @@ xchk_iscan_iter_batch(struct xfs_buf *agi_bp =NULL ;struct xfs_perag *pag =NULL ;xfs_inofree_t allocmask =0 ; +uint8_t nr_inodes =0 ; - ret =xchk_iscan_advance (iscan, &pag, &agi_bp, &allocmask); + ret =xchk_iscan_advance (iscan, &pag, &agi_bp, &allocmask, + &nr_inodes);if (ret !=1 )return ret;
@@ -452,7 +507,7 @@ xchk_iscan_iter_batch(break ; } - ret =xchk_iscan_iget (iscan, pag, agi_bp, allocmask); + ret =xchk_iscan_iget (iscan, pag, agi_bp, allocmask, nr_inodes); }while (ret == -EAGAIN );return ret;
@@ -559,6 +614,9 @@ xchk_iscan_start( start_ino =xchk_iscan_rotor (sc->mp); + iscan->__batch_ino =NULLFSINO ; + iscan->__skipped_inomask =0 ; + iscan->sc = sc;clear_bit (XCHK_ISCAN_OPSTATE_ABORTED , &iscan->__opstate); iscan->iget_timeout = iget_timeout;
@@ -587,6 +645,26 @@ xchk_iscan_mark_visited(mutex_unlock (&iscan->lock); } +/* +* Did we skip this inode because it wasn't allocated when we loaded the batch? +* If so, it is newly allocated and will not be scanned. All live updates to +* this inode must be passed to the caller to maintain scan correctness. +*/ +static inline bool +xchk_iscan_skipped ( +const struct xchk_iscan *iscan, +xfs_ino_t ino) +{ +if (iscan->__batch_ino ==NULLFSINO ) +return false; +if (ino < iscan->__batch_ino) +return false; +if (ino >= iscan->__batch_ino +XFS_INODES_PER_CHUNK ) +return false; + +return iscan->__skipped_inomask & (1ULL << (ino - iscan->__batch_ino)); +} +/* * Do we need a live update for this inode? This is true if the scanner thread * has visited this inode and the scan hasn't been aborted due to errors.
@@ -622,6 +700,15 @@ xchk_iscan_want_live_update( goto unlock; } +/* +* This inode was not allocated at the time of the iscan batch. +* The caller should receive all updates. +*/ +if (xchk_iscan_skipped (iscan, ino)) { + ret = true; + goto unlock; + } +/* * The visited cursor hasn't yet wrapped around the end of the FS. If * @ino is inside the starred range, the caller should receive updates:
fs/xfs/scrub/iscan.h +5 -1
@@ -44,8 +44,12 @@ struct xchk_iscan {/* * The scan grabs batches of inodes and stashes them here before -* handing them out with _iter. +* handing them out with _iter. Unallocated inodes are set in the +* mask so that all updates to that inode are selected for live +* update propagation. */ +xfs_ino_t __batch_ino; +xfs_inofree_t __skipped_inomask;struct xfs_inode *__inodes[XFS_INODES_PER_CHUNK ]; };
fs/xfs/scrub/trace.h +17 -4
@@ -1145,6 +1145,7 @@ DEFINE_EVENT(xchk_iscan_class, name, \ TP_ARGS(iscan))DEFINE_ISCAN_EVENT (xchk_iscan_move_cursor);DEFINE_ISCAN_EVENT (xchk_iscan_visit); +DEFINE_ISCAN_EVENT (xchk_iscan_skip);DEFINE_ISCAN_EVENT (xchk_iscan_advance_ag); DECLARE_EVENT_CLASS(xchk_iscan_ino_class,
@@ -1202,25 +1203,37 @@ TRACE_EVENT(xchk_iscan_iget,TRACE_EVENT (xchk_iscan_iget_batch, TP_PROTO(struct xfs_mount *mp, struct xchk_iscan *iscan, - unsigned int nr), -TP_ARGS (mp, iscan, nr), + unsigned int nr, unsigned int avail), +TP_ARGS (mp, iscan, nr, avail),TP_STRUCT__entry ( __field(dev_t, dev) __field(xfs_ino_t, cursor) __field(xfs_ino_t, visited) __field(unsigned int, nr) + __field(unsigned int, avail) + __field(unsigned int, unavail) + __field(xfs_ino_t, batch_ino) + __field(unsigned long long, skipmask) ),TP_fast_assign ( __entry->dev = mp->m_super->s_dev; __entry->cursor = iscan->cursor_ino; __entry->visited = iscan->__visited_ino; __entry->nr = nr; + __entry->avail = avail; + __entry->unavail = hweight64(iscan->__skipped_inomask); + __entry->batch_ino = iscan->__batch_ino; + __entry->skipmask = iscan->__skipped_inomask; ), -TP_printk ("dev %d:%d iscan cursor 0x%llx visited 0x%llx nr %d" , +TP_printk ("dev %d:%d iscan cursor 0x%llx visited 0x%llx batchino 0x%llx skipmask 0x%llx nr %u avail %u unavail %u" ,MAJOR (__entry->dev),MINOR (__entry->dev), __entry->cursor, __entry->visited, - __entry->nr) + __entry->batch_ino, + __entry->skipmask, + __entry->nr, + __entry->avail, + __entry->unavail) ); TRACE_EVENT(xchk_iscan_iget_retry_wait,
Re: [PATCH 7/7] xfs: iscan batching should handle unallocated inodes too
Any reason to not just fold this into the previous patch?
Otherwise looks good:
Re: [PATCH 7/7] xfs: iscan batching should handle unallocated inodes too
Quoted 1 line · Christoph Hellwig
Any reason to not just fold this into the previous patch?
It's a performance optimization over the code provided in the previous patch, so I kept it separate both for bisectability and to preserve the incremental improvements that I've added to online fsck over the years.
Quoted 3 lines
Otherwise looks good:
Reviewed-by Christoph Hellwig <[email protected]>
Thanks!
--D
PATCH 2/28 xfs: repair inode mode by scanning dirs
In reply to Darrick J. WongHi all,
One missing piece of functionality in the inode record repair code is figuring out what to do with a file whose mode is so corrupt that we cannot tell us the type of the file. Originally this was done by guessing the mode from the ondisk inode contents, but Christoph didn't like that because it read from data fork block 0, which could be user controlled data.
Therefore, I've replaced all that with a directory scanner that looks for any dirents that point to the file with the garbage mode. If so, the ftype in the dirent will tell us exactly what mode to set on the file. Since users cannot directly write to the ftype field of a dirent, this should be safe.
If you're going to start using this code, I strongly recommend pulling from my git trees, which are linked below.
This has been running on the djcloud for months with no problems. Enjoy! Comments and questions are, as always, welcome.
--D
kernel git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfs-linux.git/log/?h=repair-inode-mode
xfsprogs git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfsprogs-dev.git/log/?h=repair-inode-mode
--- fs/xfs/libxfs/xfs_da_format.h | 11 ++ fs/xfs/libxfs/xfs_dir2.c | 6 + fs/xfs/libxfs/xfs_dir2.h | 10 ++ fs/xfs/scrub/dir.c | 4 - fs/xfs/scrub/inode_repair.c | 236 ++++++++++++++++++++++++++++++++++++++++- fs/xfs/scrub/iscan.c | 29 +++++ fs/xfs/scrub/iscan.h | 3 + fs/xfs/scrub/trace.c | 1 fs/xfs/scrub/trace.h | 49 +++++++++ 9 files changed, 341 insertions(+), 8 deletions(-)
PATCH 1/4 xfs: create a static name for the dot entry too
From: Darrick J. Wong <[email protected]>
Create an xfs_name_dot object so that upcoming scrub code can compare against that. Offline repair already has such an object, so we're really just hoisting it to the kernel.
--- fs/xfs/libxfs/xfs_dir2.c | 6 ++++++ fs/xfs/libxfs/xfs_dir2.h | 1 + 2 files changed, 7 insertions(+)
fs/xfs/libxfs/xfs_dir2.c +6 -0
@@ -25,6 +25,12 @@ const struct xfs_name xfs_name_dotdot = { .type = XFS_DIR3_FT_DIR, }; +const struct xfs_name xfs_name_dot = { + .name = (const unsigned char *)"." , + .len =1 , + .type =XFS_DIR3_FT_DIR , +}; +/* * Convert inode mode to directory entry filetype */
fs/xfs/libxfs/xfs_dir2.h +1 -0
@@ -22,6 +22,7 @@ struct xfs_dir3_icfree_hdr;struct xfs_dir3_icleaf_hdr ;extern const struct xfs_name xfs_name_dotdot; +extern const struct xfs_name xfs_name_dot;/* * Convert inode mode to directory entry filetype
Re: [PATCH 1/4] xfs: create a static name for the dot entry too
Looks good:
PATCH 2/4 xfs: create a predicate to determine if two xfs_names are the same
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Create a simple predicate to determine if two xfs_names are the same objects or have the exact same name. The comparison is always case sensitive.
--- fs/xfs/libxfs/xfs_dir2.h | 9 +++++++++ fs/xfs/scrub/dir.c | 4 ++-- 2 files changed, 11 insertions(+), 2 deletions(-)
fs/xfs/libxfs/xfs_dir2.h +9 -0
@@ -24,6 +24,15 @@ struct xfs_dir3_icleaf_hdr;extern const struct xfs_name xfs_name_dotdot;extern const struct xfs_name xfs_name_dot; +static inline bool +xfs_dir2_samename ( +const struct xfs_name *n1, +const struct xfs_name *n2) +{ +return n1 == n2 || (n1->len == n2->len && + !memcmp (n1->name, n2->name, n1->len)); +} +/* * Convert inode mode to directory entry filetype */
fs/xfs/scrub/dir.c +2 -2
@@ -93,11 +93,11 @@ xchk_dir_actor(return -ECANCELED ; } -if (!strncmp ("." , name->name, name->len)) { +if (xfs_dir2_samename (name, &xfs_name_dot)) {/* If this is "." then check that the inum matches the dir. */ if (ino != dp->i_ino)xchk_fblock_set_corrupt (sc,XFS_DATA_FORK , offset); - }else if (!strncmp (".." , name->name, name->len)) { + }else if (xfs_dir2_samename (name, &xfs_name_dotdot)) {/* * If this is ".." in the root inode, check that the inum * matches this dir.
Re: [PATCH 2/4] xfs: create a predicate to determine if two xfs_names are the same
Quoted 18 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Create a simple predicate to determine if two
xfs_namesare the same objects or have the exact same name. The comparison is always case sensitive.Signed-off-by Darrick J. Wong <[email protected]>--- fs/xfs/libxfs/xfs_dir2.h | 9 +++++++++ fs/xfs/scrub/dir.c | 4 ++-- 2 files changed, 11 insertions(+), 2 deletions(-)fs/xfs/libxfs/xfs_dir2.h +0
-0
fs/xfs/libxfs/xfs_dir2.h struct xfs_dir3_icleaf_hdr; · line 33
Quoted 10 lines
fs/xfs/libxfs/xfs_dir2.h +7
-0@@ -24,6 +24,15 @@ struct xfs_dir3_icleaf_hdr;extern const struct xfs_name xfs_name_dotdot;extern const struct xfs_name xfs_name_dot; +static inline bool +xfs_dir2_samename ( +const struct xfs_name *n1, +const struct xfs_name *n2) +{ +return n1 == n2 || (n1->len == n2->len && + !memcmp (n1->name, n2->name, n1->len));
Nit, but to me the formatting looks weird, why not:
return n1 == n2 || (n1->len == n2->len && !memcmp(n1->name, n2->name, n1->len));
Or even more verbose:
if (n1 == n2) return true; if (n1->len != n2->len) return false; return !memcmp(n1->name, n2->name, n1->len);
Otherwise this looks good:
Re: [PATCH 2/4] xfs: create a predicate to determine if two xfs_names are the same
Quoted 35 lines · Christoph Hellwig
Quoted 18 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Create a simple predicate to determine if two
xfs_namesare the same objects or have the exact same name. The comparison is always case sensitive.Signed-off-by Darrick J. Wong <[email protected]>--- fs/xfs/libxfs/xfs_dir2.h | 9 +++++++++ fs/xfs/scrub/dir.c | 4 ++-- 2 files changed, 11 insertions(+), 2 deletions(-)fs/xfs/libxfs/xfs_dir2.h +0
-0fs/xfs/libxfs/xfs_dir2.h struct xfs_dir3_icleaf_hdr; · line 33
Quoted 10 lines
fs/xfs/libxfs/xfs_dir2.h +7
-0@@ -24,6 +24,15 @@ struct xfs_dir3_icleaf_hdr;extern const struct xfs_name xfs_name_dotdot;extern const struct xfs_name xfs_name_dot; +static inline bool +xfs_dir2_samename ( +const struct xfs_name *n1, +const struct xfs_name *n2) +{ +return n1 == n2 || (n1->len == n2->len && + !memcmp (n1->name, n2->name, n1->len));Nit, but to me the formatting looks weird, why not:
return n1 == n2 || (n1->len == n2->len && !memcmp(n1->name, n2->name, n1->len));
Quoted 7 lines
Or even more verbose:
if (n1 == n2) return true; if (n1->len != n2->len) return false; return !memcmp(n1->name, n2->name, n1->len);
Yeah, I'll do that instead of the multiline thing.
Quoted 3 lines
Otherwise this looks good:
Reviewed-by Christoph Hellwig <[email protected]>
Thanks!
--D
PATCH 3/4 xfs: create a macro for decoding ftypes in tracepoints
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Create the XFS_DIR3_FTYPE_STR macro so that we can report ftype as strings instead of numbers in tracepoints.
--- fs/xfs/libxfs/xfs_da_format.h | 11 +++++++++++ 1 file changed, 11 insertions(+)
fs/xfs/libxfs/xfs_da_format.h +11 -0
@@ -159,6 +159,17 @@ struct xfs_da3_intnode {#define XFS_DIR3_FT_MAX 9 +#define XFS_DIR3_FTYPE_STR \ + { XFS_DIR3_FT_UNKNOWN, "unknown" }, \ + { XFS_DIR3_FT_REG_FILE, "file" }, \ + { XFS_DIR3_FT_DIR, "directory" }, \ + { XFS_DIR3_FT_CHRDEV, "char" }, \ + { XFS_DIR3_FT_BLKDEV, "block" }, \ + { XFS_DIR3_FT_FIFO, "fifo" }, \ + { XFS_DIR3_FT_SOCK, "sock" }, \ + { XFS_DIR3_FT_SYMLINK, "symlink" }, \ + { XFS_DIR3_FT_WHT, "whiteout" } +/* * Byte offset in data block and shortform entry. */
Re: [PATCH 3/4] xfs: create a macro for decoding ftypes in tracepoints
Quoted 4 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Create the
XFS_DIR3_FTYPE_STRmacro so that we can report ftype as strings instead of numbers in tracepoints.
Looks good:
But why not fold this into the patch actually using the macro?
Re: [PATCH 3/4] xfs: create a macro for decoding ftypes in tracepoints
Quoted 11 lines · Christoph Hellwig
Quoted 4 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Create the
XFS_DIR3_FTYPE_STRmacro so that we can report ftype as strings instead of numbers in tracepoints.Looks good:
Reviewed-by Christoph Hellwig <[email protected]>But why not fold this into the patch actually using the macro?
That patch has slowly been jumping ahead of other patches in djwong-dev as I've wanted it for symbolic decoding of ftypes. After a couple times of carefully cutting out that hunk of the patch to paste it into another earlier patch I decided it would be much easier to do:
$ stg export -d foopatches/ $ vi foopatches/series
Change:
xfs-patch-001 xfs-patch-002 ... xfs-patch-300 xfs-dir2-create-ftype-strings-for-ftrace xfs-patch-301
Into:
xfs-patch-001 xfs-dir2-create-ftype-strings-for-ftrace xfs-patch-002 ... xfs-patch-300 xfs-patch-301
:wq
$ stg float -s foopatches/series $ <patch stack reordered with minimal work on my part>
--D
PATCH 4/4 xfs: repair file modes by scanning for a dirent pointing to us
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
An earlier version of this patch ("xfs: repair obviously broken inode modes") tried to reset the di_mode of a file by guessing it from the data fork format and/or data block 0 contents. Christoph didn't like this approach because it opens the possibility that users could craft a file to look like a directory and trick online repair into turning the mode into S_IFDIR.
However, he allowed that gathering evidence from the rest of the fs metadata would be fine as long as none of that metadata can be controlled by unprivileged users. The ftype flag of V5 filesystem directory entries fits that description!
Now that we have the ability to scan all the files in the filesystem, let's try scanning all the directory entries in the filesystem to see if there's a dirent referencing the inode that we're trying to repair. For the first dirent found we save the ftype; and compare for subsequent ones.
If all the dirents have the same ftype, then we can translate that back into an S_IFMT flag and fix the file. If not, reset the mode to S_IFREG.
--- fs/xfs/scrub/inode_repair.c | 236 ++++++++++++++++++++++++++++++++++++++++++- fs/xfs/scrub/iscan.c | 29 +++++ fs/xfs/scrub/iscan.h | 3 + fs/xfs/scrub/trace.c | 1 fs/xfs/scrub/trace.h | 49 +++++++++ 5 files changed, 312 insertions(+), 6 deletions(-)
fs/xfs/scrub/inode_repair.c +230 -6
@@ -43,6 +43,8 @@#include "scrub/btree.h" #include "scrub/trace.h" #include "scrub/repair.h" +#include "scrub/iscan.h" +#include "scrub/readdir.h" /* * Inode Record Repair
@@ -126,6 +128,10 @@ struct xrep_inode {/* Must we remove all access from this file? */ bool zap_acls; + +/* Inode scanner to see if we can find the ftype from dirents */ +struct xchk_iscan ftype_iscan; +uint8_t alleged_ftype; };/*
@@ -227,26 +233,233 @@ xrep_dinode_header( dip->di_gen =cpu_to_be32 (sc->sm->sm_gen); } -/* Turn di_mode into /something/ recognizable. */ -STATIC void +/* +* If this directory entry points to the scrub target inode, then the directory +* we're scanning is the parent of the scrub target inode. +*/ +STATIC int +xrep_dinode_findmode_dirent ( +struct xfs_scrub *sc, +struct xfs_inode *dp, +xfs_dir2_dataptr_t dapos, +const struct xfs_name *name, +xfs_ino_t ino, +void *priv) +{ +struct xrep_inode *ri = priv; +int error =0 ; + +if (xchk_should_terminate (ri->sc, &error)) +return error; + +if (ino != sc->sm->sm_ino) +return 0 ; + +/* Ignore garbage directory entry names. */ +if (name->len ==0 || !xfs_dir2_namecheck (name->name, name->len)) +return -EFSCORRUPTED ; + +/* Don't pick up dot or dotdot entries; we only want child dirents. */ +if (xfs_dir2_samename (name, &xfs_name_dotdot) || +xfs_dir2_samename (name, &xfs_name_dot)) +return 0 ; + +/* +* Uhoh, more than one parent for this inode and they don't agree on +* the file type? +*/ +if (ri->alleged_ftype !=XFS_DIR3_FT_UNKNOWN && + ri->alleged_ftype != name->type) { +trace_xrep_dinode_findmode_dirent_inval (ri->sc, dp, name->type, + ri->alleged_ftype); +return -EFSCORRUPTED ; + } + +/* We found a potential parent; remember the ftype. */ +trace_xrep_dinode_findmode_dirent (ri->sc, dp, name->type); + ri->alleged_ftype = name->type; +return 0 ; +} + +/* +* If this is a directory, walk the dirents looking for any that point to the +* scrub target inode. +*/ +STATIC int +xrep_dinode_findmode_walk_directory ( +struct xrep_inode *ri, +struct xfs_inode *dp) +{ +struct xfs_scrub *sc = ri->sc; +unsigned int lock_mode; +int error =0 ; + +/* +* Scan the directory to see if there it contains an entry pointing to +* the directory that we are repairing. +*/ + lock_mode =xfs_ilock_data_map_shared (dp); + +/* +* If this directory is known to be sick, we cannot scan it reliably +* and must abort. +*/ +if (xfs_inode_has_sickness (dp,XFS_SICK_INO_CORE | +XFS_SICK_INO_BMBTD | +XFS_SICK_INO_DIR )) { + error = -EFSCORRUPTED ; + goto out_unlock; + } + +/* +* We cannot complete our parent pointer scan if a directory looks as +* though it has been zapped by the inode record repair code. +*/ +if (xchk_dir_looks_zapped (dp)) { + error = -EBUSY ; + goto out_unlock; + } + + error =xchk_dir_walk (sc, dp, xrep_dinode_findmode_dirent, ri); +if (error) + goto out_unlock; + +out_unlock: +xfs_iunlock (dp, lock_mode); +return error; +} + +/* +* Try to find the mode of the inode being repaired by looking for directories +* that point down to this file. +*/ +STATIC int +xrep_dinode_find_mode ( +struct xrep_inode *ri, +uint16_t *mode) +{ +struct xfs_scrub *sc = ri->sc; +struct xfs_inode *dp; +int error; + +/* No ftype means we have no other metadata to consult. */ +if (!xfs_has_ftype (sc->mp)) { + *mode =S_IFREG ; +return 0 ; + } + +/* +* Scan all directories for parents that might point down to this +* inode. Skip the inode being repaired during the scan since it +* cannot be its own parent. Note that we still hold the AGI locked +* so there's a real possibility that _iscan_iter can return EBUSY. +*/ +xchk_iscan_start (sc,5000 ,100 , &ri->ftype_iscan); + ri->ftype_iscan.skip_ino = sc->sm->sm_ino; + ri->alleged_ftype =XFS_DIR3_FT_UNKNOWN ; +while ((error =xchk_iscan_iter (&ri->ftype_iscan, &dp)) ==1 ) { +if (S_ISDIR (VFS_I (dp)->i_mode)) + error =xrep_dinode_findmode_walk_directory (ri, dp); +xchk_iscan_mark_visited (&ri->ftype_iscan, dp); +xchk_irele (sc, dp); +if (error <0 ) +break ; +if (xchk_should_terminate (sc, &error)) +break ; + } +xchk_iscan_iter_finish (&ri->ftype_iscan); +xchk_iscan_teardown (&ri->ftype_iscan); + +if (error == -EBUSY ) { +if (ri->alleged_ftype !=XFS_DIR3_FT_UNKNOWN ) { +/* +* If we got an EBUSY after finding at least one +* dirent, that means the scan found an inode on the +* inactivation list and could not open it. Accept the +* alleged ftype and install a new mode below. +*/ + error =0 ; + }else if (!(sc->flags &XCHK_TRY_HARDER )) { +/* +* Otherwise, retry the operation one time to see if +* the reason for the delay is an inode from the same +* cluster buffer waiting on the inactivation list. +*/ + error = -EDEADLOCK ; + } + } +if (error) +return error; + +/* +* Convert the discovered ftype into the file mode. If all else fails, +* return S_IFREG. +*/ +switch (ri->alleged_ftype) { +case XFS_DIR3_FT_DIR : + *mode =S_IFDIR ; +break ; +case XFS_DIR3_FT_WHT : +case XFS_DIR3_FT_CHRDEV : + *mode =S_IFCHR ; +break ; +case XFS_DIR3_FT_BLKDEV : + *mode =S_IFBLK ; +break ; +case XFS_DIR3_FT_FIFO : + *mode =S_IFIFO ; +break ; +case XFS_DIR3_FT_SOCK : + *mode =S_IFSOCK ; +break ; +case XFS_DIR3_FT_SYMLINK : + *mode =S_IFLNK ; +break ; +default : + *mode =S_IFREG ; +break ; + } +return 0 ; +} + +/* Turn di_mode into /something/ recognizable. Returns true if we succeed. */ +STATIC intxrep_dinode_mode (struct xrep_inode *ri,struct xfs_dinode *dip) {struct xfs_scrub *sc = ri->sc;uint16_t mode =be16_to_cpu (dip->di_mode); +int error;trace_xrep_dinode_mode (sc, dip);if (mode ==0 ||xfs_mode_to_ftype (mode) !=XFS_DIR3_FT_UNKNOWN ) -return ; +return 0 ; + +/* Try to fix the mode. If we cannot, then leave everything alone. */ + error =xrep_dinode_find_mode (ri, &mode); +switch (error) { +case -EINTR : +case -EBUSY : +case -EDEADLOCK : +/* temporary failure or fatal signal */ +return error; +case 0 : +/* found mode */ +break ; +default : +/* some other error, assume S_IFREG */ + mode =S_IFREG ; +break ; + }/* bad mode, so we set it to a file that only root can read */ - mode =S_IFREG ; dip->di_mode =cpu_to_be16 (mode); dip->di_uid =0 ; dip->di_gid =0 ; ri->zap_acls = true; +return 0 ; }/* Fix any conflicting flags that the verifiers complain about. */
@@ -1107,12 +1320,15 @@ xrep_dinode_core(/* Fix everything the verifier will complain about. */ dip =xfs_buf_offset (bp, ri->imap.im_boffset);xrep_dinode_header (sc, dip); -xrep_dinode_mode (ri, dip); + iget_error =xrep_dinode_mode (ri, dip); +if (iget_error) + goto write;xrep_dinode_flags (sc, dip, ri->rt_extents >0 );xrep_dinode_size (ri, dip);xrep_dinode_extsize_hints (sc, dip);xrep_dinode_zap_forks (ri, dip); +write:/* Write out the inode. */ trace_xrep_dinode_fixed (sc, dip);xfs_dinode_calc_crc (sc->mp, dip);
@@ -1128,7 +1344,8 @@ xrep_dinode_core(* accessing the inode. If iget fails, we still need to commit the * changes. */ - iget_error =xchk_iget (sc, ino, &sc->ip); +if (!iget_error) + iget_error =xchk_iget (sc, ino, &sc->ip);if (!iget_error)xchk_ilock (sc,XFS_IOLOCK_EXCL );
@@ -1496,6 +1713,13 @@ xrep_inode(ASSERT (ri !=NULL ); error =xrep_dinode_problems (ri); +if (error == -EBUSY ) { +/* +* Directory scan to recover inode mode encountered a +* busy inode, so we did not continue repairing things. +*/ +return 0 ; + }if (error)return error;
fs/xfs/scrub/iscan.c +29 -0
@@ -51,6 +51,32 @@* scanner's observations must be updated. */ +/* +* If the inobt record @rec covers @iscan->skip_ino, mark the inode free so +* that the scan ignores that inode. +*/ +STATIC void +xchk_iscan_mask_skipino ( +struct xchk_iscan *iscan, +struct xfs_perag *pag, +struct xfs_inobt_rec_incore *rec, +xfs_agino_t lastrecino) +{ +struct xfs_scrub *sc = iscan->sc; +struct xfs_mount *mp = sc->mp; +xfs_agnumber_t skip_agno =XFS_INO_TO_AGNO (mp, iscan->skip_ino); +xfs_agnumber_t skip_agino =XFS_INO_TO_AGINO (mp, iscan->skip_ino); + +if (pag->pag_agno != skip_agno) +return ; +if (skip_agino < rec->ir_startino) +return ; +if (skip_agino > lastrecino) +return ; + + rec->ir_free |=xfs_inobt_maskn (skip_agino - rec->ir_startino,1 ); +} +/* * Set *cursor to the next allocated inode after whatever it's set to now. * If there are no more inodes in this AG, cursor is set to NULLAGINO.
@@ -127,6 +153,9 @@ xchk_iscan_find_next(if (rec.ir_startino +XFS_INODES_PER_CHUNK <= agino)continue ; +if (iscan->skip_ino) +xchk_iscan_mask_skipino (iscan, pag, &rec, lastino); +/* * If the incoming lookup put us in the middle of an inobt * record, mark it and the previous inodes "free" so that the
fs/xfs/scrub/iscan.h +3 -0
@@ -22,6 +22,9 @@ struct xchk_iscan {/* This is the inode that will be examined next. */ xfs_ino_t cursor_ino; +/* If nonzero and non-NULL, skip this inode when scanning. */ +xfs_ino_t skip_ino; +/* * This is the last inode that we've successfully scanned, either * because the caller scanned it, or we moved the cursor past an empty
fs/xfs/scrub/trace.c +1 -0
@@ -16,6 +16,7 @@#include "xfs_rtbitmap.h" #include "xfs_quota.h" #include "xfs_quota_defs.h" +#include "xfs_da_format.h" #include "scrub/scrub.h" #include "scrub/xfile.h" #include "scrub/xfarray.h"
fs/xfs/scrub/trace.h +49 -0
55 lines not on this page · raw message
Re: [PATCH 4/4] xfs: repair file modes by scanning for a dirent pointing to us
Quoted 8 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
An earlier version of this patch ("xfs: repair obviously broken inode modes") tried to reset the
di_modeof a file by guessing it from the data fork format and/or data block 0 contents. Christoph didn't like this approach because it opens the possibility that users could craft a file to look like a directory and trick online repair into turning the mode intoS_IFDIR.
I find the commit message here really weird. What I want doesn't matter. If what I say makes sense (I hope it does, if it doesn't please push back) then we should document thing based on the cross-checked facts and assumptions I provided. If not we should not be doing this at at all.
Re: [PATCH 4/4] xfs: repair file modes by scanning for a dirent pointing to us
Quoted 10 lines · Christoph Hellwig
Quoted 8 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
An earlier version of this patch ("xfs: repair obviously broken inode modes") tried to reset the
di_modeof a file by guessing it from the data fork format and/or data block 0 contents. Christoph didn't like this approach because it opens the possibility that users could craft a file to look like a directory and trick online repair into turning the mode intoS_IFDIR.
Quoted 5 lines
I find the commit message here really weird. What I want doesn't matter. If what I say makes sense (I hope it does, if it doesn't please push back) then we should document thing based on the cross-checked facts and assumptions I provided. If not we should not be doing this at at all.
What you said back at [1] makes sense -- user controlled data blocks should not be used to guess the inode mode. I yanked that patch and replaced it with this one, which scans the inodes looking for a dirent pointing down to the busted inode, and uses that to decide if the busted file is S_IFDIR.
How about I rephrase the whole commit message like this:
"xfs: repair file modes by scanning for a dirent pointing to us
"Repair might encounter an inode with a totally garbage i_mode. To fix this problem, we have to figure out if the file was a regular file, a directory, or a special file. One way to figure this out is to check if there are any directories with entries pointing down to the busted file.
"This patch recovers the file mode by scanning every directory entry on the filesystem to see if there are any that point to the busted file. If the ftype of all such dirents are consistent, the mode is recovered from the ftype. If no dirents are found, the file becomes a regular file. In all cases, ACLs are canceled and the file is made accessible only by root.
"A previous patch attempted to guess the mode by reading the beginning of the file data. This was rejected by Christoph on the grounds that we cannot trust user-controlled data blocks. Users do not have direct control over the ondisk contents of directory links, so this method should be much safer."
--D
Christoph Hellwig
Reviewed-byRe: [PATCH 4/4] xfs: repair file modes by scanning for a dirent pointing to us
With the updated commit message:
PATCH 3/28 xfs: online repair of quota counters
In reply to Darrick J. WongHi all,
This series uses the inode scanner and live update hook functionality introduced in the last patchset to implement quotacheck on a live filesystem. The quotacheck scrubber builds an incore copy of the dquot resource usage counters and compares it to the live dquots to report discrepancies.
If the user chooses to repair the quota counters, the repair function visits each incore dquot to update the counts from the live information. The live update hooks are key to keeping the incore copy up to date.
If you're going to start using this code, I strongly recommend pulling from my git trees, which are linked below.
This has been running on the djcloud for months with no problems. Enjoy! Comments and questions are, as always, welcome.
--D
kernel git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfs-linux.git/log/?h=repair-quotacheck
xfsprogs git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfsprogs-dev.git/log/?h=repair-quotacheck
fstests git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfstests-dev.git/log/?h=repair-quotacheck
--- fs/xfs/Makefile | 2 fs/xfs/libxfs/xfs_fs.h | 4 fs/xfs/libxfs/xfs_health.h | 4 fs/xfs/scrub/common.c | 47 ++ fs/xfs/scrub/common.h | 11 fs/xfs/scrub/fscounters.c | 2 fs/xfs/scrub/health.c | 1 fs/xfs/scrub/quotacheck.c | 862 ++++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/quotacheck.h | 76 +++ fs/xfs/scrub/quotacheck_repair.c | 261 ++++++++++++ fs/xfs/scrub/repair.c | 46 ++ fs/xfs/scrub/repair.h | 5 fs/xfs/scrub/scrub.c | 9 fs/xfs/scrub/scrub.h | 10 fs/xfs/scrub/stats.c | 1 fs/xfs/scrub/trace.h | 30 + fs/xfs/scrub/xfarray.h | 19 + fs/xfs/xfs_health.c | 1 fs/xfs/xfs_inode.c | 21 + fs/xfs/xfs_inode.h | 2 fs/xfs/xfs_qm.c | 23 + fs/xfs/xfs_qm.h | 16 + fs/xfs/xfs_qm_bhv.c | 1 fs/xfs/xfs_quota.h | 45 ++ fs/xfs/xfs_trans_dquot.c | 158 +++++++ 25 files changed, 1632 insertions(+), 25 deletions(-) create mode 100644 fs/xfs/scrub/quotacheck.c create mode 100644 fs/xfs/scrub/quotacheck.h create mode 100644 fs/xfs/scrub/quotacheck_repair.c
PATCH 1/5 xfs: report the health of quota counts
From: Darrick J. Wong <[email protected]>
Report the health of quota counts.
--- fs/xfs/libxfs/xfs_fs.h | 1 + fs/xfs/libxfs/xfs_health.h | 4 +++- fs/xfs/xfs_health.c | 1 + fs/xfs/xfs_qm.c | 7 ++++++- fs/xfs/xfs_trans_dquot.c | 2 ++ 5 files changed, 13 insertions(+), 2 deletions(-)
fs/xfs/libxfs/xfs_fs.h +1 -0
@@ -195,6 +195,7 @@ struct xfs_fsop_geom {#define XFS_FSOP_GEOM_SICK_PQUOTA (1 << 3)/* project quota */ #define XFS_FSOP_GEOM_SICK_RT_BITMAP (1 << 4)/* realtime bitmap */ #define XFS_FSOP_GEOM_SICK_RT_SUMMARY (1 << 5)/* realtime summary */ +#define XFS_FSOP_GEOM_SICK_QUOTACHECK (1 << 6)/* quota counts */ /* Output for XFS_FS_COUNTS */ typedef struct xfs_fsop_counts {
fs/xfs/libxfs/xfs_health.h +3 -1
@@ -41,6 +41,7 @@ struct xfs_fsop_geom;#define XFS_SICK_FS_UQUOTA (1 << 1)/* user quota */ #define XFS_SICK_FS_GQUOTA (1 << 2)/* group quota */ #define XFS_SICK_FS_PQUOTA (1 << 3)/* project quota */ +#define XFS_SICK_FS_QUOTACHECK (1 << 4)/* quota counts */ /* Observable health issues for realtime volume metadata. */ #define XFS_SICK_RT_BITMAP (1 << 0)/* realtime bitmap */
@@ -77,7 +78,8 @@ struct xfs_fsop_geom;#define XFS_SICK_FS_PRIMARY (XFS_SICK_FS_COUNTERS | \ XFS_SICK_FS_UQUOTA | \ XFS_SICK_FS_GQUOTA | \ - XFS_SICK_FS_PQUOTA) + XFS_SICK_FS_PQUOTA | \ + XFS_SICK_FS_QUOTACHECK)#define XFS_SICK_RT_PRIMARY (XFS_SICK_RT_BITMAP | \ XFS_SICK_RT_SUMMARY)
fs/xfs/xfs_health.c +1 -0
@@ -280,6 +280,7 @@ static const struct ioctl_sick_map fs_map[] = { { XFS_SICK_FS_UQUOTA, XFS_FSOP_GEOM_SICK_UQUOTA }, { XFS_SICK_FS_GQUOTA, XFS_FSOP_GEOM_SICK_GQUOTA }, { XFS_SICK_FS_PQUOTA, XFS_FSOP_GEOM_SICK_PQUOTA }, + { XFS_SICK_FS_QUOTACHECK, XFS_FSOP_GEOM_SICK_QUOTACHECK }, { 0, 0 }, };
fs/xfs/xfs_qm.c +6 -1
@@ -26,6 +26,7 @@#include "xfs_ag.h" #include "xfs_ialloc.h" #include "xfs_log_priv.h" +#include "xfs_health.h" /* * The global quota manager. There is only one of these for the entire
@@ -1406,8 +1407,12 @@ xfs_qm_quotacheck(xfs_warn (mp,"Quotacheck: Failed to reset quota flags." ); } - }else +xfs_fs_mark_sick (mp,XFS_SICK_FS_QUOTACHECK ); + }else {xfs_notice (mp,"Quotacheck: Done." ); +xfs_fs_mark_healthy (mp,XFS_SICK_FS_QUOTACHECK ); + } +return error; error_purge:
fs/xfs/xfs_trans_dquot.c +2 -0
@@ -17,6 +17,7 @@#include "xfs_qm.h" #include "xfs_trace.h" #include "xfs_error.h" +#include "xfs_health.h" STATIC void xfs_trans_alloc_dqinfo(xfs_trans_t *);
@@ -706,6 +707,7 @@ xfs_trans_dqresv( error_corrupt:xfs_dqunlock (dqp);xfs_force_shutdown (mp,SHUTDOWN_CORRUPT_INCORE ); +xfs_fs_mark_sick (mp,XFS_SICK_FS_QUOTACHECK );return -EFSCORRUPTED ; }
Re: [PATCH 1/5] xfs: report the health of quota counts
Looks good:
PATCH 2/5 xfs: implement live quotacheck inode scan
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Create a new trio of scrub functions to check quota counters. While the dquots themselves are filesystem metadata and should be checked early, the dquot counter values are computed from other metadata and are therefore summary counters. We don't plug these into the scrub dispatch just yet, because we still need to be able to watch quota updates while doing our scan.
--- fs/xfs/Makefile | 1 fs/xfs/libxfs/xfs_fs.h | 3 fs/xfs/scrub/common.c | 43 ++++ fs/xfs/scrub/common.h | 11 + fs/xfs/scrub/fscounters.c | 2 fs/xfs/scrub/health.c | 1 fs/xfs/scrub/quotacheck.c | 512 +++++++++++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/quotacheck.h | 67 ++++++ fs/xfs/scrub/scrub.c | 6 + fs/xfs/scrub/scrub.h | 6 + fs/xfs/scrub/stats.c | 1 fs/xfs/scrub/trace.h | 28 ++ fs/xfs/scrub/xfarray.h | 19 ++ fs/xfs/xfs_inode.c | 21 ++ fs/xfs/xfs_inode.h | 2 15 files changed, 718 insertions(+), 5 deletions(-) create mode 100644 fs/xfs/scrub/quotacheck.c create mode 100644 fs/xfs/scrub/quotacheck.h
fs/xfs/Makefile +1 -0
@@ -181,6 +181,7 @@ xfs-$(CONFIG_XFS_RT) += $(addprefix scrub/, \ xfs-$(CONFIG_XFS_QUOTA) += $(addprefix scrub/, \ dqiterate.o \ quota.o \ + quotacheck.o \ ) # online repair
fs/xfs/libxfs/xfs_fs.h +2 -1
@@ -710,9 +710,10 @@ struct xfs_scrub_metadata {#define XFS_SCRUB_TYPE_GQUOTA 22/* group quotas */ #define XFS_SCRUB_TYPE_PQUOTA 23/* project quotas */ #define XFS_SCRUB_TYPE_FSCOUNTERS 24/* fs summary counters */ +#define XFS_SCRUB_TYPE_QUOTACHECK 25/* quota counters */ /* Number of scrub subcommands. */ -#define XFS_SCRUB_TYPE_NR 25 +#define XFS_SCRUB_TYPE_NR 26/* i: Repair this metadata. */ #define XFS_SCRUB_IFLAG_REPAIR (1u << 0)
fs/xfs/scrub/common.c +41 -2
79 lines not on this page · raw message
fs/xfs/scrub/common.h +11 -0
@@ -32,6 +32,7 @@ xchk_should_terminate( }int xchk_trans_alloc (struct xfs_scrub *sc,uint resblks); +int xchk_trans_alloc_empty (struct xfs_scrub *sc);void xchk_trans_cancel (struct xfs_scrub *sc); bool xchk_process_error(struct xfs_scrub *sc, xfs_agnumber_t agno,
@@ -54,6 +55,10 @@ void xchk_block_set_corrupt(struct xfs_scrub *sc,void xchk_ino_set_corrupt (struct xfs_scrub *sc,xfs_ino_t ino);void xchk_fblock_set_corrupt (struct xfs_scrub *sc,int whichfork,xfs_fileoff_t offset); +#ifdef CONFIG_XFS_QUOTA +void xchk_qcheck_set_corrupt (struct xfs_scrub *sc,unsigned int dqtype, +xfs_dqid_t id); +#endif /* CONFIG_XFS_QUOTA */ void xchk_block_xref_set_corrupt (struct xfs_scrub *sc,struct xfs_buf *bp);
@@ -105,6 +110,7 @@ xchk_setup_rtsummary(struct xfs_scrub *sc)#ifdef CONFIG_XFS_QUOTA int xchk_ino_dqattach (struct xfs_scrub *sc);int xchk_setup_quota (struct xfs_scrub *sc); +int xchk_setup_quotacheck (struct xfs_scrub *sc);#else static inline int xchk_ino_dqattach (struct xfs_scrub *sc)
@@ -116,6 +122,11 @@ xchk_setup_quota(struct xfs_scrub *sc) {return -ENOENT ; } +static inline int +xchk_setup_quotacheck (struct xfs_scrub *sc) +{ +return -ENOENT ; +}#endif int xchk_setup_fscounters (struct xfs_scrub *sc);
fs/xfs/scrub/fscounters.c +1 -1
@@ -242,7 +242,7 @@ xchk_setup_fscounters(return error; } -return xfs_trans_alloc_empty (sc->mp, &sc->tp); +return xchk_trans_alloc_empty (sc); }/*
fs/xfs/scrub/health.c +1 -0
@@ -107,6 +107,7 @@ static const struct xchk_health_map type_to_health_flag[XFS_SCRUB_TYPE_NR] = { [XFS_SCRUB_TYPE_GQUOTA] = { XHG_FS, XFS_SICK_FS_GQUOTA }, [XFS_SCRUB_TYPE_PQUOTA] = { XHG_FS, XFS_SICK_FS_PQUOTA }, [XFS_SCRUB_TYPE_FSCOUNTERS] = { XHG_FS, XFS_SICK_FS_COUNTERS }, + [XFS_SCRUB_TYPE_QUOTACHECK] = { XHG_FS, XFS_SICK_FS_QUOTACHECK }, };/* Return the health status mask for this scrub type. */
fs/xfs/scrub/quotacheck.c new file +512 -0
512 lines not on this page · raw message
fs/xfs/scrub/quotacheck.h new file +67 -0
67 lines not on this page · raw message
fs/xfs/scrub/scrub.c +6 -0
@@ -360,6 +360,12 @@ static const struct xchk_meta_ops meta_scrub_ops[] = { .scrub = xchk_fscounters, .repair = xrep_notsupported, }, + [XFS_SCRUB_TYPE_QUOTACHECK] = { /* quota counters */ + .type = ST_FS, + .setup = xchk_setup_quotacheck, + .scrub = xchk_quotacheck, + .repair = xrep_notsupported, + }, }; static int
fs/xfs/scrub/scrub.h +6 -0
@@ -167,12 +167,18 @@ xchk_rtsummary(struct xfs_scrub *sc)#endif #ifdef CONFIG_XFS_QUOTA int xchk_quota (struct xfs_scrub *sc); +int xchk_quotacheck (struct xfs_scrub *sc);#else static inline int xchk_quota (struct xfs_scrub *sc) {return -ENOENT ; } +static inline int +xchk_quotacheck (struct xfs_scrub *sc) +{ +return -ENOENT ; +}#endif int xchk_fscounters (struct xfs_scrub *sc);
fs/xfs/scrub/stats.c +1 -0
@@ -77,6 +77,7 @@ static const char *name_map[XFS_SCRUB_TYPE_NR] = { [XFS_SCRUB_TYPE_GQUOTA] = "grpquota", [XFS_SCRUB_TYPE_PQUOTA] = "prjquota", [XFS_SCRUB_TYPE_FSCOUNTERS] = "fscounters", + [XFS_SCRUB_TYPE_QUOTACHECK] = "quotacheck", };/* Format the scrub stats into a text buffer, similar to pcp style. */
fs/xfs/scrub/trace.h +27 -1
@@ -15,6 +15,7 @@#include <linux/tracepoint.h> #include "xfs_bit.h" +#include "xfs_quota_defs.h" struct xfs_scrub ;struct xfile ;
@@ -65,6 +66,7 @@ TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_UQUOTA);TRACE_DEFINE_ENUM (XFS_SCRUB_TYPE_GQUOTA );TRACE_DEFINE_ENUM (XFS_SCRUB_TYPE_PQUOTA );TRACE_DEFINE_ENUM (XFS_SCRUB_TYPE_FSCOUNTERS ); +TRACE_DEFINE_ENUM (XFS_SCRUB_TYPE_QUOTACHECK );#define XFS_SCRUB_TYPE_STRINGS \ { XFS_SCRUB_TYPE_PROBE, "probe" }, \
@@ -91,7 +93,8 @@ TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_FSCOUNTERS); { XFS_SCRUB_TYPE_UQUOTA, "usrquota" }, \ { XFS_SCRUB_TYPE_GQUOTA, "grpquota" }, \ { XFS_SCRUB_TYPE_PQUOTA, "prjquota" }, \ - { XFS_SCRUB_TYPE_FSCOUNTERS, "fscounters" } + { XFS_SCRUB_TYPE_FSCOUNTERS, "fscounters" }, \ + { XFS_SCRUB_TYPE_QUOTACHECK, "quotacheck" } #define XFS_SCRUB_FLAG_STRINGS \ { XFS_SCRUB_IFLAG_REPAIR, "repair" }, \
@@ -397,6 +400,29 @@ DEFINE_SCRUB_DQITER_EVENT(xchk_dquot_iter_revalidate_bmap);DEFINE_SCRUB_DQITER_EVENT (xchk_dquot_iter_advance_bmap);DEFINE_SCRUB_DQITER_EVENT (xchk_dquot_iter_advance_incore);DEFINE_SCRUB_DQITER_EVENT (xchk_dquot_iter); + +TRACE_EVENT (xchk_qcheck_error, + TP_PROTO(struct xfs_scrub *sc, xfs_dqtype_t dqtype, xfs_dqid_t id, + void *ret_ip), +TP_ARGS (sc, dqtype, id, ret_ip), +TP_STRUCT__entry ( + __field(dev_t, dev) + __field(xfs_dqtype_t, dqtype) + __field(xfs_dqid_t, id) + __field(void *, ret_ip) + ), +TP_fast_assign ( + __entry->dev = sc->mp->m_super->s_dev; + __entry->dqtype = dqtype; + __entry->id = id; + __entry->ret_ip = ret_ip; + ), +TP_printk ("dev %d:%d dquot type %s id 0x%x ret_ip %pS" , +MAJOR (__entry->dev),MINOR (__entry->dev), +__print_symbolic (__entry->dqtype,XFS_DQTYPE_STRINGS ), + __entry->id, + __entry->ret_ip) +);#endif /* CONFIG_XFS_QUOTA */ TRACE_EVENT(xchk_incomplete,
fs/xfs/scrub/xfarray.h +19 -0
@@ -45,6 +45,25 @@ int xfarray_store(struct xfarray *array, xfarray_idx_t idx, const void *ptr);int xfarray_store_anywhere (struct xfarray *array,const void *ptr);bool xfarray_element_is_null (struct xfarray *array,const void *ptr); +/* +* Load an array element, but zero the buffer if there's no data because we +* haven't stored to that array element yet. +*/ +static inline int +xfarray_load_sparse ( +struct xfarray *array, +uint64_t idx, +void *rec) +{ +int error =xfarray_load (array, idx, rec); + +if (error == -ENODATA ) { +memset (rec,0 , array->obj_size); +return 0 ; + } +return error; +} +/* Append an element to the array. */ static inline int xfarray_append (struct xfarray *array,const void *ptr) {
fs/xfs/xfs_inode.c +21 -0
@@ -3777,3 +3777,24 @@ xfs_ifork_zapped(return false; } } + +/* Compute the number of data and realtime blocks used by a file. */ +void +xfs_inode_count_blocks ( +struct xfs_trans *tp, +struct xfs_inode *ip, +xfs_filblks_t *dblocks, +xfs_filblks_t *rblocks) +{ +struct xfs_ifork *ifp =xfs_ifork_ptr (ip,XFS_DATA_FORK ); + +if (!XFS_IS_REALTIME_INODE (ip)) { + *dblocks = ip->i_nblocks; + *rblocks =0 ; +return ; + } + + *rblocks =0 ; +xfs_bmap_count_leaves (ifp, rblocks); + *dblocks = ip->i_nblocks - *rblocks; +}
fs/xfs/xfs_inode.h +2 -0
@@ -623,5 +623,7 @@ int xfs_inode_reload_unlinked_bucket(struct xfs_trans *tp, struct xfs_inode *ip)int xfs_inode_reload_unlinked (struct xfs_inode *ip);bool xfs_ifork_zapped (const struct xfs_inode *ip,int whichfork); +void xfs_inode_count_blocks (struct xfs_trans *tp,struct xfs_inode *ip, +xfs_filblks_t *dblocks,xfs_filblks_t *rblocks);#endif /* __XFS_INODE_H__ */
Re: [PATCH 2/5] xfs: implement live quotacheck inode scan
Looks good,
but a few nitpick below:
fs/xfs/scrub/common.c xchk_trans_cancel( · line 693
Quoted 6 lines
fs/xfs/scrub/common.c +6
-0+int +xchk_trans_alloc_empty ( +struct xfs_scrub *sc) +{ +return xfs_trans_alloc_empty (sc->mp, &sc->tp); +}
Can this and the conversion of an existing not quota related caller of xfs_trans_alloc_empty be split into a separate patch that also documents why this pretty trivial helper is useful?
fs/xfs/scrub/common.h void xchk_block_set_corrupt(struct xfs_scrub *sc, · line 61
Quoted 4 lines
fs/xfs/scrub/common.h +4
-0+#ifdef CONFIG_XFS_QUOTA +void xchk_qcheck_set_corrupt (struct xfs_scrub *sc,unsigned int dqtype, +xfs_dqid_t id); +#endif /* CONFIG_XFS_QUOTA */
No need for the ifdef here.
fs/xfs/scrub/quotacheck.c line 139
Quoted 13 lines
fs/xfs/scrub/quotacheck.c new file +13
-0+/* Figure out the data / rt device block counts. */ +xfs_ilock (ip,XFS_IOLOCK_SHARED ); +if (isreg) +xfs_ilock (ip,XFS_MMAPLOCK_SHARED ); +if (XFS_IS_REALTIME_INODE (ip)) { + ilock_flags =xfs_ilock_data_map_shared (ip); + error =xfs_iread_extents (tp, ip,XFS_DATA_FORK ); +if (error) + goto out_incomplete; + }else { + ilock_flags =XFS_ILOCK_SHARED ; +xfs_ilock (ip,XFS_ILOCK_SHARED ); + }
The need to call xfs_iread_extents only for RT inodes here look good, but I guess it is explained by the logic in xfs_inode_count_blocks. Maybe add a comment?
Quoted 8 lines
fs/xfs/scrub/xfarray.h +8
-0+/* +* Load an array element, but zero the buffer if there's no data because we +* haven't stored to that array element yet. +*/ +static inline int +xfarray_load_sparse( + struct xfarray *array, + uint64_t idx,
fs/xfs/scrub/xfarray.h int xfarray_store(struct xfarray *array, xfarray_idx_t idx, const void *ptr); · line 65
Quoted 10 lines
fs/xfs/scrub/xfarray.h +10
-0+ void *rec) +{ +int error =xfarray_load (array, idx, rec); + +if (error == -ENODATA ) { +memset (rec,0 , array->obj_size); +return 0 ; + } +return error; +}
Please split this into a separate prep patch.
Quoted 10 lines
fs/xfs/xfs_inode.c +10
-0+/* Compute the number of data and realtime blocks used by a file. */ +void +xfs_inode_count_blocks ( +struct xfs_trans *tp, +struct xfs_inode *ip, +xfs_filblks_t *dblocks, +xfs_filblks_t *rblocks) +{ +struct xfs_ifork *ifp =xfs_ifork_ptr (ip,XFS_DATA_FORK ); +
fs/xfs/xfs_inode.c xfs_ifork_zapped( · line 3800
Quoted 10 lines
fs/xfs/xfs_inode.c +10
-0+if (!XFS_IS_REALTIME_INODE (ip)) { + *dblocks = ip->i_nblocks; + *rblocks =0 ; +return ; + } + + *rblocks =0 ; +xfs_bmap_count_leaves (ifp, rblocks); + *dblocks = ip->i_nblocks - *rblocks; +}
Same for this one. The flow here also reads a little odd to me, what speaks against:
*rblocks = 0; if (XFS_IS_REALTIME_INODE(ip)) xfs_bmap_count_leaves(&ip->i_df, rblocks); *dblocks = ip->i_nblocks - *rblocks;
Re: [PATCH 2/5] xfs: implement live quotacheck inode scan
Quoted 4 lines · Christoph Hellwig
Looks good,
but a few nitpick below:
Quoted 10 lines
fs/xfs/scrub/common.c xchk_trans_cancel( · line 693
Quoted 6 lines
fs/xfs/scrub/common.c +6
-0+int +xchk_trans_alloc_empty ( +struct xfs_scrub *sc) +{ +return xfs_trans_alloc_empty (sc->mp, &sc->tp); +}Can this and the conversion of an existing not quota related caller of
xfs_trans_alloc_emptybe split into a separate patch that also documents why this pretty trivial helper is useful?
Done.
Quoted 6 lines
fs/xfs/scrub/common.h void xchk_block_set_corrupt(struct xfs_scrub *sc, · line 61
Quoted 4 lines
fs/xfs/scrub/common.h +4
-0+#ifdef CONFIG_XFS_QUOTA +void xchk_qcheck_set_corrupt (struct xfs_scrub *sc,unsigned int dqtype, +xfs_dqid_t id); +#endif /* CONFIG_XFS_QUOTA */ No need for the ifdef here.
Fixed.
Quoted 9 lines
Quoted 9 lines
fs/xfs/scrub/quotacheck.c new file +9
-0+/* Figure out the data / rt device block counts. */ +xfs_ilock (ip,XFS_IOLOCK_SHARED ); +if (isreg) +xfs_ilock (ip,XFS_MMAPLOCK_SHARED ); +if (XFS_IS_REALTIME_INODE (ip)) { + ilock_flags =xfs_ilock_data_map_shared (ip); + error =xfs_iread_extents (tp, ip,XFS_DATA_FORK ); +if (error) + goto out_incomplete;
Quoted 8 lines
fs/xfs/scrub/quotacheck.c line 139
Quoted 4 lines
fs/xfs/scrub/quotacheck.c new file +4
-0+ }else { + ilock_flags =XFS_ILOCK_SHARED ; +xfs_ilock (ip,XFS_ILOCK_SHARED ); + }The need to call
xfs_iread_extentsonly for RT inodes here look good, but I guess it is explained by the logic inxfs_inode_count_blocks. Maybe add a comment?
/*
* Read in the data fork for rt files so that _count_blocks
* can count the number of blocks allocated from the rt volume.
* Inodes do not track that separately.
*/
Quoted 12 lines
Quoted 12 lines
fs/xfs/scrub/xfarray.h +12
-0+/* +* Load an array element, but zero the buffer if there's no data because we +* haven't stored to that array element yet. +*/ +static inline int +xfarray_load_sparse ( +struct xfarray *array, +uint64_t idx, +void *rec) +{ +int error =xfarray_load (array, idx, rec); +
Quoted 8 lines
fs/xfs/scrub/xfarray.h int xfarray_store(struct xfarray *array, xfarray_idx_t idx, const void *ptr); · line 65
Quoted 6 lines
fs/xfs/scrub/xfarray.h +6
-0+if (error == -ENODATA ) { +memset (rec,0 , array->obj_size); +return 0 ; + } +return error; +}Please split this into a separate prep patch.
Done.
Quoted 24 lines
Quoted 10 lines
fs/xfs/xfs_inode.c +10
-0+/* Compute the number of data and realtime blocks used by a file. */ +void +xfs_inode_count_blocks ( +struct xfs_trans *tp, +struct xfs_inode *ip, +xfs_filblks_t *dblocks, +xfs_filblks_t *rblocks) +{ +struct xfs_ifork *ifp =xfs_ifork_ptr (ip,XFS_DATA_FORK ); +fs/xfs/xfs_inode.c xfs_ifork_zapped( · line 3800
Quoted 10 lines
fs/xfs/xfs_inode.c +10
-0+if (!XFS_IS_REALTIME_INODE (ip)) { + *dblocks = ip->i_nblocks; + *rblocks =0 ; +return ; + } + + *rblocks =0 ; +xfs_bmap_count_leaves (ifp, rblocks); + *dblocks = ip->i_nblocks - *rblocks; +}Same for this one. The flow here also reads a little odd to me, what speaks against:
Quoted 4 lines
*rblocks = 0; if (XFS_IS_REALTIME_INODE(ip)) xfs_bmap_count_leaves(&ip->i_df, rblocks); *dblocks = ip->i_nblocks - *rblocks;
Yeah, that is more tidy. Thanks for the suggestion, I'll incorporate that.
--D
Re: [PATCH 2/5] xfs: implement live quotacheck inode scan
Quoted 18 lines · Darrick J. Wong
Quoted 4 lines · Christoph Hellwig
Looks good,
but a few nitpick below:
Quoted 10 lines
fs/xfs/scrub/common.c xchk_trans_cancel( · line 693
Quoted 6 lines
fs/xfs/scrub/common.c +6
-0+int +xchk_trans_alloc_empty ( +struct xfs_scrub *sc) +{ +return xfs_trans_alloc_empty (sc->mp, &sc->tp); +}Can this and the conversion of an existing not quota related caller of
xfs_trans_alloc_emptybe split into a separate patch that also documents why this pretty trivial helper is useful?Done.
Quoted 8 lines
Quoted 6 lines
fs/xfs/scrub/common.h void xchk_block_set_corrupt(struct xfs_scrub *sc, · line 61
Quoted 4 lines
fs/xfs/scrub/common.h +4
-0+#ifdef CONFIG_XFS_QUOTA +void xchk_qcheck_set_corrupt (struct xfs_scrub *sc,unsigned int dqtype, +xfs_dqid_t id); +#endif /* CONFIG_XFS_QUOTA */ No need for the ifdef here.
Fixed.
...and reverted because I forgot to remove the #ifdef around the tracepoint in that function. I tried to fix that, and got a ton of macro spew over ... something not being defined. In the end, I decided that it was better not to waste memory on !CONFIG_XFS_QUOTA and not to waste time on minor things like this.
(I spent all day rebasing to for-next again because I didn't realize that Chandan had pulled in a bunch more of your cleanups.)
--D
Quoted 81 lines
Quoted 9 lines
Quoted 9 lines
fs/xfs/scrub/quotacheck.c new file +9
-0+/* Figure out the data / rt device block counts. */ +xfs_ilock (ip,XFS_IOLOCK_SHARED ); +if (isreg) +xfs_ilock (ip,XFS_MMAPLOCK_SHARED ); +if (XFS_IS_REALTIME_INODE (ip)) { + ilock_flags =xfs_ilock_data_map_shared (ip); + error =xfs_iread_extents (tp, ip,XFS_DATA_FORK ); +if (error) + goto out_incomplete;Quoted 8 lines
fs/xfs/scrub/quotacheck.c line 139
Quoted 4 lines
fs/xfs/scrub/quotacheck.c new file +4
-0+ }else { + ilock_flags =XFS_ILOCK_SHARED ; +xfs_ilock (ip,XFS_ILOCK_SHARED ); + }The need to call
xfs_iread_extentsonly for RT inodes here look good, but I guess it is explained by the logic inxfs_inode_count_blocks. Maybe add a comment?/*
* Read in the data fork for rt files so that_count_blocks
* can count the number of blocks allocated from the rt volume.
* Inodes do not track that separately.
*/Quoted 12 lines
Quoted 12 lines
fs/xfs/scrub/xfarray.h +12
-0+/* +* Load an array element, but zero the buffer if there's no data because we +* haven't stored to that array element yet. +*/ +static inline int +xfarray_load_sparse ( +struct xfarray *array, +uint64_t idx, +void *rec) +{ +int error =xfarray_load (array, idx, rec); +Quoted 8 lines
fs/xfs/scrub/xfarray.h int xfarray_store(struct xfarray *array, xfarray_idx_t idx, const void *ptr); · line 65
Quoted 6 lines
fs/xfs/scrub/xfarray.h +6
-0+if (error == -ENODATA ) { +memset (rec,0 , array->obj_size); +return 0 ; + } +return error; +}Please split this into a separate prep patch.
Done.
Quoted 24 lines
Quoted 10 lines
fs/xfs/xfs_inode.c +10
-0+/* Compute the number of data and realtime blocks used by a file. */ +void +xfs_inode_count_blocks ( +struct xfs_trans *tp, +struct xfs_inode *ip, +xfs_filblks_t *dblocks, +xfs_filblks_t *rblocks) +{ +struct xfs_ifork *ifp =xfs_ifork_ptr (ip,XFS_DATA_FORK ); +fs/xfs/xfs_inode.c xfs_ifork_zapped( · line 3800
Quoted 10 lines
fs/xfs/xfs_inode.c +10
-0+if (!XFS_IS_REALTIME_INODE (ip)) { + *dblocks = ip->i_nblocks; + *rblocks =0 ; +return ; + } + + *rblocks =0 ; +xfs_bmap_count_leaves (ifp, rblocks); + *dblocks = ip->i_nblocks - *rblocks; +}Same for this one. The flow here also reads a little odd to me, what speaks against:
Quoted 4 lines
*rblocks = 0; if (XFS_IS_REALTIME_INODE(ip)) xfs_bmap_count_leaves(&ip->i_df, rblocks); *dblocks = ip->i_nblocks - *rblocks;Yeah, that is more tidy. Thanks for the suggestion, I'll incorporate that.
--D
Re: [PATCH 2/5] xfs: implement live quotacheck inode scan
Quoted 7 lines · Darrick J. Wong
Quoted 7 lines
Quoted 6 lines
fs/xfs/scrub/common.h void xchk_block_set_corrupt(struct xfs_scrub *sc, · line 61
Quoted 4 lines
fs/xfs/scrub/common.h +4
-0+#ifdef CONFIG_XFS_QUOTA +void xchk_qcheck_set_corrupt (struct xfs_scrub *sc,unsigned int dqtype, +xfs_dqid_t id); +#endif /* CONFIG_XFS_QUOTA */ No need for the ifdef here.
Quoted 7 lines
Quoted 1 line
Fixed.
...and reverted because I forgot to remove the #ifdef around the tracepoint in that function. I tried to fix that, and got a ton of macro spew over ... something not being defined. In the end, I decided that it was better not to waste memory on !CONFIG_XFS_QUOTA and not to waste time on minor things like this.
Note that I only meant the ifdef on the declaration in the header, not for the function itself anyway, sorry.
PATCH 3/5 xfs: track quota updates during live quotacheck
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Create a shadow dqtrx system in the quotacheck code that hooks the regular dquot counter update code. This will be the means to keep our copy of the dquot counters up to date while the scan runs in real time.
--- fs/xfs/scrub/common.c | 4 + fs/xfs/scrub/quotacheck.c | 358 ++++++++++++++++++++++++++++++++++++++++++++- fs/xfs/scrub/quotacheck.h | 6 + fs/xfs/scrub/scrub.c | 3 fs/xfs/scrub/scrub.h | 4 - fs/xfs/scrub/trace.h | 1 fs/xfs/xfs_qm.c | 16 +- fs/xfs/xfs_qm.h | 16 ++ fs/xfs/xfs_qm_bhv.c | 1 fs/xfs/xfs_quota.h | 45 ++++++ fs/xfs/xfs_trans_dquot.c | 156 +++++++++++++++++++- 11 files changed, 594 insertions(+), 16 deletions(-)
fs/xfs/scrub/common.c +4 -0
@@ -30,6 +30,7 @@#include "xfs_reflink.h" #include "xfs_ag.h" #include "xfs_error.h" +#include "xfs_quota.h" #include "scrub/scrub.h" #include "scrub/common.h" #include "scrub/trace.h"
@@ -1298,6 +1299,9 @@ xchk_fsgates_enable(if (scrub_fsgates &XCHK_FSGATES_DRAIN )xfs_drain_wait_enable (); +if (scrub_fsgates &XCHK_FSGATES_QUOTA ) +xfs_dqtrx_hook_enable (); + sc->flags |= scrub_fsgates; }
fs/xfs/scrub/quotacheck.c +353 -5
443 lines not on this page · raw message
fs/xfs/scrub/quotacheck.h +6 -0
@@ -43,6 +43,12 @@ struct xqcheck {struct mutex lock;struct xchk_iscan iscan; + +/* Hooks into the quota code. */ +struct xfs_dqtrx_hook hooks; + +/* Shadow quota delta tracking structure. */ +struct rhashtable shadow_dquot_acct; };/* Return the incore counter array for a given quota type. */
fs/xfs/scrub/scrub.c +3 -0
@@ -157,6 +157,9 @@ xchk_fsgates_disable(if (sc->flags &XCHK_FSGATES_DRAIN )xfs_drain_wait_disable (); +if (sc->flags &XCHK_FSGATES_QUOTA ) +xfs_dqtrx_hook_disable (); + sc->flags &= ~XCHK_FSGATES_ALL ; }
fs/xfs/scrub/scrub.h +3 -1
@@ -121,6 +121,7 @@ struct xfs_scrub {#define XCHK_HAVE_FREEZE_PROT (1U << 1)/* do we have freeze protection? */ #define XCHK_FSGATES_DRAIN (1U << 2)/* defer ops draining enabled */ #define XCHK_NEED_DRAIN (1U << 3)/* scrub needs to drain defer ops */ +#define XCHK_FSGATES_QUOTA (1U << 4)/* quota live update enabled */ #define XREP_RESET_PERAG_RESV (1U << 30)/* must reset AG space reservation */ #define XREP_ALREADY_FIXED (1U << 31)/* checking our repair work */
@@ -130,7 +131,8 @@ struct xfs_scrub {* features are gated off via dynamic code patching, which is why the state * must be enabled during scrub setup and can only be torn down afterwards. */ -#define XCHK_FSGATES_ALL (XCHK_FSGATES_DRAIN) +#define XCHK_FSGATES_ALL (XCHK_FSGATES_DRAIN | \ + XCHK_FSGATES_QUOTA)/* Metadata scrubbers */ int xchk_tester (struct xfs_scrub *sc);
fs/xfs/scrub/trace.h +1 -0
@@ -112,6 +112,7 @@ TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_QUOTACHECK); { XCHK_HAVE_FREEZE_PROT, "nofreeze" }, \ { XCHK_FSGATES_DRAIN, "fsgates_drain" }, \ { XCHK_NEED_DRAIN, "need_drain" }, \ + { XCHK_FSGATES_QUOTA, "fsgates_quota" }, \ { XREP_RESET_PERAG_RESV, "reset_perag_resv" }, \ { XREP_ALREADY_FIXED, "already_fixed" }
fs/xfs/xfs_qm.c +9 -7
@@ -692,6 +692,9 @@ xfs_qm_init_quotainfo(shrinker_register (qinf->qi_shrinker); +xfs_hooks_init (&qinf->qi_mod_ino_dqtrx_hooks); +xfs_hooks_init (&qinf->qi_apply_dqtrx_hooks); +return 0 ; out_free_inos:
@@ -1822,12 +1825,12 @@ xfs_qm_vop_chown(ASSERT (prevdq);ASSERT (prevdq != newdq); -xfs_trans_mod_dquot (tp, prevdq, bfield, -(ip->i_nblocks)); -xfs_trans_mod_dquot (tp, prevdq,XFS_TRANS_DQ_ICOUNT ,-1 ); +xfs_trans_mod_ino_dquot (tp, ip, prevdq, bfield, -(ip->i_nblocks)); +xfs_trans_mod_ino_dquot (tp, ip, prevdq,XFS_TRANS_DQ_ICOUNT ,-1 );/* the sparkling new dquot */ -xfs_trans_mod_dquot (tp, newdq, bfield, ip->i_nblocks); -xfs_trans_mod_dquot (tp, newdq,XFS_TRANS_DQ_ICOUNT ,1 ); +xfs_trans_mod_ino_dquot (tp, ip, newdq, bfield, ip->i_nblocks); +xfs_trans_mod_ino_dquot (tp, ip, newdq,XFS_TRANS_DQ_ICOUNT ,1 );/* * Back when we made quota reservations for the chown, we reserved the
@@ -1909,22 +1912,21 @@ xfs_qm_vop_create_dqattach(ASSERT (i_uid_read (VFS_I (ip)) == udqp->q_id); ip->i_udquot =xfs_qm_dqhold (udqp); -xfs_trans_mod_dquot (tp, udqp,XFS_TRANS_DQ_ICOUNT ,1 ); }if (gdqp &&XFS_IS_GQUOTA_ON (mp)) {ASSERT (ip->i_gdquot ==NULL );ASSERT (i_gid_read (VFS_I (ip)) == gdqp->q_id); ip->i_gdquot =xfs_qm_dqhold (gdqp); -xfs_trans_mod_dquot (tp, gdqp,XFS_TRANS_DQ_ICOUNT ,1 ); }if (pdqp &&XFS_IS_PQUOTA_ON (mp)) {ASSERT (ip->i_pdquot ==NULL );ASSERT (ip->i_projid == pdqp->q_id); ip->i_pdquot =xfs_qm_dqhold (pdqp); -xfs_trans_mod_dquot (tp, pdqp,XFS_TRANS_DQ_ICOUNT ,1 ); } + +xfs_trans_mod_dquot_byino (tp, ip,XFS_TRANS_DQ_ICOUNT ,1 ); }/* Decide if this inode's dquot is near an enforcement boundary. */
fs/xfs/xfs_qm.h +16 -0
@@ -68,6 +68,10 @@ struct xfs_quotainfo {/* Minimum and maximum quota expiration timestamp values. */ time64_t qi_expiry_min;time64_t qi_expiry_max; + +/* Hook to feed quota counter updates to an active online repair. */ +struct xfs_hooks qi_mod_ino_dqtrx_hooks; +struct xfs_hooks qi_apply_dqtrx_hooks; }; static inline struct radix_tree_root *
@@ -104,6 +108,18 @@ xfs_quota_inode(struct xfs_mount *mp, xfs_dqtype_t type)return NULL ; } +/* +* Parameters for tracking dqtrx changes on behalf of an inode. The hook +* function arg parameter is the field being updated. +*/ +struct xfs_mod_ino_dqtrx_params { +uintptr_t tx_id; +xfs_ino_t ino; +xfs_dqtype_t q_type; +xfs_dqid_t q_id; +int64_t delta; +}; +extern void xfs_trans_mod_dquot (struct xfs_trans *tp,struct xfs_dquot *dqp,uint field,int64_t delta);extern void xfs_trans_dqjoin (struct xfs_trans *,struct xfs_dquot *);
fs/xfs/xfs_qm_bhv.c +1 -0
@@ -9,6 +9,7 @@#include "xfs_format.h" #include "xfs_log_format.h" #include "xfs_trans_resv.h" +#include "xfs_mount.h" #include "xfs_quota.h" #include "xfs_mount.h" #include "xfs_inode.h"
fs/xfs/xfs_quota.h +45 -0
63 lines not on this page · raw message
fs/xfs/xfs_trans_dquot.c +153 -3
194 lines not on this page · raw message
Re: [PATCH 3/5] xfs: track quota updates during live quotacheck
Looks good:
PATCH 4/5 xfs: repair cannot update the summary counters when logging quota flags
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
While running xfs/804 (quota repairs racing with fsstress), I observed a filesystem shutdown in the primary sb write verifier:
run fstests xfs/804 at 2022-05-23 18:43:48
XFS (sda4): Mounting V5 Filesystem
XFS (sda4): Ending clean mount
XFS (sda4): Quotacheck needed: Please wait.
XFS (sda4): Quotacheck: Done.
XFS (sda4): EXPERIMENTAL online scrub feature in use. Use at your own risk!
XFS (sda4): SB ifree sanity check failed 0xb5 > 0x80
XFS (sda4): Metadata corruption detected at xfs_sb_write_verify+0x5e/0x100 [xfs], xfs_sb block 0x0 XFS (sda4): Unmount and run xfs_repair
The "SB ifree sanity check failed" message was a debugging printk that I added to the kernel; observe that 0xb5 - 0x80 = 53, which is less than one inode chunk.
I traced this to the xfs_log_sb calls from the online quota repair code, which tries to clear the CHKD flags from the superblock to force a mount-time quotacheck if the repair fails. On a V5 filesystem, xfs_log_sb updates the ondisk sb summary counters with the current contents of the percpu counters. This is done without quiescing other writer threads, which means it could be racing with a thread that has updated icount and is about to update ifree.
If the other write thread had incremented ifree before updating icount, the repair thread will write icount > ifree into the logged update. If the AIL writes the logged superblock back to disk before anyone else fixes this siutation, this will lead to a write verifier failure, which causes a filesystem shutdown.
Resolve this problem by updating the quota flags and calling xfs_sb_to_disk directly, which does not touch the percpu counters. While we're at it, we can elide the entire update if the selected qflags aren't set.
--- fs/xfs/scrub/repair.c | 41 ++++++++++++++++++++++++++++++++++------- 1 file changed, 34 insertions(+), 7 deletions(-)
fs/xfs/scrub/repair.c +34 -7
@@ -687,6 +687,39 @@ xrep_find_ag_btree_roots( }#ifdef CONFIG_XFS_QUOTA +/* Update some quota flags in the superblock. */ +static void +xrep_update_qflags ( +struct xfs_scrub *sc, +unsigned int clear_flags) +{ +struct xfs_mount *mp = sc->mp; +struct xfs_buf *bp; + +mutex_lock (&mp->m_quotainfo->qi_quotaofflock); +if ((mp->m_qflags & clear_flags) ==0 ) + goto no_update; + + mp->m_qflags &= ~clear_flags; +spin_lock (&mp->m_sb_lock); + mp->m_sb.sb_qflags &= ~clear_flags; +spin_unlock (&mp->m_sb_lock); + +/* +* Update the quota flags in the ondisk superblock without touching +* the summary counters. We have not quiesced inode chunk allocation, +* so we cannot coordinate with updates to the icount and ifree percpu +* counters. +*/ + bp =xfs_trans_getsb (sc->tp); +xfs_sb_to_disk (bp->b_addr, &mp->m_sb); +xfs_trans_buf_set_type (sc->tp, bp,XFS_BLFT_SB_BUF ); +xfs_trans_log_buf (sc->tp, bp,0 ,sizeof (struct xfs_dsb ) -1 ); + +no_update: +mutex_unlock (&sc->mp->m_quotainfo->qi_quotaofflock); +} +/* Force a quotacheck the next time we mount. */ void xrep_force_quotacheck(
@@ -699,13 +732,7 @@ xrep_force_quotacheck(if (!(flag & sc->mp->m_qflags))return ; -mutex_lock (&sc->mp->m_quotainfo->qi_quotaofflock); - sc->mp->m_qflags &= ~flag; -spin_lock (&sc->mp->m_sb_lock); - sc->mp->m_sb.sb_qflags &= ~flag; -spin_unlock (&sc->mp->m_sb_lock); -xfs_log_sb (sc->tp); -mutex_unlock (&sc->mp->m_quotainfo->qi_quotaofflock); +xrep_update_qflags (sc, flag); }/*
Re: [PATCH 4/5] xfs: repair cannot update the summary counters when logging quota flags
fs/xfs/scrub/repair.c xrep_find_ag_btree_roots( · line 717
Quoted 4 lines
fs/xfs/scrub/repair.c +4
-0+ bp =xfs_trans_getsb (sc->tp); +xfs_sb_to_disk (bp->b_addr, &mp->m_sb); +xfs_trans_buf_set_type (sc->tp, bp,XFS_BLFT_SB_BUF ); +xfs_trans_log_buf (sc->tp, bp,0 ,sizeof (struct xfs_dsb ) -1 );
We now have a multiple copies of this code sequence and it would probably be good to have a helper for it. Given that the current xfs_log_sb is a bit misnamed I'd be alsmost tempted to use the name just for this and split the lazy counter updates into a separate helper. That also makes it very clear that we'd need to explicitly opt into syncing them and prvent accidental bugs like this one. But I'd also be fine with another name instead of duplicating it here and in the pending imeta code.
Re: [PATCH 4/5] xfs: repair cannot update the summary counters when logging quota flags
Quoted 9 lines · Christoph Hellwig
fs/xfs/scrub/repair.c xrep_find_ag_btree_roots( · line 717
Quoted 4 lines
fs/xfs/scrub/repair.c +4
-0+ bp =xfs_trans_getsb (sc->tp); +xfs_sb_to_disk (bp->b_addr, &mp->m_sb); +xfs_trans_buf_set_type (sc->tp, bp,XFS_BLFT_SB_BUF ); +xfs_trans_log_buf (sc->tp, bp,0 ,sizeof (struct xfs_dsb ) -1 );We now have a multiple copies of this code sequence and it would probably be good to have a helper for it. Given that the current
xfs_log_sbis a bit misnamed I'd be alsmost tempted to use the name just for this and split the lazy counter updates into a separate helper.
Since we're really only updating feature flags, how about these three lines become a new xfs_trans_log_sb_featureset() helper?
That's not a totally precise name since we're logging everything /except/ the lazysbcount fields though.
Quoted 4 lines
That also makes it very clear that we'd need to explicitly opt into syncing them and prvent accidental bugs like this one. But I'd also be fine with another name instead of duplicating it here and in the pending imeta code.
If we go ahead with your suggestion not to update the superblock under the hood in the xfs_imeta.[ch] for !metadir filesystems then there won't be a third caller.
--D
PATCH 5/5 xfs: repair dquots based on live quotacheck results
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Use the shadow quota counters that live quotacheck creates to reset the incore dquot counters.
--- fs/xfs/Makefile | 1 fs/xfs/scrub/quotacheck.c | 4 - fs/xfs/scrub/quotacheck.h | 3 fs/xfs/scrub/quotacheck_repair.c | 261 ++++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/repair.c | 13 +- fs/xfs/scrub/repair.h | 5 + fs/xfs/scrub/scrub.c | 2 fs/xfs/scrub/trace.h | 1 8 files changed, 284 insertions(+), 6 deletions(-) create mode 100644 fs/xfs/scrub/quotacheck_repair.c
fs/xfs/Makefile +1 -0
@@ -205,6 +205,7 @@ xfs-$(CONFIG_XFS_RT) += $(addprefix scrub/, \ xfs-$(CONFIG_XFS_QUOTA) += $(addprefix scrub/, \ quota_repair.o \ + quotacheck_repair.o \ ) endif endif
fs/xfs/scrub/quotacheck.c +3 -1
@@ -102,7 +102,9 @@ xchk_setup_quotacheck(* set the INCOMPLETE flag even when a negative errno is returned. This care * must be taken with certain errno values (i.e. EFSBADCRC, EFSCORRUPTED, * ECANCELED) that are absorbed into a scrub state flag update by -* xchk_*_process_error. +* xchk_*_process_error. Scrub and repair share the same incore data +* structures, so the INCOMPLETE flag is critical to prevent a repair based on +* insufficient information. * * Because we are scanning a live filesystem, it's possible that another thread * will try to update the quota counters for an inode that we've already
fs/xfs/scrub/quotacheck.h +3 -0
@@ -30,6 +30,9 @@ struct xqcheck_dquot {/* Already checked this dquot. */ #define XQCHECK_DQUOT_COMPARE_SCANNED (1U << 1) +/* Already repaired this dquot. */ +#define XQCHECK_DQUOT_REPAIR_SCANNED (1U << 2) +/* Live quotacheck control structure. */ struct xqcheck {struct xfs_scrub *sc;
fs/xfs/scrub/quotacheck_repair.c new file +261 -0
261 lines not on this page · raw message
fs/xfs/scrub/repair.c +9 -4
@@ -688,21 +688,26 @@ xrep_find_ag_btree_roots(#ifdef CONFIG_XFS_QUOTA /* Update some quota flags in the superblock. */ -static void +void xrep_update_qflags (struct xfs_scrub *sc, -unsigned int clear_flags) +unsigned int clear_flags, +unsigned int set_flags) {struct xfs_mount *mp = sc->mp;struct xfs_buf *bp;mutex_lock (&mp->m_quotainfo->qi_quotaofflock); -if ((mp->m_qflags & clear_flags) ==0 ) +if ((mp->m_qflags & clear_flags) ==0 && + (mp->m_qflags & set_flags) == set_flags) goto no_update; mp->m_qflags &= ~clear_flags; + mp->m_qflags |= set_flags; +spin_lock (&mp->m_sb_lock); mp->m_sb.sb_qflags &= ~clear_flags; + mp->m_sb.sb_qflags |= set_flags;spin_unlock (&mp->m_sb_lock);/*
@@ -732,7 +737,7 @@ xrep_force_quotacheck(if (!(flag & sc->mp->m_qflags))return ; -xrep_update_qflags (sc, flag); +xrep_update_qflags (sc, flag,0 ); }/*
fs/xfs/scrub/repair.h +5 -0
@@ -72,6 +72,8 @@ int xrep_find_ag_btree_roots(struct xfs_scrub *sc, struct xfs_buf *agf_bp, struct xrep_find_ag_btree *btree_info, struct xfs_buf *agfl_bp);#ifdef CONFIG_XFS_QUOTA +void xrep_update_qflags (struct xfs_scrub *sc,unsigned int clear_flags, +unsigned int set_flags);void xrep_force_quotacheck (struct xfs_scrub *sc,xfs_dqtype_t type);int xrep_ino_dqattach (struct xfs_scrub *sc);#else
@@ -123,8 +125,10 @@ int xrep_rtbitmap(struct xfs_scrub *sc);#ifdef CONFIG_XFS_QUOTA int xrep_quota (struct xfs_scrub *sc); +int xrep_quotacheck (struct xfs_scrub *sc);#else # define xrep_quota xrep_notsupported +# define xrep_quotacheck xrep_notsupported#endif /* CONFIG_XFS_QUOTA */ int xrep_reinit_pagf (struct xfs_scrub *sc);
@@ -191,6 +195,7 @@ xrep_setup_nothing(#define xrep_bmap_cow xrep_notsupported#define xrep_rtbitmap xrep_notsupported#define xrep_quota xrep_notsupported +#define xrep_quotacheck xrep_notsupported#endif /* CONFIG_XFS_ONLINE_REPAIR */
fs/xfs/scrub/scrub.c +1 -1
@@ -367,7 +367,7 @@ static const struct xchk_meta_ops meta_scrub_ops[] = { .type = ST_FS, .setup = xchk_setup_quotacheck, .scrub = xchk_quotacheck, - .repair = xrep_notsupported, + .repair = xrep_quotacheck, }, };
fs/xfs/scrub/trace.h +1 -0
@@ -1977,6 +1977,7 @@ DEFINE_EVENT(xrep_dquot_class, name, \DEFINE_XREP_DQUOT_EVENT (xrep_dquot_item);DEFINE_XREP_DQUOT_EVENT (xrep_disk_dquot);DEFINE_XREP_DQUOT_EVENT (xrep_dquot_item_fill_bmap_hole); +DEFINE_XREP_DQUOT_EVENT (xrep_quotacheck_dquot);#endif /* CONFIG_XFS_QUOTA */ #endif /* IS_ENABLED(CONFIG_XFS_ONLINE_REPAIR) */
Re: [PATCH 5/5] xfs: repair dquots based on live quotacheck results
Looks good:
PATCH 4/28 xfs: online repair of file link counts
In reply to Darrick J. WongHi all,
Now that we've created the infrastructure to perform live scans of every file in the filesystem and the necessary hook infrastructure to observe live updates, use it to scan directories to compute the correct link counts for files in the filesystem, and reset those link counts.
This patchset creates a tailored readdir implementation for scrub because the regular version has to cycle ILOCKs to copy information to userspace. We can't cycle the ILOCK during the nlink scan and we don't need all the other VFS support code (maintaining a readdir cursor and translating XFS structures to VFS structures and back) so it was easier to duplicate the code.
If you're going to start using this code, I strongly recommend pulling from my git trees, which are linked below.
This has been running on the djcloud for months with no problems. Enjoy! Comments and questions are, as always, welcome.
--D
kernel git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfs-linux.git/log/?h=scrub-nlinks
xfsprogs git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfsprogs-dev.git/log/?h=scrub-nlinks
fstests git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfstests-dev.git/log/?h=scrub-nlinks
--- fs/xfs/Makefile | 2 fs/xfs/libxfs/xfs_fs.h | 4 fs/xfs/libxfs/xfs_health.h | 4 fs/xfs/scrub/common.c | 3 fs/xfs/scrub/common.h | 1 fs/xfs/scrub/health.c | 1 fs/xfs/scrub/nlinks.c | 930 ++++++++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/nlinks.h | 102 +++++ fs/xfs/scrub/nlinks_repair.c | 223 ++++++++++ fs/xfs/scrub/repair.h | 2 fs/xfs/scrub/scrub.c | 9 fs/xfs/scrub/scrub.h | 5 fs/xfs/scrub/stats.c | 1 fs/xfs/scrub/trace.c | 2 fs/xfs/scrub/trace.h | 183 ++++++++ fs/xfs/xfs_health.c | 1 fs/xfs/xfs_inode.c | 108 +++++ fs/xfs/xfs_inode.h | 31 + fs/xfs/xfs_mount.h | 3 fs/xfs/xfs_super.c | 2 fs/xfs/xfs_symlink.c | 1 21 files changed, 1614 insertions(+), 4 deletions(-) create mode 100644 fs/xfs/scrub/nlinks.c create mode 100644 fs/xfs/scrub/nlinks.h create mode 100644 fs/xfs/scrub/nlinks_repair.c
PATCH 1/4 xfs: report health of inode link counts
From: Darrick J. Wong <[email protected]>
Report on the health of the inode link counts.
--- fs/xfs/libxfs/xfs_fs.h | 1 + fs/xfs/libxfs/xfs_health.h | 4 +++- fs/xfs/xfs_health.c | 1 + 3 files changed, 5 insertions(+), 1 deletion(-)
fs/xfs/libxfs/xfs_fs.h +1 -0
@@ -196,6 +196,7 @@ struct xfs_fsop_geom {#define XFS_FSOP_GEOM_SICK_RT_BITMAP (1 << 4)/* realtime bitmap */ #define XFS_FSOP_GEOM_SICK_RT_SUMMARY (1 << 5)/* realtime summary */ #define XFS_FSOP_GEOM_SICK_QUOTACHECK (1 << 6)/* quota counts */ +#define XFS_FSOP_GEOM_SICK_NLINKS (1 << 7)/* inode link counts */ /* Output for XFS_FS_COUNTS */ typedef struct xfs_fsop_counts {
fs/xfs/libxfs/xfs_health.h +3 -1
@@ -42,6 +42,7 @@ struct xfs_fsop_geom;#define XFS_SICK_FS_GQUOTA (1 << 2)/* group quota */ #define XFS_SICK_FS_PQUOTA (1 << 3)/* project quota */ #define XFS_SICK_FS_QUOTACHECK (1 << 4)/* quota counts */ +#define XFS_SICK_FS_NLINKS (1 << 5)/* inode link counts */ /* Observable health issues for realtime volume metadata. */ #define XFS_SICK_RT_BITMAP (1 << 0)/* realtime bitmap */
@@ -79,7 +80,8 @@ struct xfs_fsop_geom;XFS_SICK_FS_UQUOTA | \XFS_SICK_FS_GQUOTA | \XFS_SICK_FS_PQUOTA | \ - XFS_SICK_FS_QUOTACHECK) +XFS_SICK_FS_QUOTACHECK | \ + XFS_SICK_FS_NLINKS) #define XFS_SICK_RT_PRIMARY (XFS_SICK_RT_BITMAP | \XFS_SICK_RT_SUMMARY )
fs/xfs/xfs_health.c +1 -0
@@ -281,6 +281,7 @@ static const struct ioctl_sick_map fs_map[] = { { XFS_SICK_FS_GQUOTA, XFS_FSOP_GEOM_SICK_GQUOTA }, { XFS_SICK_FS_PQUOTA, XFS_FSOP_GEOM_SICK_PQUOTA }, { XFS_SICK_FS_QUOTACHECK, XFS_FSOP_GEOM_SICK_QUOTACHECK }, + { XFS_SICK_FS_NLINKS, XFS_FSOP_GEOM_SICK_NLINKS }, { 0, 0 }, };
Re: [PATCH 1/4] xfs: report health of inode link counts
Looks good:
PATCH 2/4 xfs: teach scrub to check file nlinks
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Create the necessary scrub code to walk the filesystem's directory tree so that we can compute file link counts. Similar to quotacheck, we create an incore shadow array of link count information and then we walk the filesystem a second time to compare the link counts. We need live updates to keep the information up to date during the lengthy scan, so this scrubber remains disabled until the next patch.
--- fs/xfs/Makefile | 1 fs/xfs/libxfs/xfs_fs.h | 3 fs/xfs/scrub/common.h | 1 fs/xfs/scrub/health.c | 1 fs/xfs/scrub/nlinks.c | 839 ++++++++++++++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/nlinks.h | 93 +++++ fs/xfs/scrub/scrub.c | 6 fs/xfs/scrub/scrub.h | 1 fs/xfs/scrub/stats.c | 1 fs/xfs/scrub/trace.c | 2 fs/xfs/scrub/trace.h | 147 ++++++++ 11 files changed, 1093 insertions(+), 2 deletions(-) create mode 100644 fs/xfs/scrub/nlinks.c create mode 100644 fs/xfs/scrub/nlinks.h
fs/xfs/Makefile +1 -0
@@ -161,6 +161,7 @@ xfs-y += $(addprefix scrub/, \ ialloc.o \ inode.o \ iscan.o \ + nlinks.o \ parent.o \ readdir.o \ refcount.o \
fs/xfs/libxfs/xfs_fs.h +2 -1
@@ -712,9 +712,10 @@ struct xfs_scrub_metadata {#define XFS_SCRUB_TYPE_PQUOTA 23/* project quotas */ #define XFS_SCRUB_TYPE_FSCOUNTERS 24/* fs summary counters */ #define XFS_SCRUB_TYPE_QUOTACHECK 25/* quota counters */ +#define XFS_SCRUB_TYPE_NLINKS 26/* inode link counts */ /* Number of scrub subcommands. */ -#define XFS_SCRUB_TYPE_NR 26 +#define XFS_SCRUB_TYPE_NR 27/* i: Repair this metadata. */ #define XFS_SCRUB_IFLAG_REPAIR (1u << 0)
fs/xfs/scrub/common.h +1 -0
@@ -129,6 +129,7 @@ xchk_setup_quotacheck(struct xfs_scrub *sc) }#endif int xchk_setup_fscounters (struct xfs_scrub *sc); +int xchk_setup_nlinks (struct xfs_scrub *sc);void xchk_ag_free (struct xfs_scrub *sc,struct xchk_ag *sa); int xchk_ag_init(struct xfs_scrub *sc, xfs_agnumber_t agno,
fs/xfs/scrub/health.c +1 -0
@@ -108,6 +108,7 @@ static const struct xchk_health_map type_to_health_flag[XFS_SCRUB_TYPE_NR] = { [XFS_SCRUB_TYPE_PQUOTA] = { XHG_FS, XFS_SICK_FS_PQUOTA }, [XFS_SCRUB_TYPE_FSCOUNTERS] = { XHG_FS, XFS_SICK_FS_COUNTERS }, [XFS_SCRUB_TYPE_QUOTACHECK] = { XHG_FS, XFS_SICK_FS_QUOTACHECK }, + [XFS_SCRUB_TYPE_NLINKS] = { XHG_FS, XFS_SICK_FS_NLINKS }, };/* Return the health status mask for this scrub type. */
fs/xfs/scrub/nlinks.c new file +839 -0
839 lines not on this page · raw message
fs/xfs/scrub/nlinks.h new file +93 -0
93 lines not on this page · raw message
fs/xfs/scrub/scrub.c +6 -0
@@ -369,6 +369,12 @@ static const struct xchk_meta_ops meta_scrub_ops[] = { .scrub = xchk_quotacheck, .repair = xrep_quotacheck, }, + [XFS_SCRUB_TYPE_NLINKS] = { /* inode link counts */ + .type = ST_FS, + .setup = xchk_setup_nlinks, + .scrub = xchk_nlinks, + .repair = xrep_notsupported, + }, }; static int
fs/xfs/scrub/scrub.h +1 -0
@@ -183,6 +183,7 @@ xchk_quotacheck(struct xfs_scrub *sc) }#endif int xchk_fscounters (struct xfs_scrub *sc); +int xchk_nlinks (struct xfs_scrub *sc);/* cross-referencing helpers */ void xchk_xref_is_used_space(struct xfs_scrub *sc, xfs_agblock_t agbno,
fs/xfs/scrub/stats.c +1 -0
@@ -78,6 +78,7 @@ static const char *name_map[XFS_SCRUB_TYPE_NR] = { [XFS_SCRUB_TYPE_PQUOTA] = "prjquota", [XFS_SCRUB_TYPE_FSCOUNTERS] = "fscounters", [XFS_SCRUB_TYPE_QUOTACHECK] = "quotacheck", + [XFS_SCRUB_TYPE_NLINKS] = "nlinks", };/* Format the scrub stats into a text buffer, similar to pcp style. */
fs/xfs/scrub/trace.c +2 -0
@@ -17,11 +17,13 @@#include "xfs_quota.h" #include "xfs_quota_defs.h" #include "xfs_da_format.h" +#include "xfs_dir2.h" #include "scrub/scrub.h" #include "scrub/xfile.h" #include "scrub/xfarray.h" #include "scrub/quota.h" #include "scrub/iscan.h" +#include "scrub/nlinks.h" /* Figure out which block the btree cursor was pointing to. */ static inline xfs_fsblock_t
fs/xfs/scrub/trace.h +146 -1
171 lines not on this page · raw message
Re: [PATCH 2/4] xfs: teach scrub to check file nlinks
Looks good:
PATCH 3/4 xfs: track directory entry updates during live nlinks fsck
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Create the necessary hooks in the directory operations (create/link/unlink/rename) code so that our live nlink scrub code can stay up to date with link count updates in the rest of the filesystem. This will be the means to keep our shadow link count information up to date while the scan runs in real time.
In online fsck part 2, we'll use these same hooks to handle repairs to directories and parent pointer information.
--- fs/xfs/scrub/common.c | 3 + fs/xfs/scrub/nlinks.c | 93 +++++++++++++++++++++++++++++++++++++++++- fs/xfs/scrub/nlinks.h | 6 +++ fs/xfs/scrub/scrub.c | 3 + fs/xfs/scrub/scrub.h | 4 +- fs/xfs/scrub/trace.h | 33 +++++++++++++++ fs/xfs/xfs_inode.c | 108 +++++++++++++++++++++++++++++++++++++++++++++++++ fs/xfs/xfs_inode.h | 31 ++++++++++++++ fs/xfs/xfs_mount.h | 3 + fs/xfs/xfs_super.c | 2 + fs/xfs/xfs_symlink.c | 1 11 files changed, 284 insertions(+), 3 deletions(-)
fs/xfs/scrub/common.c +3 -0
@@ -1302,6 +1302,9 @@ xchk_fsgates_enable(if (scrub_fsgates &XCHK_FSGATES_QUOTA )xfs_dqtrx_hook_enable (); +if (scrub_fsgates &XCHK_FSGATES_DIRENTS ) +xfs_dir_hook_enable (); + sc->flags |= scrub_fsgates; }
fs/xfs/scrub/nlinks.c +91 -2
123 lines not on this page · raw message
fs/xfs/scrub/nlinks.h +6 -0
@@ -22,6 +22,12 @@ struct xchk_nlink_ctrs {*/ struct xchk_iscan collect_iscan;struct xchk_iscan compare_iscan; + +/* +* Hook into directory updates so that we can receive live updates +* from other writer threads. +*/ +struct xfs_dir_hook hooks; };/*
fs/xfs/scrub/scrub.c +3 -0
@@ -160,6 +160,9 @@ xchk_fsgates_disable(if (sc->flags &XCHK_FSGATES_QUOTA )xfs_dqtrx_hook_disable (); +if (sc->flags &XCHK_FSGATES_DIRENTS ) +xfs_dir_hook_disable (); + sc->flags &= ~XCHK_FSGATES_ALL ; }
fs/xfs/scrub/scrub.h +3 -1
@@ -122,6 +122,7 @@ struct xfs_scrub {#define XCHK_FSGATES_DRAIN (1U << 2)/* defer ops draining enabled */ #define XCHK_NEED_DRAIN (1U << 3)/* scrub needs to drain defer ops */ #define XCHK_FSGATES_QUOTA (1U << 4)/* quota live update enabled */ +#define XCHK_FSGATES_DIRENTS (1U << 5)/* directory live update enabled */ #define XREP_RESET_PERAG_RESV (1U << 30)/* must reset AG space reservation */ #define XREP_ALREADY_FIXED (1U << 31)/* checking our repair work */
@@ -132,7 +133,8 @@ struct xfs_scrub {* must be enabled during scrub setup and can only be torn down afterwards. */ #define XCHK_FSGATES_ALL (XCHK_FSGATES_DRAIN | \ - XCHK_FSGATES_QUOTA) + XCHK_FSGATES_QUOTA | \ + XCHK_FSGATES_DIRENTS)/* Metadata scrubbers */ int xchk_tester (struct xfs_scrub *sc);
fs/xfs/scrub/trace.h +33 -0
@@ -116,6 +116,7 @@ TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_NLINKS); { XCHK_FSGATES_DRAIN, "fsgates_drain" }, \ { XCHK_NEED_DRAIN, "need_drain" }, \ { XCHK_FSGATES_QUOTA, "fsgates_quota" }, \ + { XCHK_FSGATES_DIRENTS, "fsgates_dirents" }, \ { XREP_RESET_PERAG_RESV, "reset_perag_resv" }, \ { XREP_ALREADY_FIXED, "already_fixed" }
@@ -1336,6 +1337,38 @@ TRACE_EVENT(xchk_nlinks_collect_metafile, __entry->ino) ); +TRACE_EVENT (xchk_nlinks_live_update, + TP_PROTO(struct xfs_mount *mp, const struct xfs_inode *dp, + int action, xfs_ino_t ino, int delta, + const char *name, unsigned int namelen), +TP_ARGS (mp, dp, action, ino, delta, name, namelen), +TP_STRUCT__entry ( + __field(dev_t, dev) + __field(xfs_ino_t, dir) + __field(int, action) + __field(xfs_ino_t, ino) + __field(int, delta) + __field(unsigned int, namelen) +__dynamic_array (char, name, namelen) + ), +TP_fast_assign ( + __entry->dev = mp->m_super->s_dev; + __entry->dir = dp ? dp->i_ino : NULLFSINO; + __entry->action = action; + __entry->ino = ino; + __entry->delta = delta; + __entry->namelen = namelen; + memcpy(__get_str(name), name, namelen); + ), +TP_printk ("dev %d:%d dir 0x%llx ino 0x%llx nlink_delta %d name '%.*s'" , +MAJOR (__entry->dev),MINOR (__entry->dev), + __entry->dir, + __entry->ino, + __entry->delta, + __entry->namelen, +__get_str (name)) +); + TRACE_EVENT(xchk_nlinks_check_zero, TP_PROTO(struct xfs_mount *mp, xfs_ino_t ino, const struct xchk_nlink *live),
fs/xfs/xfs_inode.c +108 -0
144 lines not on this page · raw message
fs/xfs/xfs_inode.h +31 -0
@@ -171,6 +171,12 @@ static inline struct inode *VFS_I(struct xfs_inode *ip)return &ip->i_vnode; } +/* convert from const xfs inode to const vfs inode */ +static inline const struct inode *VFS_IC (const struct xfs_inode *ip) +{ +return &ip->i_vnode; +} +/* * For regular files we only update the on-disk filesize when actually * writing data back to disk. Until then only the copy in the VFS inode
@@ -626,4 +632,29 @@ bool xfs_ifork_zapped(const struct xfs_inode *ip, int whichfork);void xfs_inode_count_blocks (struct xfs_trans *tp,struct xfs_inode *ip,xfs_filblks_t *dblocks,xfs_filblks_t *rblocks); +struct xfs_dir_update_params { +const struct xfs_inode *dp; +const struct xfs_inode *ip; +const struct xfs_name *name; +int delta; +}; + +#ifdef CONFIG_XFS_LIVE_HOOKS +void xfs_dir_update_hook (struct xfs_inode *dp,struct xfs_inode *ip, +int delta,const struct xfs_name *name); + +struct xfs_dir_hook { +struct xfs_hook dirent_hook; +}; + +void xfs_dir_hook_disable (void ); +void xfs_dir_hook_enable (void ); + +int xfs_dir_hook_add (struct xfs_mount *mp,struct xfs_dir_hook *hook); +void xfs_dir_hook_del (struct xfs_mount *mp,struct xfs_dir_hook *hook); + +#else +# define xfs_dir_update_hook (dp, ip, delta, name) ((void)0) +#endif /* CONFIG_XFS_LIVE_HOOKS */ +#endif /* __XFS_INODE_H__ */
fs/xfs/xfs_mount.h +3 -0
@@ -252,6 +252,9 @@ typedef struct xfs_mount {/* cpus that have inodes queued for inactivation */ struct cpumask m_inodegc_cpumask; + +/* Hook to feed dirent updates to an active online repair. */ +struct xfs_hooks m_dir_update_hooks; } xfs_mount_t;#define M_IGEO (mp) (&(mp)->m_ino_geo)
fs/xfs/xfs_super.c +2 -0
@@ -2010,6 +2010,8 @@ static int xfs_init_fs_context( mp->m_logbsize =-1 ; mp->m_allocsize_log =16 ;/* 64k */ +xfs_hooks_init (&mp->m_dir_update_hooks); +/* * Copy binary VFS mount flags we are interested in. */
fs/xfs/xfs_symlink.c +1 -0
@@ -322,6 +322,7 @@ xfs_symlink( goto out_trans_cancel;xfs_trans_ichgtime (tp, dp,XFS_ICHGTIME_MOD |XFS_ICHGTIME_CHG );xfs_trans_log_inode (tp, dp,XFS_ILOG_CORE ); +xfs_dir_update_hook (dp, ip,1 , link_name);/* * If this is a synchronous mount, make sure that the
Re: [PATCH 3/4] xfs: track directory entry updates during live nlinks fsck
Looks good:
PATCH 4/4 xfs: teach repair to fix file nlinks
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Fix the nlinks now too.
--- fs/xfs/Makefile | 1 fs/xfs/scrub/nlinks.c | 4 + fs/xfs/scrub/nlinks.h | 5 + fs/xfs/scrub/nlinks_repair.c | 223 ++++++++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/repair.h | 2 fs/xfs/scrub/scrub.c | 2 fs/xfs/scrub/trace.h | 3 + 7 files changed, 237 insertions(+), 3 deletions(-) create mode 100644 fs/xfs/scrub/nlinks_repair.c
fs/xfs/Makefile +1 -0
@@ -195,6 +195,7 @@ xfs-y += $(addprefix scrub/, \ ialloc_repair.o \ inode_repair.o \ newbt.o \ + nlinks_repair.o \ reap.o \ refcount_repair.o \ repair.o \
fs/xfs/scrub/nlinks.c +3 -1
@@ -61,7 +61,9 @@ xchk_setup_nlinks(* set the INCOMPLETE flag even when a negative errno is returned. This care * must be taken with certain errno values (i.e. EFSBADCRC, EFSCORRUPTED, * ECANCELED) that are absorbed into a scrub state flag update by -* xchk_*_process_error. +* xchk_*_process_error. Scrub and repair share the same incore data +* structures, so the INCOMPLETE flag is critical to prevent a repair based on +* insufficient information. * * Because we are scanning a live filesystem, it's possible that another thread * will try to update the link counts for an inode that we've already scanned.
fs/xfs/scrub/nlinks.h +4 -1
@@ -81,9 +81,12 @@ struct xchk_nlink {*/ #define XCHK_NLINK_WRITTEN (1U << 0) -/* This data item was seen by the check-time compare function. */ +/* Already checked this link count record. */ #define XCHK_NLINK_COMPARE_SCANNED (1U << 1) +/* Already made a repair with this link count record. */ +#define XREP_NLINK_DIRTY (1U << 2) +/* Compute total link count, using large enough variables to detect overflow. */ static inline uint64_t xchk_nlink_total (struct xfs_inode *ip,const struct xchk_nlink *live)
fs/xfs/scrub/nlinks_repair.c new file +223 -0
223 lines not on this page · raw message
fs/xfs/scrub/repair.h +2 -0
@@ -116,6 +116,7 @@ int xrep_inode(struct xfs_scrub *sc);int xrep_bmap_data (struct xfs_scrub *sc);int xrep_bmap_attr (struct xfs_scrub *sc);int xrep_bmap_cow (struct xfs_scrub *sc); +int xrep_nlinks (struct xfs_scrub *sc);#ifdef CONFIG_XFS_RT int xrep_rtbitmap (struct xfs_scrub *sc);
@@ -196,6 +197,7 @@ xrep_setup_nothing(#define xrep_rtbitmap xrep_notsupported#define xrep_quota xrep_notsupported#define xrep_quotacheck xrep_notsupported +#define xrep_nlinks xrep_notsupported#endif /* CONFIG_XFS_ONLINE_REPAIR */
fs/xfs/scrub/scrub.c +1 -1
@@ -376,7 +376,7 @@ static const struct xchk_meta_ops meta_scrub_ops[] = { .type = ST_FS, .setup = xchk_setup_nlinks, .scrub = xchk_nlinks, - .repair = xrep_notsupported, + .repair = xrep_nlinks, }, };
fs/xfs/scrub/trace.h +3 -0
@@ -2158,6 +2158,9 @@ DEFINE_XREP_DQUOT_EVENT(xrep_dquot_item_fill_bmap_hole);DEFINE_XREP_DQUOT_EVENT (xrep_quotacheck_dquot);#endif /* CONFIG_XFS_QUOTA */ +DEFINE_SCRUB_NLINKS_DIFF_EVENT (xrep_nlinks_update_inode); +DEFINE_SCRUB_NLINKS_DIFF_EVENT (xrep_nlinks_unfixable_inode); +#endif /* IS_ENABLED(CONFIG_XFS_ONLINE_REPAIR) */ #endif /* _TRACE_XFS_SCRUB_TRACE_H */
Re: [PATCH 4/4] xfs: teach repair to fix file nlinks
Looks good:
PATCH 5/28 xfs: report corruption to the health trackers
In reply to Darrick J. WongHi all,
Any time that the runtime code thinks it has found corrupt metadata, it should tell the health tracking subsystem that the corresponding part of the filesystem is sick. These reports come primarily from two places -- code that is reading a buffer that fails validation, and higher level pieces that observe a conflict involving multiple buffers. This patchset uses automated scanning to update all such callsites with a mark_sick call.
Doing this enables the health system to record problem observed at runtime, which (for now) can prompt the sysadmin to run xfs_scrub, and (later) may enable more targetted fixing of the filesystem.
Note: Earlier reviewers of this patchset suggested that the verifier functions themselves should be responsible for calling _mark_sick. In a higher level language this would be easily accomplished with lambda functions and closures. For the kernel, however, we'd have to create the necessary closures by hand, pass them to the buf_read calls, and then implement necessary state tracking to detach the xfs_buf from the closure at the necessary time. This is far too much work and complexity and will not be pursued further.
If you're going to start using this code, I strongly recommend pulling from my git trees, which are linked below.
This has been running on the djcloud for months with no problems. Enjoy! Comments and questions are, as always, welcome.
--D
kernel git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfs-linux.git/log/?h=corruption-health-reports
xfsprogs git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfsprogs-dev.git/log/?h=corruption-health-reports
fstests git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfstests-dev.git/log/?h=corruption-health-reports
--- fs/xfs/libxfs/xfs_ag.c | 5 + fs/xfs/libxfs/xfs_alloc.c | 105 ++++++++++++++++++++---- fs/xfs/libxfs/xfs_attr_leaf.c | 4 + fs/xfs/libxfs/xfs_attr_remote.c | 35 +++++--- fs/xfs/libxfs/xfs_bmap.c | 135 +++++++++++++++++++++++++++---- fs/xfs/libxfs/xfs_btree.c | 39 ++++++++- fs/xfs/libxfs/xfs_da_btree.c | 37 +++++++- fs/xfs/libxfs/xfs_dir2.c | 5 + fs/xfs/libxfs/xfs_dir2_block.c | 2 fs/xfs/libxfs/xfs_dir2_data.c | 3 + fs/xfs/libxfs/xfs_dir2_leaf.c | 3 + fs/xfs/libxfs/xfs_dir2_node.c | 7 ++ fs/xfs/libxfs/xfs_health.h | 35 +++++++- fs/xfs/libxfs/xfs_ialloc.c | 57 +++++++++++-- fs/xfs/libxfs/xfs_inode_buf.c | 12 ++- fs/xfs/libxfs/xfs_inode_fork.c | 8 ++ fs/xfs/libxfs/xfs_refcount.c | 43 +++++++++- fs/xfs/libxfs/xfs_rmap.c | 83 ++++++++++++++++++- fs/xfs/libxfs/xfs_rtbitmap.c | 9 ++ fs/xfs/libxfs/xfs_sb.c | 2 fs/xfs/scrub/health.c | 20 +++-- fs/xfs/scrub/refcount_repair.c | 9 ++ fs/xfs/xfs_attr_inactive.c | 4 + fs/xfs/xfs_attr_list.c | 18 +++- fs/xfs/xfs_dir2_readdir.c | 6 + fs/xfs/xfs_discard.c | 2 fs/xfs/xfs_dquot.c | 30 +++++++ fs/xfs/xfs_health.c | 172 +++++++++++++++++++++++++++++++++++++++ fs/xfs/xfs_icache.c | 9 ++ fs/xfs/xfs_inode.c | 16 +++- fs/xfs/xfs_iomap.c | 15 +++ fs/xfs/xfs_iwalk.c | 5 + fs/xfs/xfs_mount.c | 5 + fs/xfs/xfs_qm.c | 8 +- fs/xfs/xfs_reflink.c | 6 + fs/xfs/xfs_rtalloc.c | 6 + fs/xfs/xfs_symlink.c | 17 +++- 37 files changed, 867 insertions(+), 110 deletions(-)
PATCH 1/11 xfs: separate the marking of sick and checked metadata
From: Darrick J. Wong <[email protected]>
Split the setting of the sick and checked masks into separate functions as part of preparing to add the ability for regular runtime fs code (i.e. not scrub) to mark metadata structures sick when corruptions are found. Improve the documentation of libxfs' requirements for helper behavior.
--- fs/xfs/libxfs/xfs_health.h | 16 +++++++++++++- fs/xfs/scrub/health.c | 20 ++++++++++------- fs/xfs/xfs_health.c | 51 +++++++++++++++++++++++++++++++++++++++++++- fs/xfs/xfs_mount.c | 5 +++- 4 files changed, 81 insertions(+), 11 deletions(-)
fs/xfs/libxfs/xfs_health.h +15 -1
@@ -111,24 +111,38 @@ struct xfs_fsop_geom; XFS_SICK_INO_DIR_ZAPPED | \ XFS_SICK_INO_SYMLINK_ZAPPED) -/* These functions must be provided by the xfs implementation. */ +/* +* These functions must be provided by the xfs implementation. Function +* behavior with respect to the first argument should be as follows: +* +* xfs_*_mark_sick: set the sick flags and do not set checked flags. +* xfs_*_mark_checked: set the checked flags. +* xfs_*_mark_healthy: clear the sick flags and set the checked flags. +* +* xfs_*_measure_sickness: return the sick and check status in the provided +* out parameters. +*/ void xfs_fs_mark_sick (struct xfs_mount *mp,unsigned int mask); +void xfs_fs_mark_checked (struct xfs_mount *mp,unsigned int mask);void xfs_fs_mark_healthy (struct xfs_mount *mp,unsigned int mask);void xfs_fs_measure_sickness (struct xfs_mount *mp,unsigned int *sick,unsigned int *checked);void xfs_rt_mark_sick (struct xfs_mount *mp,unsigned int mask); +void xfs_rt_mark_checked (struct xfs_mount *mp,unsigned int mask);void xfs_rt_mark_healthy (struct xfs_mount *mp,unsigned int mask);void xfs_rt_measure_sickness (struct xfs_mount *mp,unsigned int *sick,unsigned int *checked);void xfs_ag_mark_sick (struct xfs_perag *pag,unsigned int mask); +void xfs_ag_mark_checked (struct xfs_perag *pag,unsigned int mask);void xfs_ag_mark_healthy (struct xfs_perag *pag,unsigned int mask);void xfs_ag_measure_sickness (struct xfs_perag *pag,unsigned int *sick,unsigned int *checked);void xfs_inode_mark_sick (struct xfs_inode *ip,unsigned int mask); +void xfs_inode_mark_checked (struct xfs_inode *ip,unsigned int mask);void xfs_inode_mark_healthy (struct xfs_inode *ip,unsigned int mask);void xfs_inode_measure_sickness (struct xfs_inode *ip,unsigned int *sick,unsigned int *checked);
fs/xfs/scrub/health.c +12 -8
@@ -176,30 +176,34 @@ xchk_update_health(switch (type_to_health_flag[sc->sm->sm_type].group) {case XHG_AG : pag =xfs_perag_get (sc->mp, sc->sm->sm_agno); -if (bad) +if (bad) {xfs_ag_mark_sick (pag, sc->sick_mask); -else +xfs_ag_mark_checked (pag, sc->sick_mask); + }else xfs_ag_mark_healthy (pag, sc->sick_mask);xfs_perag_put (pag);break ;case XHG_INO :if (!sc->ip)return ; -if (bad) +if (bad) {xfs_inode_mark_sick (sc->ip, sc->sick_mask); -else +xfs_inode_mark_checked (sc->ip, sc->sick_mask); + }else xfs_inode_mark_healthy (sc->ip, sc->sick_mask);break ;case XHG_FS : -if (bad) +if (bad) {xfs_fs_mark_sick (sc->mp, sc->sick_mask); -else +xfs_fs_mark_checked (sc->mp, sc->sick_mask); + }else xfs_fs_mark_healthy (sc->mp, sc->sick_mask);break ;case XHG_RT : -if (bad) +if (bad) {xfs_rt_mark_sick (sc->mp, sc->sick_mask); -else +xfs_rt_mark_checked (sc->mp, sc->sick_mask); + }else xfs_rt_mark_healthy (sc->mp, sc->sick_mask);break ;default :
fs/xfs/xfs_health.c +50 -1
81 lines not on this page · raw message
fs/xfs/xfs_mount.c +4 -1
@@ -497,8 +497,10 @@ xfs_check_summary_counts(if (xfs_is_clean (mp) && (mp->m_sb.sb_fdblocks > mp->m_sb.sb_dblocks || !xfs_verify_icount (mp, mp->m_sb.sb_icount) || - mp->m_sb.sb_ifree > mp->m_sb.sb_icount)) + mp->m_sb.sb_ifree > mp->m_sb.sb_icount)) {xfs_fs_mark_sick (mp,XFS_SICK_FS_COUNTERS ); +xfs_fs_mark_checked (mp,XFS_SICK_FS_COUNTERS ); + }/* * We can safely re-initialise incore superblock counters from the
@@ -1276,6 +1278,7 @@ xfs_force_summary_recalc(return ;xfs_fs_mark_sick (mp,XFS_SICK_FS_COUNTERS ); +xfs_fs_mark_checked (mp,XFS_SICK_FS_COUNTERS ); }/*
Re: [PATCH 01/11] xfs: separate the marking of sick and checked metadata
Looks good:
PATCH 2/11 xfs: report fs corruption errors to the health tracking system
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Whenever we encounter corrupt fs metadata, we should report that to the health monitoring system for later reporting. A convenient program for identifying places to insert xfs_*_mark_sick calls is as follows:
#!/bin/bash
# Detect missing calls to xfs_*_mark_sick
filter=cat
tty -s && filter=less
git grep -B3 EFSCORRUPTED fs/xfs/*.[ch] fs/xfs/libxfs/*.[ch] fs/xfs/scrub/*.[ch] | awk '
BEGIN {
ignore = 0;
lineno = 0;
delete lines;
}
{
if ($0 == "--") {
if (!ignore) {
for (i = 0; i < lineno; i++) {
print(lines[i]);
}
printf("--\n");
}
delete lines;
lineno = 0;
ignore = 0;
} else if ($0 ~ /mark_sick/) {
ignore = 1;
} else if ($0 ~ /if .fa/) {
ignore = 1;
} else if ($0 ~ /failaddr/) {
ignore = 1;
} else if ($0 ~ /_verifier_error/) {
ignore = 1;
} else if ($0 ~ /^ \* .*EFSCORRUPTED/) {
ignore = 1;
} else if ($0 ~ /== -EFSCORRUPTED/) {
ignore = 1;
} else if ($0 ~ /!= -EFSCORRUPTED/) {
ignore = 1;
} else {
lines[lineno++] = $0;
}
}' | $filter
--- fs/xfs/libxfs/xfs_ag.c | 1 + 1 file changed, 1 insertion(+)
fs/xfs/libxfs/xfs_ag.c +1 -0
@@ -217,6 +217,7 @@ xfs_initialize_perag_data(*/ if (fdblocks > sbp->sb_dblocks || ifree > ialloc) {xfs_alert (mp,"AGF corruption. Please run xfs_repair." ); +xfs_fs_mark_sick (mp,XFS_SICK_FS_COUNTERS ); error = -EFSCORRUPTED ; goto out; }
Re: [PATCH 02/11] xfs: report fs corruption errors to the health tracking system
Looks good:
PATCH 3/11 xfs: report ag header corruption errors to the health tracking system
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Whenever we encounter a corrupt AG header, we should report that to the health monitoring system for later reporting. Buffer readers that don't respond to corruption events with a _mark_sick call can be detected with the following script:
#!/bin/bash
# Detect missing calls to xfs_*_mark_sick
filter=cat
tty -s && filter=less
git grep -A10 -E '( = xfs_trans_read_buf| = xfs_buf_read\()' fs/xfs/*.[ch] fs/xfs/libxfs/*.[ch] | awk '
BEGIN {
ignore = 0;
lineno = 0;
delete lines;
}
{
if ($0 == "--") {
if (!ignore) {
for (i = 0; i < lineno; i++) {
print(lines[i]);
}
printf("--\n");
}
delete lines;
lineno = 0;
ignore = 0;
} else if ($0 ~ /mark_sick/) {
ignore = 1;
} else {
lines[lineno++] = $0;
}
}' | $filter
--- fs/xfs/libxfs/xfs_alloc.c | 6 ++++++ fs/xfs/libxfs/xfs_health.h | 13 ++++++++++--- fs/xfs/libxfs/xfs_ialloc.c | 3 +++ fs/xfs/libxfs/xfs_sb.c | 2 ++ fs/xfs/xfs_health.c | 17 +++++++++++++++++ fs/xfs/xfs_inode.c | 14 ++++++++++++-- 6 files changed, 50 insertions(+), 5 deletions(-)
fs/xfs/libxfs/xfs_alloc.c +6 -0
@@ -26,6 +26,7 @@#include "xfs_ag.h" #include "xfs_ag_resv.h" #include "xfs_bmap.h" +#include "xfs_health.h" struct kmem_cache *xfs_extfree_item_cache;
@@ -755,6 +756,8 @@ xfs_alloc_read_agfl( mp, tp, mp->m_ddev_targp,XFS_AG_DADDR (mp, pag->pag_agno,XFS_AGFL_DADDR (mp)), XFS_FSS_TO_BB(mp, 1), 0, &bp, &xfs_agfl_buf_ops); +if (xfs_metadata_is_sick (error)) +xfs_ag_mark_sick (pag,XFS_SICK_AG_AGFL );if (error)return error;xfs_buf_set_ref (bp,XFS_AGFL_REF );
@@ -776,6 +779,7 @@ xfs_alloc_update_counters(if (unlikely (be32_to_cpu (agf->agf_freeblks) >be32_to_cpu (agf->agf_length))) {xfs_buf_mark_corrupt (agbp); +xfs_ag_mark_sick (agbp->b_pag,XFS_SICK_AG_AGF );return -EFSCORRUPTED ; }
@@ -3268,6 +3272,8 @@ xfs_read_agf( error =xfs_trans_read_buf (mp, tp, mp->m_ddev_targp,XFS_AG_DADDR (mp, pag->pag_agno,XFS_AGF_DADDR (mp)),XFS_FSS_TO_BB (mp,1 ), flags, agfbpp, &xfs_agf_buf_ops); +if (xfs_metadata_is_sick (error)) +xfs_ag_mark_sick (pag,XFS_SICK_AG_AGF );if (error)return error;
fs/xfs/libxfs/xfs_health.h +10 -3
@@ -26,9 +26,11 @@* and the "sick" field tells us if that piece was found to need repairs. * Therefore we can conclude that for a given sick flag value: * -* - checked && sick => metadata needs repair -* - checked && !sick => metadata is ok -* - !checked => has not been examined since mount +* - checked && sick => metadata needs repair +* - checked && !sick => metadata is ok +* - !checked && sick => errors have been observed during normal operation, +* but the metadata has not been checked thoroughly +* - !checked && !sick => has not been examined since mount */ struct xfs_mount ;
@@ -135,6 +137,8 @@ void xfs_rt_mark_healthy(struct xfs_mount *mp, unsigned int mask);void xfs_rt_measure_sickness (struct xfs_mount *mp,unsigned int *sick,unsigned int *checked); +void xfs_agno_mark_sick (struct xfs_mount *mp,xfs_agnumber_t agno, +unsigned int mask);void xfs_ag_mark_sick (struct xfs_perag *pag,unsigned int mask);void xfs_ag_mark_checked (struct xfs_perag *pag,unsigned int mask);void xfs_ag_mark_healthy (struct xfs_perag *pag,unsigned int mask);
@@ -215,4 +219,7 @@ void xfs_fsop_geom_health(struct xfs_mount *mp, struct xfs_fsop_geom *geo);void xfs_ag_geom_health (struct xfs_perag *pag,struct xfs_ag_geometry *ageo);void xfs_bulkstat_health (struct xfs_inode *ip,struct xfs_bulkstat *bs); +#define xfs_metadata_is_sick (error) \ + (unlikely((error) == -EFSCORRUPTED || (error) == -EFSBADCRC)) +#endif /* __XFS_HEALTH_H__ */
fs/xfs/libxfs/xfs_ialloc.c +3 -0
@@ -27,6 +27,7 @@#include "xfs_log.h" #include "xfs_rmap.h" #include "xfs_ag.h" +#include "xfs_health.h" /* * Lookup a record by ino in the btree given by cur.
@@ -2604,6 +2605,8 @@ xfs_read_agi( error =xfs_trans_read_buf (mp, tp, mp->m_ddev_targp,XFS_AG_DADDR (mp, pag->pag_agno,XFS_AGI_DADDR (mp)),XFS_FSS_TO_BB (mp,1 ),0 , agibpp, &xfs_agi_buf_ops); +if (xfs_metadata_is_sick (error)) +xfs_ag_mark_sick (pag,XFS_SICK_AG_AGI );if (error)return error;if (tp)
fs/xfs/libxfs/xfs_sb.c +2 -0
@@ -1290,6 +1290,8 @@ xfs_sb_read_secondary( error =xfs_trans_read_buf (mp, tp, mp->m_ddev_targp,XFS_AG_DADDR (mp, agno,XFS_SB_BLOCK (mp)),XFS_FSS_TO_BB (mp,1 ),0 , &bp, &xfs_sb_buf_ops); +if (xfs_metadata_is_sick (error)) +xfs_agno_mark_sick (mp, agno,XFS_SICK_AG_SB );if (error)return error;xfs_buf_set_ref (bp,XFS_SSB_REF );
fs/xfs/xfs_health.c +17 -0
@@ -198,6 +198,23 @@ xfs_rt_measure_sickness(spin_unlock (&mp->m_sb_lock); } +/* Mark unhealthy per-ag metadata given a raw AG number. */ +void +xfs_agno_mark_sick ( +struct xfs_mount *mp, +xfs_agnumber_t agno, +unsigned int mask) +{ +struct xfs_perag *pag =xfs_perag_get (mp, agno); + +/* per-ag structure not set up yet? */ +if (!pag) +return ; + +xfs_ag_mark_sick (pag, mask); +xfs_perag_put (pag); +} +/* Mark unhealthy per-ag metadata. */ void xfs_ag_mark_sick(
fs/xfs/xfs_inode.c +12 -2
@@ -802,6 +802,8 @@ xfs_init_new_inode(*/ if ((pip && ino == pip->i_ino) || !xfs_verify_dir_ino (mp, ino)) {xfs_alert (mp,"Allocated a known in-use inode 0x%llx!" , ino); +xfs_agno_mark_sick (mp,XFS_INO_TO_AGNO (mp, ino), +XFS_SICK_AG_INOBT );return -EFSCORRUPTED ; }
@@ -1983,6 +1985,7 @@ xfs_iunlink_update_bucket(*/ if (old_value == new_agino) {xfs_buf_mark_corrupt (agibp); +xfs_ag_mark_sick (pag,XFS_SICK_AG_AGI );return -EFSCORRUPTED ; }
@@ -2032,11 +2035,14 @@ xfs_iunlink_reload_next(*/ ino =XFS_AGINO_TO_INO (mp, pag->pag_agno, next_agino); error =xfs_iget (mp, tp, ino,XFS_IGET_UNTRUSTED ,0 , &next_ip); -if (error) +if (error) { +xfs_ag_mark_sick (pag,XFS_SICK_AG_AGI );return error; + }/* If this is not an unlinked inode, something is very wrong. */ if (VFS_I (next_ip)->i_nlink !=0 ) { +xfs_ag_mark_sick (pag,XFS_SICK_AG_AGI ); error = -EFSCORRUPTED ; goto rele; }
@@ -2074,6 +2080,7 @@ xfs_iunlink_insert_inode(if (next_agino == agino || !xfs_verify_agino_or_null (pag, next_agino)) {xfs_buf_mark_corrupt (agibp); +xfs_ag_mark_sick (pag,XFS_SICK_AG_AGI );return -EFSCORRUPTED ; }
@@ -2161,6 +2168,7 @@ xfs_iunlink_remove_inode(if (!xfs_verify_agino (pag, head_agino)) {XFS_CORRUPTION_ERROR (__func__,XFS_ERRLEVEL_LOW , mp, agi,sizeof (*agi)); +xfs_ag_mark_sick (pag,XFS_SICK_AG_AGI );return -EFSCORRUPTED ; }
@@ -2189,8 +2197,10 @@ xfs_iunlink_remove_inode(struct xfs_inode *prev_ip; prev_ip =xfs_iunlink_lookup (pag, ip->i_prev_unlinked); -if (!prev_ip) +if (!prev_ip) { +xfs_inode_mark_sick (ip,XFS_SICK_INO_CORE );return -EFSCORRUPTED ; + } error =xfs_iunlink_log_inode (tp, prev_ip, pag, ip->i_next_unlinked);
Re: [PATCH 03/11] xfs: report ag header corruption errors to the health tracking system
Looks good:
PATCH 4/11 xfs: report block map corruption errors to the health tracking system
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Whenever we encounter a corrupt block mapping, we should report that to the health monitoring system for later reporting.
--- fs/xfs/libxfs/xfs_bmap.c | 35 +++++++++++++++++++++++++++++------ fs/xfs/libxfs/xfs_health.h | 1 + fs/xfs/xfs_health.c | 26 ++++++++++++++++++++++++++ fs/xfs/xfs_iomap.c | 15 ++++++++++++--- fs/xfs/xfs_reflink.c | 6 +++++- 5 files changed, 73 insertions(+), 10 deletions(-)
fs/xfs/libxfs/xfs_bmap.c +29 -6
@@ -36,6 +36,7 @@#include "xfs_refcount.h" #include "xfs_icache.h" #include "xfs_iomap.h" +#include "xfs_health.h" struct kmem_cache *xfs_bmap_intent_cache;
@@ -960,6 +961,7 @@ xfs_bmap_add_attrfork_local(/* should only be called for types that support local format data */ ASSERT (0 ); +xfs_bmap_mark_sick (ip,XFS_ATTR_FORK );return -EFSCORRUPTED ; }
@@ -1143,6 +1145,7 @@ xfs_iread_bmbt_block( (unsigned long long)ip->i_ino);xfs_inode_verifier_error (ip, -EFSCORRUPTED , __func__, block,sizeof (*block), __this_address); +xfs_bmap_mark_sick (ip, whichfork);return -EFSCORRUPTED ; }
@@ -1158,6 +1161,7 @@ xfs_iread_bmbt_block(xfs_inode_verifier_error (ip, -EFSCORRUPTED ,"xfs_iread_extents(2)" , frp,sizeof (*frp), fa); +xfs_bmap_mark_sick (ip, whichfork);return xfs_bmap_complain_bad_rec (ip, whichfork, fa, &new); }
@@ -1213,6 +1217,8 @@ xfs_iread_extents(smp_store_release (&ifp->if_needextents,0 );return 0 ; out: +if (xfs_metadata_is_sick (error)) +xfs_bmap_mark_sick (ip, whichfork);xfs_iext_destroy (ifp);return error; }
@@ -1292,6 +1298,7 @@ xfs_bmap_last_before(break ;default :ASSERT (0 ); +xfs_bmap_mark_sick (ip, whichfork);return -EFSCORRUPTED ; }
@@ -3885,12 +3892,16 @@ xfs_bmapi_read(ASSERT (!(flags & ~(XFS_BMAPI_ATTRFORK |XFS_BMAPI_ENTIRE )));ASSERT (xfs_isilocked (ip,XFS_ILOCK_SHARED |XFS_ILOCK_EXCL )); -if (WARN_ON_ONCE (!ifp)) +if (WARN_ON_ONCE (!ifp)) { +xfs_bmap_mark_sick (ip, whichfork);return -EFSCORRUPTED ; + }if (XFS_IS_CORRUPT (mp, !xfs_ifork_has_extents (ifp)) || -XFS_TEST_ERROR (false, mp,XFS_ERRTAG_BMAPIFORMAT )) +XFS_TEST_ERROR (false, mp,XFS_ERRTAG_BMAPIFORMAT )) { +xfs_bmap_mark_sick (ip, whichfork);return -EFSCORRUPTED ; + }if (xfs_is_shutdown (mp))return -EIO ;
@@ -4371,6 +4382,7 @@ xfs_bmapi_write(if (XFS_IS_CORRUPT (mp, !xfs_ifork_has_extents (ifp)) ||XFS_TEST_ERROR (false, mp,XFS_ERRTAG_BMAPIFORMAT )) { +xfs_bmap_mark_sick (ip, whichfork);return -EFSCORRUPTED ; }
@@ -4598,9 +4610,11 @@ xfs_bmapi_convert_delalloc( error = -ENOSPC ;if (WARN_ON_ONCE (bma.blkno ==NULLFSBLOCK )) goto out_finish; - error = -EFSCORRUPTED ; -if (WARN_ON_ONCE (!xfs_valid_startblock (ip, bma.got.br_startblock))) +if (WARN_ON_ONCE (!xfs_valid_startblock (ip, bma.got.br_startblock))) { +xfs_bmap_mark_sick (ip, whichfork); + error = -EFSCORRUPTED ; goto out_finish; + }XFS_STATS_ADD (mp, xs_xstrat_bytes,XFS_FSB_TO_B (mp, bma.length));XFS_STATS_INC (mp, xs_xstrat_quick);
@@ -4659,6 +4673,7 @@ xfs_bmapi_remap(if (XFS_IS_CORRUPT (mp, !xfs_ifork_has_extents (ifp)) ||XFS_TEST_ERROR (false, mp,XFS_ERRTAG_BMAPIFORMAT )) { +xfs_bmap_mark_sick (ip, whichfork);return -EFSCORRUPTED ; }
@@ -5271,8 +5286,10 @@ __xfs_bunmapi( whichfork =xfs_bmapi_whichfork (flags);ASSERT (whichfork !=XFS_COW_FORK ); ifp =xfs_ifork_ptr (ip, whichfork); -if (XFS_IS_CORRUPT (mp, !xfs_ifork_has_extents (ifp))) +if (XFS_IS_CORRUPT (mp, !xfs_ifork_has_extents (ifp))) { +xfs_bmap_mark_sick (ip, whichfork);return -EFSCORRUPTED ; + }if (xfs_is_shutdown (mp))return -EIO ;
@@ -5743,6 +5760,7 @@ xfs_bmap_collapse_extents(if (XFS_IS_CORRUPT (mp, !xfs_ifork_has_extents (ifp)) ||XFS_TEST_ERROR (false, mp,XFS_ERRTAG_BMAPIFORMAT )) { +xfs_bmap_mark_sick (ip, whichfork);return -EFSCORRUPTED ; }
@@ -5858,6 +5876,7 @@ xfs_bmap_insert_extents(if (XFS_IS_CORRUPT (mp, !xfs_ifork_has_extents (ifp)) ||XFS_TEST_ERROR (false, mp,XFS_ERRTAG_BMAPIFORMAT )) { +xfs_bmap_mark_sick (ip, whichfork);return -EFSCORRUPTED ; }
@@ -5961,6 +5980,7 @@ xfs_bmap_split_extent(if (XFS_IS_CORRUPT (mp, !xfs_ifork_has_extents (ifp)) ||XFS_TEST_ERROR (false, mp,XFS_ERRTAG_BMAPIFORMAT )) { +xfs_bmap_mark_sick (ip, whichfork);return -EFSCORRUPTED ; }
@@ -6143,8 +6163,10 @@ xfs_bmap_finish_one( bmap->br_startoff, bmap->br_blockcount, bmap->br_state); -if (WARN_ON_ONCE (bi->bi_whichfork !=XFS_DATA_FORK )) +if (WARN_ON_ONCE (bi->bi_whichfork !=XFS_DATA_FORK )) { +xfs_bmap_mark_sick (bi->bi_owner, bi->bi_whichfork);return -EFSCORRUPTED ; + }if (XFS_TEST_ERROR (false, tp->t_mountp,XFS_ERRTAG_BMAP_FINISH_ONE ))
@@ -6162,6 +6184,7 @@ xfs_bmap_finish_one(break ;default :ASSERT (0 ); +xfs_bmap_mark_sick (bi->bi_owner, bi->bi_whichfork); error = -EFSCORRUPTED ; }
fs/xfs/libxfs/xfs_health.h +1 -0
@@ -152,6 +152,7 @@ void xfs_inode_measure_sickness(struct xfs_inode *ip, unsigned int *sick, unsigned int *checked);void xfs_health_unmount (struct xfs_mount *mp); +void xfs_bmap_mark_sick (struct xfs_inode *ip,int whichfork);/* Now some helpers. */
fs/xfs/xfs_health.c +26 -0
@@ -465,3 +465,29 @@ xfs_bulkstat_health( bs->bs_sick |= m->ioctl_mask; } } + +/* Mark a block mapping sick. */ +void +xfs_bmap_mark_sick ( +struct xfs_inode *ip, +int whichfork) +{ +unsigned int mask; + +switch (whichfork) { +case XFS_DATA_FORK : + mask =XFS_SICK_INO_BMBTD ; +break ; +case XFS_ATTR_FORK : + mask =XFS_SICK_INO_BMBTA ; +break ; +case XFS_COW_FORK : + mask =XFS_SICK_INO_BMBTC ; +break ; +default : +ASSERT (0 ); +return ; + } + +xfs_inode_mark_sick (ip, mask); +}
fs/xfs/xfs_iomap.c +12 -3
@@ -27,6 +27,7 @@#include "xfs_dquot_item.h" #include "xfs_dquot.h" #include "xfs_reflink.h" +#include "xfs_health.h" #define XFS_ALLOC_ALIGN (mp, off) \ (((off) >> mp->m_allocsize_log) << mp->m_allocsize_log)
@@ -45,6 +46,7 @@ xfs_alert_fsblock_zero( (unsigned long long )imap->br_startoff, (unsigned long long )imap->br_blockcount, imap->br_state); +xfs_bmap_mark_sick (ip,XFS_DATA_FORK );return -EFSCORRUPTED ; }
@@ -99,8 +101,10 @@ xfs_bmbt_to_iomap(struct xfs_mount *mp = ip->i_mount;struct xfs_buftarg *target =xfs_inode_buftarg (ip); -if (unlikely (!xfs_valid_startblock (ip, imap->br_startblock))) +if (unlikely (!xfs_valid_startblock (ip, imap->br_startblock))) { +xfs_bmap_mark_sick (ip,XFS_DATA_FORK );return xfs_alert_fsblock_zero (ip, imap); + }if (imap->br_startblock ==HOLESTARTBLOCK ) { iomap->addr =IOMAP_NULL_ADDR ;
@@ -325,8 +329,10 @@ xfs_iomap_write_direct( goto out_unlock; } -if (unlikely (!xfs_valid_startblock (ip, imap->br_startblock))) +if (unlikely (!xfs_valid_startblock (ip, imap->br_startblock))) { +xfs_bmap_mark_sick (ip,XFS_DATA_FORK ); error =xfs_alert_fsblock_zero (ip, imap); + } out_unlock: *seq =xfs_iomap_inode_sequence (ip,0 );
@@ -639,8 +645,10 @@ xfs_iomap_write_unwritten(if (error)return error; -if (unlikely (!xfs_valid_startblock (ip, imap.br_startblock))) +if (unlikely (!xfs_valid_startblock (ip, imap.br_startblock))) { +xfs_bmap_mark_sick (ip,XFS_DATA_FORK );return xfs_alert_fsblock_zero (ip, &imap); + }if ((numblks_fsb = imap.br_blockcount) ==0 ) {/*
@@ -986,6 +994,7 @@ xfs_buffered_write_iomap_begin(if (XFS_IS_CORRUPT (mp, !xfs_ifork_has_extents (&ip->i_df)) ||XFS_TEST_ERROR (false, mp,XFS_ERRTAG_BMAPIFORMAT )) { +xfs_bmap_mark_sick (ip,XFS_DATA_FORK ); error = -EFSCORRUPTED ; goto out_unlock; }
fs/xfs/xfs_reflink.c +5 -1
@@ -29,6 +29,7 @@#include "xfs_iomap.h" #include "xfs_ag.h" #include "xfs_ag_resv.h" +#include "xfs_health.h" /* * Copy on Write of Shared Blocks
@@ -1227,8 +1228,10 @@ xfs_reflink_remap_extent(* extent if they're both holes or both the same physical extent. */ if (dmap->br_startblock == smap.br_startblock) { -if (dmap->br_state != smap.br_state) +if (dmap->br_state != smap.br_state) { +xfs_bmap_mark_sick (ip,XFS_DATA_FORK ); error = -EFSCORRUPTED ; + } goto out_cancel; }
@@ -1391,6 +1394,7 @@ xfs_reflink_remap_blocks(ASSERT (nimaps ==1 && imap.br_startoff == srcoff);if (imap.br_startblock ==DELAYSTARTBLOCK ) {ASSERT (imap.br_startblock !=DELAYSTARTBLOCK ); +xfs_bmap_mark_sick (src,XFS_DATA_FORK ); error = -EFSCORRUPTED ;break ; }
Re: [PATCH 04/11] xfs: report block map corruption errors to the health tracking system
Looks good:
PATCH 5/11 xfs: report btree block corruption errors to the health system
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Whenever we encounter corrupt btree blocks, we should report that to the health monitoring system for later reporting.
--- fs/xfs/libxfs/xfs_alloc.c | 2 ++ fs/xfs/libxfs/xfs_bmap.c | 6 ++++++ fs/xfs/libxfs/xfs_btree.c | 25 ++++++++++++++++++++++--- fs/xfs/libxfs/xfs_health.h | 2 ++ fs/xfs/libxfs/xfs_ialloc.c | 1 + fs/xfs/libxfs/xfs_refcount.c | 6 +++++- fs/xfs/libxfs/xfs_rmap.c | 6 +++++- fs/xfs/xfs_health.c | 38 ++++++++++++++++++++++++++++++++++++++ 8 files changed, 81 insertions(+), 5 deletions(-)
fs/xfs/libxfs/xfs_alloc.c +2 -0
@@ -275,6 +275,7 @@ xfs_alloc_complain_bad_rec(xfs_warn (mp,"start block 0x%x block count 0x%x" , irec->ar_startblock, irec->ar_blockcount); +xfs_btree_mark_sick (cur);return -EFSCORRUPTED ; }
@@ -2702,6 +2703,7 @@ xfs_exact_minlen_extent_available( goto out;if (*stat ==0 ) { +xfs_btree_mark_sick (cnt_cur); error = -EFSCORRUPTED ; goto out; }
fs/xfs/libxfs/xfs_bmap.c +6 -0
@@ -368,6 +368,8 @@ xfs_bmap_check_leaf_extents( error =xfs_btree_read_bufl (mp,NULL , bno, &bp,XFS_BMAP_BTREE_REF , &xfs_bmbt_buf_ops); +if (xfs_metadata_is_sick (error)) +xfs_btree_mark_sick (cur);if (error) goto error_norelse; }
@@ -454,6 +456,8 @@ xfs_bmap_check_leaf_extents( error =xfs_btree_read_bufl (mp,NULL , bno, &bp,XFS_BMAP_BTREE_REF , &xfs_bmbt_buf_ops); +if (xfs_metadata_is_sick (error)) +xfs_btree_mark_sick (cur);if (error) goto error_norelse; }
@@ -568,6 +572,8 @@ xfs_bmap_btree_to_extents(#endif error =xfs_btree_read_bufl (mp, tp, cbno, &cbp,XFS_BMAP_BTREE_REF , &xfs_bmbt_buf_ops); +if (xfs_metadata_is_sick (error)) +xfs_btree_mark_sick (cur);if (error)return error; cblock =XFS_BUF_TO_BLOCK (cbp);
fs/xfs/libxfs/xfs_btree.c +22 -3
@@ -27,6 +27,7 @@#include "xfs_bmap_btree.h" #include "xfs_rmap_btree.h" #include "xfs_refcount_btree.h" +#include "xfs_health.h" /* * Btree magic numbers.
@@ -177,6 +178,7 @@ xfs_btree_check_lblock( XFS_TEST_ERROR(false, mp, XFS_ERRTAG_BTREE_CHECK_LBLOCK)) {if (bp)trace_xfs_btree_corrupt (bp, _RET_IP_); +xfs_btree_mark_sick (cur);return -EFSCORRUPTED ; }return 0 ;
@@ -243,6 +245,7 @@ xfs_btree_check_sblock( XFS_TEST_ERROR(false, mp, XFS_ERRTAG_BTREE_CHECK_SBLOCK)) {if (bp)trace_xfs_btree_corrupt (bp, _RET_IP_); +xfs_btree_mark_sick (cur);return -EFSCORRUPTED ; }return 0 ;
@@ -318,6 +321,7 @@ xfs_btree_check_ptr( level, index); } +xfs_btree_mark_sick (cur);return -EFSCORRUPTED ; }
@@ -498,6 +502,8 @@ xfs_btree_dup_cursor(xfs_buf_daddr (bp), mp->m_bsize,0 , &bp, cur->bc_ops->buf_ops); +if (xfs_metadata_is_sick (error)) +xfs_btree_mark_sick (new);if (error) {xfs_btree_del_cursor (new, error); *ncur =NULL ;
@@ -1351,6 +1357,8 @@ xfs_btree_read_buf_block( error =xfs_trans_read_buf (mp, cur->bc_tp, mp->m_ddev_targp, d, mp->m_bsize, flags, bpp, cur->bc_ops->buf_ops); +if (xfs_metadata_is_sick (error)) +xfs_btree_mark_sick (cur);if (error)return error;
@@ -1661,6 +1669,7 @@ xfs_btree_increment(if (cur->bc_flags &XFS_BTREE_ROOT_IN_INODE ) goto out0;ASSERT (0 ); +xfs_btree_mark_sick (cur); error = -EFSCORRUPTED ; goto error0; }
@@ -1754,6 +1763,7 @@ xfs_btree_decrement(if (cur->bc_flags &XFS_BTREE_ROOT_IN_INODE ) goto out0;ASSERT (0 ); +xfs_btree_mark_sick (cur); error = -EFSCORRUPTED ; goto error0; }
@@ -1846,6 +1856,7 @@ xfs_btree_lookup_get_block( *blkp =NULL ;xfs_buf_mark_corrupt (bp);xfs_trans_brelse (cur->bc_tp, bp); +xfs_btree_mark_sick (cur);return -EFSCORRUPTED ; }
@@ -1892,8 +1903,10 @@ xfs_btree_lookup(XFS_BTREE_STATS_INC (cur, lookup);/* No such thing as a zero-level tree. */ -if (XFS_IS_CORRUPT (cur->bc_mp, cur->bc_nlevels ==0 )) +if (XFS_IS_CORRUPT (cur->bc_mp, cur->bc_nlevels ==0 )) { +xfs_btree_mark_sick (cur);return -EFSCORRUPTED ; + } block =NULL ; keyno =0 ;
@@ -1936,6 +1949,7 @@ xfs_btree_lookup(XFS_ERRLEVEL_LOW , cur->bc_mp, block, sizeof(*block)); +xfs_btree_mark_sick (cur);return -EFSCORRUPTED ; }
@@ -4369,12 +4383,16 @@ xfs_btree_visit_block(*/ if (cur->bc_flags &XFS_BTREE_LONG_PTRS ) {if (be64_to_cpu (rptr.l) ==XFS_DADDR_TO_FSB (cur->bc_mp, -xfs_buf_daddr (bp))) +xfs_buf_daddr (bp))) { +xfs_btree_mark_sick (cur);return -EFSCORRUPTED ; + } }else {if (be32_to_cpu (rptr.s) ==xfs_daddr_to_agbno (cur->bc_mp, -xfs_buf_daddr (bp))) +xfs_buf_daddr (bp))) { +xfs_btree_mark_sick (cur);return -EFSCORRUPTED ; + } }return xfs_btree_lookup_get_block (cur, level, &rptr, &block); }
@@ -5233,6 +5251,7 @@ xfs_btree_goto_left_edge(return error;if (stat !=0 ) {ASSERT (0 ); +xfs_btree_mark_sick (cur);return -EFSCORRUPTED ; }
fs/xfs/libxfs/xfs_health.h +2 -0
@@ -37,6 +37,7 @@ struct xfs_mount;struct xfs_perag ;struct xfs_inode ;struct xfs_fsop_geom ; +struct xfs_btree_cur ;/* Observable health issues for metadata spanning the entire filesystem. */ #define XFS_SICK_FS_COUNTERS (1 << 0)/* summary counters */
@@ -153,6 +154,7 @@ void xfs_inode_measure_sickness(struct xfs_inode *ip, unsigned int *sick,void xfs_health_unmount (struct xfs_mount *mp);void xfs_bmap_mark_sick (struct xfs_inode *ip,int whichfork); +void xfs_btree_mark_sick (struct xfs_btree_cur *cur);/* Now some helpers. */
fs/xfs/libxfs/xfs_ialloc.c +1 -0
@@ -148,6 +148,7 @@ xfs_inobt_complain_bad_rec("start inode 0x%x, count 0x%x, free 0x%x freemask 0x%llx, holemask 0x%x" , irec->ir_startino, irec->ir_count, irec->ir_freecount, irec->ir_free, irec->ir_holemask); +xfs_btree_mark_sick (cur);return -EFSCORRUPTED ; }
fs/xfs/libxfs/xfs_refcount.c +5 -1
@@ -23,6 +23,7 @@#include "xfs_refcount.h" #include "xfs_rmap.h" #include "xfs_ag.h" +#include "xfs_health.h" struct kmem_cache *xfs_refcount_intent_cache;
@@ -156,6 +157,7 @@ xfs_refcount_complain_bad_rec(xfs_warn (mp,"Start block 0x%x, block count 0x%x, references 0x%x" , irec->rc_startblock, irec->rc_blockcount, irec->rc_refcount); +xfs_btree_mark_sick (cur);return -EFSCORRUPTED ; }
@@ -1889,8 +1891,10 @@ xfs_refcount_recover_extent(struct xfs_refcount_recovery *rr;if (XFS_IS_CORRUPT (cur->bc_mp, -be32_to_cpu (rec->refc.rc_refcount) !=1 )) +be32_to_cpu (rec->refc.rc_refcount) !=1 )) { +xfs_btree_mark_sick (cur);return -EFSCORRUPTED ; + } rr =kmalloc (sizeof (struct xfs_refcount_recovery ),GFP_KERNEL | __GFP_NOFAIL);
fs/xfs/libxfs/xfs_rmap.c +5 -1
@@ -23,6 +23,7 @@#include "xfs_error.h" #include "xfs_inode.h" #include "xfs_ag.h" +#include "xfs_health.h" struct kmem_cache *xfs_rmap_intent_cache;
@@ -56,8 +57,10 @@ xfs_rmap_lookup_le( error =xfs_rmap_get_rec (cur, irec, &get_stat);if (error)return error; -if (!get_stat) +if (!get_stat) { +xfs_btree_mark_sick (cur);return -EFSCORRUPTED ; + }return 0 ; }
@@ -277,6 +280,7 @@ xfs_rmap_complain_bad_rec("Owner 0x%llx, flags 0x%x, start block 0x%x block count 0x%x" , irec->rm_owner, irec->rm_flags, irec->rm_startblock, irec->rm_blockcount); +xfs_btree_mark_sick (cur);return -EFSCORRUPTED ; }
fs/xfs/xfs_health.c +38 -0
@@ -14,6 +14,7 @@#include "xfs_trace.h" #include "xfs_health.h" #include "xfs_ag.h" +#include "xfs_btree.h" /* * Warn about metadata corruption that we detected but haven't fixed, and
@@ -491,3 +492,40 @@ xfs_bmap_mark_sick(xfs_inode_mark_sick (ip, mask); } + +/* Record observations of btree corruption with the health tracking system. */ +void +xfs_btree_mark_sick ( +struct xfs_btree_cur *cur) +{ +unsigned int mask; + +switch (cur->bc_btnum) { +case XFS_BTNUM_BMAP : +xfs_bmap_mark_sick (cur->bc_ino.ip, cur->bc_ino.whichfork); +return ; +case XFS_BTNUM_BNO : + mask =XFS_SICK_AG_BNOBT ; +break ; +case XFS_BTNUM_CNT : + mask =XFS_SICK_AG_CNTBT ; +break ; +case XFS_BTNUM_INO : + mask =XFS_SICK_AG_INOBT ; +break ; +case XFS_BTNUM_FINO : + mask =XFS_SICK_AG_FINOBT ; +break ; +case XFS_BTNUM_RMAP : + mask =XFS_SICK_AG_RMAPBT ; +break ; +case XFS_BTNUM_REFC : + mask =XFS_SICK_AG_REFCNTBT ; +break ; +default : +ASSERT (0 ); +return ; + } + +xfs_ag_mark_sick (cur->bc_ag.pag, mask); +}
Re: [PATCH 05/11] xfs: report btree block corruption errors to the health system
Looks good:
PATCH 6/11 xfs: report dir/attr block corruption errors to the health system
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Whenever we encounter corrupt directory or extended attribute blocks, we should report that to the health monitoring system for later reporting.
--- fs/xfs/libxfs/xfs_attr_leaf.c | 4 ++++ fs/xfs/libxfs/xfs_attr_remote.c | 27 ++++++++++++++++----------- fs/xfs/libxfs/xfs_da_btree.c | 37 ++++++++++++++++++++++++++++++++----- fs/xfs/libxfs/xfs_dir2.c | 5 ++++- fs/xfs/libxfs/xfs_dir2_block.c | 2 ++ fs/xfs/libxfs/xfs_dir2_data.c | 3 +++ fs/xfs/libxfs/xfs_dir2_leaf.c | 3 +++ fs/xfs/libxfs/xfs_dir2_node.c | 7 +++++++ fs/xfs/libxfs/xfs_health.h | 3 +++ fs/xfs/xfs_attr_inactive.c | 4 ++++ fs/xfs/xfs_attr_list.c | 9 ++++++++- fs/xfs/xfs_health.c | 39 +++++++++++++++++++++++++++++++++++++++ 12 files changed, 125 insertions(+), 18 deletions(-)
fs/xfs/libxfs/xfs_attr_leaf.c +4 -0
@@ -29,6 +29,7 @@#include "xfs_log.h" #include "xfs_ag.h" #include "xfs_errortag.h" +#include "xfs_health.h" /*
@@ -2414,6 +2415,7 @@ xfs_attr3_leaf_lookup_int( entries =xfs_attr3_leaf_entryp (leaf);if (ichdr.count >= args->geo->blksize /8 ) {xfs_buf_mark_corrupt (bp); +xfs_da_mark_sick (args);return -EFSCORRUPTED ; }
@@ -2433,10 +2435,12 @@ xfs_attr3_leaf_lookup_int( }if (!(probe >=0 && (!ichdr.count || probe < ichdr.count))) {xfs_buf_mark_corrupt (bp); +xfs_da_mark_sick (args);return -EFSCORRUPTED ; }if (!(span <=4 ||be32_to_cpu (entry->hashval) == hashval)) {xfs_buf_mark_corrupt (bp); +xfs_da_mark_sick (args);return -EFSCORRUPTED ; }
fs/xfs/libxfs/xfs_attr_remote.c +16 -11
@@ -22,6 +22,7 @@#include "xfs_attr_remote.h" #include "xfs_trace.h" #include "xfs_error.h" +#include "xfs_health.h" #define ATTR_RMTVALUE_MAPSIZE 1/* # of map entries at once */
@@ -276,17 +277,18 @@ xfs_attr3_rmt_hdr_set(*/ STATIC intxfs_attr_rmtval_copyout ( -struct xfs_mount *mp, -struct xfs_buf *bp, -xfs_ino_t ino, -int *offset, -int *valuelen, -uint8_t **dst) +struct xfs_mount *mp, +struct xfs_buf *bp, +struct xfs_inode *dp, +int *offset, +int *valuelen, +uint8_t **dst) { -char *src = bp->b_addr; -xfs_daddr_t bno =xfs_buf_daddr (bp); -int len =BBTOB (bp->b_length); -int blksize = mp->m_attr_geo->blksize; +char *src = bp->b_addr; +xfs_ino_t ino = dp->i_ino; +xfs_daddr_t bno =xfs_buf_daddr (bp); +int len =BBTOB (bp->b_length); +int blksize = mp->m_attr_geo->blksize;ASSERT (len >= blksize);
@@ -302,6 +304,7 @@ xfs_attr_rmtval_copyout(xfs_alert (mp,"remote attribute header mismatch bno/off/len/owner (0x%llx/0x%x/Ox%x/0x%llx)" , bno, *offset, byte_cnt, ino); +xfs_dirattr_mark_sick (dp,XFS_ATTR_FORK );return -EFSCORRUPTED ; } hdr_size =sizeof (struct xfs_attr3_rmt_hdr );
@@ -418,10 +421,12 @@ xfs_attr_rmtval_get( dblkcnt =XFS_FSB_TO_BB (mp, map[i].br_blockcount); error =xfs_buf_read (mp->m_ddev_targp, dblkno, dblkcnt,0 , &bp, &xfs_attr3_rmt_buf_ops); +if (xfs_metadata_is_sick (error)) +xfs_dirattr_mark_sick (args->dp,XFS_ATTR_FORK );if (error)return error; - error =xfs_attr_rmtval_copyout (mp, bp, args->dp->i_ino, + error =xfs_attr_rmtval_copyout (mp, bp, args->dp, &offset, &valuelen, &dst);xfs_buf_relse (bp);
fs/xfs/libxfs/xfs_da_btree.c +32 -5
@@ -23,6 +23,7 @@#include "xfs_buf_item.h" #include "xfs_log.h" #include "xfs_errortag.h" +#include "xfs_health.h" /* * xfs_da_btree.c
@@ -352,6 +353,8 @@ const struct xfs_buf_ops xfs_da3_node_buf_ops = {static int xfs_da3_node_set_type (struct xfs_trans *tp, +struct xfs_inode *dp, +int whichfork,struct xfs_buf *bp) {struct xfs_da_blkinfo *info = bp->b_addr;
@@ -373,6 +376,7 @@ xfs_da3_node_set_type(XFS_CORRUPTION_ERROR (__func__,XFS_ERRLEVEL_LOW , tp->t_mountp, info,sizeof (*info));xfs_trans_brelse (tp, bp); +xfs_dirattr_mark_sick (dp, whichfork);return -EFSCORRUPTED ; } }
@@ -391,7 +395,7 @@ xfs_da3_node_read( &xfs_da3_node_buf_ops);if (error || !*bpp || !tp)return error; -return xfs_da3_node_set_type (tp, *bpp); +return xfs_da3_node_set_type (tp, dp, whichfork, *bpp); }int
@@ -408,6 +412,8 @@ xfs_da3_node_read_mapped( error =xfs_trans_read_buf (mp, tp, mp->m_ddev_targp, mappedbno,XFS_FSB_TO_BB (mp,xfs_dabuf_nfsb (mp, whichfork)),0 , bpp, &xfs_da3_node_buf_ops); +if (xfs_metadata_is_sick (error)) +xfs_dirattr_mark_sick (dp, whichfork);if (error || !*bpp)return error;
@@ -418,7 +424,7 @@ xfs_da3_node_read_mapped(if (!tp)return 0 ; -return xfs_da3_node_set_type (tp, *bpp); +return xfs_da3_node_set_type (tp, dp, whichfork, *bpp); }/*
@@ -631,6 +637,7 @@ xfs_da3_split(if (node->hdr.info.forw) {if (be32_to_cpu (node->hdr.info.forw) != addblk->blkno) {xfs_buf_mark_corrupt (oldblk->bp); +xfs_da_mark_sick (state->args); error = -EFSCORRUPTED ; goto out; }
@@ -644,6 +651,7 @@ xfs_da3_split(if (node->hdr.info.back) {if (be32_to_cpu (node->hdr.info.back) != addblk->blkno) {xfs_buf_mark_corrupt (oldblk->bp); +xfs_da_mark_sick (state->args); error = -EFSCORRUPTED ; goto out; }
@@ -1635,6 +1643,7 @@ xfs_da3_node_lookup_int(if (magic !=XFS_DA_NODE_MAGIC && magic !=XFS_DA3_NODE_MAGIC ) {xfs_buf_mark_corrupt (blk->bp); +xfs_da_mark_sick (args);return -EFSCORRUPTED ; }
@@ -1650,6 +1659,7 @@ xfs_da3_node_lookup_int(/* Tree taller than we can handle; bail out! */ if (nodehdr.level >=XFS_DA_NODE_MAXDEPTH ) {xfs_buf_mark_corrupt (blk->bp); +xfs_da_mark_sick (args);return -EFSCORRUPTED ; }
@@ -1658,6 +1668,7 @@ xfs_da3_node_lookup_int( expected_level = nodehdr.level -1 ; else if (expected_level != nodehdr.level) {xfs_buf_mark_corrupt (blk->bp); +xfs_da_mark_sick (args);return -EFSCORRUPTED ; } else expected_level--;
@@ -1709,12 +1720,16 @@ xfs_da3_node_lookup_int( }/* We can't point back to the root. */ -if (XFS_IS_CORRUPT (dp->i_mount, blkno == args->geo->leafblk)) +if (XFS_IS_CORRUPT (dp->i_mount, blkno == args->geo->leafblk)) { +xfs_da_mark_sick (args);return -EFSCORRUPTED ; + } } -if (XFS_IS_CORRUPT (dp->i_mount, expected_level !=0 )) +if (XFS_IS_CORRUPT (dp->i_mount, expected_level !=0 )) { +xfs_da_mark_sick (args);return -EFSCORRUPTED ; + }/* * A leaf block that ends in the hashval that we are interested in
@@ -1732,6 +1747,7 @@ xfs_da3_node_lookup_int( args->blkno = blk->blkno; }else {ASSERT (0 ); +xfs_da_mark_sick (args);return -EFSCORRUPTED ; } if (((retval == -ENOENT) || (retval == -ENOATTR)) &&
@@ -2297,8 +2313,10 @@ xfs_da3_swap_lastblock( error =xfs_bmap_last_before (tp, dp, &lastoff, w);if (error)return error; -if (XFS_IS_CORRUPT (mp, lastoff ==0 )) +if (XFS_IS_CORRUPT (mp, lastoff ==0 )) { +xfs_da_mark_sick (args);return -EFSCORRUPTED ; + }/* * Read the last block in the btree space. */
@@ -2348,6 +2366,7 @@ xfs_da3_swap_lastblock(if (XFS_IS_CORRUPT (mp,be32_to_cpu (sib_info->forw) != last_blkno || sib_info->magic != dead_info->magic)) { +xfs_da_mark_sick (args); error = -EFSCORRUPTED ; goto done; }
@@ -2368,6 +2387,7 @@ xfs_da3_swap_lastblock(if (XFS_IS_CORRUPT (mp,be32_to_cpu (sib_info->back) != last_blkno || sib_info->magic != dead_info->magic)) { +xfs_da_mark_sick (args); error = -EFSCORRUPTED ; goto done; }
@@ -2390,6 +2410,7 @@ xfs_da3_swap_lastblock(xfs_da3_node_hdr_from_disk (dp->i_mount, &par_hdr, par_node);if (XFS_IS_CORRUPT (mp, level >=0 && level != par_hdr.level +1 )) { +xfs_da_mark_sick (args); error = -EFSCORRUPTED ; goto done; }
@@ -2401,6 +2422,7 @@ xfs_da3_swap_lastblock( entno++)continue ;if (XFS_IS_CORRUPT (mp, entno == par_hdr.count)) { +xfs_da_mark_sick (args); error = -EFSCORRUPTED ; goto done; }
@@ -2426,6 +2448,7 @@ xfs_da3_swap_lastblock(xfs_trans_brelse (tp, par_buf); par_buf =NULL ;if (XFS_IS_CORRUPT (mp, par_blkno ==0 )) { +xfs_da_mark_sick (args); error = -EFSCORRUPTED ; goto done; }
@@ -2435,6 +2458,7 @@ xfs_da3_swap_lastblock( par_node = par_buf->b_addr;xfs_da3_node_hdr_from_disk (dp->i_mount, &par_hdr, par_node);if (XFS_IS_CORRUPT (mp, par_hdr.level != level)) { +xfs_da_mark_sick (args); error = -EFSCORRUPTED ; goto done; }
@@ -2563,6 +2587,7 @@ xfs_dabuf_map( invalid_mapping:/* Caller ok with no mapping. */ if (XFS_IS_CORRUPT (mp, !(flags &XFS_DABUF_MAP_HOLE_OK ))) { +xfs_dirattr_mark_sick (dp, whichfork); error = -EFSCORRUPTED ;if (xfs_error_level >=XFS_ERRLEVEL_LOW ) { xfs_alert(mp, "%s: bno %u inode %llu",
@@ -2644,6 +2669,8 @@ xfs_da_read_buf( error =xfs_trans_read_buf_map (mp, tp, mp->m_ddev_targp, mapp, nmap,0 , &bp, ops); +if (xfs_metadata_is_sick (error)) +xfs_dirattr_mark_sick (dp, whichfork);if (error) goto out_free;
fs/xfs/libxfs/xfs_dir2.c +4 -1
@@ -18,6 +18,7 @@#include "xfs_errortag.h" #include "xfs_error.h" #include "xfs_trace.h" +#include "xfs_health.h" const struct xfs_name xfs_name_dotdot = { .name = (const unsigned char *)".." ,
@@ -632,8 +633,10 @@ xfs_dir2_isblock(return 0 ; *isblock = true; -if (XFS_IS_CORRUPT (mp, args->dp->i_disk_size != args->geo->blksize)) +if (XFS_IS_CORRUPT (mp, args->dp->i_disk_size != args->geo->blksize)) { +xfs_da_mark_sick (args);return -EFSCORRUPTED ; + }return 0 ; }
fs/xfs/libxfs/xfs_dir2_block.c +2 -0
@@ -20,6 +20,7 @@#include "xfs_error.h" #include "xfs_trace.h" #include "xfs_log.h" +#include "xfs_health.h" /* * Local function prototypes.
@@ -152,6 +153,7 @@ xfs_dir3_block_read(__xfs_buf_mark_corrupt (*bpp, fa);xfs_trans_brelse (tp, *bpp); *bpp =NULL ; +xfs_dirattr_mark_sick (dp,XFS_DATA_FORK );return -EFSCORRUPTED ; }
fs/xfs/libxfs/xfs_dir2_data.c +3 -0
@@ -18,6 +18,7 @@#include "xfs_trans.h" #include "xfs_buf_item.h" #include "xfs_log.h" +#include "xfs_health.h" static xfs_failaddr_t xfs_dir2_data_freefind_verify( struct xfs_dir2_data_hdr *hdr, struct xfs_dir2_data_free *bf,
@@ -433,6 +434,7 @@ xfs_dir3_data_read(__xfs_buf_mark_corrupt (*bpp, fa);xfs_trans_brelse (tp, *bpp); *bpp =NULL ; +xfs_dirattr_mark_sick (dp,XFS_DATA_FORK );return -EFSCORRUPTED ; }
@@ -1198,6 +1200,7 @@ xfs_dir2_data_use_free( corrupt:xfs_corruption_error (__func__,XFS_ERRLEVEL_LOW , args->dp->i_mount, hdr,sizeof (*hdr), __FILE__, __LINE__, fa); +xfs_da_mark_sick (args);return -EFSCORRUPTED ; }
fs/xfs/libxfs/xfs_dir2_leaf.c +3 -0
@@ -19,6 +19,7 @@#include "xfs_trace.h" #include "xfs_trans.h" #include "xfs_buf_item.h" +#include "xfs_health.h" /* * Local function declarations.
@@ -1393,8 +1394,10 @@ xfs_dir2_leaf_removename( bestsp =xfs_dir2_leaf_bests_p (ltp);if (be16_to_cpu (bestsp[db]) != oldbest) {xfs_buf_mark_corrupt (lbp); +xfs_da_mark_sick (args);return -EFSCORRUPTED ; } +/* * Mark the former data entry unused. */
fs/xfs/libxfs/xfs_dir2_node.c +7 -0
@@ -20,6 +20,7 @@#include "xfs_trans.h" #include "xfs_buf_item.h" #include "xfs_log.h" +#include "xfs_health.h" /* * Function declarations.
@@ -231,6 +232,7 @@ __xfs_dir3_free_read(__xfs_buf_mark_corrupt (*bpp, fa);xfs_trans_brelse (tp, *bpp); *bpp =NULL ; +xfs_dirattr_mark_sick (dp,XFS_DATA_FORK );return -EFSCORRUPTED ; }
@@ -443,6 +445,7 @@ xfs_dir2_leaf_to_node(if (be32_to_cpu (ltp->bestcount) > (uint )dp->i_disk_size / args->geo->blksize) {xfs_buf_mark_corrupt (lbp); +xfs_da_mark_sick (args);return -EFSCORRUPTED ; }
@@ -517,6 +520,7 @@ xfs_dir2_leafn_add(*/ if (index <0 ) {xfs_buf_mark_corrupt (bp); +xfs_da_mark_sick (args);return -EFSCORRUPTED ; }
@@ -736,6 +740,7 @@ xfs_dir2_leafn_lookup_for_addname( cpu_to_be16(NULLDATAOFF))) {if (curfdb != newfdb)xfs_trans_brelse (tp, curbp); +xfs_da_mark_sick (args);return -EFSCORRUPTED ; } curfdb = newfdb;
@@ -804,6 +809,7 @@ xfs_dir2_leafn_lookup_for_entry(xfs_dir3_leaf_check (dp, bp);if (leafhdr.count <=0 ) {xfs_buf_mark_corrupt (bp); +xfs_da_mark_sick (args);return -EFSCORRUPTED ; }
@@ -1739,6 +1745,7 @@ xfs_dir2_node_add_datablk( }else {xfs_alert (mp," ... fblk is NULL" ); } +xfs_da_mark_sick (args);return -EFSCORRUPTED ; }
fs/xfs/libxfs/xfs_health.h +3 -0
@@ -38,6 +38,7 @@ struct xfs_perag;struct xfs_inode ;struct xfs_fsop_geom ;struct xfs_btree_cur ; +struct xfs_da_args ;/* Observable health issues for metadata spanning the entire filesystem. */ #define XFS_SICK_FS_COUNTERS (1 << 0)/* summary counters */
@@ -155,6 +156,8 @@ void xfs_inode_measure_sickness(struct xfs_inode *ip, unsigned int *sick,void xfs_health_unmount (struct xfs_mount *mp);void xfs_bmap_mark_sick (struct xfs_inode *ip,int whichfork);void xfs_btree_mark_sick (struct xfs_btree_cur *cur); +void xfs_dirattr_mark_sick (struct xfs_inode *ip,int whichfork); +void xfs_da_mark_sick (struct xfs_da_args *args);/* Now some helpers. */
fs/xfs/xfs_attr_inactive.c +4 -0
@@ -23,6 +23,7 @@#include "xfs_quota.h" #include "xfs_dir2.h" #include "xfs_error.h" +#include "xfs_health.h" /* * Invalidate any incore buffers associated with this remote attribute value
@@ -147,6 +148,7 @@ xfs_attr3_node_inactive(if (level >XFS_DA_NODE_MAXDEPTH ) {xfs_buf_mark_corrupt (bp);xfs_trans_brelse (*trans, bp);/* no locks for later trans */ +xfs_dirattr_mark_sick (dp,XFS_ATTR_FORK );return -EFSCORRUPTED ; }
@@ -197,6 +199,7 @@ xfs_attr3_node_inactive(default :xfs_buf_mark_corrupt (child_bp);xfs_trans_brelse (*trans, child_bp); +xfs_dirattr_mark_sick (dp,XFS_ATTR_FORK ); error = -EFSCORRUPTED ;break ; }
@@ -286,6 +289,7 @@ xfs_attr3_root_inactive( error =xfs_attr3_leaf_inactive (trans, dp, bp);break ;default : +xfs_dirattr_mark_sick (dp,XFS_ATTR_FORK ); error = -EFSCORRUPTED ;xfs_buf_mark_corrupt (bp);xfs_trans_brelse (*trans, bp);
fs/xfs/xfs_attr_list.c +8 -1
@@ -22,6 +22,7 @@#include "xfs_error.h" #include "xfs_trace.h" #include "xfs_dir2.h" +#include "xfs_health.h" STATIC intxfs_attr_shortform_compare (const void *a,const void *b)
@@ -126,6 +127,7 @@ xfs_attr_shortform_list( context->dp->i_mount, sfe, sizeof(*sfe));kmem_free (sbuf); +xfs_dirattr_mark_sick (dp,XFS_ATTR_FORK );return -EFSCORRUPTED ; }
@@ -263,8 +265,10 @@ xfs_attr_node_list_lookup(return 0 ;/* We can't point back to the root. */ -if (XFS_IS_CORRUPT (mp, cursor->blkno ==0 )) +if (XFS_IS_CORRUPT (mp, cursor->blkno ==0 )) { +xfs_dirattr_mark_sick (dp,XFS_ATTR_FORK );return -EFSCORRUPTED ; + } }if (expected_level !=0 )
@@ -276,6 +280,7 @@ xfs_attr_node_list_lookup( out_corruptbuf:xfs_buf_mark_corrupt (bp);xfs_trans_brelse (tp, bp); +xfs_dirattr_mark_sick (dp,XFS_ATTR_FORK );return -EFSCORRUPTED ; }
@@ -305,6 +310,8 @@ xfs_attr_node_list(if (cursor->blkno >0 ) { error =xfs_da3_node_read (context->tp, dp, cursor->blkno, &bp,XFS_ATTR_FORK ); +if (xfs_metadata_is_sick (error)) +xfs_dirattr_mark_sick (dp,XFS_ATTR_FORK );if ((error !=0 ) && (error != -EFSCORRUPTED ))return error;if (bp) {
fs/xfs/xfs_health.c +39 -0
@@ -15,6 +15,8 @@#include "xfs_health.h" #include "xfs_ag.h" #include "xfs_btree.h" +#include "xfs_da_format.h" +#include "xfs_da_btree.h" /* * Warn about metadata corruption that we detected but haven't fixed, and
@@ -529,3 +531,40 @@ xfs_btree_mark_sick(xfs_ag_mark_sick (cur->bc_ag.pag, mask); } + +/* +* Record observations of dir/attr btree corruption with the health tracking +* system. +*/ +void +xfs_dirattr_mark_sick ( +struct xfs_inode *ip, +int whichfork) +{ +unsigned int mask; + +switch (whichfork) { +case XFS_DATA_FORK : + mask =XFS_SICK_INO_DIR ; +break ; +case XFS_ATTR_FORK : + mask =XFS_SICK_INO_XATTR ; +break ; +default : +ASSERT (0 ); +return ; + } + +xfs_inode_mark_sick (ip, mask); +} + +/* +* Record observations of dir/attr btree corruption with the health tracking +* system. +*/ +void +xfs_da_mark_sick ( +struct xfs_da_args *args) +{ +xfs_dirattr_mark_sick (args->dp, args->whichfork); +}
Re: [PATCH 06/11] xfs: report dir/attr block corruption errors to the health system
Looks good:
PATCH 7/11 xfs: report symlink block corruption errors to the health system
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Whenever we encounter corrupt symbolic link blocks, we should report that to the health monitoring system for later reporting.
--- fs/xfs/xfs_symlink.c | 17 ++++++++++++----- 1 file changed, 12 insertions(+), 5 deletions(-)
fs/xfs/xfs_symlink.c +12 -5
@@ -58,6 +58,8 @@ xfs_readlink_bmap_ilocked( error =xfs_buf_read (mp->m_ddev_targp, d,BTOBB (byte_cnt),0 , &bp, &xfs_symlink_buf_ops); +if (xfs_metadata_is_sick (error)) +xfs_inode_mark_sick (ip,XFS_SICK_INO_SYMLINK );if (error)return error; byte_cnt =XFS_SYMLINK_BUF_SPACE (mp, byte_cnt);
@@ -68,6 +70,7 @@ xfs_readlink_bmap_ilocked(if (xfs_has_crc (mp)) {if (!xfs_symlink_hdr_ok (ip->i_ino, offset, byte_cnt, bp)) { +xfs_inode_mark_sick (ip,XFS_SICK_INO_SYMLINK ); error = -EFSCORRUPTED ; xfs_alert(mp, "symlink header does not match required off/len/owner (0x%x/Ox%x,0x%llx)",
@@ -103,7 +106,7 @@ xfs_readlink( {struct xfs_mount *mp = ip->i_mount;xfs_fsize_t pathlen; -int error = -EFSCORRUPTED ; +int error;trace_xfs_readlink (ip);
@@ -116,14 +119,14 @@ xfs_readlink( pathlen = ip->i_disk_size;if (!pathlen) - goto out; + goto out_corrupt;if (pathlen <0 || pathlen >XFS_SYMLINK_MAXLEN ) {xfs_alert (mp,"%s: inode (%llu) bad symlink length (%lld)" , __func__, (unsigned long long ) ip->i_ino, (long long ) pathlen);ASSERT (0 ); - goto out; + goto out_corrupt; }if (ip->i_df.if_format ==XFS_DINODE_FMT_LOCAL ) {
@@ -132,7 +135,7 @@ xfs_readlink(* if if_data is junk. */ if (XFS_IS_CORRUPT (ip->i_mount, !ip->i_df.if_u1.if_data)) - goto out; + goto out_corrupt;memcpy (link, ip->i_df.if_u1.if_data, pathlen +1 ); error =0 ;
@@ -140,9 +143,12 @@ xfs_readlink( error =xfs_readlink_bmap_ilocked (ip, link); } - out:xfs_iunlock (ip,XFS_ILOCK_SHARED );return error; + out_corrupt: +xfs_iunlock (ip,XFS_ILOCK_SHARED ); +xfs_inode_mark_sick (ip,XFS_SICK_INO_SYMLINK ); +return -EFSCORRUPTED ; }int
@@ -497,6 +503,7 @@ xfs_inactive_symlink( __func__, (unsigned long long)ip->i_ino, pathlen);xfs_iunlock (ip,XFS_ILOCK_EXCL );ASSERT (0 ); +xfs_inode_mark_sick (ip,XFS_SICK_INO_SYMLINK );return -EFSCORRUPTED ; }
Re: [PATCH 07/11] xfs: report symlink block corruption errors to the health system
Looks good:
PATCH 8/11 xfs: report inode corruption errors to the health system
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Whenever we encounter corrupt inode records, we should report that to the health monitoring system for later reporting.
--- fs/xfs/libxfs/xfs_ialloc.c | 1 + fs/xfs/libxfs/xfs_inode_buf.c | 12 +++++++++--- fs/xfs/libxfs/xfs_inode_fork.c | 8 ++++++++ fs/xfs/xfs_icache.c | 9 +++++++++ fs/xfs/xfs_inode.c | 2 ++ 5 files changed, 29 insertions(+), 3 deletions(-)
fs/xfs/libxfs/xfs_ialloc.c +1 -0
@@ -2999,6 +2999,7 @@ xfs_ialloc_check_shrink( goto out;if (!has) { +xfs_ag_mark_sick (pag,XFS_SICK_AG_INOBT ); error = -EFSCORRUPTED ; goto out; }
fs/xfs/libxfs/xfs_inode_buf.c +9 -3
@@ -18,6 +18,7 @@#include "xfs_trans.h" #include "xfs_ialloc.h" #include "xfs_dir2.h" +#include "xfs_health.h" #include <linux/iversion.h>
@@ -132,9 +133,14 @@ xfs_imap_to_bp(struct xfs_imap *imap, struct xfs_buf **bpp) { - return xfs_trans_read_buf(mp, tp, mp->m_ddev_targp, imap->im_blkno, - imap->im_len, XBF_UNMAPPED, bpp, - &xfs_inode_buf_ops); + int error; + + error =xfs_trans_read_buf (mp, tp, mp->m_ddev_targp, imap->im_blkno, + imap->im_len,XBF_UNMAPPED , bpp, &xfs_inode_buf_ops); +if (xfs_metadata_is_sick (error)) +xfs_agno_mark_sick (mp,xfs_daddr_to_agno (mp, imap->im_blkno), +XFS_SICK_AG_INOBT ); +return error; }static inline struct timespec64 xfs_inode_decode_bigtime (uint64_t ts)
fs/xfs/libxfs/xfs_inode_fork.c +8 -0
@@ -25,6 +25,7 @@#include "xfs_attr_leaf.h" #include "xfs_types.h" #include "xfs_errortag.h" +#include "xfs_health.h" struct kmem_cache *xfs_ifork_cache;
@@ -84,6 +85,7 @@ xfs_iformat_local(xfs_inode_verifier_error (ip, -EFSCORRUPTED ,"xfs_iformat_local" , dip,sizeof (*dip), __this_address); +xfs_inode_mark_sick (ip,XFS_SICK_INO_CORE );return -EFSCORRUPTED ; }
@@ -121,6 +123,7 @@ xfs_iformat_extents(xfs_inode_verifier_error (ip, -EFSCORRUPTED ,"xfs_iformat_extents(1)" , dip,sizeof (*dip), __this_address); +xfs_inode_mark_sick (ip,XFS_SICK_INO_CORE );return -EFSCORRUPTED ; }
@@ -140,6 +143,7 @@ xfs_iformat_extents(xfs_inode_verifier_error (ip, -EFSCORRUPTED ,"xfs_iformat_extents(2)" , dp,sizeof (*dp), fa); +xfs_inode_mark_sick (ip,XFS_SICK_INO_CORE );return xfs_bmap_complain_bad_rec (ip, whichfork, fa, &new); }
@@ -198,6 +202,7 @@ xfs_iformat_btree(xfs_inode_verifier_error (ip, -EFSCORRUPTED ,"xfs_iformat_btree" , dfp, size, __this_address); +xfs_inode_mark_sick (ip,XFS_SICK_INO_CORE );return -EFSCORRUPTED ; }
@@ -262,12 +267,14 @@ xfs_iformat_data_fork(default :xfs_inode_verifier_error (ip, -EFSCORRUPTED , __func__, dip,sizeof (*dip), __this_address); +xfs_inode_mark_sick (ip,XFS_SICK_INO_CORE );return -EFSCORRUPTED ; }break ;default :xfs_inode_verifier_error (ip, -EFSCORRUPTED , __func__, dip,sizeof (*dip), __this_address); +xfs_inode_mark_sick (ip,XFS_SICK_INO_CORE );return -EFSCORRUPTED ; } }
@@ -340,6 +347,7 @@ xfs_iformat_attr_fork(default :xfs_inode_verifier_error (ip, error, __func__, dip,sizeof (*dip), __this_address); +xfs_inode_mark_sick (ip,XFS_SICK_INO_CORE ); error = -EFSCORRUPTED ;break ; }
fs/xfs/xfs_icache.c +9 -0
@@ -24,6 +24,7 @@#include "xfs_ialloc.h" #include "xfs_ag.h" #include "xfs_log_priv.h" +#include "xfs_health.h" #include <linux/iversion.h>
@@ -415,6 +416,9 @@ xfs_iget_check_free_state(xfs_warn (ip->i_mount,"Corruption detected! Free inode 0x%llx not marked free! (mode 0x%x)" , ip->i_ino,VFS_I (ip)->i_mode); +xfs_agno_mark_sick (ip->i_mount, +XFS_INO_TO_AGNO (ip->i_mount, ip->i_ino), +XFS_SICK_AG_INOBT );return -EFSCORRUPTED ; }
@@ -422,6 +426,9 @@ xfs_iget_check_free_state(xfs_warn (ip->i_mount,"Corruption detected! Free inode 0x%llx has blocks allocated!" , ip->i_ino); +xfs_agno_mark_sick (ip->i_mount, +XFS_INO_TO_AGNO (ip->i_mount, ip->i_ino), +XFS_SICK_AG_INOBT );return -EFSCORRUPTED ; }return 0 ;
@@ -640,6 +647,8 @@ xfs_iget_cache_miss( xfs_buf_offset(bp, ip->i_imap.im_boffset));if (!error)xfs_buf_set_ref (bp,XFS_INO_REF ); +else +xfs_inode_mark_sick (ip,XFS_SICK_INO_CORE );xfs_trans_brelse (tp, bp);if (error)
fs/xfs/xfs_inode.c +2 -0
@@ -3435,6 +3435,8 @@ xfs_iflush(/* generate the checksum. */ xfs_dinode_calc_crc (mp, dip); +if (error) +xfs_inode_mark_sick (ip,XFS_SICK_INO_CORE );return error; }
Re: [PATCH 08/11] xfs: report inode corruption errors to the health system
Looks good:
PATCH 9/11 xfs: report quota block corruption errors to the health system
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Whenever we encounter corrupt quota blocks, we should report that to the health monitoring system for later reporting.
--- fs/xfs/xfs_dquot.c | 30 ++++++++++++++++++++++++++++++ fs/xfs/xfs_health.c | 1 + fs/xfs/xfs_qm.c | 8 ++++++-- 3 files changed, 37 insertions(+), 2 deletions(-)
fs/xfs/xfs_dquot.c +30 -0
@@ -24,6 +24,7 @@#include "xfs_log.h" #include "xfs_bmap_btree.h" #include "xfs_error.h" +#include "xfs_health.h" /* * Lock order:
@@ -44,6 +45,29 @@ static struct kmem_cache *xfs_dquot_cache;static struct lock_class_key xfs_dquot_group_class;static struct lock_class_key xfs_dquot_project_class; +/* Record observations of quota corruption with the health tracking system. */ +static void +xfs_dquot_mark_sick ( +struct xfs_dquot *dqp) +{ +struct xfs_mount *mp = dqp->q_mount; + +switch (dqp->q_type) { +case XFS_DQTYPE_USER : +xfs_fs_mark_sick (mp,XFS_SICK_FS_UQUOTA ); +break ; +case XFS_DQTYPE_GROUP : +xfs_fs_mark_sick (mp,XFS_SICK_FS_GQUOTA ); +break ; +case XFS_DQTYPE_PROJ : +xfs_fs_mark_sick (mp,XFS_SICK_FS_PQUOTA ); +break ; +default : +ASSERT (0 ); +break ; + } +} +/* * This is called to free all the memory associated with a dquot */
@@ -451,6 +475,8 @@ xfs_dquot_disk_read( error =xfs_trans_read_buf (mp,NULL , mp->m_ddev_targp, dqp->q_blkno, mp->m_quotainfo->qi_dqchunklen,0 , &bp, &xfs_dquot_buf_ops); +if (xfs_metadata_is_sick (error)) +xfs_dquot_mark_sick (dqp);if (error) {ASSERT (bp ==NULL );return error;
@@ -574,6 +600,7 @@ xfs_dquot_from_disk("Metadata corruption detected at %pS, quota %u" , __this_address, dqp->q_id);xfs_alert (bp->b_mount,"Unmount and run xfs_repair" ); +xfs_dquot_mark_sick (dqp);return -EFSCORRUPTED ; }
@@ -1238,6 +1265,8 @@ xfs_qm_dqflush( &bp, &xfs_dquot_buf_ops);if (error == -EAGAIN ) goto out_unlock; +if (xfs_metadata_is_sick (error)) +xfs_dquot_mark_sick (dqp);if (error) goto out_abort;
@@ -1246,6 +1275,7 @@ xfs_qm_dqflush(xfs_alert (mp,"corrupt dquot ID 0x%x in memory at %pS" , dqp->q_id, fa);xfs_buf_relse (bp); +xfs_dquot_mark_sick (dqp); error = -EFSCORRUPTED ; goto out_abort; }
fs/xfs/xfs_health.c +1 -0
@@ -17,6 +17,7 @@#include "xfs_btree.h" #include "xfs_da_format.h" #include "xfs_da_btree.h" +#include "xfs_quota_defs.h" /* * Warn about metadata corruption that we detected but haven't fixed, and
fs/xfs/xfs_qm.c +6 -2
@@ -762,14 +762,18 @@ xfs_qm_qino_alloc( (mp->m_sb.sb_gquotino != NULLFSINO)) { ino = mp->m_sb.sb_gquotino;if (XFS_IS_CORRUPT (mp, - mp->m_sb.sb_pquotino !=NULLFSINO )) + mp->m_sb.sb_pquotino !=NULLFSINO )) { +xfs_fs_mark_sick (mp,XFS_SICK_FS_PQUOTA );return -EFSCORRUPTED ; + } } else if ((flags & XFS_QMOPT_GQUOTA) && (mp->m_sb.sb_pquotino != NULLFSINO)) { ino = mp->m_sb.sb_pquotino;if (XFS_IS_CORRUPT (mp, - mp->m_sb.sb_gquotino !=NULLFSINO )) + mp->m_sb.sb_gquotino !=NULLFSINO )) { +xfs_fs_mark_sick (mp,XFS_SICK_FS_GQUOTA );return -EFSCORRUPTED ; + } }if (ino !=NULLFSINO ) { error =xfs_iget (mp,NULL , ino,0 ,0 , ipp);
Re: [PATCH 09/11] xfs: report quota block corruption errors to the health system
Looks good:
PATCH 10/11 xfs: report realtime metadata corruption errors to the health system
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Whenever we encounter corrupt realtime metadat blocks, we should report that to the health monitoring system for later reporting.
--- fs/xfs/libxfs/xfs_rtbitmap.c | 9 ++++++++- fs/xfs/xfs_rtalloc.c | 6 ++++++ 2 files changed, 14 insertions(+), 1 deletion(-)
fs/xfs/libxfs/xfs_rtbitmap.c +8 -1
@@ -17,6 +17,7 @@#include "xfs_rtalloc.h" #include "xfs_error.h" #include "xfs_rtbitmap.h" +#include "xfs_health.h" /* * Realtime allocator bitmap functions shared with userspace.
@@ -115,13 +116,19 @@ xfs_rtbuf_get(if (error)return error; -if (XFS_IS_CORRUPT (mp, nmap ==0 || !xfs_bmap_is_written_extent (&map))) +if (XFS_IS_CORRUPT (mp, nmap ==0 || !xfs_bmap_is_written_extent (&map))) { +xfs_rt_mark_sick (mp, issum ?XFS_SICK_RT_SUMMARY : +XFS_SICK_RT_BITMAP );return -EFSCORRUPTED ; + }ASSERT (map.br_startblock !=NULLFSBLOCK ); error =xfs_trans_read_buf (mp, args->tp, mp->m_ddev_targp,XFS_FSB_TO_DADDR (mp, map.br_startblock), mp->m_bsize,0 , &bp, &xfs_rtbuf_ops); +if (xfs_metadata_is_sick (error)) +xfs_rt_mark_sick (mp, issum ?XFS_SICK_RT_SUMMARY : +XFS_SICK_RT_BITMAP );if (error)return error;
fs/xfs/xfs_rtalloc.c +6 -0
@@ -20,6 +20,8 @@#include "xfs_rtalloc.h" #include "xfs_sb.h" #include "xfs_rtbitmap.h" +#include "xfs_log_priv.h" +#include "xfs_health.h" /* * Read and return the summary information for a given extent size,
@@ -1374,6 +1376,8 @@ xfs_rtmount_inodes( sbp = &mp->m_sb; error =xfs_iget (mp,NULL , sbp->sb_rbmino,0 ,0 , &mp->m_rbmip); +if (xfs_metadata_is_sick (error)) +xfs_rt_mark_sick (mp,XFS_SICK_RT_BITMAP );if (error)return error;ASSERT (mp->m_rbmip !=NULL );
@@ -1383,6 +1387,8 @@ xfs_rtmount_inodes( goto out_rele_bitmap; error =xfs_iget (mp,NULL , sbp->sb_rsumino,0 ,0 , &mp->m_rsumip); +if (xfs_metadata_is_sick (error)) +xfs_rt_mark_sick (mp,XFS_SICK_RT_SUMMARY );if (error) goto out_rele_bitmap;ASSERT (mp->m_rsumip !=NULL );
Re: [PATCH 10/11] xfs: report realtime metadata corruption errors to the health system
Looks good:
PATCH 11/11 xfs: report XFS_IS_CORRUPT errors to the health system
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Whenever we encounter XFS_IS_CORRUPT failures, we should report that to the health monitoring system for later reporting.
I started with this semantic patch and massaged everything until it built:
@@
expression mp, test;
@@
- if (XFS_IS_CORRUPT(mp, test)) return -EFSCORRUPTED;
+ if (XFS_IS_CORRUPT(mp, test)) { xfs_btree_mark_sick(cur); return -EFSCORRUPTED; }
@@
expression mp, test;
identifier label, error;
@@
- if (XFS_IS_CORRUPT(mp, test)) { error = -EFSCORRUPTED; goto label; }
+ if (XFS_IS_CORRUPT(mp, test)) { xfs_btree_mark_sick(cur); error = -EFSCORRUPTED; goto label; }
--- fs/xfs/libxfs/xfs_ag.c | 4 +- fs/xfs/libxfs/xfs_alloc.c | 97 +++++++++++++++++++++++++++++++++------ fs/xfs/libxfs/xfs_attr_remote.c | 8 ++- fs/xfs/libxfs/xfs_bmap.c | 94 ++++++++++++++++++++++++++++++++++---- fs/xfs/libxfs/xfs_btree.c | 14 +++++- fs/xfs/libxfs/xfs_ialloc.c | 52 +++++++++++++++++---- fs/xfs/libxfs/xfs_refcount.c | 37 ++++++++++++++- fs/xfs/libxfs/xfs_rmap.c | 77 +++++++++++++++++++++++++++++-- fs/xfs/scrub/refcount_repair.c | 9 +++- fs/xfs/xfs_attr_list.c | 9 +++- fs/xfs/xfs_dir2_readdir.c | 6 ++ fs/xfs/xfs_discard.c | 2 + fs/xfs/xfs_iwalk.c | 5 ++ 13 files changed, 364 insertions(+), 50 deletions(-)
fs/xfs/libxfs/xfs_ag.c +3 -1
@@ -931,8 +931,10 @@ xfs_ag_shrink_space( agf = agfbp->b_addr; aglen =be32_to_cpu (agi->agi_length);/* some extra paranoid checks before we shrink the ag */ -if (XFS_IS_CORRUPT (mp, agf->agf_length != agi->agi_length)) +if (XFS_IS_CORRUPT (mp, agf->agf_length != agi->agi_length)) { +xfs_ag_mark_sick (pag,XFS_SICK_AG_AGF );return -EFSCORRUPTED ; + }if (delta >= aglen)return -EINVAL ;
fs/xfs/libxfs/xfs_alloc.c +81 -16
374 lines not on this page · raw message
fs/xfs/libxfs/xfs_attr_remote.c +6 -2
@@ -553,8 +553,10 @@ xfs_attr_rmtval_stale(ASSERT (xfs_isilocked (ip,XFS_ILOCK_EXCL ));if (XFS_IS_CORRUPT (mp, map->br_startblock ==DELAYSTARTBLOCK ) || -XFS_IS_CORRUPT (mp, map->br_startblock ==HOLESTARTBLOCK )) +XFS_IS_CORRUPT (mp, map->br_startblock ==HOLESTARTBLOCK )) { +xfs_bmap_mark_sick (ip,XFS_ATTR_FORK );return -EFSCORRUPTED ; + } error = xfs_buf_incore(mp->m_ddev_targp, XFS_FSB_TO_DADDR(mp, map->br_startblock),
@@ -664,8 +666,10 @@ xfs_attr_rmtval_invalidate( blkcnt, &map, &nmap, XFS_BMAPI_ATTRFORK);if (error)return error; -if (XFS_IS_CORRUPT (args->dp->i_mount, nmap !=1 )) +if (XFS_IS_CORRUPT (args->dp->i_mount, nmap !=1 )) { +xfs_bmap_mark_sick (args->dp,XFS_ATTR_FORK );return -EFSCORRUPTED ; + } error =xfs_attr_rmtval_stale (args->dp, &map,XBF_TRYLOCK );if (error)return error;
fs/xfs/libxfs/xfs_bmap.c +84 -10
484 lines not on this page · raw message
fs/xfs/libxfs/xfs_btree.c +13 -1
@@ -2026,8 +2026,10 @@ xfs_btree_lookup( error =xfs_btree_increment (cur,0 , &i);if (error) goto error0; -if (XFS_IS_CORRUPT (cur->bc_mp, i !=1 )) +if (XFS_IS_CORRUPT (cur->bc_mp, i !=1 )) { +xfs_btree_mark_sick (cur);return -EFSCORRUPTED ; + } *stat =1 ;return 0 ; }
@@ -2480,6 +2482,7 @@ xfs_btree_lshift( goto error0; i =xfs_btree_firstrec (tcur, level);if (XFS_IS_CORRUPT (tcur->bc_mp, i !=1 )) { +xfs_btree_mark_sick (cur); error = -EFSCORRUPTED ; goto error0; }
@@ -2650,6 +2653,7 @@ xfs_btree_rshift( goto error0; i =xfs_btree_lastrec (tcur, level);if (XFS_IS_CORRUPT (tcur->bc_mp, i !=1 )) { +xfs_btree_mark_sick (cur); error = -EFSCORRUPTED ; goto error0; }
@@ -3538,6 +3542,7 @@ xfs_btree_insert( }if (XFS_IS_CORRUPT (cur->bc_mp, i !=1 )) { +xfs_btree_mark_sick (cur); error = -EFSCORRUPTED ; goto error0; }
@@ -3945,6 +3950,7 @@ xfs_btree_delrec(*/ i =xfs_btree_lastrec (tcur, level);if (XFS_IS_CORRUPT (cur->bc_mp, i !=1 )) { +xfs_btree_mark_sick (cur); error = -EFSCORRUPTED ; goto error0; }
@@ -3953,12 +3959,14 @@ xfs_btree_delrec(if (error) goto error0;if (XFS_IS_CORRUPT (cur->bc_mp, i !=1 )) { +xfs_btree_mark_sick (cur); error = -EFSCORRUPTED ; goto error0; } i =xfs_btree_lastrec (tcur, level);if (XFS_IS_CORRUPT (cur->bc_mp, i !=1 )) { +xfs_btree_mark_sick (cur); error = -EFSCORRUPTED ; goto error0; }
@@ -4006,6 +4014,7 @@ xfs_btree_delrec(if (!xfs_btree_ptr_is_null (cur, &lptr)) { i =xfs_btree_firstrec (tcur, level);if (XFS_IS_CORRUPT (cur->bc_mp, i !=1 )) { +xfs_btree_mark_sick (cur); error = -EFSCORRUPTED ; goto error0; }
@@ -4014,6 +4023,7 @@ xfs_btree_delrec(if (error) goto error0;if (XFS_IS_CORRUPT (cur->bc_mp, i !=1 )) { +xfs_btree_mark_sick (cur); error = -EFSCORRUPTED ; goto error0; }
@@ -4031,6 +4041,7 @@ xfs_btree_delrec(*/ i =xfs_btree_firstrec (tcur, level);if (XFS_IS_CORRUPT (cur->bc_mp, i !=1 )) { +xfs_btree_mark_sick (cur); error = -EFSCORRUPTED ; goto error0; }
@@ -4040,6 +4051,7 @@ xfs_btree_delrec( goto error0; i =xfs_btree_firstrec (tcur, level);if (XFS_IS_CORRUPT (cur->bc_mp, i !=1 )) { +xfs_btree_mark_sick (cur); error = -EFSCORRUPTED ; goto error0; }
fs/xfs/libxfs/xfs_ialloc.c +43 -9
205 lines not on this page · raw message
fs/xfs/libxfs/xfs_refcount.c +36 -1
@@ -240,6 +240,7 @@ xfs_refcount_insert(if (error) goto out_error;if (XFS_IS_CORRUPT (cur->bc_mp, *i !=1 )) { +xfs_btree_mark_sick (cur); error = -EFSCORRUPTED ; goto out_error; }
@@ -270,12 +271,14 @@ xfs_refcount_delete(if (error) goto out_error;if (XFS_IS_CORRUPT (cur->bc_mp, found_rec !=1 )) { +xfs_btree_mark_sick (cur); error = -EFSCORRUPTED ; goto out_error; }trace_xfs_refcount_delete (cur->bc_mp, cur->bc_ag.pag->pag_agno, &irec); error =xfs_btree_delete (cur, i);if (XFS_IS_CORRUPT (cur->bc_mp, *i !=1 )) { +xfs_btree_mark_sick (cur); error = -EFSCORRUPTED ; goto out_error; }
@@ -400,6 +403,7 @@ xfs_refcount_split_extent(if (error) goto out_error;if (XFS_IS_CORRUPT (cur->bc_mp, found_rec !=1 )) { +xfs_btree_mark_sick (cur); error = -EFSCORRUPTED ; goto out_error; }
@@ -427,6 +431,7 @@ xfs_refcount_split_extent(if (error) goto out_error;if (XFS_IS_CORRUPT (cur->bc_mp, found_rec !=1 )) { +xfs_btree_mark_sick (cur); error = -EFSCORRUPTED ; goto out_error; }
@@ -472,6 +477,7 @@ xfs_refcount_merge_center_extents(if (error) goto out_error;if (XFS_IS_CORRUPT (cur->bc_mp, found_rec !=1 )) { +xfs_btree_mark_sick (cur); error = -EFSCORRUPTED ; goto out_error; }
@@ -480,6 +486,7 @@ xfs_refcount_merge_center_extents(if (error) goto out_error;if (XFS_IS_CORRUPT (cur->bc_mp, found_rec !=1 )) { +xfs_btree_mark_sick (cur); error = -EFSCORRUPTED ; goto out_error; }
@@ -489,6 +496,7 @@ xfs_refcount_merge_center_extents(if (error) goto out_error;if (XFS_IS_CORRUPT (cur->bc_mp, found_rec !=1 )) { +xfs_btree_mark_sick (cur); error = -EFSCORRUPTED ; goto out_error; }
@@ -500,6 +508,7 @@ xfs_refcount_merge_center_extents(if (error) goto out_error;if (XFS_IS_CORRUPT (cur->bc_mp, found_rec !=1 )) { +xfs_btree_mark_sick (cur); error = -EFSCORRUPTED ; goto out_error; }
@@ -544,6 +553,7 @@ xfs_refcount_merge_left_extent(if (error) goto out_error;if (XFS_IS_CORRUPT (cur->bc_mp, found_rec !=1 )) { +xfs_btree_mark_sick (cur); error = -EFSCORRUPTED ; goto out_error; }
@@ -552,6 +562,7 @@ xfs_refcount_merge_left_extent(if (error) goto out_error;if (XFS_IS_CORRUPT (cur->bc_mp, found_rec !=1 )) { +xfs_btree_mark_sick (cur); error = -EFSCORRUPTED ; goto out_error; }
@@ -563,6 +574,7 @@ xfs_refcount_merge_left_extent(if (error) goto out_error;if (XFS_IS_CORRUPT (cur->bc_mp, found_rec !=1 )) { +xfs_btree_mark_sick (cur); error = -EFSCORRUPTED ; goto out_error; }
@@ -610,6 +622,7 @@ xfs_refcount_merge_right_extent(if (error) goto out_error;if (XFS_IS_CORRUPT (cur->bc_mp, found_rec !=1 )) { +xfs_btree_mark_sick (cur); error = -EFSCORRUPTED ; goto out_error; }
@@ -618,6 +631,7 @@ xfs_refcount_merge_right_extent(if (error) goto out_error;if (XFS_IS_CORRUPT (cur->bc_mp, found_rec !=1 )) { +xfs_btree_mark_sick (cur); error = -EFSCORRUPTED ; goto out_error; }
@@ -629,6 +643,7 @@ xfs_refcount_merge_right_extent(if (error) goto out_error;if (XFS_IS_CORRUPT (cur->bc_mp, found_rec !=1 )) { +xfs_btree_mark_sick (cur); error = -EFSCORRUPTED ; goto out_error; }
@@ -676,6 +691,7 @@ xfs_refcount_find_left_extents(if (error) goto out_error;if (XFS_IS_CORRUPT (cur->bc_mp, found_rec !=1 )) { +xfs_btree_mark_sick (cur); error = -EFSCORRUPTED ; goto out_error; }
@@ -695,6 +711,7 @@ xfs_refcount_find_left_extents(if (error) goto out_error;if (XFS_IS_CORRUPT (cur->bc_mp, found_rec !=1 )) { +xfs_btree_mark_sick (cur); error = -EFSCORRUPTED ; goto out_error; }
@@ -769,6 +786,7 @@ xfs_refcount_find_right_extents(if (error) goto out_error;if (XFS_IS_CORRUPT (cur->bc_mp, found_rec !=1 )) { +xfs_btree_mark_sick (cur); error = -EFSCORRUPTED ; goto out_error; }
@@ -788,6 +806,7 @@ xfs_refcount_find_right_extents(if (error) goto out_error;if (XFS_IS_CORRUPT (cur->bc_mp, found_rec !=1 )) { +xfs_btree_mark_sick (cur); error = -EFSCORRUPTED ; goto out_error; }
@@ -1144,6 +1163,7 @@ xfs_refcount_adjust_extents( goto out_error;if (XFS_IS_CORRUPT (cur->bc_mp, found_tmp !=1 )) { +xfs_btree_mark_sick (cur); error = -EFSCORRUPTED ; goto out_error; }
@@ -1182,6 +1202,7 @@ xfs_refcount_adjust_extents(*/ if (XFS_IS_CORRUPT (cur->bc_mp, ext.rc_blockcount ==0 ) ||XFS_IS_CORRUPT (cur->bc_mp, ext.rc_blockcount > *aglen)) { +xfs_btree_mark_sick (cur); error = -EFSCORRUPTED ; goto out_error; }
@@ -1205,6 +1226,7 @@ xfs_refcount_adjust_extents(if (error) goto out_error;if (XFS_IS_CORRUPT (cur->bc_mp, found_rec !=1 )) { +xfs_btree_mark_sick (cur); error = -EFSCORRUPTED ; goto out_error; }
@@ -1329,8 +1351,10 @@ xfs_refcount_continue_op(struct xfs_perag *pag = cur->bc_ag.pag;if (XFS_IS_CORRUPT (mp, !xfs_verify_agbext (pag, new_agbno, - ri->ri_blockcount))) + ri->ri_blockcount))) { +xfs_btree_mark_sick (cur);return -EFSCORRUPTED ; + } ri->ri_startblock =XFS_AGB_TO_FSB (mp, pag->pag_agno, new_agbno);
@@ -1537,6 +1561,7 @@ xfs_refcount_find_shared(if (error) goto out_error;if (XFS_IS_CORRUPT (cur->bc_mp, i !=1 )) { +xfs_btree_mark_sick (cur); error = -EFSCORRUPTED ; goto out_error; }
@@ -1554,6 +1579,7 @@ xfs_refcount_find_shared(if (error) goto out_error;if (XFS_IS_CORRUPT (cur->bc_mp, i !=1 )) { +xfs_btree_mark_sick (cur); error = -EFSCORRUPTED ; goto out_error; }
@@ -1587,6 +1613,7 @@ xfs_refcount_find_shared(if (error) goto out_error;if (XFS_IS_CORRUPT (cur->bc_mp, i !=1 )) { +xfs_btree_mark_sick (cur); error = -EFSCORRUPTED ; goto out_error; }
@@ -1684,6 +1711,7 @@ xfs_refcount_adjust_cow_extents( goto out_error;if (XFS_IS_CORRUPT (cur->bc_mp, found_rec && ext.rc_domain !=XFS_REFC_DOMAIN_COW )) { +xfs_btree_mark_sick (cur); error = -EFSCORRUPTED ; goto out_error; }
@@ -1699,6 +1727,7 @@ xfs_refcount_adjust_cow_extents(/* Adding a CoW reservation, there should be nothing here. */ if (XFS_IS_CORRUPT (cur->bc_mp, agbno + aglen > ext.rc_startblock)) { +xfs_btree_mark_sick (cur); error = -EFSCORRUPTED ; goto out_error; }
@@ -1716,6 +1745,7 @@ xfs_refcount_adjust_cow_extents(if (error) goto out_error;if (XFS_IS_CORRUPT (cur->bc_mp, found_tmp !=1 )) { +xfs_btree_mark_sick (cur); error = -EFSCORRUPTED ; goto out_error; }
@@ -1723,14 +1753,17 @@ xfs_refcount_adjust_cow_extents(case XFS_REFCOUNT_ADJUST_COW_FREE :/* Removing a CoW reservation, there should be one extent. */ if (XFS_IS_CORRUPT (cur->bc_mp, ext.rc_startblock != agbno)) { +xfs_btree_mark_sick (cur); error = -EFSCORRUPTED ; goto out_error; }if (XFS_IS_CORRUPT (cur->bc_mp, ext.rc_blockcount != aglen)) { +xfs_btree_mark_sick (cur); error = -EFSCORRUPTED ; goto out_error; }if (XFS_IS_CORRUPT (cur->bc_mp, ext.rc_refcount !=1 )) { +xfs_btree_mark_sick (cur); error = -EFSCORRUPTED ; goto out_error; }
@@ -1742,6 +1775,7 @@ xfs_refcount_adjust_cow_extents(if (error) goto out_error;if (XFS_IS_CORRUPT (cur->bc_mp, found_rec !=1 )) { +xfs_btree_mark_sick (cur); error = -EFSCORRUPTED ; goto out_error; }
@@ -1904,6 +1938,7 @@ xfs_refcount_recover_extent(if (xfs_refcount_check_irec (cur->bc_ag.pag, &rr->rr_rrec) !=NULL ||XFS_IS_CORRUPT (cur->bc_mp, rr->rr_rrec.rc_domain !=XFS_REFC_DOMAIN_COW )) { +xfs_btree_mark_sick (cur);kfree (rr);return -EFSCORRUPTED ; }
fs/xfs/libxfs/xfs_rmap.c +73 -4
476 lines not on this page · raw message
fs/xfs/scrub/refcount_repair.c +7 -2
@@ -25,6 +25,7 @@#include "xfs_refcount_btree.h" #include "xfs_error.h" #include "xfs_ag.h" +#include "xfs_health.h" #include "scrub/xfs_scrub.h" #include "scrub/scrub.h" #include "scrub/common.h"
@@ -253,8 +254,10 @@ xrep_refc_walk_rmaps( error =xfs_rmap_get_rec (cur, &rmap, &have_gt);if (error)return error; -if (XFS_IS_CORRUPT (mp, !have_gt)) +if (XFS_IS_CORRUPT (mp, !have_gt)) { +xfs_btree_mark_sick (cur);return -EFSCORRUPTED ; + }if (rmap.rm_owner ==XFS_RMAP_OWN_COW ) { error = xrep_refc_stash_cow(rr, rmap.rm_startblock,
@@ -425,8 +428,10 @@ xrep_refc_push_rmaps_at( error =xfs_btree_decrement (sc->sa.rmap_cur,0 , &have_gt);if (error)return error; -if (XFS_IS_CORRUPT (sc->mp, !have_gt)) +if (XFS_IS_CORRUPT (sc->mp, !have_gt)) { +xfs_btree_mark_sick (sc->sa.rmap_cur);return -EFSCORRUPTED ; + }return 0 ; }
fs/xfs/xfs_attr_list.c +7 -2
@@ -84,8 +84,10 @@ xfs_attr_shortform_list(for (i =0 , sfe = &sf->list[0 ]; i < sf->hdr.count; i++) {if (XFS_IS_CORRUPT (context->dp->i_mount, !xfs_attr_namecheck (sfe->nameval, - sfe->namelen))) + sfe->namelen))) { +xfs_dirattr_mark_sick (context->dp,XFS_ATTR_FORK );return -EFSCORRUPTED ; + } context->put_listent(context, sfe->flags, sfe->nameval,
@@ -178,6 +180,7 @@ xfs_attr_shortform_list(if (XFS_IS_CORRUPT (context->dp->i_mount, !xfs_attr_namecheck (sbp->name, sbp->namelen))) { +xfs_dirattr_mark_sick (context->dp,XFS_ATTR_FORK ); error = -EFSCORRUPTED ; goto out; }
@@ -472,8 +475,10 @@ xfs_attr3_leaf_list_int( }if (XFS_IS_CORRUPT (context->dp->i_mount, - !xfs_attr_namecheck (name, namelen))) + !xfs_attr_namecheck (name, namelen))) { +xfs_dirattr_mark_sick (context->dp,XFS_ATTR_FORK );return -EFSCORRUPTED ; + } context->put_listent (context, entry->flags, name, namelen, valuelen);if (context->seen_enough)
fs/xfs/xfs_dir2_readdir.c +5 -1
@@ -120,8 +120,10 @@ xfs_dir2_sf_getdents( ctx->pos = off &0x7fffffff ;if (XFS_IS_CORRUPT (dp->i_mount, !xfs_dir2_namecheck (sfep->name, - sfep->namelen))) + sfep->namelen))) { +xfs_dirattr_mark_sick (dp,XFS_DATA_FORK );return -EFSCORRUPTED ; + }if (!dir_emit (ctx, (char *)sfep->name, sfep->namelen, ino,xfs_dir3_get_dtype (mp, filetype)))return 0 ;
@@ -213,6 +215,7 @@ xfs_dir2_block_getdents(if (XFS_IS_CORRUPT (dp->i_mount, !xfs_dir2_namecheck (dep->name, dep->namelen))) { +xfs_dirattr_mark_sick (dp,XFS_DATA_FORK ); error = -EFSCORRUPTED ; goto out_rele; }
@@ -467,6 +470,7 @@ xfs_dir2_leaf_getdents(if (XFS_IS_CORRUPT (dp->i_mount, !xfs_dir2_namecheck (dep->name, dep->namelen))) { +xfs_dirattr_mark_sick (dp,XFS_DATA_FORK ); error = -EFSCORRUPTED ;break ; }
fs/xfs/xfs_discard.c +2 -0
@@ -18,6 +18,7 @@#include "xfs_trace.h" #include "xfs_log.h" #include "xfs_ag.h" +#include "xfs_health.h" /* * Notes on an efficient, low latency fstrim algorithm
@@ -204,6 +205,7 @@ xfs_trim_gather_extents(if (error)break ;if (XFS_IS_CORRUPT (mp, i !=1 )) { +xfs_btree_mark_sick (cur); error = -EFSCORRUPTED ;break ; }
fs/xfs/xfs_iwalk.c +4 -1
@@ -297,8 +297,10 @@ xfs_iwalk_ag_start( error =xfs_inobt_get_rec (*curpp, irec, has_more);if (error)return error; -if (XFS_IS_CORRUPT (mp, *has_more !=1 )) +if (XFS_IS_CORRUPT (mp, *has_more !=1 )) { +xfs_btree_mark_sick (*curpp);return -EFSCORRUPTED ; + } iwag->lastino =XFS_AGINO_TO_INO (mp, pag->pag_agno, irec->ir_startino +XFS_INODES_PER_CHUNK -1 );
@@ -425,6 +427,7 @@ xfs_iwalk_ag( rec_fsino =XFS_AGINO_TO_INO (mp, pag->pag_agno, irec->ir_startino);if (iwag->lastino !=NULLFSINO &&XFS_IS_CORRUPT (mp, iwag->lastino >= rec_fsino)) { +xfs_btree_mark_sick (cur); error = -EFSCORRUPTED ; goto out; }
Re: [PATCH 11/11] xfs: report XFS_IS_CORRUPT errors to the health system
Looks good:
PATCH 6/28 xfs: indirect health reporting
In reply to Darrick J. WongHi all,
This series enables the XFS health reporting infrastructure to remember indirect health concerns when resources are scarce. For example, if a scrub notices that there's something wrong with an inode's metadata but memory reclaim needs to free the incore inode, we want to record in the perag data the fact that there was some inode somewhere with an error. The perag structures never go away.
The first two patches in this series set that up, and the third one provides a means for xfs_scrub to tell the kernel that it can forget the indirect problem report.
If you're going to start using this code, I strongly recommend pulling from my git trees, which are linked below.
This has been running on the djcloud for months with no problems. Enjoy! Comments and questions are, as always, welcome.
--D
kernel git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfs-linux.git/log/?h=indirect-health-reporting
xfsprogs git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfsprogs-dev.git/log/?h=indirect-health-reporting
--- fs/xfs/libxfs/xfs_fs.h | 4 ++ fs/xfs/libxfs/xfs_health.h | 47 +++++++++++++++++++++++++ fs/xfs/libxfs/xfs_inode_buf.c | 2 + fs/xfs/scrub/health.c | 76 ++++++++++++++++++++++++++++++++++++++++- fs/xfs/scrub/health.h | 1 + fs/xfs/scrub/repair.c | 1 + fs/xfs/scrub/scrub.c | 6 +++ fs/xfs/scrub/trace.h | 4 ++ fs/xfs/xfs_health.c | 27 ++++++++++----- fs/xfs/xfs_inode.c | 35 +++++++++++++++++++ fs/xfs/xfs_trace.h | 1 + 11 files changed, 191 insertions(+), 13 deletions(-)
PATCH 1/3 xfs: add secondary and indirect classes to the health tracking system
From: Darrick J. Wong <[email protected]>
Establish two more classes of health tracking bits:
* Indirect problems, which suggest problems in other health domains that we weren't able to preserve.
* Secondary problems, which track state that's related to primary evidence of health problems; and
The first class we'll use in an upcoming patch to record in the AG health status the fact that we ran out of memory and had to inactivate an inode with defective metadata. The second class we use to indicate that repair knows that an inode is bad and we need to fix it later.
--- fs/xfs/libxfs/xfs_health.h | 43 +++++++++++++++++++++++++++++++++++++++++++ fs/xfs/xfs_health.c | 26 +++++++++++++++++--------- 2 files changed, 60 insertions(+), 9 deletions(-)
fs/xfs/libxfs/xfs_health.h +43 -0
@@ -31,6 +31,19 @@* - !checked && sick => errors have been observed during normal operation, * but the metadata has not been checked thoroughly * - !checked && !sick => has not been examined since mount +* +* Evidence of health problems can be sorted into three basic categories: +* +* a) Primary evidence, which signals that something is defective within the +* general grouping of metadata. +* +* b) Secondary evidence, which are side effects of primary problem but are +* not themselves problems. These can be forgotten when the primary +* health problems are addressed. +* +* c) Indirect evidence, which points to something being wrong in another +* group, but we had to release resources and this is all that's left of +* that state. */ struct xfs_mount ;
@@ -115,6 +128,36 @@ struct xfs_da_args; XFS_SICK_INO_DIR_ZAPPED | \ XFS_SICK_INO_SYMLINK_ZAPPED) +/* Secondary state related to (but not primary evidence of) health problems. */ +#define XFS_SICK_FS_SECONDARY (0) +#define XFS_SICK_RT_SECONDARY (0) +#define XFS_SICK_AG_SECONDARY (0) +#define XFS_SICK_INO_SECONDARY (0) + +/* Evidence of health problems elsewhere. */ +#define XFS_SICK_FS_INDIRECT (0) +#define XFS_SICK_RT_INDIRECT (0) +#define XFS_SICK_AG_INDIRECT (0) +#define XFS_SICK_INO_INDIRECT (0) + +/* All health masks. */ +#define XFS_SICK_FS_ALL (XFS_SICK_FS_PRIMARY | \ + XFS_SICK_FS_SECONDARY | \ + XFS_SICK_FS_INDIRECT) + +#define XFS_SICK_RT_ALL (XFS_SICK_RT_PRIMARY | \ + XFS_SICK_RT_SECONDARY | \ + XFS_SICK_RT_INDIRECT) + +#define XFS_SICK_AG_ALL (XFS_SICK_AG_PRIMARY | \ + XFS_SICK_AG_SECONDARY | \ + XFS_SICK_AG_INDIRECT) + +#define XFS_SICK_INO_ALL (XFS_SICK_INO_PRIMARY | \ + XFS_SICK_INO_SECONDARY | \ + XFS_SICK_INO_INDIRECT | \ + XFS_SICK_INO_ZAPPED) +/* * These functions must be provided by the xfs implementation. Function * behavior with respect to the first argument should be as follows:
fs/xfs/xfs_health.c +17 -9
@@ -97,7 +97,7 @@ xfs_fs_mark_sick( struct xfs_mount *mp, unsigned int mask) { -ASSERT (!(mask & ~XFS_SICK_FS_PRIMARY )); +ASSERT (!(mask & ~XFS_SICK_FS_ALL ));trace_xfs_fs_mark_sick (mp, mask);spin_lock (&mp->m_sb_lock);
@@ -124,11 +124,13 @@ xfs_fs_mark_healthy( struct xfs_mount *mp, unsigned int mask) { -ASSERT (!(mask & ~XFS_SICK_FS_PRIMARY )); +ASSERT (!(mask & ~XFS_SICK_FS_ALL ));trace_xfs_fs_mark_healthy (mp, mask);spin_lock (&mp->m_sb_lock); mp->m_fs_sick &= ~mask; +if (!(mp->m_fs_sick &XFS_SICK_FS_PRIMARY )) + mp->m_fs_sick &= ~XFS_SICK_FS_SECONDARY ; mp->m_fs_checked |= mask;spin_unlock (&mp->m_sb_lock); }
@@ -152,7 +154,7 @@ xfs_rt_mark_sick( struct xfs_mount *mp, unsigned int mask) { -ASSERT (!(mask & ~XFS_SICK_RT_PRIMARY )); +ASSERT (!(mask & ~XFS_SICK_RT_ALL ));trace_xfs_rt_mark_sick (mp, mask);spin_lock (&mp->m_sb_lock);
@@ -180,11 +182,13 @@ xfs_rt_mark_healthy( struct xfs_mount *mp, unsigned int mask) { -ASSERT (!(mask & ~XFS_SICK_RT_PRIMARY )); +ASSERT (!(mask & ~XFS_SICK_RT_ALL ));trace_xfs_rt_mark_healthy (mp, mask);spin_lock (&mp->m_sb_lock); mp->m_rt_sick &= ~mask; +if (!(mp->m_rt_sick &XFS_SICK_RT_PRIMARY )) + mp->m_rt_sick &= ~XFS_SICK_RT_SECONDARY ; mp->m_rt_checked |= mask;spin_unlock (&mp->m_sb_lock); }
@@ -225,7 +229,7 @@ xfs_ag_mark_sick( struct xfs_perag *pag, unsigned int mask) { -ASSERT (!(mask & ~XFS_SICK_AG_PRIMARY )); +ASSERT (!(mask & ~XFS_SICK_AG_ALL ));trace_xfs_ag_mark_sick (pag->pag_mount, pag->pag_agno, mask);spin_lock (&pag->pag_state_lock);
@@ -252,11 +256,13 @@ xfs_ag_mark_healthy( struct xfs_perag *pag, unsigned int mask) { -ASSERT (!(mask & ~XFS_SICK_AG_PRIMARY )); +ASSERT (!(mask & ~XFS_SICK_AG_ALL ));trace_xfs_ag_mark_healthy (pag->pag_mount, pag->pag_agno, mask);spin_lock (&pag->pag_state_lock); pag->pag_sick &= ~mask; +if (!(pag->pag_sick &XFS_SICK_AG_PRIMARY )) + pag->pag_sick &= ~XFS_SICK_AG_SECONDARY ; pag->pag_checked |= mask;spin_unlock (&pag->pag_state_lock); }
@@ -280,7 +286,7 @@ xfs_inode_mark_sick( struct xfs_inode *ip, unsigned int mask) { -ASSERT (!(mask & ~(XFS_SICK_INO_PRIMARY |XFS_SICK_INO_ZAPPED ))); +ASSERT (!(mask & ~XFS_SICK_INO_ALL ));trace_xfs_inode_mark_sick (ip, mask);spin_lock (&ip->i_flags_lock);
@@ -303,7 +309,7 @@ xfs_inode_mark_checked( struct xfs_inode *ip, unsigned int mask) { -ASSERT (!(mask & ~(XFS_SICK_INO_PRIMARY |XFS_SICK_INO_ZAPPED ))); +ASSERT (!(mask & ~XFS_SICK_INO_ALL ));spin_lock (&ip->i_flags_lock); ip->i_checked |= mask;
@@ -316,11 +322,13 @@ xfs_inode_mark_healthy( struct xfs_inode *ip, unsigned int mask) { -ASSERT (!(mask & ~(XFS_SICK_INO_PRIMARY |XFS_SICK_INO_ZAPPED ))); +ASSERT (!(mask & ~XFS_SICK_INO_ALL ));trace_xfs_inode_mark_healthy (ip, mask);spin_lock (&ip->i_flags_lock); ip->i_sick &= ~mask; +if (!(ip->i_sick &XFS_SICK_INO_PRIMARY )) + ip->i_sick &= ~XFS_SICK_INO_SECONDARY ; ip->i_checked |= mask;spin_unlock (&ip->i_flags_lock); }
Re: [PATCH 1/3] xfs: add secondary and indirect classes to the health tracking system
Looks good:
PATCH 2/3 xfs: remember sick inodes that get inactivated
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
If an unhealthy inode gets inactivated, remember this fact in the per-fs health summary.
--- fs/xfs/libxfs/xfs_fs.h | 1 + fs/xfs/libxfs/xfs_health.h | 8 ++++++-- fs/xfs/libxfs/xfs_inode_buf.c | 2 +- fs/xfs/scrub/health.c | 12 +++++++++++- fs/xfs/xfs_health.c | 1 + fs/xfs/xfs_inode.c | 35 +++++++++++++++++++++++++++++++++++ fs/xfs/xfs_trace.h | 1 + 7 files changed, 56 insertions(+), 4 deletions(-)
fs/xfs/libxfs/xfs_fs.h +1 -0
@@ -294,6 +294,7 @@ struct xfs_ag_geometry {#define XFS_AG_GEOM_SICK_FINOBT (1 << 7)/* free inode index */ #define XFS_AG_GEOM_SICK_RMAPBT (1 << 8)/* reverse mappings */ #define XFS_AG_GEOM_SICK_REFCNTBT (1 << 9)/* reference counts */ +#define XFS_AG_GEOM_SICK_INODES (1 << 10)/* bad inodes were seen */ /* * Structures for XFS_IOC_FSGROWFSDATA, XFS_IOC_FSGROWFSLOG & XFS_IOC_FSGROWFSRT
fs/xfs/libxfs/xfs_health.h +6 -2
@@ -76,6 +76,7 @@ struct xfs_da_args;#define XFS_SICK_AG_FINOBT (1 << 7)/* free inode index */ #define XFS_SICK_AG_RMAPBT (1 << 8)/* reverse mappings */ #define XFS_SICK_AG_REFCNTBT (1 << 9)/* reference counts */ +#define XFS_SICK_AG_INODES (1 << 10)/* inactivated bad inodes */ /* Observable health issues for inode metadata. */ #define XFS_SICK_INO_CORE (1 << 0)/* inode core */
@@ -92,6 +93,9 @@ struct xfs_da_args;#define XFS_SICK_INO_DIR_ZAPPED (1 << 10)/* directory erased */ #define XFS_SICK_INO_SYMLINK_ZAPPED (1 << 11)/* symlink erased */ +/* Don't propagate sick status to ag health summary during inactivation */ +#define XFS_SICK_INO_FORGET (1 << 12) +/* Primary evidence of health problems in a given group. */ #define XFS_SICK_FS_PRIMARY (XFS_SICK_FS_COUNTERS | \ XFS_SICK_FS_UQUOTA | \
@@ -132,12 +136,12 @@ struct xfs_da_args;#define XFS_SICK_FS_SECONDARY (0)#define XFS_SICK_RT_SECONDARY (0)#define XFS_SICK_AG_SECONDARY (0) -#define XFS_SICK_INO_SECONDARY (0) +#define XFS_SICK_INO_SECONDARY (XFS_SICK_INO_FORGET)/* Evidence of health problems elsewhere. */ #define XFS_SICK_FS_INDIRECT (0)#define XFS_SICK_RT_INDIRECT (0) -#define XFS_SICK_AG_INDIRECT (0) +#define XFS_SICK_AG_INDIRECT (XFS_SICK_AG_INODES)#define XFS_SICK_INO_INDIRECT (0)/* All health masks. */
fs/xfs/libxfs/xfs_inode_buf.c +1 -1
@@ -139,7 +139,7 @@ xfs_imap_to_bp( imap->im_len, XBF_UNMAPPED, bpp, &xfs_inode_buf_ops);if (xfs_metadata_is_sick (error))xfs_agno_mark_sick (mp,xfs_daddr_to_agno (mp, imap->im_blkno), -XFS_SICK_AG_INOBT ); +XFS_SICK_AG_INODES );return error; }
fs/xfs/scrub/health.c +11 -1
@@ -187,7 +187,17 @@ xchk_update_health(if (!sc->ip)return ;if (bad) { -xfs_inode_mark_sick (sc->ip, sc->sick_mask); +unsigned int mask = sc->sick_mask; + +/* +* If we're coming in for repairs then we don't want +* sickness flags to propagate to the incore health +* status if the inode gets inactivated before we can +* fix it. +*/ +if (sc->sm->sm_flags &XFS_SCRUB_IFLAG_REPAIR ) + mask |=XFS_SICK_INO_FORGET ; +xfs_inode_mark_sick (sc->ip, mask);xfs_inode_mark_checked (sc->ip, sc->sick_mask); }else xfs_inode_mark_healthy (sc->ip, sc->sick_mask);
fs/xfs/xfs_health.c +1 -0
@@ -415,6 +415,7 @@ static const struct ioctl_sick_map ag_map[] = { { XFS_SICK_AG_FINOBT, XFS_AG_GEOM_SICK_FINOBT }, { XFS_SICK_AG_RMAPBT, XFS_AG_GEOM_SICK_RMAPBT }, { XFS_SICK_AG_REFCNTBT, XFS_AG_GEOM_SICK_REFCNTBT }, + { XFS_SICK_AG_INODES, XFS_AG_GEOM_SICK_INODES }, { 0, 0 }, };
fs/xfs/xfs_inode.c +35 -0
@@ -1751,6 +1751,39 @@ xfs_inode_needs_inactive(return xfs_can_free_eofblocks (ip, true); } +/* +* Save health status somewhere, if we're dumping an inode with uncorrected +* errors and online repair isn't running. +*/ +static inline void +xfs_inactive_health ( +struct xfs_inode *ip) +{ +struct xfs_mount *mp = ip->i_mount; +struct xfs_perag *pag; +unsigned int sick; +unsigned int checked; + +xfs_inode_measure_sickness (ip, &sick, &checked); +if (!sick) +return ; + +trace_xfs_inode_unfixed_corruption (ip, sick); + +if (sick &XFS_SICK_INO_FORGET ) +return ; + + pag =xfs_perag_get (mp,XFS_INO_TO_AGNO (mp, ip->i_ino)); +if (!pag) { +/* There had better still be a perag structure! */ +ASSERT (0 ); +return ; + } + +xfs_ag_mark_sick (pag,XFS_SICK_AG_INODES ); +xfs_perag_put (pag); +} +/* * xfs_inactive *
@@ -1779,6 +1812,8 @@ xfs_inactive( mp = ip->i_mount;ASSERT (!xfs_iflags_test (ip,XFS_IRECOVERY )); +xfs_inactive_health (ip); +/* * If this is a read-only mount, don't do this (would generate I/O) * unless we're in log recovery and cleaning the iunlinked list.
fs/xfs/xfs_trace.h +1 -0
@@ -3978,6 +3978,7 @@ DEFINE_EVENT(xfs_inode_corrupt_class, name, \ TP_ARGS(ip, flags))DEFINE_INODE_CORRUPT_EVENT (xfs_inode_mark_sick);DEFINE_INODE_CORRUPT_EVENT (xfs_inode_mark_healthy); +DEFINE_INODE_CORRUPT_EVENT (xfs_inode_unfixed_corruption); TRACE_EVENT(xfs_iwalk_ag, TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno,
Re: [PATCH 2/3] xfs: remember sick inodes that get inactivated
Looks good:
PATCH 3/3 xfs: update health status if we get a clean bill of health
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
If scrub finds that everything is ok with the filesystem, we need a way to tell the health tracking that it can let go of indirect health flags, since indirect flags only mean that at some point in the past we lost some context.
--- fs/xfs/libxfs/xfs_fs.h | 3 ++ fs/xfs/scrub/health.c | 64 ++++++++++++++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/health.h | 1 + fs/xfs/scrub/repair.c | 1 + fs/xfs/scrub/scrub.c | 6 +++++ fs/xfs/scrub/trace.h | 4 ++- 6 files changed, 77 insertions(+), 2 deletions(-)
fs/xfs/libxfs/xfs_fs.h +2 -1
@@ -714,9 +714,10 @@ struct xfs_scrub_metadata {#define XFS_SCRUB_TYPE_FSCOUNTERS 24/* fs summary counters */ #define XFS_SCRUB_TYPE_QUOTACHECK 25/* quota counters */ #define XFS_SCRUB_TYPE_NLINKS 26/* inode link counts */ +#define XFS_SCRUB_TYPE_HEALTHY 27/* everything checked out ok */ /* Number of scrub subcommands. */ -#define XFS_SCRUB_TYPE_NR 27 +#define XFS_SCRUB_TYPE_NR 28/* i: Repair this metadata. */ #define XFS_SCRUB_IFLAG_REPAIR (1u << 0)
fs/xfs/scrub/health.c +64 -0
85 lines not on this page · raw message
fs/xfs/scrub/health.h +1 -0
@@ -12,5 +12,6 @@ bool xchk_ag_btree_healthy_enough(struct xfs_scrub *sc, struct xfs_perag *pag, xfs_btnum_t btnum);void xchk_mark_healthy_if_clean (struct xfs_scrub *sc,unsigned int mask);bool xchk_file_looks_zapped (struct xfs_scrub *sc,unsigned int mask); +int xchk_health_record (struct xfs_scrub *sc);#endif /* __XFS_SCRUB_HEALTH_H__ */
fs/xfs/scrub/repair.c +1 -0
@@ -30,6 +30,7 @@#include "xfs_errortag.h" #include "xfs_error.h" #include "xfs_reflink.h" +#include "xfs_health.h" #include "scrub/scrub.h" #include "scrub/common.h" #include "scrub/trace.h"
fs/xfs/scrub/scrub.c +6 -0
@@ -378,6 +378,12 @@ static const struct xchk_meta_ops meta_scrub_ops[] = { .scrub = xchk_nlinks, .repair = xrep_nlinks, }, + [XFS_SCRUB_TYPE_HEALTHY] = { /* fs healthy; clean all reminders */ + .type = ST_FS, + .setup = xchk_setup_fs, + .scrub = xchk_health_record, + .repair = xrep_notsupported, + }, }; static int
fs/xfs/scrub/trace.h +3 -1
@@ -69,6 +69,7 @@ TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_PQUOTA);TRACE_DEFINE_ENUM (XFS_SCRUB_TYPE_FSCOUNTERS );TRACE_DEFINE_ENUM (XFS_SCRUB_TYPE_QUOTACHECK );TRACE_DEFINE_ENUM (XFS_SCRUB_TYPE_NLINKS ); +TRACE_DEFINE_ENUM (XFS_SCRUB_TYPE_HEALTHY );#define XFS_SCRUB_TYPE_STRINGS \ { XFS_SCRUB_TYPE_PROBE, "probe" }, \
@@ -97,7 +98,8 @@ TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_NLINKS); { XFS_SCRUB_TYPE_PQUOTA, "prjquota" }, \ { XFS_SCRUB_TYPE_FSCOUNTERS, "fscounters" }, \ { XFS_SCRUB_TYPE_QUOTACHECK, "quotacheck" }, \ - { XFS_SCRUB_TYPE_NLINKS, "nlinks" } + { XFS_SCRUB_TYPE_NLINKS, "nlinks" }, \ + { XFS_SCRUB_TYPE_HEALTHY, "healthy" } #define XFS_SCRUB_FLAG_STRINGS \ { XFS_SCRUB_IFLAG_REPAIR, "repair" }, \
Re: [PATCH 3/3] xfs: update health status if we get a clean bill of health
Looks good:
PATCH 7/28 xfs: online repair for fs summary counters
In reply to Darrick J. WongHi all,
A longstanding deficiency in the online fs summary counter scrubbing code is that it hasn't any means to quiesce the incore percpu counters while it's running. There is no way to coordinate with other threads are reserving or freeing free space simultaneously, which leads to false error reports. Right now, if the discrepancy is large, we just sort of shrug and bail out with an incomplete flag, but this is lame.
For repair activity, we actually /do/ need to stabilize the counters to get an accurate reading and install it in the percpu counter. To improve the former and enable the latter, allow the fscounters online fsck code to perform an exclusive mini-freeze on the filesystem. The exclusivity prevents userspace from thawing while we're running, and the mini-freeze means that we don't wait for the log to quiesce, which will make both speedier.
If you're going to start using this code, I strongly recommend pulling from my git trees, which are linked below.
This has been running on the djcloud for months with no problems. Enjoy! Comments and questions are, as always, welcome.
--D
kernel git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfs-linux.git/log/?h=repair-fscounters
fstests git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfstests-dev.git/log/?h=repair-fscounters
--- fs/xfs/Makefile | 1 + fs/xfs/scrub/fscounters.c | 27 +++++++------- fs/xfs/scrub/fscounters.h | 20 +++++++++++ fs/xfs/scrub/fscounters_repair.c | 72 ++++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/repair.h | 2 + fs/xfs/scrub/scrub.c | 2 + fs/xfs/scrub/trace.c | 1 + fs/xfs/scrub/trace.h | 21 +++++++++-- 8 files changed, 128 insertions(+), 18 deletions(-) create mode 100644 fs/xfs/scrub/fscounters.h create mode 100644 fs/xfs/scrub/fscounters_repair.c
PATCH 1/1 xfs: repair summary counters
From: Darrick J. Wong <[email protected]>
Use the same summary counter calculation infrastructure to generate new
values for the in-core summary counters. The difference between the
scrubber and the repairer is that the repairer will freeze the fs during setup, which means that the values should match exactly.
--- fs/xfs/Makefile | 1 + fs/xfs/scrub/fscounters.c | 27 +++++++------- fs/xfs/scrub/fscounters.h | 20 +++++++++++ fs/xfs/scrub/fscounters_repair.c | 72 ++++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/repair.h | 2 + fs/xfs/scrub/scrub.c | 2 + fs/xfs/scrub/trace.c | 1 + fs/xfs/scrub/trace.h | 21 +++++++++-- 8 files changed, 128 insertions(+), 18 deletions(-) create mode 100644 fs/xfs/scrub/fscounters.h create mode 100644 fs/xfs/scrub/fscounters_repair.c
fs/xfs/Makefile +1 -0
@@ -192,6 +192,7 @@ xfs-y += $(addprefix scrub/, \ alloc_repair.o \ bmap_repair.o \ cow_repair.o \ + fscounters_repair.o \ ialloc_repair.o \ inode_repair.o \ newbt.o \
fs/xfs/scrub/fscounters.c +14 -13
@@ -22,6 +22,7 @@#include "scrub/scrub.h" #include "scrub/common.h" #include "scrub/trace.h" +#include "scrub/fscounters.h" /* * FS Summary Counters
@@ -48,17 +49,6 @@* our tolerance for mismatch between expected and actual counter values. */ -struct xchk_fscounters { -struct xfs_scrub *sc; -uint64_t icount; -uint64_t ifree; -uint64_t fdblocks; -uint64_t frextents; -unsigned long long icount_min; -unsigned long long icount_max; -bool frozen; -}; -/* * Since the expected value computation is lockless but only browses incore * values, the percpu counters should be fairly close to each other. However,
@@ -235,8 +225,13 @@ xchk_setup_fscounters(* Pause all writer activity in the filesystem while we're scrubbing to * reduce the likelihood of background perturbations to the counters * throwing off our calculations. +* +* If we're repairing, we need to prevent any other thread from +* changing the global fs summary counters while we're repairing them. +* This requires the fs to be frozen, which will disable background +* reclaim and purge all inactive inodes. */ -if (sc->flags &XCHK_TRY_HARDER ) { +if ((sc->flags &XCHK_TRY_HARDER ) ||xchk_could_repair (sc)) { error =xchk_fscounters_freeze (sc);if (error)return error;
@@ -254,7 +249,9 @@ xchk_setup_fscounters(* set the INCOMPLETE flag even when a negative errno is returned. This care * must be taken with certain errno values (i.e. EFSBADCRC, EFSCORRUPTED, * ECANCELED) that are absorbed into a scrub state flag update by -* xchk_*_process_error. +* xchk_*_process_error. Scrub and repair share the same incore data +* structures, so the INCOMPLETE flag is critical to prevent a repair based on +* insufficient information. */ /* Count free space btree blocks manually for pre-lazysbcount filesystems. */
@@ -482,6 +479,10 @@ xchk_fscount_within_range(if (curr_value == expected)return true; +/* We require exact matches when repair is running. */ +if (sc->sm->sm_flags &XFS_SCRUB_IFLAG_REPAIR ) +return false; + min_value =min (old_value, curr_value); max_value =max (old_value, curr_value);
fs/xfs/scrub/fscounters.h new file +20 -0
@@ -0,0 +1,20 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ +/* +* Copyright (c) 2021-2024 Oracle. All Rights Reserved. +* Author: Darrick J. Wong <[email protected]> +*/ +#ifndef __XFS_SCRUB_FSCOUNTERS_H__ +#define __XFS_SCRUB_FSCOUNTERS_H__ + +struct xchk_fscounters { +struct xfs_scrub *sc; +uint64_t icount; +uint64_t ifree; +uint64_t fdblocks; +uint64_t frextents; +unsigned long long icount_min; +unsigned long long icount_max; +bool frozen; +}; + +#endif /* __XFS_SCRUB_FSCOUNTERS_H__ */
fs/xfs/scrub/fscounters_repair.c new file +72 -0
72 lines not on this page · raw message
fs/xfs/scrub/repair.h +2 -0
@@ -117,6 +117,7 @@ int xrep_bmap_data(struct xfs_scrub *sc);int xrep_bmap_attr (struct xfs_scrub *sc);int xrep_bmap_cow (struct xfs_scrub *sc);int xrep_nlinks (struct xfs_scrub *sc); +int xrep_fscounters (struct xfs_scrub *sc);#ifdef CONFIG_XFS_RT int xrep_rtbitmap (struct xfs_scrub *sc);
@@ -198,6 +199,7 @@ xrep_setup_nothing(#define xrep_quota xrep_notsupported#define xrep_quotacheck xrep_notsupported#define xrep_nlinks xrep_notsupported +#define xrep_fscounters xrep_notsupported#endif /* CONFIG_XFS_ONLINE_REPAIR */
fs/xfs/scrub/scrub.c +1 -1
@@ -364,7 +364,7 @@ static const struct xchk_meta_ops meta_scrub_ops[] = { .type = ST_FS, .setup = xchk_setup_fscounters, .scrub = xchk_fscounters, - .repair = xrep_notsupported, + .repair = xrep_fscounters, }, [XFS_SCRUB_TYPE_QUOTACHECK] = { /* quota counters */ .type = ST_FS,
fs/xfs/scrub/trace.c +1 -0
@@ -24,6 +24,7 @@#include "scrub/quota.h" #include "scrub/iscan.h" #include "scrub/nlinks.h" +#include "scrub/fscounters.h" /* Figure out which block the btree cursor was pointing to. */ static inline xfs_fsblock_t
fs/xfs/scrub/trace.h +17 -4
@@ -24,6 +24,7 @@ struct xfarray_sortinfo;struct xchk_dqiter ;struct xchk_iscan ;struct xchk_nlink ; +struct xchk_fscounters ;/* * ftrace's __print_symbolic requires that all enum values be wrapped in the
@@ -1777,16 +1778,28 @@ TRACE_EVENT(xrep_calc_ag_resblks_btsize, __entry->refcbt_sz) )TRACE_EVENT (xrep_reset_counters, - TP_PROTO(struct xfs_mount *mp), -TP_ARGS (mp), + TP_PROTO(struct xfs_mount *mp, struct xchk_fscounters *fsc), +TP_ARGS (mp, fsc),TP_STRUCT__entry ( __field(dev_t, dev) + __field(uint64_t, icount) + __field(uint64_t, ifree) + __field(uint64_t, fdblocks) +__field (uint64_t, frextents) ),TP_fast_assign ( __entry->dev = mp->m_super->s_dev; + __entry->icount = fsc->icount; + __entry->ifree = fsc->ifree; + __entry->fdblocks = fsc->fdblocks; + __entry->frextents = fsc->frextents; ), -TP_printk ("dev %d:%d" , -MAJOR (__entry->dev),MINOR (__entry->dev)) +TP_printk ("dev %d:%d icount %llu ifree %llu fdblocks %llu frextents %llu" , +MAJOR (__entry->dev),MINOR (__entry->dev), + __entry->icount, + __entry->ifree, + __entry->fdblocks, + __entry->frextents) ) DECLARE_EVENT_CLASS(xrep_newbt_extent_class,
Re: [PATCH 1/1] xfs: repair summary counters
Looks good:
PATCH 8/28 xfs: support in-memory btrees
In reply to Darrick J. WongHi all,
Online repair of the reverse-mapping btrees presens some unique challenges. To construct a new reverse mapping btree, we must scan the entire filesystem, but we cannot afford to quiesce the entire filesystem for the potentially lengthy scan.
For rmap btrees, therefore, we relax our requirements of totally atomic repairs. Instead, repairs will scan all inodes, construct a new reverse mapping dataset, format a new btree, and commit it before anyone trips over the corruption. This is exactly the same strategy as was used in the quotacheck and nlink scanners.
Unfortunately, the xfarray cannot perform key-based lookups and is therefore unsuitable for supporting live updates. Luckily, we already a data structure that maintains an indexed rmap recordset -- the existing rmap btree code! Hence we port the existing btree and buffer target code to be able to create a btree using the xfile we developed earlier. Live hooks keep the in-memory btree up to date for any resources that have already been scanned.
This approach is not maximally memory efficient, but we can use the same rmap code that we do everywhere else, which provides improved stability without growing the code base even more. Note that in-memory btree blocks are always page sized.
This patchset modifies the kernel xfs buffer cache to be capable of using a xfile (aka a shmem file) as a backing device. It then augments the btree code to support creating btree cursors with buffers that come from a buftarg other than the data device (namely an xfile-backed buftarg). For the userspace xfs buffer cache, we instead use a memfd or an O_TMPFILE file as a backing device.
If you're going to start using this code, I strongly recommend pulling from my git trees, which are linked below.
This has been running on the djcloud for months with no problems. Enjoy! Comments and questions are, as always, welcome.
--D
kernel git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfs-linux.git/log/?h=in-memory-btrees
xfsprogs git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfsprogs-dev.git/log/?h=in-memory-btrees
--- fs/xfs/Kconfig | 8 fs/xfs/Makefile | 2 fs/xfs/libxfs/xfs_ag.c | 6 fs/xfs/libxfs/xfs_ag.h | 4 fs/xfs/libxfs/xfs_btree.c | 173 ++++++- fs/xfs/libxfs/xfs_btree.h | 17 + fs/xfs/libxfs/xfs_btree_mem.h | 128 ++++++ fs/xfs/libxfs/xfs_refcount_btree.c | 4 fs/xfs/libxfs/xfs_rmap_btree.c | 4 fs/xfs/scrub/bitmap.c | 28 + fs/xfs/scrub/bitmap.h | 3 fs/xfs/scrub/scrub.c | 5 fs/xfs/scrub/scrub.h | 3 fs/xfs/scrub/trace.c | 11 fs/xfs/scrub/trace.h | 109 +++++ fs/xfs/scrub/xfbtree.c | 837 ++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/xfbtree.h | 63 +++ fs/xfs/scrub/xfile.c | 181 ++++++++ fs/xfs/scrub/xfile.h | 66 +++ fs/xfs/xfs_aops.c | 5 fs/xfs/xfs_bmap_util.c | 8 fs/xfs/xfs_buf.c | 203 ++++++--- fs/xfs/xfs_buf.h | 79 +++ fs/xfs/xfs_buf_xfile.c | 97 ++++ fs/xfs/xfs_buf_xfile.h | 20 + fs/xfs/xfs_discard.c | 9 fs/xfs/xfs_file.c | 6 fs/xfs/xfs_health.c | 3 fs/xfs/xfs_ioctl.c | 3 fs/xfs/xfs_iomap.c | 4 fs/xfs/xfs_log.c | 4 fs/xfs/xfs_log_recover.c | 3 fs/xfs/xfs_mount.h | 3 fs/xfs/xfs_trace.c | 3 fs/xfs/xfs_trace.h | 85 +++- fs/xfs/xfs_trans.h | 1 fs/xfs/xfs_trans_buf.c | 42 ++ 37 files changed, 2105 insertions(+), 125 deletions(-) create mode 100644 fs/xfs/libxfs/xfs_btree_mem.h create mode 100644 fs/xfs/scrub/xfbtree.c create mode 100644 fs/xfs/scrub/xfbtree.h create mode 100644 fs/xfs/xfs_buf_xfile.c create mode 100644 fs/xfs/xfs_buf_xfile.h
PATCH 1/9 xfs: dump xfiles for debugging purposes
From: Darrick J. Wong <[email protected]>
Add a debug function to dump an xfile's contents for debug purposes.
--- fs/xfs/scrub/xfile.c | 98 ++++++++++++++++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/xfile.h | 2 + 2 files changed, 100 insertions(+)
fs/xfs/scrub/xfile.c +98 -0
@@ -417,3 +417,101 @@ xfile_put_page(return -EIO ;return 0 ; } + +/* Dump an xfile to dmesg. */ +int +xfile_dump ( +struct xfile *xf) +{ +struct xfile_stat sb; +struct inode *inode =file_inode (xf->file); +struct address_space *mapping = inode->i_mapping; +loff_t holepos =0 ; +loff_t datapos; +loff_t ret; +unsigned int pflags; +bool all_zeroes = true; +int error =0 ; + + error =xfile_stat (xf, &sb); +if (error) +return error; + +printk (KERN_ALERT "xfile ino 0x%lx isize 0x%llx dump:" , inode->i_ino, + sb.size); + pflags =memalloc_nofs_save (); + +while ((ret =vfs_llseek (xf->file, holepos,SEEK_DATA )) >=0 ) { + datapos =rounddown_64 (ret,PAGE_SIZE ); + ret =vfs_llseek (xf->file, datapos,SEEK_HOLE ); +if (ret <0 ) +break ; + holepos =min_t (loff_t, sb.size,roundup_64 (ret,PAGE_SIZE )); + +while (datapos < holepos) { +struct page *page =NULL ; +void *p, *kaddr; +u64 datalen = holepos - datapos; +unsigned int pagepos; +unsigned int pagelen; + +cond_resched (); + +if (fatal_signal_pending (current)) { + error = -EINTR ; + goto out_pflags; + } + + pagelen =min_t (u64, datalen,PAGE_SIZE ); + + page =shmem_read_mapping_page_gfp (mapping, + datapos >>PAGE_SHIFT , __GFP_NOWARN); +if (IS_ERR (page)) { + error =PTR_ERR (page); +if (error == -EIO ) +printk (KERN_ALERT "%.8llx: poisoned" , + datapos); +else if (error != -ENOMEM ) + goto out_pflags; + + goto next_pgoff; + } + +if (!PageUptodate (page)) + goto next_page; + + kaddr =kmap_local_page (page); + p = kaddr; + +for (pagepos =0 ; pagepos < pagelen; pagepos +=16 ) { +char prefix[16 ]; +unsigned int linelen; + + linelen = min_t(unsigned int, pagelen, 16); + +if (!memchr_inv (p + pagepos,0 , linelen)) +continue ; + +snprintf (prefix,16 ,"%.8llx: " , + datapos + pagepos); + + all_zeroes = false; +print_hex_dump (KERN_ALERT , prefix, +DUMP_PREFIX_NONE ,16 ,1 , + p + pagepos, linelen, true); + } +kunmap_local (kaddr); +next_page: +put_page (page); +next_pgoff: + datapos +=PAGE_SIZE ; + } + } +if (all_zeroes) +printk (KERN_ALERT "<all zeroes>" ); +if (ret != -ENXIO ) + error = ret; +out_pflags: +memalloc_nofs_restore (pflags); +return error; +}
fs/xfs/scrub/xfile.h +2 -0
@@ -74,4 +74,6 @@ int xfile_get_page(struct xfile *xf, loff_t offset, unsigned int len, struct xfile_page *xbuf);int xfile_put_page (struct xfile *xf,struct xfile_page *xbuf); +int xfile_dump (struct xfile *xf); +#endif /* __XFS_SCRUB_XFILE_H__ */
Re: [PATCH 1/9] xfs: dump xfiles for debugging purposes
fs/xfs/scrub/xfile.c xfile_put_page( · line 442
Quoted 7 lines · Darrick J. Wong
fs/xfs/scrub/xfile.c +7
-0+ error =xfile_stat (xf, &sb); +if (error) +return error; + +printk (KERN_ALERT "xfile ino 0x%lx isize 0x%llx dump:" , inode->i_ino, + sb.size); + pflags =memalloc_nofs_save ();
Hm, why? What makes it a bad idea to call back into the filesysteam at this point?
fs/xfs/scrub/xfile.c xfile_put_page( · line 468
Quoted 2 lines
fs/xfs/scrub/xfile.c +2
-0+ page =shmem_read_mapping_page_gfp (mapping, + datapos >>PAGE_SHIFT , __GFP_NOWARN);
This GFP flag looks wrong. Why can't we use GFP_KERNEL here?
I'm also not thrilled about the use of page APIs instead of folio APIs, but given how long this patchset has been in development, I understand why you didn't start out with folio APIs. It's not a blocker by any means.
I can come through and convert it later when I decide that it's finally time to get rid of shmem_read_mapping_page_gfp(), which is going to take a big gulp because it now means touching GPU drivers ...
Re: [PATCH 1/9] xfs: dump xfiles for debugging purposes
Quoted 11 lines · Matthew Wilcox
fs/xfs/scrub/xfile.c xfile_put_page( · line 442
Quoted 7 lines · Darrick J. Wong
fs/xfs/scrub/xfile.c +7
-0+ error =xfile_stat (xf, &sb); +if (error) +return error; + +printk (KERN_ALERT "xfile ino 0x%lx isize 0x%llx dump:" , inode->i_ino, + sb.size); + pflags =memalloc_nofs_save ();Hm, why? What makes it a bad idea to call back into the filesysteam at this point?
I don't want xfile_dump to invoke direct reclaim which will then call back into xfs because scrub (or any xfile caller) might already be holding the an ILOCK.
Granted it's /probably/ redundant since the scrub transaction will have already memalloc_nofs_save'd. But as this is a debug function, I figured it was better to burn an unsigned long to prevent making problems worse...
Quoted 4 lines
fs/xfs/scrub/xfile.c xfile_put_page( · line 468
Quoted 2 lines
fs/xfs/scrub/xfile.c +2
-0+ page =shmem_read_mapping_page_gfp (mapping, + datapos >>PAGE_SHIFT , __GFP_NOWARN);This GFP flag looks wrong. Why can't we use
GFP_KERNELhere?
I think that's an omission.
Quoted 3 lines
I'm also not thrilled about the use of page APIs instead of folio APIs, but given how long this patchset has been in development, I understand why you didn't start out with folio APIs. It's not a blocker by any means.
Heh. Yeah, I really wish xfiles had been merged before you started the folioization instead of adding to legacy code creeping.
Quoted 3 lines
I can come through and convert it later when I decide that it's finally time to get rid of
shmem_read_mapping_page_gfp(), which is going to take a big gulp because it now means touching GPU drivers ...
Hehhehee yep.
--D
Re: [PATCH 1/9] xfs: dump xfiles for debugging purposes
In reply to Darrick J. WongQuoted 3 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Add a debug function to dump an xfile's contents for debug purposes.
This doesn't actually seem to ever get used in the entire patch bomb.
PATCH 2/9 xfs: teach buftargs to maintain their own buffer hashtable
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Currently, cached buffers are indexed by per-AG hashtables. This works great for the data device, but won't work for in-memory btrees. Make it so that buftargs can index buffers too.
We accomplish this by hoisting the rhashtable and its lock into a separate xfs_buf_cache structure and reworking various functions to use it. Next, we introduce to the buftarg a new XFS_BUFTARG_SELF_CACHED flag to indicate that the buftarg's cache is active (vs. the per-ag cache for the regular filesystem).
Finally, make it so that each xfs_buf points to its cache if there is one. This is how we distinguish uncached buffers from now on.
--- fs/xfs/libxfs/xfs_ag.c | 6 +- fs/xfs/libxfs/xfs_ag.h | 4 - fs/xfs/xfs_buf.c | 143 +++++++++++++++++++++++++++++++++--------------- fs/xfs/xfs_buf.h | 10 +++ fs/xfs/xfs_mount.h | 3 - 5 files changed, 111 insertions(+), 55 deletions(-)
fs/xfs/libxfs/xfs_ag.c +3 -3
@@ -264,7 +264,7 @@ xfs_free_perag(xfs_defer_drain_free (&pag->pag_intents_drain);cancel_delayed_work_sync (&pag->pag_blockgc_work); -xfs_buf_hash_destroy (pag); +xfs_buf_cache_destroy (&pag->pag_bcache);/* drop the mount's active reference */ xfs_perag_rele (pag);
@@ -394,7 +394,7 @@ xfs_initialize_perag( pag->pagb_tree =RB_ROOT ;#endif /* __KERNEL__ */ - error =xfs_buf_hash_init (pag); + error =xfs_buf_cache_init (&pag->pag_bcache);if (error) goto out_remove_pag;
@@ -434,7 +434,7 @@ xfs_initialize_perag( pag =radix_tree_delete (&mp->m_perag_tree, index);if (!pag)break ; -xfs_buf_hash_destroy (pag); +xfs_buf_cache_destroy (&pag->pag_bcache);xfs_defer_drain_free (&pag->pag_intents_drain);kmem_free (pag); }
fs/xfs/libxfs/xfs_ag.h +1 -3
@@ -104,9 +104,7 @@ struct xfs_perag {int pag_ici_reclaimable;/* reclaimable inodes */ unsigned long pag_ici_reclaim_cursor;/* reclaim restart point */ -/* buffer cache index */ -spinlock_t pag_buf_lock;/* lock for pag_buf_hash */ -struct rhashtable pag_buf_hash; +struct xfs_buf_cache pag_bcache;/* background prealloc block trimming */ struct delayed_work pag_blockgc_work;
fs/xfs/xfs_buf.c +97 -46
290 lines not on this page · raw message
fs/xfs/xfs_buf.h +10 -0
@@ -83,6 +83,14 @@ typedef unsigned int xfs_buf_flags_t;#define XFS_BSTATE_DISPOSE (1 << 0)/* buffer being discarded */ #define XFS_BSTATE_IN_FLIGHT (1 << 1)/* I/O in flight */ +struct xfs_buf_cache { +spinlock_t bc_lock; +struct rhashtable bc_hash; +}; + +int xfs_buf_cache_init (struct xfs_buf_cache *bch); +void xfs_buf_cache_destroy (struct xfs_buf_cache *bch); +/* * The xfs_buftarg contains 2 notions of "sector size" - *
@@ -103,6 +111,7 @@ typedef struct xfs_buftarg {struct dax_device *bt_daxdev;u64 bt_dax_part_off;struct xfs_mount *bt_mount; +struct xfs_buf_cache *bt_cache;unsigned int bt_meta_sectorsize;size_t bt_meta_sectormask;size_t bt_logical_sectorsize;
@@ -212,6 +221,7 @@ struct xfs_buf {int b_last_error;const struct xfs_buf_ops *b_ops; +struct xfs_buf_cache *b_cache;struct rcu_head b_rcu; };
fs/xfs/xfs_mount.h +0 -3
@@ -505,9 +505,6 @@ xfs_daddr_to_agbno(struct xfs_mount *mp, xfs_daddr_t d)return (xfs_agblock_t )do_div (ld, mp->m_sb.sb_agblocks); } -int xfs_buf_hash_init (struct xfs_perag *pag); -void xfs_buf_hash_destroy (struct xfs_perag *pag); -extern void xfs_uuid_table_free (void );extern uint64_t xfs_default_resblks (xfs_mount_t *mp);extern int xfs_mountfs (xfs_mount_t *mp);
PATCH 3/9 xfs: create buftarg helpers to abstract block_device operations
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
In the next few patches, we're going into introduce buffer targets that are not block devices. Introduce block_device helpers so that the compiler can check that we're not feeding an xfile object to something expecting a block device.
--- fs/xfs/xfs_aops.c | 5 ++++- fs/xfs/xfs_bmap_util.c | 8 ++++---- fs/xfs/xfs_buf.h | 37 +++++++++++++++++++++++++++++++++++-- fs/xfs/xfs_discard.c | 9 +++++---- fs/xfs/xfs_file.c | 6 +++--- fs/xfs/xfs_ioctl.c | 3 ++- fs/xfs/xfs_iomap.c | 4 ++-- fs/xfs/xfs_log.c | 4 ++-- fs/xfs/xfs_log_recover.c | 3 ++- 9 files changed, 59 insertions(+), 20 deletions(-)
fs/xfs/xfs_aops.c +4 -1
@@ -569,7 +569,10 @@ xfs_iomap_swapfile_activate(struct file *swap_file, sector_t *span) { - sis->bdev = xfs_inode_buftarg(XFS_I(file_inode(swap_file)))->bt_bdev; + struct xfs_inode *ip = XFS_I(file_inode(swap_file)); +struct xfs_buftarg *btp =xfs_inode_buftarg (ip); + + sis->bdev =xfs_buftarg_bdev (btp);return iomap_swapfile_activate (sis, swap_file, span, &xfs_read_iomap_ops); }
fs/xfs/xfs_bmap_util.c +4 -4
@@ -63,10 +63,10 @@ xfs_zero_extent(xfs_daddr_t sector =xfs_fsb_to_db (ip, start_fsb);sector_t block =XFS_BB_TO_FSBT (mp, sector); -return blkdev_issue_zeroout (target->bt_bdev, - block << (mp->m_super->s_blocksize_bits -9 ), - count_fsb << (mp->m_super->s_blocksize_bits -9 ), -GFP_NOFS ,0 ); +return xfs_buftarg_zeroout (target, + block << (mp->m_super->s_blocksize_bits -9 ), + count_fsb << (mp->m_super->s_blocksize_bits -9 ), +GFP_NOFS ,0 ); }#ifdef CONFIG_XFS_RT
fs/xfs/xfs_buf.h +35 -2
@@ -382,8 +382,41 @@ extern void xfs_buftarg_wait(struct xfs_buftarg *);extern void xfs_buftarg_drain (struct xfs_buftarg *);extern int xfs_setsize_buftarg (struct xfs_buftarg *,unsigned int ); -#define xfs_getsize_buftarg (buftarg) block_size((buftarg)->bt_bdev) -#define xfs_readonly_buftarg (buftarg) bdev_read_only((buftarg)->bt_bdev) +static inline struct block_device * +xfs_buftarg_bdev (struct xfs_buftarg *btp) +{ +return btp->bt_bdev; +} + +static inline unsigned int +xfs_getsize_buftarg (struct xfs_buftarg *btp) +{ +return block_size (btp->bt_bdev); +} + +static inline bool +xfs_readonly_buftarg (struct xfs_buftarg *btp) +{ +return bdev_read_only (btp->bt_bdev); +} + +static inline int +xfs_buftarg_flush (struct xfs_buftarg *btp) +{ +return blkdev_issue_flush (btp->bt_bdev); +} + +static inline int +xfs_buftarg_zeroout ( +struct xfs_buftarg *btp, +sector_t sector, +sector_t nr_sects, +gfp_t gfp_mask, +unsigned int flags) +{ +return blkdev_issue_zeroout (btp->bt_bdev, sector, nr_sects, gfp_mask, + flags); +}int xfs_buf_reverify (struct xfs_buf *bp,const struct xfs_buf_ops *ops);bool xfs_verify_magic (struct xfs_buf *bp,__be32 dmagic);
fs/xfs/xfs_discard.c +5 -4
@@ -108,6 +108,7 @@ xfs_discard_extents(struct xfs_mount *mp, struct xfs_busy_extents *extents) { + struct block_device *bdev = xfs_buftarg_bdev(mp->m_ddev_targp);struct xfs_extent_busy *busyp;struct bio *bio =NULL ;struct blk_plug plug;
@@ -118,7 +119,7 @@ xfs_discard_extents(trace_xfs_discard_extent (mp, busyp->agno, busyp->bno, busyp->length); - error =__blkdev_issue_discard (mp->m_ddev_targp->bt_bdev, + error =__blkdev_issue_discard (bdev,XFS_AGB_TO_DADDR (mp, busyp->agno, busyp->bno),XFS_FSB_TO_BB (mp, busyp->length),GFP_NOFS , &bio);
@@ -368,8 +369,8 @@ xfs_ioc_trim( struct fstrim_range __user *urange) {struct xfs_perag *pag; -unsigned int granularity = -bdev_discard_granularity (mp->m_ddev_targp->bt_bdev); +struct block_device *bdev =xfs_buftarg_bdev (mp->m_ddev_targp); +unsigned int granularity =bdev_discard_granularity (bdev);struct fstrim_range range;xfs_daddr_t start, end, minlen;xfs_agnumber_t agno;
@@ -378,7 +379,7 @@ xfs_ioc_trim(if (!capable (CAP_SYS_ADMIN ))return -EPERM ; -if (!bdev_max_discard_sectors (mp->m_ddev_targp->bt_bdev)) +if (!bdev_max_discard_sectors (bdev))return -EOPNOTSUPP ;/*
fs/xfs/xfs_file.c +3 -3
@@ -164,9 +164,9 @@ xfs_file_fsync(* inode size in case of an extending write. */ if (XFS_IS_REALTIME_INODE (ip)) - error =blkdev_issue_flush (mp->m_rtdev_targp->bt_bdev); + error =xfs_buftarg_flush (mp->m_rtdev_targp);else if (mp->m_logdev_targp != mp->m_ddev_targp) - error =blkdev_issue_flush (mp->m_ddev_targp->bt_bdev); + error =xfs_buftarg_flush (mp->m_ddev_targp);/* * Any inode that has dirty modifications in the log is pinned. The
@@ -189,7 +189,7 @@ xfs_file_fsync(*/ if (!log_flushed && !XFS_IS_REALTIME_INODE (ip) && mp->m_logdev_targp == mp->m_ddev_targp) { - err2 =blkdev_issue_flush (mp->m_ddev_targp->bt_bdev); + err2 =xfs_buftarg_flush (mp->m_ddev_targp);if (err2 && !error) error = err2; }
fs/xfs/xfs_ioctl.c +2 -1
@@ -1773,6 +1773,7 @@ xfs_ioc_setlabel( char __user *newlabel) {struct xfs_sb *sbp = &mp->m_sb; +struct block_device *bdev =xfs_buftarg_bdev (mp->m_ddev_targp);char label[XFSLABEL_MAX +1 ];size_t len;int error;
@@ -1819,7 +1820,7 @@ xfs_ioc_setlabel( error =xfs_update_secondary_sbs (mp);mutex_unlock (&mp->m_growlock); -invalidate_bdev (mp->m_ddev_targp->bt_bdev); +invalidate_bdev (bdev); out:mnt_drop_write_file (filp);
fs/xfs/xfs_iomap.c +2 -2
@@ -129,7 +129,7 @@ xfs_bmbt_to_iomap(if (mapping_flags &IOMAP_DAX ) iomap->dax_dev = target->bt_daxdev;else - iomap->bdev = target->bt_bdev; + iomap->bdev =xfs_buftarg_bdev (target); iomap->flags = iomap_flags; if (xfs_ipincount(ip) &&
@@ -154,7 +154,7 @@ xfs_hole_to_iomap( iomap->type =IOMAP_HOLE ; iomap->offset =XFS_FSB_TO_B (ip->i_mount, offset_fsb); iomap->length =XFS_FSB_TO_B (ip->i_mount, end_fsb - offset_fsb); - iomap->bdev = target->bt_bdev; + iomap->bdev =xfs_buftarg_bdev (target); iomap->dax_dev = target->bt_daxdev; }
fs/xfs/xfs_log.c +2 -2
@@ -1903,7 +1903,7 @@ xlog_write_iclog(* writeback throttle from throttling log writes behind background * metadata writeback and causing priority inversions. */ -bio_init (&iclog->ic_bio, log->l_targ->bt_bdev, iclog->ic_bvec, +bio_init (&iclog->ic_bio,xfs_buftarg_bdev (log->l_targ), iclog->ic_bvec,howmany (count,PAGE_SIZE ),REQ_OP_WRITE |REQ_META |REQ_SYNC |REQ_IDLE ); iclog->ic_bio.bi_iter.bi_sector = log->l_logBBstart + bno;
@@ -1924,7 +1924,7 @@ xlog_write_iclog(* avoid shutdown re-entering this path and erroring out again. */ if (log->l_targ != log->l_mp->m_ddev_targp && -blkdev_issue_flush (log->l_mp->m_ddev_targp->bt_bdev)) +xfs_buftarg_flush (log->l_mp->m_ddev_targp)) goto shutdown; }if (iclog->ic_flags &XLOG_ICL_NEED_FUA )
fs/xfs/xfs_log_recover.c +2 -1
@@ -137,7 +137,8 @@ xlog_do_io( nbblks =round_up (nbblks, log->l_sectBBsize);ASSERT (nbblks >0 ); - error =xfs_rw_bdev (log->l_targ->bt_bdev, log->l_logBBstart + blk_no, + error =xfs_rw_bdev (xfs_buftarg_bdev (log->l_targ), + log->l_logBBstart + blk_no,BBTOB (nbblks), data, op);if (error && !xlog_is_shutdown (log)) { xfs_alert(log->l_mp,
Re: [PATCH 3/9] xfs: create buftarg helpers to abstract block_device operations
Quoted 6 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
In the next few patches, we're going into introduce buffer targets that are not block devices. Introduce
block_devicehelpers so that the compiler can check that we're not feeding an xfile object to something expecting a block device.
I don't see how these helpers allow the compiler to check anything. I also don't see any other good reason for the helpers, but maybe I'm just missing something.
Re: [PATCH 3/9] xfs: create buftarg helpers to abstract block_device operations
Quoted 11 lines · Christoph Hellwig
Quoted 6 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
In the next few patches, we're going into introduce buffer targets that are not block devices. Introduce
block_devicehelpers so that the compiler can check that we're not feeding an xfile object to something expecting a block device.I don't see how these helpers allow the compiler to check anything. I also don't see any other good reason for the helpers, but maybe I'm just missing something.
Oh, right -- originally, this patch made struct xfs_buftarg do this:
struct xfs_buftarg {
dev_t bt_dev;
union {
struct block_device *bt_bdev;
struct xfile *bt_xfile;
};
struct dax_device *bt_daxdev;Dereferencing bt_bdev/bt_xfile was controlled through a buftarg flag. IOWs, it employed the tagged union pattern.
When bt_bdev_handle came about, I gave up on the tagged union and simply added another pointer to struct xfs_buftarg. There aren't that many of them floating around in the system, so the extra 8 bytes isn't a giant drain on resources.
struct xfs_buftarg {
dev_t bt_dev;
struct bdev_handle *bt_bdev_handle;
struct block_device *bt_bdev;
struct dax_device *bt_daxdev;
struct xfile *bt_xfile;Now we don't need these wrappers since we can't accidentally dereference bt_xfile as a struct block_device. I'll drop this one.
--D
Re: [PATCH 3/9] xfs: create buftarg helpers to abstract block_device operations
Quoted 2 lines · Darrick J. Wong
Now we don't need these wrappers since we can't accidentally dereference
bt_xfileas a structblock_device. I'll drop this one.
And Christian posted a ptch to make the bdev_handle a file, so we might end up using files a lot more here :)
PATCH 4/9 xfs: make GFP_ usage consistent when allocating buftargs
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Convert kmem_zalloc to kzalloc, and make it so that both memory allocation functions in this function use GFP_NOFS.
--- fs/xfs/xfs_buf.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-)
fs/xfs/xfs_buf.c +4 -4
@@ -1981,7 +1981,7 @@ xfs_free_buftarg(if (btp->bt_bdev != btp->bt_mount->m_super->s_bdev)bdev_release (btp->bt_bdev_handle); -kmem_free (btp); +kvfree (btp); }int
@@ -2026,7 +2026,7 @@ xfs_alloc_buftarg_common( {struct xfs_buftarg *btp; - btp =kmem_zalloc (sizeof (*btp),KM_NOFS ); + btp =kzalloc (sizeof (*btp),GFP_NOFS );if (!btp)return NULL ;
@@ -2042,7 +2042,7 @@ xfs_alloc_buftarg_common(if (list_lru_init (&btp->bt_lru)) goto error_free; -if (percpu_counter_init (&btp->bt_io_count,0 ,GFP_KERNEL )) +if (percpu_counter_init (&btp->bt_io_count,0 ,GFP_NOFS )) goto error_lru; btp->bt_shrinker = shrinker_alloc(SHRINKER_NUMA_AWARE, "xfs-%s:%s",
@@ -2063,7 +2063,7 @@ xfs_alloc_buftarg_common( error_lru:list_lru_destroy (&btp->bt_lru); error_free: -kmem_free (btp); +kvfree (btp);return NULL ; }
Re: [PATCH 4/9] xfs: make GFP_ usage consistent when allocating buftargs
Looks good:
PATCH 5/9 xfs: support in-memory buffer cache targets
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Allow the buffer cache to target in-memory files by connecting it to xfiles.
--- fs/xfs/Kconfig | 4 ++ fs/xfs/Makefile | 1 + fs/xfs/scrub/xfile.h | 16 +++++++++ fs/xfs/xfs_buf.c | 46 ++++++++++++++++++++++--- fs/xfs/xfs_buf.h | 22 ++++++++++++ fs/xfs/xfs_buf_xfile.c | 89 ++++++++++++++++++++++++++++++++++++++++++++++++ fs/xfs/xfs_buf_xfile.h | 18 ++++++++++ 7 files changed, 191 insertions(+), 5 deletions(-) create mode 100644 fs/xfs/xfs_buf_xfile.c create mode 100644 fs/xfs/xfs_buf_xfile.h
fs/xfs/Kconfig +4 -0
@@ -128,6 +128,9 @@ config XFS_LIVE_HOOKS bool select JUMP_LABEL if HAVE_ARCH_JUMP_LABEL +config XFS_IN_MEMORY_FILE + bool + config XFS_ONLINE_SCRUB bool "XFS online metadata check support" default n
@@ -135,6 +138,7 @@ config XFS_ONLINE_SCRUB depends on TMPFS && SHMEM select XFS_LIVE_HOOKS select XFS_DRAIN_INTENTS + select XFS_IN_MEMORY_FILE help If you say Y here you will be able to check metadata on a mounted XFS filesystem. This feature is intended to reduce
fs/xfs/Makefile +1 -0
@@ -138,6 +138,7 @@ endif xfs-$(CONFIG_XFS_DRAIN_INTENTS) += xfs_drain.o xfs-$(CONFIG_XFS_LIVE_HOOKS) += xfs_hooks.o +xfs-$(CONFIG_XFS_IN_MEMORY_FILE) += xfs_buf_xfile.o # online scrub/repair ifeq ($(CONFIG_XFS_ONLINE_SCRUB),y)
fs/xfs/scrub/xfile.h +16 -0
@@ -6,6 +6,8 @@ #ifndef __XFS_SCRUB_XFILE_H__ #define __XFS_SCRUB_XFILE_H__ +#ifdef CONFIG_XFS_IN_MEMORY_FILE + struct xfile_page { struct page *page; void *fsdata;
@@ -24,6 +26,7 @@ static inline pgoff_t xfile_page_index(const struct xfile_page *xfpage)struct xfile {struct file *file; +struct xfs_buf_cache bcache; };int xfile_create (const char *description,loff_t isize,struct xfile **xfilep);
@@ -75,5 +78,18 @@ int xfile_get_page(struct xfile *xf, loff_t offset, unsigned int len,int xfile_put_page (struct xfile *xf,struct xfile_page *xbuf);int xfile_dump (struct xfile *xf); +#else +static inline int +xfile_obj_load (struct xfile *xf,void *buf,size_t count,loff_t offset) +{ +return -EIO ; +} + +static inline int +xfile_obj_store (struct xfile *xf,const void *buf,size_t count,loff_t offset) +{ +return -EIO ; +} +#endif /* CONFIG_XFS_IN_MEMORY_FILE */ #endif /* __XFS_SCRUB_XFILE_H__ */
fs/xfs/xfs_buf.c +41 -5
76 lines not on this page · raw message
fs/xfs/xfs_buf.h +22 -0
@@ -21,6 +21,7 @@ extern struct kmem_cache *xfs_buf_cache;* Base types */ struct xfs_buf ; +struct xfile ;#define XFS_BUF_DADDR_NULL ((xfs_daddr_t) (-1LL))
@@ -109,9 +110,11 @@ typedef struct xfs_buftarg {struct bdev_handle *bt_bdev_handle;struct block_device *bt_bdev;struct dax_device *bt_daxdev; +struct xfile *bt_xfile;u64 bt_dax_part_off;struct xfs_mount *bt_mount;struct xfs_buf_cache *bt_cache; +unsigned int bt_flags;unsigned int bt_meta_sectorsize;size_t bt_meta_sectormask;size_t bt_logical_sectorsize;
@@ -125,6 +128,13 @@ typedef struct xfs_buftarg {struct ratelimit_state bt_ioerror_rl; } xfs_buftarg_t; +#ifdef CONFIG_XFS_IN_MEMORY_FILE +/* in-memory buftarg via bt_xfile */ +# define XFS_BUFTARG_XFILE (1U << 0) +#else +# define XFS_BUFTARG_XFILE (0) +#endif +#define XB_PAGES 2struct xfs_buf_map {
@@ -375,6 +385,8 @@ xfs_buf_update_cksum(struct xfs_buf *bp, unsigned long cksum_offset)/* * Handling of buftargs. */ +struct xfs_buftarg *xfs_alloc_buftarg_common (struct xfs_mount *mp, +const char *descr);struct xfs_buftarg *xfs_alloc_buftarg (struct xfs_mount *mp,struct bdev_handle *bdev_handle);extern void xfs_free_buftarg (struct xfs_buftarg *);
@@ -385,24 +397,32 @@ extern int xfs_setsize_buftarg(struct xfs_buftarg *, unsigned int);static inline struct block_device *xfs_buftarg_bdev (struct xfs_buftarg *btp) { +if (btp->bt_flags &XFS_BUFTARG_XFILE ) +return NULL ;return btp->bt_bdev; }static inline unsigned int xfs_getsize_buftarg (struct xfs_buftarg *btp) { +if (btp->bt_flags &XFS_BUFTARG_XFILE ) +return SECTOR_SIZE ;return block_size (btp->bt_bdev); }static inline bool xfs_readonly_buftarg (struct xfs_buftarg *btp) { +if (btp->bt_flags &XFS_BUFTARG_XFILE ) +return false;return bdev_read_only (btp->bt_bdev); }static inline int xfs_buftarg_flush (struct xfs_buftarg *btp) { +if (btp->bt_flags &XFS_BUFTARG_XFILE ) +return 0 ;return blkdev_issue_flush (btp->bt_bdev); }
@@ -414,6 +434,8 @@ xfs_buftarg_zeroout( gfp_t gfp_mask, unsigned int flags) { +if (btp->bt_flags &XFS_BUFTARG_XFILE ) +return -EOPNOTSUPP ;return blkdev_issue_zeroout (btp->bt_bdev, sector, nr_sects, gfp_mask, flags); }
fs/xfs/xfs_buf_xfile.c new file +89 -0
89 lines not on this page · raw message
fs/xfs/xfs_buf_xfile.h new file +18 -0
@@ -0,0 +1,18 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/* +* Copyright (c) 2023-2024 Oracle. All Rights Reserved. +* Author: Darrick J. Wong <[email protected]> +*/ +#ifndef __XFS_BUF_XFILE_H__ +#define __XFS_BUF_XFILE_H__ + +#ifdef CONFIG_XFS_IN_MEMORY_FILE +int xfile_buf_ioapply (struct xfs_buf *bp); +int xfile_alloc_buftarg (struct xfs_mount *mp,const char *descr, +struct xfs_buftarg **btpp); +void xfile_free_buftarg (struct xfs_buftarg *btp); +#else +# define xfile_buf_ioapply (bp) (-EOPNOTSUPP) +#endif /* CONFIG_XFS_IN_MEMORY_FILE */ + +#endif /* __XFS_BUF_XFILE_H__ */
PATCH 6/9 xfs: consolidate btree block freeing tracepoints
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Don't waste tracepoint segment memory on per-btree block freeing tracepoints when we can do it from the generic btree code.
--- fs/xfs/libxfs/xfs_btree.c | 2 ++ fs/xfs/libxfs/xfs_refcount_btree.c | 2 -- fs/xfs/libxfs/xfs_rmap_btree.c | 2 -- fs/xfs/xfs_trace.h | 32 ++++++++++++++++++++++++++++++-- 4 files changed, 32 insertions(+), 6 deletions(-)
fs/xfs/libxfs/xfs_btree.c +2 -0
@@ -414,6 +414,8 @@ xfs_btree_free_block( {int error; +trace_xfs_btree_free_block (cur, bp); + error = cur->bc_ops->free_block (cur, bp);if (!error) {xfs_trans_binval (cur->bc_tp, bp);
fs/xfs/libxfs/xfs_refcount_btree.c +0 -2
@@ -107,8 +107,6 @@ xfs_refcountbt_free_block(struct xfs_agf *agf = agbp->b_addr;xfs_fsblock_t fsbno =XFS_DADDR_TO_FSB (mp,xfs_buf_daddr (bp)); -trace_xfs_refcountbt_free_block (cur->bc_mp, cur->bc_ag.pag->pag_agno, -XFS_FSB_TO_AGBNO (cur->bc_mp, fsbno),1 );be32_add_cpu (&agf->agf_refcount_blocks,-1 );xfs_alloc_log_agf (cur->bc_tp, agbp,XFS_AGF_REFCOUNT_BLOCKS ); return xfs_free_extent_later(cur->bc_tp, fsbno, 1,
fs/xfs/libxfs/xfs_rmap_btree.c +0 -2
@@ -125,8 +125,6 @@ xfs_rmapbt_free_block(int error; bno =xfs_daddr_to_agbno (cur->bc_mp,xfs_buf_daddr (bp)); -trace_xfs_rmapbt_free_block (cur->bc_mp, pag->pag_agno, - bno,1 );be32_add_cpu (&agf->agf_rmap_blocks,-1 );xfs_alloc_log_agf (cur->bc_tp, agbp,XFS_AGF_RMAP_BLOCKS ); error =xfs_alloc_put_freelist (pag, cur->bc_tp, agbp,NULL , bno,1 );
fs/xfs/xfs_trace.h +30 -2
@@ -2493,6 +2493,36 @@ DEFINE_EVENT(xfs_btree_cur_class, name, \DEFINE_BTREE_CUR_EVENT (xfs_btree_updkeys);DEFINE_BTREE_CUR_EVENT (xfs_btree_overlapped_query_range); +TRACE_EVENT (xfs_btree_free_block, + TP_PROTO(struct xfs_btree_cur *cur, struct xfs_buf *bp), +TP_ARGS (cur, bp), +TP_STRUCT__entry ( + __field(dev_t, dev) + __field(xfs_agnumber_t, agno) + __field(xfs_ino_t, ino) + __field(xfs_btnum_t, btnum) +__field (xfs_agblock_t, agbno) + ), +TP_fast_assign ( + __entry->dev = cur->bc_mp->m_super->s_dev; + __entry->agno = xfs_daddr_to_agno(cur->bc_mp, + xfs_buf_daddr(bp)); + if (cur->bc_flags & XFS_BTREE_ROOT_IN_INODE) + __entry->ino = cur->bc_ino.ip->i_ino; + else + __entry->ino = 0; + __entry->btnum = cur->bc_btnum; + __entry->agbno = xfs_daddr_to_agbno(cur->bc_mp, + xfs_buf_daddr(bp)); + ), +TP_printk ("dev %d:%d btree %s agno 0x%x ino 0x%llx agbno 0x%x" , +MAJOR (__entry->dev),MINOR (__entry->dev), +__print_symbolic (__entry->btnum,XFS_BTNUM_STRINGS ), + __entry->agno, + __entry->ino, + __entry->agbno) +); +/* deferred ops */ struct xfs_defer_pending ;
@@ -2856,7 +2886,6 @@ DEFINE_RMAP_DEFERRED_EVENT(xfs_rmap_defer);DEFINE_RMAP_DEFERRED_EVENT (xfs_rmap_deferred);DEFINE_BUSY_EVENT (xfs_rmapbt_alloc_block); -DEFINE_BUSY_EVENT (xfs_rmapbt_free_block);DEFINE_RMAPBT_EVENT (xfs_rmap_update);DEFINE_RMAPBT_EVENT (xfs_rmap_insert);DEFINE_RMAPBT_EVENT (xfs_rmap_delete);
@@ -3215,7 +3244,6 @@ DEFINE_EVENT(xfs_refcount_triple_extent_class, name, \/* refcount btree tracepoints */ DEFINE_BUSY_EVENT (xfs_refcountbt_alloc_block); -DEFINE_BUSY_EVENT (xfs_refcountbt_free_block);DEFINE_AG_BTREE_LOOKUP_EVENT (xfs_refcount_lookup);DEFINE_REFCOUNT_EXTENT_EVENT (xfs_refcount_get);DEFINE_REFCOUNT_EXTENT_EVENT (xfs_refcount_update);
Re: [PATCH 6/9] xfs: consolidate btree block freeing tracepoints
Quoted 4 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Don't waste tracepoint segment memory on per-btree block freeing tracepoints when we can do it from the generic btree code.
The patch looks good, but what is "tracepoint segment memory"?
Re: [PATCH 6/9] xfs: consolidate btree block freeing tracepoints
Quoted 7 lines · Christoph Hellwig
Quoted 4 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Don't waste tracepoint segment memory on per-btree block freeing tracepoints when we can do it from the generic btree code.
The patch looks good, but what is "tracepoint segment memory"?
The size of the ELF segments where the ftrace strings/code/etc are stored. With this and the next patch applied, the output of:
$ objdump -x fs/xfs/xfs.ko | grep tracepoint
Before:
10 __tracepoints_ptrs 00000b38 0000000000000000 0000000000000000 001418b0 2**2 14 __tracepoints_strings 00005433 0000000000000000 0000000000000000 00168f60 2**5 29 __tracepoints 00010d30 0000000000000000 0000000000000000 00240080 2**5
After:
10 __tracepoints_ptrs 00000b30 0000000000000000 0000000000000000 00142170 2**2 14 __tracepoints_strings 000053f3 0000000000000000 0000000000000000 00169860 2**5 29 __tracepoints 00010c70 0000000000000000 0000000000000000 00241180 2**5
Removing these two tracepoints reduces the size of the ELF segments by 264 bytes. I'll add this note to the commit message.
--D
Re: [PATCH 6/9] xfs: consolidate btree block freeing tracepoints
Quoted 2 lines · Darrick J. Wong
Removing these two tracepoints reduces the size of the ELF segments by 264 bytes. I'll add this note to the commit message.
Yeah. Maybe just say memory usage - segment size feels awfully specific to an implementation detail.
Re: [PATCH 6/9] xfs: consolidate btree block freeing tracepoints
Quoted 6 lines · Christoph Hellwig
Quoted 2 lines · Darrick J. Wong
Removing these two tracepoints reduces the size of the ELF segments by 264 bytes. I'll add this note to the commit message.
Yeah. Maybe just say memory usage - segment size feels awfully specific to an implementation detail.
Done.
--D
PATCH 7/9 xfs: consolidate btree block allocation tracepoints
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Don't waste tracepoint segment memory on per-btree block allocation tracepoints when we can do it from the generic btree code.
--- fs/xfs/libxfs/xfs_btree.c | 20 ++++++++++++--- fs/xfs/libxfs/xfs_refcount_btree.c | 2 - fs/xfs/libxfs/xfs_rmap_btree.c | 2 - fs/xfs/xfs_trace.h | 49 +++++++++++++++++++++++++++++++++++- 4 files changed, 64 insertions(+), 9 deletions(-)
fs/xfs/libxfs/xfs_btree.c +17 -3
@@ -2693,6 +2693,20 @@ xfs_btree_rshift(return error; } +static inline int +xfs_btree_alloc_block ( +struct xfs_btree_cur *cur, +const union xfs_btree_ptr *hint_block, +union xfs_btree_ptr *new_block, +int *stat) +{ +int error; + + error = cur->bc_ops->alloc_block (cur, hint_block, new_block, stat); +trace_xfs_btree_alloc_block (cur, new_block, *stat, error); +return error; +} +/* * Split cur/level block in half. * Return new block number and the key to its first
@@ -2736,7 +2750,7 @@ __xfs_btree_split(xfs_btree_buf_to_ptr (cur, lbp, &lptr);/* Allocate the new block. If we can't do it, we're toast. Give up. */ - error = cur->bc_ops->alloc_block (cur, &lptr, &rptr, stat); + error =xfs_btree_alloc_block (cur, &lptr, &rptr, stat);if (error) goto error0;if (*stat ==0 )
@@ -3016,7 +3030,7 @@ xfs_btree_new_iroot( pp =xfs_btree_ptr_addr (cur,1 , block);/* Allocate the new block. If we can't do it, we're toast. Give up. */ - error = cur->bc_ops->alloc_block (cur, pp, &nptr, stat); + error =xfs_btree_alloc_block (cur, pp, &nptr, stat);if (error) goto error0;if (*stat ==0 )
@@ -3116,7 +3130,7 @@ xfs_btree_new_root( cur->bc_ops->init_ptr_from_cur (cur, &rptr);/* Allocate the new block. If we can't do it, we're toast. Give up. */ - error = cur->bc_ops->alloc_block (cur, &rptr, &lptr, stat); + error =xfs_btree_alloc_block (cur, &rptr, &lptr, stat);if (error) goto error0;if (*stat ==0 )
fs/xfs/libxfs/xfs_refcount_btree.c +0 -2
@@ -77,8 +77,6 @@ xfs_refcountbt_alloc_block( xfs_refc_block(args.mp)));if (error) goto out_error; -trace_xfs_refcountbt_alloc_block (cur->bc_mp, cur->bc_ag.pag->pag_agno, - args.agbno,1 );if (args.fsbno ==NULLFSBLOCK ) { *stat =0 ;return 0 ;
fs/xfs/libxfs/xfs_rmap_btree.c +0 -2
@@ -94,8 +94,6 @@ xfs_rmapbt_alloc_block( &bno, 1);if (error)return error; - -trace_xfs_rmapbt_alloc_block (cur->bc_mp, pag->pag_agno, bno,1 );if (bno ==NULLAGBLOCK ) { *stat =0 ;return 0 ;
fs/xfs/xfs_trace.h +47 -2
67 lines not on this page · raw message
PATCH 8/9 xfs: support in-memory btrees
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Adapt the generic btree cursor code to be able to create a btree whose buffers come from a (presumably in-memory) buftarg with a header block that's specific to in-memory btrees. We'll connect this to other parts of online scrub in the next patches.
Note that in-memory btrees always have a block size matching the system memory page size for efficiency reasons.
--- fs/xfs/Kconfig | 4 fs/xfs/Makefile | 1 fs/xfs/libxfs/xfs_btree.c | 151 ++++++++++++++---- fs/xfs/libxfs/xfs_btree.h | 17 ++ fs/xfs/libxfs/xfs_btree_mem.h | 87 ++++++++++ fs/xfs/scrub/xfbtree.c | 352 +++++++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/xfbtree.h | 34 ++++ fs/xfs/scrub/xfile.h | 46 +++++ fs/xfs/xfs_buf.c | 10 + fs/xfs/xfs_buf.h | 10 + fs/xfs/xfs_buf_xfile.c | 8 + fs/xfs/xfs_buf_xfile.h | 2 fs/xfs/xfs_health.c | 3 fs/xfs/xfs_trace.c | 3 fs/xfs/xfs_trace.h | 5 - 15 files changed, 704 insertions(+), 29 deletions(-) create mode 100644 fs/xfs/libxfs/xfs_btree_mem.h create mode 100644 fs/xfs/scrub/xfbtree.c create mode 100644 fs/xfs/scrub/xfbtree.h
fs/xfs/Kconfig +4 -0
@@ -131,6 +131,9 @@ config XFS_LIVE_HOOKS config XFS_IN_MEMORY_FILE bool +config XFS_BTREE_IN_XFILE + bool + config XFS_ONLINE_SCRUB bool "XFS online metadata check support" default n
@@ -204,6 +207,7 @@ config XFS_ONLINE_REPAIR bool "XFS online metadata repair support" default n depends on XFS_FS && XFS_ONLINE_SCRUB + select XFS_BTREE_IN_XFILE help If you say Y here you will be able to repair metadata on a mounted XFS filesystem. This feature is intended to reduce
fs/xfs/Makefile +1 -0
@@ -201,6 +201,7 @@ xfs-y += $(addprefix scrub/, \ reap.o \ refcount_repair.o \ repair.o \ + xfbtree.o \ ) xfs-$(CONFIG_XFS_RT) += $(addprefix scrub/, \
fs/xfs/libxfs/xfs_btree.c +123 -28
309 lines not on this page · raw message
fs/xfs/libxfs/xfs_btree.h +17 -0
@@ -248,6 +248,15 @@ struct xfs_btree_cur_ino {#define XFS_BTCUR_BMBT_INVALID_OWNER (1 << 1) }; +/* In-memory btree information */ +struct xfbtree ; + +struct xfs_btree_cur_mem { +struct xfbtree *xfbtree; +struct xfs_buf *head_bp; +struct xfs_perag *pag; +}; +struct xfs_btree_level {/* buffer pointer */ struct xfs_buf *bp;
@@ -287,6 +296,7 @@ struct xfs_btree_curunion {struct xfs_btree_cur_ag bc_ag;struct xfs_btree_cur_ino bc_ino; +struct xfs_btree_cur_mem bc_mem; };/* Must be at the end of the struct! */
@@ -317,6 +327,13 @@ xfs_btree_cur_sizeof(unsigned int nlevels)*/ #define XFS_BTREE_STAGING (1<<5) +/* btree stored in memory; not compatible with ROOT_IN_INODE */ +#ifdef CONFIG_XFS_BTREE_IN_XFILE +# define XFS_BTREE_IN_XFILE (1<<7) +#else +# define XFS_BTREE_IN_XFILE (0) +#endif +#define XFS_BTREE_NOERROR 0#define XFS_BTREE_ERROR 1
fs/xfs/libxfs/xfs_btree_mem.h new file +87 -0
87 lines not on this page · raw message
fs/xfs/scrub/xfbtree.c new file +352 -0
352 lines not on this page · raw message
fs/xfs/scrub/xfbtree.h new file +34 -0
@@ -0,0 +1,34 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* +* Copyright (c) 2021-2024 Oracle. All Rights Reserved. +* Author: Darrick J. Wong <[email protected]> +*/ +#ifndef XFS_SCRUB_XFBTREE_H__ +#define XFS_SCRUB_XFBTREE_H__ + +#ifdef CONFIG_XFS_BTREE_IN_XFILE + +/* Root block for an in-memory btree. */ +struct xfs_btree_mem_head { +__be32 mh_magic; +__be32 mh_nlevels; +__be64 mh_owner; +__be64 mh_root; +uuid_t mh_uuid; +}; + +#define XFS_BTREE_MEM_HEAD_MAGIC 0x4341544D/* "CATM" */ + +/* xfile-backed in-memory btrees */ + +struct xfbtree { +/* buffer cache target for this in-memory btree */ +struct xfs_buftarg *target; + +/* Owner of this btree. */ +unsigned long long owner; +}; + +#endif /* CONFIG_XFS_BTREE_IN_XFILE */ + +#endif /* XFS_SCRUB_XFBTREE_H__ */
fs/xfs/scrub/xfile.h +46 -0
58 lines not on this page · raw message
fs/xfs/xfs_buf.c +10 -0
@@ -2497,3 +2497,13 @@ xfs_verify_magic16(return false;return dmagic == bp->b_ops->magic16[idx]; } + +/* Return the number of sectors for a buffer target. */ +xfs_daddr_t +xfs_buftarg_nr_sectors ( +struct xfs_buftarg *btp) +{ +if (btp->bt_flags &XFS_BUFTARG_XFILE ) +return xfile_buftarg_nr_sectors (btp); +return bdev_nr_sectors (btp->bt_bdev); +}
fs/xfs/xfs_buf.h +10 -0
@@ -440,6 +440,16 @@ xfs_buftarg_zeroout( flags); } +xfs_daddr_t xfs_buftarg_nr_sectors (struct xfs_buftarg *btp); + +static inline bool +xfs_buftarg_verify_daddr ( +struct xfs_buftarg *btp, +xfs_daddr_t daddr) +{ +return daddr <xfs_buftarg_nr_sectors (btp); +} +int xfs_buf_reverify (struct xfs_buf *bp,const struct xfs_buf_ops *ops);bool xfs_verify_magic (struct xfs_buf *bp,__be32 dmagic);bool xfs_verify_magic16 (struct xfs_buf *bp,__be16 dmagic);
fs/xfs/xfs_buf_xfile.c +8 -0
@@ -87,3 +87,11 @@ xfile_free_buftarg(xfs_buf_cache_destroy (&xfile->bcache);xfile_destroy (xfile); } + +/* Sector count for this xfile buftarg. */ +xfs_daddr_t +xfile_buftarg_nr_sectors ( +struct xfs_buftarg *btp) +{ +return xfile_size (btp->bt_xfile) >>SECTOR_SHIFT ; +}
fs/xfs/xfs_buf_xfile.h +2 -0
@@ -11,8 +11,10 @@ int xfile_buf_ioapply(struct xfs_buf *bp);int xfile_alloc_buftarg (struct xfs_mount *mp,const char *descr,struct xfs_buftarg **btpp);void xfile_free_buftarg (struct xfs_buftarg *btp); +xfs_daddr_t xfile_buftarg_nr_sectors (struct xfs_buftarg *btp);#else # define xfile_buf_ioapply (bp) (-EOPNOTSUPP) +# define xfile_buftarg_nr_sectors (btp) (0)#endif /* CONFIG_XFS_IN_MEMORY_FILE */ #endif /* __XFS_BUF_XFILE_H__ */
fs/xfs/xfs_health.c +3 -0
@@ -512,6 +512,9 @@ xfs_btree_mark_sick( {unsigned int mask; +if (cur->bc_flags &XFS_BTREE_IN_XFILE ) +return ; +switch (cur->bc_btnum) {case XFS_BTNUM_BMAP :xfs_bmap_mark_sick (cur->bc_ino.ip, cur->bc_ino.whichfork);
fs/xfs/xfs_trace.c +3 -0
@@ -36,6 +36,9 @@#include "xfs_error.h" #include <linux/iomap.h> #include "xfs_iomap.h" +#include "scrub/xfile.h" +#include "scrub/xfbtree.h" +#include "xfs_btree_mem.h" /* * We include this last to have the helpers above available for the trace
fs/xfs/xfs_trace.h +4 -1
@@ -2507,7 +2507,10 @@ TRACE_EVENT(xfs_btree_alloc_block, ), TP_fast_assign( __entry->dev = cur->bc_mp->m_super->s_dev; -if (cur->bc_flags &XFS_BTREE_ROOT_IN_INODE ) { +if (cur->bc_flags &XFS_BTREE_IN_XFILE ) { + __entry->agno =0 ; + __entry->ino =0 ; + }else if (cur->bc_flags &XFS_BTREE_ROOT_IN_INODE ) { __entry->agno =0 ; __entry->ino = cur->bc_ino.ip->i_ino; }else {
Re: [PATCH 8/9] xfs: support in-memory btrees
fs/xfs/libxfs/xfs_btree.c xfs_btree_del_cursor( · line 489
Quoted 8 lines
fs/xfs/libxfs/xfs_btree.c +6
-1-if (!(cur->bc_flags &XFS_BTREE_LONG_PTRS ) && cur->bc_ag.pag) +if (!(cur->bc_flags &XFS_BTREE_LONG_PTRS ) && + !(cur->bc_flags &XFS_BTREE_IN_XFILE ) && cur->bc_ag.pag)xfs_perag_put (cur->bc_ag.pag); +if (cur->bc_flags &XFS_BTREE_IN_XFILE ) { +if (cur->bc_mem.pag) +xfs_perag_put (cur->bc_mem.pag); + }
Btw, one thing I noticed is that we have a lot of confusion on what part of the bc_ino/ag/mem union is used for a given btree. For On-disk inodes we abuse the long ptrs flag, and then we through in the xfile flags. If you're fine with it I can try to sort it out. It's not really a blocker, but I think it would be a lot claner if we used the chance to sort it out. This will become even more important with the rt rmap/reflink trees that will further increase the confusion here.
fs/xfs/libxfs/xfs_btree.c xfs_btree_del_cursor( · line 511
Quoted 4 lines
fs/xfs/libxfs/xfs_btree.c +4
-0+if (cur->bc_flags &XFS_BTREE_IN_XFILE ) +return xfbtree_bbsize (); +return cur->bc_mp->m_bsize; +}
One thing I've been wondering is if we should split
a strut xfs_btree outof struct xfbtree that contains most of the fields from it minuts the space allocation (and the new fake header from my patches) and also use that for the on-disk btrees.
That means xfs_btree.c can use the target from it, and the owner and we can remove the indirect calls for calculcating maxrecs/minrecs, and then also add a field for the block size like this one and remove a lof of the XFS_BTREE_IN_XFILE checks.
fs/xfs/libxfs/xfs_btree.c xfs_btree_readahead_lblock( · line 999
Quoted 5 lines
fs/xfs/libxfs/xfs_btree.c +3
-0+if (cur->bc_flags &XFS_BTREE_IN_XFILE ) +return 0 ; +if ((lr &XFS_BTCUR_LEFTRA ) && left !=NULLFSBLOCK ) { xfs_btree_reada_bufl(cur->bc_mp, left, 1,
Should the xfile check go into xfs_buf_readahead instead? That would execute a little more useles code for in-memory btrees, but keep this check in one place (where we could also write a nice comment explaining it :))
fs/xfs/libxfs/xfs_btree.c xfs_btree_visit_block( · line 4511
Quoted 12 lines
fs/xfs/libxfs/xfs_btree.c +3
-4+xfs_btree_buf_to_ptr (cur, bp, &bufptr);if (cur->bc_flags &XFS_BTREE_LONG_PTRS ) { -if (be64_to_cpu (rptr.l) ==XFS_DADDR_TO_FSB (cur->bc_mp, -xfs_buf_daddr (bp))) { +if (rptr.l == bufptr.l) {xfs_btree_mark_sick (cur);return -EFSCORRUPTED ; } }else { -if (be32_to_cpu (rptr.s) ==xfs_daddr_to_agbno (cur->bc_mp, -xfs_buf_daddr (bp))) { +if (rptr.s == bufptr.s) {
This almost screams for a xfs_btree_ptr_cmp helper, even if this seems to be the only user so far..
fs/xfs/scrub/xfile.h int xfile_get_page(struct xfile *xf, loff_t offset, unsigned int len, · line 85
Quoted 4 lines
fs/xfs/scrub/xfile.h +4
-0+static inline loff_t xfile_size (struct xfile *xf) +{ +return i_size_read (file_inode (xf->file)); +}
Despite looking over the whole patch for a while I only noticed this one, and I think I could add it in my xfile diet series instea dof open coding it in trace.h.
In general it would be really nice to split out patches that add infrastructure in other parts of the XFS codebase to make them stick out a bit more.
fs/xfs/scrub/xfile.h int xfile_get_page(struct xfile *xf, loff_t offset, unsigned int len, · line 96
Quoted 10 lines
fs/xfs/scrub/xfile.h +10
-0+/* file block (aka system page size) to basic block conversions. */ +typedef unsigned long long xfileoff_t ; +#define XFB_BLOCKSIZE (PAGE_SIZE) +#define XFB_BSHIFT (PAGE_SHIFT) +#define XFB_SHIFT (XFB_BSHIFT - BBSHIFT) + +static inline loff_t xfo_to_b (xfileoff_t xfoff) +{ +return xfoff <<XFB_BSHIFT ; +}
...
xfile.h feels like the wrong place for this - the encoding only really makes sense fo the xfbtree. And in a way it feels redundant over just using pgoff_t and the PAGE_* constants directly which should be pretty obvious to everyone knowning the Linux MM and page cache APIs.
fs/xfs/xfs_buf.c xfs_verify_magic16( · line 2507
Quoted 7 lines
fs/xfs/xfs_buf.c +7
-0+/* Return the number of sectors for a buffer target. */ +xfs_daddr_t +xfs_buftarg_nr_sectors ( +struct xfs_buftarg *btp) +{ +if (btp->bt_flags &XFS_BUFTARG_XFILE ) +return xfile_buftarg_nr_sectors (btp);
If we didn't add an ifdef around the struct xfile definition, this could just be open coded and rely on the compiler eliminating dead code when XFS_BUFTARG_XFILE isn't defined.
Re: [PATCH 8/9] xfs: support in-memory btrees
Quoted 9 lines · Christoph Hellwig
fs/xfs/libxfs/xfs_btree.c xfs_btree_del_cursor( · line 489
Quoted 8 lines
fs/xfs/libxfs/xfs_btree.c +6
-1-if (!(cur->bc_flags &XFS_BTREE_LONG_PTRS ) && cur->bc_ag.pag) +if (!(cur->bc_flags &XFS_BTREE_LONG_PTRS ) && + !(cur->bc_flags &XFS_BTREE_IN_XFILE ) && cur->bc_ag.pag)xfs_perag_put (cur->bc_ag.pag); +if (cur->bc_flags &XFS_BTREE_IN_XFILE ) { +if (cur->bc_mem.pag) +xfs_perag_put (cur->bc_mem.pag); + }
Quoted 8 lines
Btw, one thing I noticed is that we have a lot of confusion on what part of the bc_ino/ag/mem union is used for a given btree. For On-disk inodes we abuse the long ptrs flag, and then we through in the xfile flags. If you're fine with it I can try to sort it out. It's not really a blocker, but I think it would be a lot claner if we used the chance to sort it out. This will become even more important with the rt rmap/reflink trees that will further increase the confusion here.
Go for it! :)
Quoted 10 lines
fs/xfs/libxfs/xfs_btree.c xfs_btree_del_cursor( · line 511
Quoted 4 lines
fs/xfs/libxfs/xfs_btree.c +4
-0+if (cur->bc_flags &XFS_BTREE_IN_XFILE ) +return xfbtree_bbsize (); +return cur->bc_mp->m_bsize; +}One thing I've been wondering is if we should split
a strutxfs_btreeoutof struct xfbtree that contains most of the fields from it minuts the space allocation (and the new fake header from my patches) and also use that for the on-disk btrees.
Quoted 4 lines
That means
xfs_btree.ccan use the target from it, and the owner and we can remove the indirect calls for calculcating maxrecs/minrecs, and then also add a field for the block size like this one and remove a lof of theXFS_BTREE_IN_XFILEchecks.
Sounds like a good idea.
Quoted 10 lines
fs/xfs/libxfs/xfs_btree.c xfs_btree_readahead_lblock( · line 999
Quoted 5 lines
fs/xfs/libxfs/xfs_btree.c +3
-0+if (cur->bc_flags &XFS_BTREE_IN_XFILE ) +return 0 ; +if ((lr &XFS_BTCUR_LEFTRA ) && left !=NULLFSBLOCK ) { xfs_btree_reada_bufl(cur->bc_mp, left, 1,Should the xfile check go into
xfs_buf_readaheadinstead? That would execute a little more useles code for in-memory btrees, but keep this check in one place (where we could also write a nice comment explaining it :))
Sure, why not? It's too bad that readahead to an xfile can't asynchronously call xfile_get_page; maybe we wouldn't need so much caching.
Quoted 7 lines
Quoted 7 lines
fs/xfs/libxfs/xfs_btree.c +2
-2+xfs_btree_buf_to_ptr (cur, bp, &bufptr);if (cur->bc_flags &XFS_BTREE_LONG_PTRS ) { -if (be64_to_cpu (rptr.l) ==XFS_DADDR_TO_FSB (cur->bc_mp, -xfs_buf_daddr (bp))) { +if (rptr.l == bufptr.l) {xfs_btree_mark_sick (cur);return -EFSCORRUPTED ;
Quoted 8 lines
fs/xfs/libxfs/xfs_btree.c xfs_btree_visit_block( · line 4511
Quoted 5 lines
fs/xfs/libxfs/xfs_btree.c +1
-2} }else { -if (be32_to_cpu (rptr.s) ==xfs_daddr_to_agbno (cur->bc_mp, -xfs_buf_daddr (bp))) { +if (rptr.s == bufptr.s) {This almost screams for a
xfs_btree_ptr_cmphelper, even if this seems to be the only user so far..
<nod>
Quoted 9 lines
fs/xfs/scrub/xfile.h int xfile_get_page(struct xfile *xf, loff_t offset, unsigned int len, · line 85
Quoted 4 lines
fs/xfs/scrub/xfile.h +4
-0+static inline loff_t xfile_size (struct xfile *xf) +{ +return i_size_read (file_inode (xf->file)); +}Despite looking over the whole patch for a while I only noticed this one, and I think I could add it in my xfile diet series instea dof open coding it in
trace.h.
Quoted 3 lines
In general it would be really nice to split out patches that add infrastructure in other parts of the XFS codebase to make them stick out a bit more.
<nod>
Quoted 13 lines
Quoted 10 lines
fs/xfs/scrub/xfile.h +10
-0+/* file block (aka system page size) to basic block conversions. */ +typedef unsigned long long xfileoff_t ; +#define XFB_BLOCKSIZE (PAGE_SIZE) +#define XFB_BSHIFT (PAGE_SHIFT) +#define XFB_SHIFT (XFB_BSHIFT - BBSHIFT) + +static inline loff_t xfo_to_b (xfileoff_t xfoff) +{ +return xfoff <<XFB_BSHIFT ; +}...
Quoted 4 lines
xfile.hfeels like the wrong place for this - the encoding only really makes sense fo the xfbtree. And in a way it feels redundant over just usingpgoff_tand the PAGE_* constants directly which should be pretty obvious to everyone knowning the Linux MM and page cache APIs.
Especially if it ends up in the xfs_btree stub object that you were talking about above. Just be careful not to make the userspace xfile.c and xfbtree.c too weird -- some of the quirky apis here are a result of me trying to keep things similar between kernel and xfsprogs.
(and the userspace xfile is weird because we're constrained by the size of the fd table and hence have to partition memfds)
Quoted 11 lines
fs/xfs/xfs_buf.c xfs_verify_magic16( · line 2507
Quoted 7 lines
fs/xfs/xfs_buf.c +7
-0+/* Return the number of sectors for a buffer target. */ +xfs_daddr_t +xfs_buftarg_nr_sectors ( +struct xfs_buftarg *btp) +{ +if (btp->bt_flags &XFS_BUFTARG_XFILE ) +return xfile_buftarg_nr_sectors (btp);If we didn't add an ifdef around the struct xfile definition, this could just be open coded and rely on the compiler eliminating dead code when
XFS_BUFTARG_XFILEisn't defined.
Ok.
--D
Re: [PATCH 8/9] xfs: support in-memory btrees
Quoted 10 lines · Darrick J. Wong
Quoted 8 lines
Btw, one thing I noticed is that we have a lot of confusion on what part of the bc_ino/ag/mem union is used for a given btree. For On-disk inodes we abuse the long ptrs flag, and then we through in the xfile flags. If you're fine with it I can try to sort it out. It's not really a blocker, but I think it would be a lot claner if we used the chance to sort it out. This will become even more important with the rt rmap/reflink trees that will further increase the confusion here.
Go for it! :)
Happy to do it you don't complain about all the rebase pain it'll cause..
Quoted 6 lines
Quoted 4 lines
That means
xfs_btree.ccan use the target from it, and the owner and we can remove the indirect calls for calculcating maxrecs/minrecs, and then also add a field for the block size like this one and remove a lof of theXFS_BTREE_IN_XFILEchecks.Sounds like a good idea.
Same here.
Quoted 12 lines
Quoted 11 lines
fs/xfs/libxfs/xfs_btree.c xfs_btree_readahead_lblock( · line 999
Quoted 6 lines
fs/xfs/libxfs/xfs_btree.c +3
-0+if (cur->bc_flags &XFS_BTREE_IN_XFILE ) +return 0 ; +if ((lr &XFS_BTCUR_LEFTRA ) && left !=NULLFSBLOCK ) { xfs_btree_reada_bufl(cur->bc_mp, left, 1,Should the xfile check go into
xfs_buf_readaheadinstead? That would execute a little more useles code for in-memory btrees, but keep this check in one place (where we could also write a nice comment explaining it :))
Quoted 3 lines
Sure, why not? It's too bad that readahead to an xfile can't asynchronously call
xfile_get_page; maybe we wouldn't need so much caching.
Actualy page lookup or allocation never is async, so this would only be about reading swap from disk. And given what a mess the swap code is I don't think we'll have an async read for that any time soon.
Re: [PATCH 8/9] xfs: support in-memory btrees
Quoted 10 lines · Christoph Hellwig
Quoted 9 lines · Darrick J. Wong
Quoted 8 lines
Btw, one thing I noticed is that we have a lot of confusion on what part of the bc_ino/ag/mem union is used for a given btree. For On-disk inodes we abuse the long ptrs flag, and then we through in the xfile flags. If you're fine with it I can try to sort it out. It's not really a blocker, but I think it would be a lot claner if we used the chance to sort it out. This will become even more important with the rt rmap/reflink trees that will further increase the confusion here.
Quoted 4 lines
Quoted 1 line
Go for it! :)
Happy to do it you don't complain about all the rebase pain it'll cause..
You might want to wait a bit for my XFS_BTREE_ -> XFS_BTGEO_ change to finish testing so I can repost. That alone will cause a fair amount of rebasing.
Quoted 21 lines
Quoted 6 lines
Quoted 4 lines
That means
xfs_btree.ccan use the target from it, and the owner and we can remove the indirect calls for calculcating maxrecs/minrecs, and then also add a field for the block size like this one and remove a lof of theXFS_BTREE_IN_XFILEchecks.Sounds like a good idea.
Same here.
Quoted 12 lines
Quoted 11 lines
fs/xfs/libxfs/xfs_btree.c xfs_btree_readahead_lblock( · line 999
Quoted 6 lines
fs/xfs/libxfs/xfs_btree.c +3
-0+if (cur->bc_flags &XFS_BTREE_IN_XFILE ) +return 0 ; +if ((lr &XFS_BTCUR_LEFTRA ) && left !=NULLFSBLOCK ) { xfs_btree_reada_bufl(cur->bc_mp, left, 1,Should the xfile check go into
xfs_buf_readaheadinstead? That would execute a little more useles code for in-memory btrees, but keep this check in one place (where we could also write a nice comment explaining it :))
Quoted 7 lines
Quoted 3 lines
Sure, why not? It's too bad that readahead to an xfile can't asynchronously call
xfile_get_page; maybe we wouldn't need so much caching.Actualy page lookup or allocation never is async, so this would only be about reading swap from disk. And given what a mess the swap code is I don't think we'll have an async read for that any time soon.
Yeah, I was afraid you were gonna say that. :(
--D
Re: [PATCH 8/9] xfs: support in-memory btrees
Quoted 6 lines · Darrick J. Wong
Quoted 2 lines
Happy to do it you don't complain about all the rebase pain it'll cause..
You might want to wait a bit for my
XFS_BTREE_->XFS_BTGEO_change to finish testing so I can repost. That alone will cause a fair amount of rebasing.
Good idea.
PATCH 9/9 xfs: connect in-memory btrees to xfiles
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Add to our stubbed-out in-memory btrees the ability to connect them with an actual in-memory backing file (aka xfiles) and the necessary pieces to track free space in the xfile and flush dirty xfbtree buffers on demand, which we'll need for online repair.
--- fs/xfs/libxfs/xfs_btree_mem.h | 41 +++ fs/xfs/scrub/bitmap.c | 28 ++ fs/xfs/scrub/bitmap.h | 3 fs/xfs/scrub/scrub.c | 5 fs/xfs/scrub/scrub.h | 3 fs/xfs/scrub/trace.c | 11 + fs/xfs/scrub/trace.h | 109 +++++++++ fs/xfs/scrub/xfbtree.c | 487 +++++++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/xfbtree.h | 31 +++ fs/xfs/scrub/xfile.c | 83 +++++++ fs/xfs/scrub/xfile.h | 2 fs/xfs/xfs_trace.h | 1 fs/xfs/xfs_trans.h | 1 fs/xfs/xfs_trans_buf.c | 42 ++++ 14 files changed, 845 insertions(+), 2 deletions(-)
fs/xfs/libxfs/xfs_btree_mem.h +41 -0
@@ -8,6 +8,26 @@struct xfbtree ; +struct xfbtree_config { +/* Buffer ops for the btree root block */ +const struct xfs_btree_ops *btree_ops; + +/* Buffer target for the xfile backing this btree. */ +struct xfs_buftarg *target; + +/* Owner of this btree. */ +unsigned long long owner; + +/* Btree type number */ +xfs_btnum_t btnum; + +/* XFBTREE_CREATE_* flags */ +unsigned int flags; +}; + +/* btree has long pointers */ +#define XFBTREE_CREATE_LONG_PTRS (1U << 0) +#ifdef CONFIG_XFS_BTREE_IN_XFILE unsigned int xfs_btree_mem_head_nlevels (struct xfs_buf *head_bp);
@@ -35,6 +55,16 @@ xfs_failaddr_t xfbtree_lblock_verify(struct xfs_buf *bp, unsigned int max_recs);xfs_failaddr_t xfbtree_sblock_verify (struct xfs_buf *bp,unsigned int max_recs);unsigned long long xfbtree_buf_to_xfoff (struct xfs_btree_cur *cur,struct xfs_buf *bp); + +int xfbtree_get_minrecs (struct xfs_btree_cur *cur,int level); +int xfbtree_get_maxrecs (struct xfs_btree_cur *cur,int level); + +int xfbtree_create (struct xfs_mount *mp,const struct xfbtree_config *cfg, +struct xfbtree **xfbtreep); +int xfbtree_alloc_block (struct xfs_btree_cur *cur, +const union xfs_btree_ptr *start,union xfs_btree_ptr *ptr, +int *stat); +int xfbtree_free_block (struct xfs_btree_cur *cur,struct xfs_buf *bp);#else static inline unsigned int xfs_btree_mem_head_nlevels (struct xfs_buf *head_bp) {
@@ -77,11 +107,22 @@ static inline unsigned int xfbtree_bbsize(void)#define xfbtree_set_root NULL#define xfbtree_init_ptr_from_cur NULL#define xfbtree_dup_cursor NULL +#define xfbtree_get_minrecs NULL +#define xfbtree_get_maxrecs NULL +#define xfbtree_alloc_block NULL +#define xfbtree_free_block NULL#define xfbtree_verify_xfileoff (cur, xfoff) (false)#define xfbtree_check_block_owner (cur, block) NULL#define xfbtree_owner (cur) (0ULL)#define xfbtree_buf_to_xfoff (cur, bp) (-1) +static inline int +xfbtree_create (struct xfs_mount *mp,const struct xfbtree_config *cfg, +struct xfbtree **xfbtreep) +{ +return -EOPNOTSUPP ; +} +#endif /* CONFIG_XFS_BTREE_IN_XFILE */ #endif /* __XFS_BTREE_MEM_H__ */
fs/xfs/scrub/bitmap.c +28 -0
@@ -293,6 +293,34 @@ xbitmap64_test(return false; } +/* +* Find the first set bit in this bitmap, clear it, and return the index of +* that bit in @valp. Returns -ENODATA if no bits were set, or the usual +* negative errno. +*/ +int +xbitmap64_take_first_set ( +struct xbitmap64 *bitmap, +uint64_t start, +uint64_t last, +uint64_t *valp) +{ +struct xbitmap64_node *bn; +uint64_t val; +int error; + + bn =xbitmap64_tree_iter_first (&bitmap->xb_root, start, last); +if (!bn) +return -ENODATA ; + + val = bn->bn_start; + error =xbitmap64_clear (bitmap, bn->bn_start,1 ); +if (error) +return error; + *valp = val; +return 0 ; +} +/* u32 bitmap */ struct xbitmap32_node {
fs/xfs/scrub/bitmap.h +3 -0
@@ -34,6 +34,9 @@ int xbitmap64_walk(struct xbitmap64 *bitmap, xbitmap64_walk_fn fn,bool xbitmap64_empty (struct xbitmap64 *bitmap);bool xbitmap64_test (struct xbitmap64 *bitmap,uint64_t start,uint64_t *len); +int xbitmap64_take_first_set (struct xbitmap64 *bitmap,uint64_t start, +uint64_t last,uint64_t *valp); +/* u32 bitmap */ struct xbitmap32 {
fs/xfs/scrub/scrub.c +5 -0
@@ -15,6 +15,7 @@#include "xfs_quota.h" #include "xfs_qm.h" #include "xfs_scrub.h" +#include "xfs_buf_xfile.h" #include "scrub/scrub.h" #include "scrub/common.h" #include "scrub/trace.h"
@@ -190,6 +191,10 @@ xchk_teardown( sc->flags &= ~XCHK_HAVE_FREEZE_PROT ;mnt_drop_write_file (sc->file); } +if (sc->xfile_buftarg) { +xfile_free_buftarg (sc->xfile_buftarg); + sc->xfile_buftarg =NULL ; + }if (sc->xfile) {xfile_destroy (sc->xfile); sc->xfile =NULL ;
fs/xfs/scrub/scrub.h +3 -0
@@ -99,6 +99,9 @@ struct xfs_scrub {/* xfile used by the scrubbers; freed at teardown. */ struct xfile *xfile; +/* buffer target for the xfile; also freed at teardown. */ +struct xfs_buftarg *xfile_buftarg; +/* Lock flags for @ip. */ uint ilock_flags;
fs/xfs/scrub/trace.c +11 -0
@@ -12,6 +12,7 @@#include "xfs_mount.h" #include "xfs_inode.h" #include "xfs_btree.h" +#include "xfs_btree_mem.h" #include "xfs_ag.h" #include "xfs_rtbitmap.h" #include "xfs_quota.h"
@@ -25,6 +26,7 @@#include "scrub/iscan.h" #include "scrub/nlinks.h" #include "scrub/fscounters.h" +#include "scrub/xfbtree.h" /* Figure out which block the btree cursor was pointing to. */ static inline xfs_fsblock_t
@@ -43,6 +45,15 @@ xchk_btree_cur_fsbno(return NULLFSBLOCK ; } +#ifdef CONFIG_XFS_BTREE_IN_XFILE +static inline unsigned long +xfbtree_ino ( +struct xfbtree *xfbt) +{ +return file_inode (xfbt->target->bt_xfile->file)->i_ino; +} +#endif /* CONFIG_XFS_BTREE_IN_XFILE */ +/* * We include this last to have the helpers above available for the trace * event implementations.
fs/xfs/scrub/trace.h +109 -0
129 lines not on this page · raw message
fs/xfs/scrub/xfbtree.c +486 -1
512 lines not on this page · raw message
fs/xfs/scrub/xfbtree.h +30 -1
@@ -8,6 +8,8 @@ #ifdef CONFIG_XFS_BTREE_IN_XFILE +#include "scrub/bitmap.h" + /* Root block for an in-memory btree. */ struct xfs_btree_mem_head { __be32 mh_magic;
@@ -21,14 +23,41 @@ struct xfs_btree_mem_head {/* xfile-backed in-memory btrees */ +struct xfboff_bitmap { +struct xbitmap64 xfoffbitmap; +}; +struct xfbtree { -/* buffer cache target for this in-memory btree */ +/* buffer cache target for the xfile backing this in-memory btree */ struct xfs_buftarg *target; +/* Bitmap of free space from pos to used */ +struct xfboff_bitmap freespace; + +/* Highest xfile offset that has been written to. */ +xfileoff_t highest_offset; +/* Owner of this btree. */ unsigned long long owner; + +/* Minimum and maximum records per block. */ +unsigned int maxrecs[2 ]; +unsigned int minrecs[2 ]; }; +/* The head of the in-memory btree is always at block 0 */ +#define XFBTREE_HEAD_BLOCK 0 + +/* in-memory btrees are always created with an empty leaf block at block 1 */ +#define XFBTREE_INIT_LEAF_BLOCK 1 + +int xfbtree_head_read_buf (struct xfbtree *xfbt,struct xfs_trans *tp, +struct xfs_buf **bpp); + +void xfbtree_destroy (struct xfbtree *xfbt); +int xfbtree_trans_commit (struct xfbtree *xfbt,struct xfs_trans *tp); +void xfbtree_trans_cancel (struct xfbtree *xfbt,struct xfs_trans *tp); +#endif /* CONFIG_XFS_BTREE_IN_XFILE */ #endif /* XFS_SCRUB_XFBTREE_H__ */
fs/xfs/scrub/xfile.c +83 -0
89 lines not on this page · raw message
fs/xfs/scrub/xfile.h +2 -0
@@ -64,6 +64,8 @@ xfile_obj_store(struct xfile *xf, const void *buf, size_t count, loff_t pos)return 0 ; } +void xfile_discard (struct xfile *xf,loff_t pos,u64 count); +int xfile_prealloc (struct xfile *xf,loff_t pos,u64 count);loff_t xfile_seek_data (struct xfile *xf,loff_t pos);struct xfile_stat {
fs/xfs/xfs_trace.h +1 -0
@@ -637,6 +637,7 @@ DEFINE_BUF_ITEM_EVENT(xfs_trans_read_buf);DEFINE_BUF_ITEM_EVENT (xfs_trans_read_buf_recur);DEFINE_BUF_ITEM_EVENT (xfs_trans_log_buf);DEFINE_BUF_ITEM_EVENT (xfs_trans_brelse); +DEFINE_BUF_ITEM_EVENT (xfs_trans_bdetach);DEFINE_BUF_ITEM_EVENT (xfs_trans_bjoin);DEFINE_BUF_ITEM_EVENT (xfs_trans_bhold);DEFINE_BUF_ITEM_EVENT (xfs_trans_bhold_release);
fs/xfs/xfs_trans.h +1 -0
@@ -215,6 +215,7 @@ struct xfs_buf *xfs_trans_getsb(struct xfs_trans *);void xfs_trans_brelse (xfs_trans_t *,struct xfs_buf *);void xfs_trans_bjoin (xfs_trans_t *,struct xfs_buf *); +void xfs_trans_bdetach (struct xfs_trans *tp,struct xfs_buf *bp);void xfs_trans_bhold (xfs_trans_t *,struct xfs_buf *);void xfs_trans_bhold_release (xfs_trans_t *,struct xfs_buf *);void xfs_trans_binval (xfs_trans_t *,struct xfs_buf *);
fs/xfs/xfs_trans_buf.c +42 -0
48 lines not on this page · raw message
Re: [PATCH 9/9] xfs: connect in-memory btrees to xfiles
Quoted 42 lines · Darrick J. Wong
fs/xfs/scrub/xfile.c +42
-0+/* Ensure that there is storage backing the given range. */ +int +xfile_prealloc ( +struct xfile *xf, +loff_t pos, +u64 count) +{ +struct inode *inode =file_inode (xf->file); +struct address_space *mapping = inode->i_mapping; +const struct address_space_operations *aops = mapping->a_ops; +struct page *page =NULL ; +unsigned int pflags; +int error =0 ; + +if (count >MAX_RW_COUNT ) +return -E2BIG ; +if (inode->i_sb->s_maxbytes - pos < count) +return -EFBIG ; + +trace_xfile_prealloc (xf, pos, count); + + pflags =memalloc_nofs_save (); +while (count >0 ) { +void *fsdata =NULL ; +unsigned int len; +int ret; + + len =min_t (ssize_t, count,PAGE_SIZE -offset_in_page (pos)); + +/* +* We call write_begin directly here to avoid all the freezer +* protection lock-taking that happens in the normal path. +* shmem doesn't support fs freeze, but lockdep doesn't know +* that and will trip over that. +*/ + error = aops->write_begin (NULL , mapping, pos, len, &page, + &fsdata); +if (error) +break ; + +/* +* xfile pages must never be mapped into userspace, so we skip
fs/xfs/scrub/xfile.c xfile_pwrite( · line 343
Quoted 10 lines
fs/xfs/scrub/xfile.c +10
-0+* the dcache flush. If the page is not uptodate, zero it to +* ensure we never go lacking for space here. +*/ +if (!PageUptodate (page)) { +void *kaddr =kmap_local_page (page); + +memset (kaddr,0 ,PAGE_SIZE ); +SetPageUptodate (page); +kunmap_local (kaddr); + }
Does the xfiles implementation prevent THPs from being created? If not, this could lead to an entire THP being marked uptodate even though we've only zeroed one page of it.
Re: [PATCH 9/9] xfs: connect in-memory btrees to xfiles
Quoted 49 lines · Matthew Wilcox
Quoted 48 lines · Darrick J. Wong
fs/xfs/scrub/xfile.c +48
-0+/* Ensure that there is storage backing the given range. */ +int +xfile_prealloc ( +struct xfile *xf, +loff_t pos, +u64 count) +{ +struct inode *inode =file_inode (xf->file); +struct address_space *mapping = inode->i_mapping; +const struct address_space_operations *aops = mapping->a_ops; +struct page *page =NULL ; +unsigned int pflags; +int error =0 ; + +if (count >MAX_RW_COUNT ) +return -E2BIG ; +if (inode->i_sb->s_maxbytes - pos < count) +return -EFBIG ; + +trace_xfile_prealloc (xf, pos, count); + + pflags =memalloc_nofs_save (); +while (count >0 ) { +void *fsdata =NULL ; +unsigned int len; +int ret; + + len =min_t (ssize_t, count,PAGE_SIZE -offset_in_page (pos)); + +/* +* We call write_begin directly here to avoid all the freezer +* protection lock-taking that happens in the normal path. +* shmem doesn't support fs freeze, but lockdep doesn't know +* that and will trip over that. +*/ + error = aops->write_begin (NULL , mapping, pos, len, &page, + &fsdata); +if (error) +break ; + +/* +* xfile pages must never be mapped into userspace, so we skip +* the dcache flush. If the page is not uptodate, zero it to +* ensure we never go lacking for space here. +*/ +if (!PageUptodate (page)) { +void *kaddr =kmap_local_page (page); +
Quoted 8 lines
fs/xfs/scrub/xfile.c xfile_pwrite( · line 343
Quoted 4 lines
fs/xfs/scrub/xfile.c +4
-0+memset (kaddr,0 ,PAGE_SIZE ); +SetPageUptodate (page); +kunmap_local (kaddr); + }Does the xfiles implementation prevent THPs from being created? If not, this could lead to an entire THP being marked uptodate even though we've only zeroed one page of it.
No. How does one prevent THPs from being created for a specific tmpfs file? It's probably time you and I burned a 1x1 on straightening out some of xfile.c's folio-idiocy. ;)
--D
Re: [PATCH 9/9] xfs: connect in-memory btrees to xfiles
In reply to Darrick J. WongQuoted 6 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Add to our stubbed-out in-memory btrees the ability to connect them with an actual in-memory backing file (aka xfiles) and the necessary pieces to track free space in the xfile and flush dirty xfbtree buffers on demand, which we'll need for online repair.
I guess this is is split from the last patch because of the size of
the changes? Because it feels they relong belong together. Maybe with
my patches for the diet and splitting out the new helpers outside the btree code these could now become a single commit?
fs/xfs/scrub/trace.c xchk_btree_cur_fsbno( · line 55
Quoted 8 lines
fs/xfs/scrub/trace.c +8
-0+#ifdef CONFIG_XFS_BTREE_IN_XFILE +static inline unsigned long +xfbtree_ino ( +struct xfbtree *xfbt) +{ +return file_inode (xfbt->target->bt_xfile->file)->i_ino; +} +#endif /* CONFIG_XFS_BTREE_IN_XFILE */
This should probably move to xfile.h?
fs/xfs/scrub/xfbtree.c xfbtree_sblock_verify( · line 619
Quoted 5 lines
fs/xfs/scrub/xfbtree.c +5
-0+/* Make sure we actually can write to the block before we return it. */ + pos =xfo_to_b (bt_xfoff); + error =xfile_prealloc (xfbtree_xfile (xfbt), pos,xfo_to_b (1 )); +if (error) +return error;
IFF we stick to always backing the buffers directly by the shmem pages this won't be needed - the btree code does a buf_get right after calling into ->alloc_blocks that will allocate the page.
Quoted 6 lines
fs/xfs/scrub/xfbtree.c +6
-0+int +xfbtree_free_block ( +struct xfs_btree_cur *cur, +struct xfs_buf *bp) +{ +struct xfbtree *xfbt = cur->bc_mem.xfbtree;
fs/xfs/scrub/xfbtree.c xfbtree_sblock_verify( · line 646
Quoted 10 lines
fs/xfs/scrub/xfbtree.c +10
-0+xfileoff_t bt_xfoff, bt_xflen; + +ASSERT (cur->bc_flags &XFS_BTREE_IN_XFILE ); + + bt_xfoff =xfs_daddr_to_xfot (xfs_buf_daddr (bp)); + bt_xflen =xfs_daddr_to_xfot (bp->b_length); + +trace_xfbtree_free_block (xfbt, cur, bt_xfoff); + +return xfboff_bitmap_set (&xfbt->freespace, bt_xfoff, bt_xflen);
Any reason this doesn't actually remove the page from shmem?
fs/xfs/scrub/xfbtree.c xfbtree_sblock_verify( · line 742
Quoted 9 lines
fs/xfs/scrub/xfbtree.c +9
-0+int +xfbtree_trans_commit ( +struct xfbtree *xfbt, +struct xfs_trans *tp) +{ +LIST_HEAD (buffer_list); +struct xfs_log_item *lip, *n; +bool corrupt = false; +bool tp_dirty = false;
Can we have some sort of flag on the xfs_trans structure that marks it as fake for xfbtree, and assert it gets fed here, and add ansother assert it desn't get fed to xfs_trans_commit/cancel?
fs/xfs/scrub/xfile.c xfile_pwrite( · line 290
Quoted 10 lines
fs/xfs/scrub/xfile.c +10
-0+/* Discard pages backing a range of the xfile. */ +void +xfile_discard ( +struct xfile *xf, +loff_t pos, +u64 count) +{ +trace_xfile_discard (xf, pos, count); +shmem_truncate_range (file_inode (xf->file), pos, pos + count -1 ); +}
This doesn't end up being used.
fs/xfs/scrub/xfile.c xfile_pwrite( · line 297
Quoted 6 lines
fs/xfs/scrub/xfile.c +6
-0+/* Ensure that there is storage backing the given range. */ +int +xfile_prealloc ( +struct xfile *xf, +loff_t pos, +u64 count)
If we end up needing this somewhere else in the end (and it really should be a separate patch), we should be able to replace it with a simple xfile_get_page/xfile_put_page pair.
Re: [PATCH 9/9] xfs: connect in-memory btrees to xfiles
Quoted 8 lines · Christoph Hellwig
Quoted 6 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Add to our stubbed-out in-memory btrees the ability to connect them with an actual in-memory backing file (aka xfiles) and the necessary pieces to track free space in the xfile and flush dirty xfbtree buffers on demand, which we'll need for online repair.
Quoted 4 lines
I guess this is is split from the last patch because of the size of
the changes? Because it feels they relong belong together. Maybe with
my patches for the diet and splitting out the new helpers outside the btree code these could now become a single commit?
Yep.
Quoted 11 lines
fs/xfs/scrub/trace.c xchk_btree_cur_fsbno( · line 55
Quoted 8 lines
fs/xfs/scrub/trace.c +8
-0+#ifdef CONFIG_XFS_BTREE_IN_XFILE +static inline unsigned long +xfbtree_ino ( +struct xfbtree *xfbt) +{ +return file_inode (xfbt->target->bt_xfile->file)->i_ino; +} +#endif /* CONFIG_XFS_BTREE_IN_XFILE */ This should probably move to
xfile.h?
Quoted 9 lines
fs/xfs/scrub/xfbtree.c xfbtree_sblock_verify( · line 619
Quoted 5 lines
fs/xfs/scrub/xfbtree.c +5
-0+/* Make sure we actually can write to the block before we return it. */ + pos =xfo_to_b (bt_xfoff); + error =xfile_prealloc (xfbtree_xfile (xfbt), pos,xfo_to_b (1 )); +if (error) +return error;IFF we stick to always backing the buffers directly by the shmem pages this won't be needed - the btree code does a
buf_getright after calling into ->alloc_blocks that will allocate the page.
Yep, that would make things much simpler.
Quoted 10 lines
Quoted 10 lines
fs/xfs/scrub/xfbtree.c +10
-0+int +xfbtree_free_block ( +struct xfs_btree_cur *cur, +struct xfs_buf *bp) +{ +struct xfbtree *xfbt = cur->bc_mem.xfbtree; +xfileoff_t bt_xfoff, bt_xflen; + +ASSERT (cur->bc_flags &XFS_BTREE_IN_XFILE ); +
Quoted 8 lines
fs/xfs/scrub/xfbtree.c xfbtree_sblock_verify( · line 646
Quoted 6 lines
fs/xfs/scrub/xfbtree.c +6
-0+ bt_xfoff =xfs_daddr_to_xfot (xfs_buf_daddr (bp)); + bt_xflen =xfs_daddr_to_xfot (bp->b_length); + +trace_xfbtree_free_block (xfbt, cur, bt_xfoff); + +return xfboff_bitmap_set (&xfbt->freespace, bt_xfoff, bt_xflen);Any reason this doesn't actually remove the page from shmem?
I think I skipped the shmem_truncate_range call because the next btree block allocation will re-use the page immediately.
Quoted 5 lines
Quoted 5 lines
fs/xfs/scrub/xfbtree.c +5
-0+int +xfbtree_trans_commit ( +struct xfbtree *xfbt, +struct xfs_trans *tp) +{
Quoted 8 lines
fs/xfs/scrub/xfbtree.c xfbtree_sblock_verify( · line 742
Quoted 4 lines
fs/xfs/scrub/xfbtree.c +4
-0+LIST_HEAD (buffer_list); +struct xfs_log_item *lip, *n; +bool corrupt = false; +bool tp_dirty = false;Can we have some sort of flag on the
xfs_transstructure that marks it as fake for xfbtree, and assert it gets fed here, and add ansother assert it desn't get fed to xfs_trans_commit/cancel?
Use an "empty" transaction?
Quoted 4 lines
Quoted 4 lines
fs/xfs/scrub/xfile.c +4
-0+/* Discard pages backing a range of the xfile. */ +void +xfile_discard( + struct xfile *xf,
Quoted 8 lines
fs/xfs/scrub/xfile.c xfile_pwrite( · line 290
Quoted 6 lines
fs/xfs/scrub/xfile.c +6
-0+loff_t pos, + u64 count) +{ +trace_xfile_discard (xf ,pos ,count ); +shmem_truncate_range (file_inode (xf->file), pos, pos + count -1 ); +}This doesn't end up being used.
I'll remove it then.
Quoted 10 lines
fs/xfs/scrub/xfile.c xfile_pwrite( · line 297
Quoted 6 lines
fs/xfs/scrub/xfile.c +6
-0+/* Ensure that there is storage backing the given range. */ +int +xfile_prealloc ( +struct xfile *xf, +loff_t pos, +u64 count)If we end up needing this somewhere else in the end (and it really should be a separate patch), we should be able to replace it with a simple xfile_get_page/xfile_put_page pair.
I think the only place it gets used is btree block allocation to make sure a page has been stuffed into the xfile/memfd recently. Probably it could go away since a write failure will be noticed quickly anyway.
--D
Re: [PATCH 9/9] xfs: connect in-memory btrees to xfiles
Quoted 4 lines · Darrick J. Wong
Quoted 1 line
Any reason this doesn't actually remove the page from shmem?
I think I skipped the
shmem_truncate_rangecall because the next btree block allocation will re-use the page immediately.
Maybe add a comment explaining that? Note that shmemfs pages once dirties will keep space allocated for them in memory/swap until explicitly punched out.
PATCH 9/28 xfs: online repair of rmap btrees
In reply to Darrick J. WongHi all,
We have now constructed the four tools that we need to scan the filesystem looking for reverse mappings: an inode scanner, hooks to receive live updates from other writer threads, the ability to construct btrees in memory, and a btree bulk loader.
This series glues those three together, enabling us to scan the filesystem for mappings and keep it up to date while other writers run, and then commit the new btree to disk atomically.
To reduce the size of each patch, the functionality is left disabled until the end of the series and broken up into three patches: one to create the mechanics of scanning the filesystem, a second to transition to in-memory btrees, and a third to set up the live hooks.
If you're going to start using this code, I strongly recommend pulling from my git trees, which are linked below.
This has been running on the djcloud for months with no problems. Enjoy! Comments and questions are, as always, welcome.
--D
kernel git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfs-linux.git/log/?h=repair-rmap-btree
xfsprogs git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfsprogs-dev.git/log/?h=repair-rmap-btree
fstests git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfstests-dev.git/log/?h=repair-rmap-btree
--- fs/xfs/Makefile | 1 fs/xfs/libxfs/xfs_ag.c | 1 fs/xfs/libxfs/xfs_ag.h | 3 fs/xfs/libxfs/xfs_bmap.c | 49 + fs/xfs/libxfs/xfs_bmap.h | 8 fs/xfs/libxfs/xfs_inode_fork.c | 9 fs/xfs/libxfs/xfs_inode_fork.h | 1 fs/xfs/libxfs/xfs_rmap.c | 190 +++- fs/xfs/libxfs/xfs_rmap.h | 30 + fs/xfs/libxfs/xfs_rmap_btree.c | 136 +++ fs/xfs/libxfs/xfs_rmap_btree.h | 9 fs/xfs/scrub/agb_bitmap.h | 5 fs/xfs/scrub/bitmap.c | 14 fs/xfs/scrub/bitmap.h | 2 fs/xfs/scrub/bmap.c | 2 fs/xfs/scrub/common.c | 7 fs/xfs/scrub/common.h | 1 fs/xfs/scrub/newbt.c | 12 fs/xfs/scrub/newbt.h | 7 fs/xfs/scrub/reap.c | 2 fs/xfs/scrub/repair.c | 59 + fs/xfs/scrub/repair.h | 12 fs/xfs/scrub/rmap.c | 11 fs/xfs/scrub/rmap_repair.c | 1726 ++++++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/scrub.c | 6 fs/xfs/scrub/scrub.h | 4 fs/xfs/scrub/trace.c | 1 fs/xfs/scrub/trace.h | 80 ++ 28 files changed, 2319 insertions(+), 69 deletions(-) create mode 100644 fs/xfs/scrub/rmap_repair.c
PATCH 1/4 xfs: create a helper to decide if a file mapping targets the rt volume
From: Darrick J. Wong <[email protected]>
Create a helper so that we can stop open-coding this decision everywhere.
--- fs/xfs/libxfs/xfs_bmap.c | 6 +++--- fs/xfs/libxfs/xfs_inode_fork.c | 9 +++++++++ fs/xfs/libxfs/xfs_inode_fork.h | 1 + fs/xfs/scrub/bmap.c | 2 +- 4 files changed, 14 insertions(+), 4 deletions(-)
fs/xfs/libxfs/xfs_bmap.c +3 -3
@@ -4889,7 +4889,7 @@ xfs_bmap_del_extent_delay(XFS_STATS_INC (mp, xs_del_exlist); - isrt = (whichfork ==XFS_DATA_FORK ) &&XFS_IS_REALTIME_INODE (ip); + isrt =xfs_ifork_is_realtime (ip, whichfork); del_endoff = del->br_startoff + del->br_blockcount; got_endoff = got->br_startoff + got->br_blockcount; da_old =startblockval (got->br_startblock);
@@ -5125,7 +5125,7 @@ xfs_bmap_del_extent_real(return -ENOSPC ; *logflagsp =XFS_ILOG_CORE ; -if (whichfork ==XFS_DATA_FORK &&XFS_IS_REALTIME_INODE (ip)) { +if (xfs_ifork_is_realtime (ip, whichfork)) {if (!(bflags &XFS_BMAPI_REMAP )) { error =xfs_rtfree_blocks (tp, del->br_startblock, del->br_blockcount);
@@ -5372,7 +5372,7 @@ __xfs_bunmapi(return 0 ; }XFS_STATS_INC (mp, xs_blk_unmap); - isrt = (whichfork ==XFS_DATA_FORK ) &&XFS_IS_REALTIME_INODE (ip); + isrt =xfs_ifork_is_realtime (ip, whichfork); end = start + len;if (!xfs_iext_lookup_extent_before (ip, ifp, &end, &icur, &got)) {
fs/xfs/libxfs/xfs_inode_fork.c +9 -0
@@ -820,3 +820,12 @@ xfs_iext_count_upgrade(return 0 ; } + +/* Decide if a file mapping is on the realtime device or not. */ +bool +xfs_ifork_is_realtime ( +struct xfs_inode *ip, +int whichfork) +{ +return XFS_IS_REALTIME_INODE (ip) && whichfork !=XFS_ATTR_FORK ; +}
fs/xfs/libxfs/xfs_inode_fork.h +1 -0
@@ -262,6 +262,7 @@ int xfs_iext_count_may_overflow(struct xfs_inode *ip, int whichfork, int nr_to_add);int xfs_iext_count_upgrade (struct xfs_trans *tp,struct xfs_inode *ip,uint nr_to_add); +bool xfs_ifork_is_realtime (struct xfs_inode *ip,int whichfork);/* returns true if the fork has extents but they are not read in yet. */ static inline bool xfs_need_iread_extents (const struct xfs_ifork *ifp)
fs/xfs/scrub/bmap.c +1 -1
@@ -924,7 +924,7 @@ xchk_bmap(if (!ifp)return -ENOENT ; - info.is_rt = whichfork ==XFS_DATA_FORK &&XFS_IS_REALTIME_INODE (ip); + info.is_rt =xfs_ifork_is_realtime (ip, whichfork); info.whichfork = whichfork; info.is_shared = whichfork ==XFS_DATA_FORK &&xfs_is_reflink_inode (ip); info.sc = sc;
Re: [PATCH 1/4] xfs: create a helper to decide if a file mapping targets the rt volume
Quoted 4 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Create a helper so that we can stop open-coding this decision everywhere.
Looks good:
PATCH 2/4 xfs: repair the rmapbt
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Rebuild the reverse mapping btree from all primary metadata. This first patch establishes the bare mechanics of finding records and putting together a new ondisk tree; more complex pieces are needed to make it work properly.
--- fs/xfs/Makefile | 1 fs/xfs/libxfs/xfs_bmap.c | 43 + fs/xfs/libxfs/xfs_bmap.h | 8 fs/xfs/libxfs/xfs_rmap.c | 12 fs/xfs/libxfs/xfs_rmap.h | 2 fs/xfs/libxfs/xfs_rmap_btree.c | 13 fs/xfs/scrub/agb_bitmap.h | 5 fs/xfs/scrub/bitmap.c | 14 fs/xfs/scrub/bitmap.h | 2 fs/xfs/scrub/common.c | 4 fs/xfs/scrub/common.h | 1 fs/xfs/scrub/newbt.c | 12 fs/xfs/scrub/newbt.h | 7 fs/xfs/scrub/reap.c | 2 fs/xfs/scrub/repair.c | 5 fs/xfs/scrub/repair.h | 6 fs/xfs/scrub/rmap.c | 11 fs/xfs/scrub/rmap_repair.c | 1465 ++++++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/scrub.c | 2 fs/xfs/scrub/trace.h | 33 + 20 files changed, 1628 insertions(+), 20 deletions(-) create mode 100644 fs/xfs/scrub/rmap_repair.c
fs/xfs/Makefile +1 -0
@@ -201,6 +201,7 @@ xfs-y += $(addprefix scrub/, \ reap.o \ refcount_repair.o \ repair.o \ + rmap_repair.o \ xfbtree.o \ )
fs/xfs/libxfs/xfs_bmap.c +43 -0
46 lines not on this page · raw message
fs/xfs/libxfs/xfs_bmap.h +8 -0
@@ -278,4 +278,12 @@ extern struct kmem_cache *xfs_bmap_intent_cache;int __init xfs_bmap_intent_init_cache (void );void xfs_bmap_intent_destroy_cache (void ); +typedef int (*xfs_bmap_query_range_fn )( +struct xfs_btree_cur *cur, +struct xfs_bmbt_irec *rec, +void *priv); + +int xfs_bmap_query_all (struct xfs_btree_cur *cur,xfs_bmap_query_range_fn fn, +void *priv); +#endif /* __XFS_BMAP_H__ */
fs/xfs/libxfs/xfs_rmap.c +6 -6
@@ -215,10 +215,10 @@ xfs_rmap_btrec_to_irec(/* Simple checks for rmap records. */ xfs_failaddr_t xfs_rmap_check_irec ( -struct xfs_btree_cur *cur, +struct xfs_perag *pag,const struct xfs_rmap_irec *irec) { -struct xfs_mount *mp = cur->bc_mp; +struct xfs_mount *mp = pag->pag_mount;bool is_inode;bool is_unwritten;bool is_bmbt;
@@ -233,8 +233,8 @@ xfs_rmap_check_irec(return __this_address; }else {/* check for valid extent range, including overflow */ -if (!xfs_verify_agbext (cur->bc_ag.pag, irec->rm_startblock, - irec->rm_blockcount)) +if (!xfs_verify_agbext (pag, irec->rm_startblock, + irec->rm_blockcount))return __this_address; }
@@ -307,7 +307,7 @@ xfs_rmap_get_rec( fa =xfs_rmap_btrec_to_irec (rec, irec);if (!fa) - fa =xfs_rmap_check_irec (cur, irec); + fa =xfs_rmap_check_irec (cur->bc_ag.pag, irec);if (fa)return xfs_rmap_complain_bad_rec (cur, fa, irec);
@@ -2442,7 +2442,7 @@ xfs_rmap_query_range_helper( fa =xfs_rmap_btrec_to_irec (rec, &irec);if (!fa) - fa =xfs_rmap_check_irec (cur, &irec); + fa =xfs_rmap_check_irec (cur->bc_ag.pag, &irec);if (fa)return xfs_rmap_complain_bad_rec (cur, fa, &irec);
fs/xfs/libxfs/xfs_rmap.h +1 -1
@@ -195,7 +195,7 @@ int xfs_rmap_compare(const struct xfs_rmap_irec *a,union xfs_btree_rec ;xfs_failaddr_t xfs_rmap_btrec_to_irec (const union xfs_btree_rec *rec,struct xfs_rmap_irec *irec); -xfs_failaddr_t xfs_rmap_check_irec (struct xfs_btree_cur *cur, +xfs_failaddr_t xfs_rmap_check_irec (struct xfs_perag *pag,const struct xfs_rmap_irec *irec); int xfs_rmap_has_records(struct xfs_btree_cur *cur, xfs_agblock_t bno,
fs/xfs/libxfs/xfs_rmap_btree.c +12 -1
@@ -342,7 +342,18 @@ xfs_rmapbt_verify( level =be16_to_cpu (block->bb_level);if (pag &&xfs_perag_initialised_agf (pag)) { -if (level >= pag->pagf_levels[XFS_BTNUM_RMAPi]) +unsigned int maxlevel = pag->pagf_levels[XFS_BTNUM_RMAPi]; + +#ifdef CONFIG_XFS_ONLINE_REPAIR +/* +* Online repair could be rewriting the free space btrees, so +* we'll validate against the larger of either tree while this +* is going on. +*/ + maxlevel = max_t(unsigned int, maxlevel, + pag->pagf_repair_levels[XFS_BTNUM_RMAPi]); +#endif +if (level >= maxlevel)return __this_address; }else if (level >= mp->m_rmap_maxlevels)return __this_address;
fs/xfs/scrub/agb_bitmap.h +5 -0
@@ -65,4 +65,9 @@ int xagb_bitmap_set_btblocks(struct xagb_bitmap *bitmap,int xagb_bitmap_set_btcur_path (struct xagb_bitmap *bitmap,struct xfs_btree_cur *cur); +static inline uint32_t xagb_bitmap_count_set_regions (struct xagb_bitmap *b) +{ +return xbitmap32_count_set_regions (&b->agbitmap); +} +#endif /* __XFS_SCRUB_AGB_BITMAP_H__ */
fs/xfs/scrub/bitmap.c +14 -0
@@ -594,3 +594,17 @@ xbitmap32_test( *len = bn->bn_start - start;return false; } + +/* Count the number of set regions in this bitmap. */ +uint32_t +xbitmap32_count_set_regions ( +struct xbitmap32 *bitmap) +{ +struct xbitmap32_node *bn; +uint32_t nr =0 ; + +for_each_xbitmap32_extent (bn, bitmap) + nr++; + +return nr; +}
fs/xfs/scrub/bitmap.h +2 -0
@@ -65,4 +65,6 @@ int xbitmap32_walk(struct xbitmap32 *bitmap, xbitmap32_walk_fn fn,bool xbitmap32_empty (struct xbitmap32 *bitmap);bool xbitmap32_test (struct xbitmap32 *bitmap,uint32_t start,uint32_t *len); +uint32_t xbitmap32_count_set_regions (struct xbitmap32 *bitmap); +#endif /* __XFS_SCRUB_BITMAP_H__ */
fs/xfs/scrub/common.c +2 -2
@@ -460,7 +460,7 @@ xchk_perag_read_headers(* Grab the AG headers for the attached perag structure and wait for pending * intents to drain. */ -static int +int xchk_perag_drain_and_lock (struct xfs_scrub *sc) {
@@ -712,7 +712,7 @@ xchk_trans_alloc(return xfs_trans_alloc (sc->mp, &M_RES (sc->mp)->tr_itruncate, resblks,0 ,0 , &sc->tp); -return xfs_trans_alloc_empty (sc->mp, &sc->tp); +return xchk_trans_alloc_empty (sc); }/* Set us up with a transaction and an empty context. */
fs/xfs/scrub/common.h +1 -0
@@ -134,6 +134,7 @@ int xchk_setup_nlinks(struct xfs_scrub *sc);void xchk_ag_free (struct xfs_scrub *sc,struct xchk_ag *sa);int xchk_ag_init (struct xfs_scrub *sc,xfs_agnumber_t agno,struct xchk_ag *sa); +int xchk_perag_drain_and_lock (struct xfs_scrub *sc);/* * Grab all AG resources, treating the inability to grab the perag structure as
fs/xfs/scrub/newbt.c +10 -2
@@ -239,7 +239,11 @@ xrep_newbt_alloc_ag_blocks(xrep_newbt_validate_ag_alloc_hint (xnr); - error =xfs_alloc_vextent_near_bno (&args, xnr->alloc_hint); +if (xnr->alloc_vextent) + error = xnr->alloc_vextent (sc, &args, xnr->alloc_hint); +else + error =xfs_alloc_vextent_near_bno (&args, + xnr->alloc_hint);if (error)return error;if (args.fsbno ==NULLFSBLOCK )
@@ -309,7 +313,11 @@ xrep_newbt_alloc_file_blocks(xrep_newbt_validate_file_alloc_hint (xnr); - error =xfs_alloc_vextent_start_ag (&args, xnr->alloc_hint); +if (xnr->alloc_vextent) + error = xnr->alloc_vextent (sc, &args, xnr->alloc_hint); +else + error =xfs_alloc_vextent_start_ag (&args, + xnr->alloc_hint);if (error)return error;if (args.fsbno ==NULLFSBLOCK )
fs/xfs/scrub/newbt.h +7 -0
@@ -6,6 +6,8 @@ #ifndef __XFS_SCRUB_NEWBT_H__ #define __XFS_SCRUB_NEWBT_H__ +struct xfs_alloc_arg; + struct xrep_newbt_resv { /* Link to list of extents that we've reserved. */ struct list_head list;
@@ -28,6 +30,11 @@ struct xrep_newbt_resv {struct xrep_newbt {struct xfs_scrub *sc; +/* Custom allocation function, or NULL for xfs_alloc_vextent */ +int (*alloc_vextent)(struct xfs_scrub *sc, +struct xfs_alloc_arg *args, +xfs_fsblock_t alloc_hint); +/* List of extents that we've reserved. */ struct list_head resv_list;
fs/xfs/scrub/reap.c +1 -1
@@ -114,7 +114,7 @@ xreap_put_freelist(int error;/* Make sure there's space on the freelist. */ - error =xrep_fix_freelist (sc, true); + error =xrep_fix_freelist (sc,0 );if (error)return error;
fs/xfs/scrub/repair.c +2 -3
@@ -401,7 +401,7 @@ xrep_calc_ag_resblks(int xrep_fix_freelist (struct xfs_scrub *sc, -bool can_shrink) +int alloc_flags) {struct xfs_alloc_arg args = {0 };
@@ -411,8 +411,7 @@ xrep_fix_freelist( args.alignment =1 ; args.pag = sc->sa.pag; -return xfs_alloc_fix_freelist (&args, - can_shrink ?0 :XFS_ALLOC_FLAG_NOSHRINK ); +return xfs_alloc_fix_freelist (&args, alloc_flags); }/*
fs/xfs/scrub/repair.h +5 -1
@@ -51,7 +51,7 @@ struct xbitmap;struct xagb_bitmap ;struct xfsb_bitmap ; -int xrep_fix_freelist (struct xfs_scrub *sc,bool can_shrink); +int xrep_fix_freelist (struct xfs_scrub *sc,int alloc_flags);struct xrep_find_ag_btree {/* in: rmap owner of the btree we're looking for */
@@ -86,6 +86,7 @@ int xrep_ino_ensure_extent_count(struct xfs_scrub *sc, int whichfork,int xrep_reset_perag_resv (struct xfs_scrub *sc);int xrep_bmap (struct xfs_scrub *sc,int whichfork,bool allow_unwritten);int xrep_metadata_inode_forks (struct xfs_scrub *sc); +int xrep_setup_ag_rmapbt (struct xfs_scrub *sc);/* Repair setup functions */ int xrep_setup_ag_allocbt (struct xfs_scrub *sc);
@@ -111,6 +112,7 @@ int xrep_agfl(struct xfs_scrub *sc);int xrep_agi (struct xfs_scrub *sc);int xrep_allocbt (struct xfs_scrub *sc);int xrep_iallocbt (struct xfs_scrub *sc); +int xrep_rmapbt (struct xfs_scrub *sc);int xrep_refcountbt (struct xfs_scrub *sc);int xrep_inode (struct xfs_scrub *sc);int xrep_bmap_data (struct xfs_scrub *sc);
@@ -177,6 +179,7 @@ xrep_setup_nothing(return 0 ; }#define xrep_setup_ag_allocbt xrep_setup_nothing +#define xrep_setup_ag_rmapbt xrep_setup_nothing#define xrep_setup_inode (sc, imap) ((void)0)
@@ -190,6 +193,7 @@ xrep_setup_nothing(#define xrep_agi xrep_notsupported#define xrep_allocbt xrep_notsupported#define xrep_iallocbt xrep_notsupported +#define xrep_rmapbt xrep_notsupported#define xrep_refcountbt xrep_notsupported#define xrep_inode xrep_notsupported#define xrep_bmap_data xrep_notsupported
fs/xfs/scrub/rmap.c +10 -1
@@ -25,6 +25,7 @@#include "scrub/btree.h" #include "scrub/bitmap.h" #include "scrub/agb_bitmap.h" +#include "scrub/repair.h" /* * Set us up to scrub reverse mapping btrees.
@@ -36,6 +37,14 @@ xchk_setup_ag_rmapbt(if (xchk_need_intent_drain (sc))xchk_fsgates_enable (sc,XCHK_FSGATES_DRAIN ); +if (xchk_could_repair (sc)) { +int error; + + error =xrep_setup_ag_rmapbt (sc); +if (error) +return error; + } +return xchk_setup_ag_btree (sc, false); }
@@ -349,7 +358,7 @@ xchk_rmapbt_rec(struct xfs_rmap_irec irec;if (xfs_rmap_btrec_to_irec (rec, &irec) !=NULL || -xfs_rmap_check_irec (bs->cur, &irec) !=NULL ) { +xfs_rmap_check_irec (bs->cur->bc_ag.pag, &irec) !=NULL ) {xchk_btree_set_corrupt (bs->sc, bs->cur,0 );return 0 ; }
fs/xfs/scrub/rmap_repair.c new file +1465 -0
1,465 lines not on this page · raw message
fs/xfs/scrub/scrub.c +1 -1
@@ -278,7 +278,7 @@ static const struct xchk_meta_ops meta_scrub_ops[] = { .setup = xchk_setup_ag_rmapbt, .scrub = xchk_rmapbt, .has = xfs_has_rmapbt, - .repair = xrep_notsupported, + .repair = xrep_rmapbt, }, [XFS_SCRUB_TYPE_REFCNTBT] = { /* refcountbt */ .type = ST_PERAG,
fs/xfs/scrub/trace.h +32 -1
@@ -1580,7 +1580,6 @@ DEFINE_EVENT(xrep_rmap_class, name, \ uint64_t owner, uint64_t offset, unsigned int flags), \ TP_ARGS(mp, agno, agbno, len, owner, offset, flags)) DEFINE_REPAIR_RMAP_EVENT(xrep_ibt_walk_rmap); -DEFINE_REPAIR_RMAP_EVENT (xrep_rmap_extent_fn);DEFINE_REPAIR_RMAP_EVENT (xrep_bmap_walk_rmap); TRACE_EVENT(xrep_abt_found,
@@ -1698,6 +1697,38 @@ TRACE_EVENT(xrep_bmap_found, __entry->state) ); +TRACE_EVENT (xrep_rmap_found, + TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, + const struct xfs_rmap_irec *rec), +TP_ARGS (mp, agno, rec), +TP_STRUCT__entry ( + __field(dev_t, dev) + __field(xfs_agnumber_t, agno) + __field(xfs_agblock_t, agbno) + __field(xfs_extlen_t, len) + __field(uint64_t, owner) + __field(uint64_t, offset) + __field(unsigned int, flags) + ), +TP_fast_assign ( + __entry->dev = mp->m_super->s_dev; + __entry->agno = agno; + __entry->agbno = rec->rm_startblock; + __entry->len = rec->rm_blockcount; + __entry->owner = rec->rm_owner; + __entry->offset = rec->rm_offset; + __entry->flags = rec->rm_flags; + ), +TP_printk ("dev %d:%d agno 0x%x agbno 0x%x fsbcount 0x%x owner 0x%llx fileoff 0x%llx flags 0x%x" , +MAJOR (__entry->dev),MINOR (__entry->dev), + __entry->agno, + __entry->agbno, + __entry->len, + __entry->owner, + __entry->offset, + __entry->flags) +); + TRACE_EVENT(xrep_findroot_block, TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, xfs_agblock_t agbno, uint32_t magic, uint16_t level),
PATCH 3/4 xfs: create a shadow rmap btree during rmap repair
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Create an in-memory btree of rmap records instead of an array. This enables us to do live record collection instead of freezing the fs.
--- fs/xfs/libxfs/xfs_rmap.c | 37 ++++-- fs/xfs/libxfs/xfs_rmap_btree.c | 123 +++++++++++++++++++ fs/xfs/libxfs/xfs_rmap_btree.h | 9 + fs/xfs/scrub/repair.c | 18 +++ fs/xfs/scrub/repair.h | 2 fs/xfs/scrub/rmap_repair.c | 258 +++++++++++++++++++++++++++++----------- 6 files changed, 365 insertions(+), 82 deletions(-)
fs/xfs/libxfs/xfs_rmap.c +24 -13
@@ -269,6 +269,16 @@ xfs_rmap_check_irec(return NULL ; } +static inline xfs_failaddr_t +xfs_rmap_check_btrec ( +struct xfs_btree_cur *cur, +const struct xfs_rmap_irec *irec) +{ +if (cur->bc_flags &XFS_BTREE_IN_XFILE ) +return xfs_rmap_check_irec (cur->bc_mem.pag, irec); +return xfs_rmap_check_irec (cur->bc_ag.pag, irec); +} + static inline int xfs_rmap_complain_bad_rec( struct xfs_btree_cur *cur,
@@ -277,9 +287,13 @@ xfs_rmap_complain_bad_rec( {struct xfs_mount *mp = cur->bc_mp; -xfs_warn (mp, -"Reverse Mapping BTree record corruption in AG %d detected at %pS!" , - cur->bc_ag.pag->pag_agno, fa); +if (cur->bc_flags &XFS_BTREE_IN_XFILE ) +xfs_warn (mp, +"In-Memory Reverse Mapping BTree record corruption detected at %pS!" , fa); +else +xfs_warn (mp, +"Reverse Mapping BTree record corruption in AG %d detected at %pS!" , + cur->bc_ag.pag->pag_agno, fa); xfs_warn(mp, "Owner 0x%llx, flags 0x%x, start block 0x%x block count 0x%x", irec->rm_owner, irec->rm_flags, irec->rm_startblock,
@@ -307,7 +321,7 @@ xfs_rmap_get_rec( fa =xfs_rmap_btrec_to_irec (rec, irec);if (!fa) - fa =xfs_rmap_check_irec (cur->bc_ag.pag, irec); + fa =xfs_rmap_check_btrec (cur, irec);if (fa)return xfs_rmap_complain_bad_rec (cur, fa, irec);
@@ -2404,15 +2418,12 @@ xfs_rmap_map_raw( {struct xfs_owner_info oinfo; - oinfo.oi_owner = rmap->rm_owner; - oinfo.oi_offset = rmap->rm_offset; - oinfo.oi_flags =0 ; -if (rmap->rm_flags &XFS_RMAP_ATTR_FORK ) - oinfo.oi_flags |=XFS_OWNER_INFO_ATTR_FORK ; -if (rmap->rm_flags &XFS_RMAP_BMBT_BLOCK ) - oinfo.oi_flags |=XFS_OWNER_INFO_BMBT_BLOCK ; +xfs_owner_info_pack (&oinfo, rmap->rm_owner, rmap->rm_offset, + rmap->rm_flags); -if (rmap->rm_flags ||XFS_RMAP_NON_INODE_OWNER (rmap->rm_owner)) +if ((rmap->rm_flags & (XFS_RMAP_ATTR_FORK |XFS_RMAP_BMBT_BLOCK | +XFS_RMAP_UNWRITTEN )) || +XFS_RMAP_NON_INODE_OWNER (rmap->rm_owner)) return xfs_rmap_map(cur, rmap->rm_startblock, rmap->rm_blockcount, rmap->rm_flags & XFS_RMAP_UNWRITTEN,
@@ -2442,7 +2453,7 @@ xfs_rmap_query_range_helper( fa =xfs_rmap_btrec_to_irec (rec, &irec);if (!fa) - fa =xfs_rmap_check_irec (cur->bc_ag.pag, &irec); + fa =xfs_rmap_check_btrec (cur, &irec);if (fa)return xfs_rmap_complain_bad_rec (cur, fa, &irec);
fs/xfs/libxfs/xfs_rmap_btree.c +123 -0
135 lines not on this page · raw message
fs/xfs/libxfs/xfs_rmap_btree.h +9 -0
@@ -64,4 +64,13 @@ unsigned int xfs_rmapbt_maxlevels_ondisk(void);int __init xfs_rmapbt_init_cur_cache (void );void xfs_rmapbt_destroy_cur_cache (void ); +#ifdef CONFIG_XFS_BTREE_IN_XFILE +struct xfbtree ; +struct xfs_btree_cur *xfs_rmapbt_mem_cursor (struct xfs_perag *pag, +struct xfs_trans *tp,struct xfs_buf *head_bp, +struct xfbtree *xfbtree); +int xfs_rmapbt_mem_create (struct xfs_mount *mp,xfs_agnumber_t agno, +struct xfs_buftarg *target,struct xfbtree **xfbtreep); +#endif /* CONFIG_XFS_BTREE_IN_XFILE */ +#endif /* __XFS_RMAP_BTREE_H__ */
fs/xfs/scrub/repair.c +18 -0
@@ -31,12 +31,14 @@#include "xfs_error.h" #include "xfs_reflink.h" #include "xfs_health.h" +#include "xfs_buf_xfile.h" #include "scrub/scrub.h" #include "scrub/common.h" #include "scrub/trace.h" #include "scrub/repair.h" #include "scrub/bitmap.h" #include "scrub/stats.h" +#include "scrub/xfile.h" /* * Attempt to repair some metadata, if the metadata is corrupt and userspace
@@ -1147,3 +1149,19 @@ xrep_metadata_inode_forks(return 0 ; } + +/* +* Set up an xfile and a buffer cache so that we can use the xfbtree. Buffer +* target initialization registers a shrinker, so we cannot be in transaction +* context. Park our resources in the scrub context and let the teardown +* function take care of them at the right time. +*/ +int +xrep_setup_buftarg ( +struct xfs_scrub *sc, +const char *descr) +{ +ASSERT (sc->tp ==NULL ); + +return xfile_alloc_buftarg (sc->mp, descr, &sc->xfile_buftarg); +}
fs/xfs/scrub/repair.h +2 -0
@@ -81,6 +81,8 @@ int xrep_ino_dqattach(struct xfs_scrub *sc);# define xrep_ino_dqattach (sc) (0)#endif /* CONFIG_XFS_QUOTA */ +int xrep_setup_buftarg (struct xfs_scrub *sc,const char *descr); +int xrep_ino_ensure_extent_count (struct xfs_scrub *sc,int whichfork,xfs_extnum_t nextents);int xrep_reset_perag_resv (struct xfs_scrub *sc);
fs/xfs/scrub/rmap_repair.c +189 -69
450 lines not on this page · raw message