Commit 21d75009 authored by Darrick J. Wong's avatar Darrick J. Wong
Browse files

xfs: improve dquot iteration for scrub 



Upon a closer inspection of the quota record scrubber, I noticed that
dqiterate wasn't actually walking all possible dquots for the mapped
blocks in the quota file.  This is due to xfs_qm_dqget_next skipping all
XFS_IS_DQUOT_UNINITIALIZED dquots.

For a fsck program, we really want to look at all the dquots, even if
all counters and limits in the dquot record are zero.  Rewrite the
implementation to do this, as well as switching to an iterator paradigm
to reduce the number of indirect calls.

This enables removal of the old broken dqiterate code from xfs_dquot.c.

Signed-off-by: default avatarDarrick J. Wong <djwong@kernel.org>
Reviewed-by: default avatarChristoph Hellwig <hch@lst.de>
parent 774b5c0a

fs/xfs/Makefile

+4 −1
Original line number Diff line number Diff line
@@ -176,7 +176,10 @@ xfs-$(CONFIG_XFS_RT) += $(addprefix scrub/, \ 
				   rtsummary.o \

				   )



xfs-$(CONFIG_XFS_QUOTA)		+= scrub/quota.o

xfs-$(CONFIG_XFS_QUOTA)		+= $(addprefix scrub/, \

				   dqiterate.o \

				   quota.o \

				   )



# online repair

ifeq ($(CONFIG_XFS_ONLINE_REPAIR),y)

fs/xfs/libxfs/xfs_format.h

+3 −0
Original line number Diff line number Diff line
@@ -1272,6 +1272,9 @@ static inline time64_t xfs_dq_bigtime_to_unix(uint32_t ondisk_seconds) 
#define XFS_DQ_GRACE_MIN		((int64_t)0)

#define XFS_DQ_GRACE_MAX		((int64_t)U32_MAX)



/* Maximum id value for a quota record */

#define XFS_DQ_ID_MAX			(U32_MAX)



/*

 * This is the main portion of the on-disk representation of quota information

 * for a user.  We pad this with some more expansion room to construct the on

fs/xfs/scrub/dqiterate.c

0 → 100644
+211 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0-or-later

/*

 * Copyright (C) 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_bit.h"

#include "xfs_format.h"

#include "xfs_trans_resv.h"

#include "xfs_mount.h"

#include "xfs_log_format.h"

#include "xfs_trans.h"

#include "xfs_inode.h"

#include "xfs_quota.h"

#include "xfs_qm.h"

#include "xfs_bmap.h"

#include "scrub/scrub.h"

#include "scrub/common.h"

#include "scrub/quota.h"

#include "scrub/trace.h"



/* Initialize a dquot iteration cursor. */

void

xchk_dqiter_init(

	struct xchk_dqiter	*cursor,

	struct xfs_scrub	*sc,

	xfs_dqtype_t		dqtype)

{

	cursor->sc = sc;

	cursor->bmap.br_startoff = NULLFILEOFF;

	cursor->dqtype = dqtype & XFS_DQTYPE_REC_MASK;

	cursor->quota_ip = xfs_quota_inode(sc->mp, cursor->dqtype);

	cursor->id = 0;

}



/*

 * Ensure that the cached data fork mapping for the dqiter cursor is fresh and

 * covers the dquot pointed to by the scan cursor.

 */

STATIC int

xchk_dquot_iter_revalidate_bmap(

	struct xchk_dqiter	*cursor)

{

	struct xfs_quotainfo	*qi = cursor->sc->mp->m_quotainfo;

	struct xfs_ifork	*ifp = xfs_ifork_ptr(cursor->quota_ip,

								XFS_DATA_FORK);

	xfs_fileoff_t		fileoff;

	xfs_dqid_t		this_id = cursor->id;

	int			nmaps = 1;

	int			error;



	fileoff = this_id / qi->qi_dqperchunk;



	/*

	 * If we have a mapping for cursor->id and it's still fresh, there's

	 * no need to reread the bmbt.

	 */

	if (cursor->bmap.br_startoff != NULLFILEOFF &&

	    cursor->if_seq == ifp->if_seq &&

	    cursor->bmap.br_startoff + cursor->bmap.br_blockcount > fileoff)

		return 0;



	/* Look up the data fork mapping for the dquot id of interest. */

	error = xfs_bmapi_read(cursor->quota_ip, fileoff,

			XFS_MAX_FILEOFF - fileoff, &cursor->bmap, &nmaps, 0);

	if (error)

		return error;

	if (!nmaps) {

		ASSERT(nmaps > 0);

		return -EFSCORRUPTED;

	}

