mirror of
git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
synced 2025-04-13 09:59:31 +00:00
428e488465
When a writer thread executes a chain of log intent items for the realtime volume, the ILOCKs taken during each step are for each rt metadata file, not the entire rt volume itself. Although scrub takes all rt metadata ILOCKs, this isn't sufficient to guard against scrub checking the rt volume while that writer thread is in the middle of finishing a chain because there's no higher level locking primitive guarding the realtime volume. When there's a collision, cross-referencing between data structures (e.g. rtrmapbt and rtrefcountbt) yields false corruption events; if repair is running, this results in incorrect repairs, which is catastrophic. Fix this by adding to the mount structure the same drain that we use to protect scrub against concurrent AG updates, but this time for the realtime volume. Signed-off-by: "Darrick J. Wong" <djwong@kernel.org> Reviewed-by: Christoph Hellwig <hch@lst.de>
152 lines
3.7 KiB
C
152 lines
3.7 KiB
C
// SPDX-License-Identifier: GPL-2.0-or-later
|
|
/*
|
|
* Copyright (C) 2022-2023 Oracle. All Rights Reserved.
|
|
* Author: Darrick J. Wong <djwong@kernel.org>
|
|
*/
|
|
#include "xfs.h"
|
|
#include "xfs_fs.h"
|
|
#include "xfs_shared.h"
|
|
#include "xfs_format.h"
|
|
#include "xfs_trans_resv.h"
|
|
#include "xfs_mount.h"
|
|
#include "xfs_ag.h"
|
|
#include "xfs_trace.h"
|
|
|
|
/*
|
|
* Use a static key here to reduce the overhead of xfs_defer_drain_rele. If
|
|
* the compiler supports jump labels, the static branch will be replaced by a
|
|
* nop sled when there are no xfs_defer_drain_wait callers. Online fsck is
|
|
* currently the only caller, so this is a reasonable tradeoff.
|
|
*
|
|
* Note: Patching the kernel code requires taking the cpu hotplug lock. Other
|
|
* parts of the kernel allocate memory with that lock held, which means that
|
|
* XFS callers cannot hold any locks that might be used by memory reclaim or
|
|
* writeback when calling the static_branch_{inc,dec} functions.
|
|
*/
|
|
static DEFINE_STATIC_KEY_FALSE(xfs_defer_drain_waiter_gate);
|
|
|
|
void
|
|
xfs_defer_drain_wait_disable(void)
|
|
{
|
|
static_branch_dec(&xfs_defer_drain_waiter_gate);
|
|
}
|
|
|
|
void
|
|
xfs_defer_drain_wait_enable(void)
|
|
{
|
|
static_branch_inc(&xfs_defer_drain_waiter_gate);
|
|
}
|
|
|
|
void
|
|
xfs_defer_drain_init(
|
|
struct xfs_defer_drain *dr)
|
|
{
|
|
atomic_set(&dr->dr_count, 0);
|
|
init_waitqueue_head(&dr->dr_waiters);
|
|
}
|
|
|
|
void
|
|
xfs_defer_drain_free(struct xfs_defer_drain *dr)
|
|
{
|
|
ASSERT(atomic_read(&dr->dr_count) == 0);
|
|
}
|
|
|
|
/* Increase the pending intent count. */
|
|
static inline void xfs_defer_drain_grab(struct xfs_defer_drain *dr)
|
|
{
|
|
atomic_inc(&dr->dr_count);
|
|
}
|
|
|
|
static inline bool has_waiters(struct wait_queue_head *wq_head)
|
|
{
|
|
/*
|
|
* This memory barrier is paired with the one in set_current_state on
|
|
* the waiting side.
|
|
*/
|
|
smp_mb__after_atomic();
|
|
return waitqueue_active(wq_head);
|
|
}
|
|
|
|
/* Decrease the pending intent count, and wake any waiters, if appropriate. */
|
|
static inline void xfs_defer_drain_rele(struct xfs_defer_drain *dr)
|
|
{
|
|
if (atomic_dec_and_test(&dr->dr_count) &&
|
|
static_branch_unlikely(&xfs_defer_drain_waiter_gate) &&
|
|
has_waiters(&dr->dr_waiters))
|
|
wake_up(&dr->dr_waiters);
|
|
}
|
|
|
|
/* Are there intents pending? */
|
|
static inline bool xfs_defer_drain_busy(struct xfs_defer_drain *dr)
|
|
{
|
|
return atomic_read(&dr->dr_count) > 0;
|
|
}
|
|
|
|
/*
|
|
* Wait for the pending intent count for a drain to hit zero.
|
|
*
|
|
* Callers must not hold any locks that would prevent intents from being
|
|
* finished.
|
|
*/
|
|
static inline int xfs_defer_drain_wait(struct xfs_defer_drain *dr)
|
|
{
|
|
return wait_event_killable(dr->dr_waiters, !xfs_defer_drain_busy(dr));
|
|
}
|
|
|
|
/*
|
|
* Get a passive reference to the group that contains a fsbno and declare an
|
|
* intent to update its metadata.
|
|
*
|
|
* Other threads that need exclusive access can decide to back off if they see
|
|
* declared intentions.
|
|
*/
|
|
struct xfs_group *
|
|
xfs_group_intent_get(
|
|
struct xfs_mount *mp,
|
|
xfs_fsblock_t fsbno,
|
|
enum xfs_group_type type)
|
|
{
|
|
struct xfs_group *xg;
|
|
|
|
xg = xfs_group_get_by_fsb(mp, fsbno, type);
|
|
if (!xg)
|
|
return NULL;
|
|
trace_xfs_group_intent_hold(xg, __return_address);
|
|
xfs_defer_drain_grab(&xg->xg_intents_drain);
|
|
return xg;
|
|
}
|
|
|
|
/*
|
|
* Release our intent to update this groups metadata, and then release our
|
|
* passive ref to it.
|
|
*/
|
|
void
|
|
xfs_group_intent_put(
|
|
struct xfs_group *xg)
|
|
{
|
|
trace_xfs_group_intent_rele(xg, __return_address);
|
|
xfs_defer_drain_rele(&xg->xg_intents_drain);
|
|
xfs_group_put(xg);
|
|
}
|
|
|
|
/*
|
|
* Wait for the intent update count for this AG to hit zero.
|
|
* Callers must not hold any AG header buffers.
|
|
*/
|
|
int
|
|
xfs_group_intent_drain(
|
|
struct xfs_group *xg)
|
|
{
|
|
trace_xfs_group_wait_intents(xg, __return_address);
|
|
return xfs_defer_drain_wait(&xg->xg_intents_drain);
|
|
}
|
|
|
|
/*
|
|
* Has anyone declared an intent to update this group?
|
|
*/
|
|
bool
|
|
xfs_group_intent_busy(
|
|
struct xfs_group *xg)
|
|
{
|
|
return xfs_defer_drain_busy(&xg->xg_intents_drain);
|
|
}
|