	if (cursor->bmap.br_startoff > fileoff) {

		ASSERT(cursor->bmap.br_startoff == fileoff);

		return -EFSCORRUPTED;

	}



	cursor->if_seq = ifp->if_seq;

	trace_xchk_dquot_iter_revalidate_bmap(cursor, cursor->id);

	return 0;

}



/* Advance the dqiter cursor to the next non-sparse region of the quota file. */

STATIC int

xchk_dquot_iter_advance_bmap(

	struct xchk_dqiter	*cursor,

	uint64_t		*next_ondisk_id)

{

	struct xfs_quotainfo	*qi = cursor->sc->mp->m_quotainfo;

	struct xfs_ifork	*ifp = xfs_ifork_ptr(cursor->quota_ip,

								XFS_DATA_FORK);

	xfs_fileoff_t		fileoff;

	uint64_t		next_id;

	int			nmaps = 1;

	int			error;



	/* Find the dquot id for the next non-hole mapping. */

	do {

		fileoff = cursor->bmap.br_startoff + cursor->bmap.br_blockcount;

		if (fileoff > XFS_DQ_ID_MAX / qi->qi_dqperchunk) {

			/* The hole goes beyond the max dquot id, we're done */

			*next_ondisk_id = -1ULL;

			return 0;

		}



		error = xfs_bmapi_read(cursor->quota_ip, fileoff,

				XFS_MAX_FILEOFF - fileoff, &cursor->bmap,

				&nmaps, 0);

		if (error)

			return error;

		if (!nmaps) {

			/* Must have reached the end of the mappings. */

			*next_ondisk_id = -1ULL;

			return 0;

		}

		if (cursor->bmap.br_startoff > fileoff) {

			ASSERT(cursor->bmap.br_startoff == fileoff);

			return -EFSCORRUPTED;

		}

	} while (!xfs_bmap_is_real_extent(&cursor->bmap));



	next_id = cursor->bmap.br_startoff * qi->qi_dqperchunk;

	if (next_id > XFS_DQ_ID_MAX) {

		/* The hole goes beyond the max dquot id, we're done */

		*next_ondisk_id = -1ULL;

		return 0;

	}



	/* Propose jumping forward to the dquot in the next allocated block. */

	*next_ondisk_id = next_id;

	cursor->if_seq = ifp->if_seq;

	trace_xchk_dquot_iter_advance_bmap(cursor, *next_ondisk_id);

	return 0;

}



/*

 * Find the id of the next highest incore dquot.  Normally this will correspond

 * exactly with the quota file block mappings, but repair might have erased a

 * mapping because it was crosslinked; in that case, we need to re-allocate the

 * space so that we can reset q_blkno.

 */

STATIC void

xchk_dquot_iter_advance_incore(

	struct xchk_dqiter	*cursor,

	uint64_t		*next_incore_id)

{

	struct xfs_quotainfo	*qi = cursor->sc->mp->m_quotainfo;

	struct radix_tree_root	*tree = xfs_dquot_tree(qi, cursor->dqtype);

	struct xfs_dquot	*dq;

	unsigned int		nr_found;



	*next_incore_id = -1ULL;



	mutex_lock(&qi->qi_tree_lock);

	nr_found = radix_tree_gang_lookup(tree, (void **)&dq, cursor->id, 1);

	if (nr_found)

		*next_incore_id = dq->q_id;

	mutex_unlock(&qi->qi_tree_lock);



	trace_xchk_dquot_iter_advance_incore(cursor, *next_incore_id);

}



/*

 * Walk all incore dquots of this filesystem.  Caller must set *@cursorp to

 * zero before the first call, and must not hold the quota file ILOCK.

 * Returns 1 and a valid *@dqpp; 0 and *@dqpp == NULL when there are no more

 * dquots to iterate; or a negative errno.

 */

int

xchk_dquot_iter(

	struct xchk_dqiter	*cursor,

	struct xfs_dquot	**dqpp)

{

	struct xfs_mount	*mp = cursor->sc->mp;

	struct xfs_dquot	*dq = NULL;

	uint64_t		next_ondisk, next_incore = -1ULL;

	unsigned int		lock_mode;

	int			error = 0;



	if (cursor->id > XFS_DQ_ID_MAX)

		return 0;

	next_ondisk = cursor->id;



	/* Revalidate and/or advance the cursor. */

	lock_mode = xfs_ilock_data_map_shared(cursor->quota_ip);

	error = xchk_dquot_iter_revalidate_bmap(cursor);

	if (!error && !xfs_bmap_is_real_extent(&cursor->bmap))

		error = xchk_dquot_iter_advance_bmap(cursor, &next_ondisk);

	xfs_iunlock(cursor->quota_ip, lock_mode);

	if (error)

		return error;



	if (next_ondisk > cursor->id)

		xchk_dquot_iter_advance_incore(cursor, &next_incore);



	/* Pick the next dquot in the sequence and return it. */

	cursor->id = min(next_ondisk, next_incore);

	if (cursor->id > XFS_DQ_ID_MAX)

		return 0;



	trace_xchk_dquot_iter(cursor, cursor->id);



	error = xfs_qm_dqget(mp, cursor->id, cursor->dqtype, false, &dq);

	if (error)

		return error;



	cursor->id = dq->q_id + 1;

	*dqpp = dq;

	return 1;

}

fs/xfs/scrub/quota.c

+16 −9
Original line number Diff line number Diff line
@@ -18,6 +18,7 @@ 
#include "xfs_bmap.h"

#include "scrub/scrub.h"

#include "scrub/common.h"

#include "scrub/quota.h"



/* Convert a scrub type code to a DQ flag, or return 0 if error. */

static inline xfs_dqtype_t
@@ -137,11 +138,9 @@ xchk_quota_item_timer( 
/* Scrub the fields in an individual quota item. */

STATIC int

xchk_quota_item(

	struct xfs_dquot	*dq,

	xfs_dqtype_t		dqtype,

	void			*priv)

	struct xchk_quota_info	*sqi,

	struct xfs_dquot	*dq)

{

	struct xchk_quota_info	*sqi = priv;

	struct xfs_scrub	*sc = sqi->sc;

	struct xfs_mount	*mp = sc->mp;

	struct xfs_quotainfo	*qi = mp->m_quotainfo;
@@ -270,7 +269,7 @@ xchk_quota_data_fork( 
		return error;



	/* Check for data fork problems that apply only to quota files. */

	max_dqid_off = ((xfs_dqid_t)-1) / qi->qi_dqperchunk;

	max_dqid_off = XFS_DQ_ID_MAX / qi->qi_dqperchunk;

	ifp = xfs_ifork_ptr(sc->ip, XFS_DATA_FORK);

	for_each_xfs_iext(ifp, &icur, &irec) {

		if (xchk_should_terminate(sc, &error))
@@ -297,9 +296,11 @@ int 
xchk_quota(

	struct xfs_scrub	*sc)

{

	struct xchk_quota_info	sqi;

	struct xchk_dqiter	cursor = { };

	struct xchk_quota_info	sqi = { .sc = sc };

	struct xfs_mount	*mp = sc->mp;

	struct xfs_quotainfo	*qi = mp->m_quotainfo;

	struct xfs_dquot	*dq;

	xfs_dqtype_t		dqtype;

	int			error = 0;
@@ -318,9 +319,15 @@ xchk_quota( 
	 * functions.

	 */

	xchk_iunlock(sc, sc->ilock_flags);

	sqi.sc = sc;

	sqi.last_id = 0;

	error = xfs_qm_dqiterate(mp, dqtype, xchk_quota_item, &sqi);



	/* Now look for things that the quota verifiers won't complain about. */

	xchk_dqiter_init(&cursor, sc, dqtype);

	while ((error = xchk_dquot_iter(&cursor, &dq)) == 1) {

		error = xchk_quota_item(&sqi, dq);

		xfs_qm_dqput(dq);

		if (error)

			break;

	}

	xchk_ilock(sc, XFS_ILOCK_EXCL);

	if (error == -ECANCELED)

		error = 0;

fs/xfs/scrub/quota.h

0 → 100644
+34 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0-or-later

/*

 * Copyright (C) 2018-2023 Oracle.  All Rights Reserved.

 * Author: Darrick J. Wong <djwong@kernel.org>

 */

#ifndef __XFS_SCRUB_QUOTA_H__

#define __XFS_SCRUB_QUOTA_H__



/* dquot iteration code */



struct xchk_dqiter {

	struct xfs_scrub	*sc;



	/* Quota file that we're walking. */

	struct xfs_inode	*quota_ip;



	/* Cached data fork mapping for the dquot. */

	struct xfs_bmbt_irec	bmap;



	/* The next dquot to scan. */

	uint64_t		id;



	/* Quota type (user/group/project). */

	xfs_dqtype_t		dqtype;



	/* Data fork sequence number to detect stale mappings. */

	unsigned int		if_seq;

};



void xchk_dqiter_init(struct xchk_dqiter *cursor, struct xfs_scrub *sc,

		xfs_dqtype_t dqtype);

int xchk_dquot_iter(struct xchk_dqiter *cursor, struct xfs_dquot **dqpp);



#endif /* __XFS_SCRUB_QUOTA_H__ */