Commit 7be97138 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'xfs-5.7-merge-8' of git://git.kernel.org/pub/scm/fs/xfs/xfs-linux 

Pull xfs updates from Darrick Wong:
 "There's a lot going on this cycle with cleanups in the log code, the
  btree code, and the xattr code.

  We're tightening of metadata validation and online fsck checking, and
  introducing a common btree rebuilding library so that we can refactor
  xfs_repair and introduce online repair in a future cycle.

  We also fixed a few visible bugs -- most notably there's one in
  getdents that we introduced in 5.6; and a fix for hangs when disabling
  quotas.

  This series has been running fstests & other QA in the background for
  over a week and looks good so far.

  I anticipate sending a second pull request next week. That batch will
  change how xfs interacts with memory reclaim; how the log batches and
  throttles log items; how hard writes near ENOSPC will try to squeeze
  more space out of the filesystem; and hopefully fix the last of the
  umount hangs after a catastrophic failure. That should ease a lot of
  problems when running at the limits, but for now I'm leaving that in
  for-next for another week to make sure we got all the subtleties
  right.

  Summary:

   - Fix a hard to trigger race between iclog error checking and log
     shutdown.

   - Strengthen the AGF verifier.

   - Ratelimit some of the more spammy error messages.

   - Remove the icdinode uid/gid members and just use the ones in the
     vfs inode.

   - Hold ILOCK across insert/collapse range.

   - Clean up the extended attribute interfaces.

   - Clean up the attr flags mess.

   - Restore PF_MEMALLOC after exiting xfsaild thread to avoid
     triggering warnings in the process accounting code.

   - Remove the flexibly-sized array from struct xfs_agfl to eliminate
     compiler warnings about unaligned pointers and packed structures.

   - Various macro and typedef removals.

   - Stale metadata buffers if we decide they're corrupt outside of a
     verifier.

   - Check directory data/block/free block owners.

   - Fix a UAF when aborting inactivation of a corrupt xattr fork.

   - Teach online scrub to report failed directory and attr name lookups
     as a metadata corruption instead of a runtime error.

   - Avoid potential buffer overflows in sysfs files by using scnprintf.

   - Fix a regression in getdents lookups due to a mistake in pointer
     arithmetic.

   - Refactor btree cursor private data structures to use anonymous
     unions.

   - Cleanups in the log unmounting code.

   - Fix a potential mishandling of ENOMEM errors on multi-block
     directory buffer lookups.

   - Fix an incorrect test in the block allocation code.

   - Cleanups and name prefix shortening in the scrub code.

   - Introduce btree bulk loading code for online repair and scrub.

   - Fix a quotaoff log item leak (and hang) when the fs goes down
     midway through a quotaoff operation.

   - Remove di_version from the incore inode.

   - Refactor some of the log shutdown checking code.

   - Record the forcing of the log unmount records in the log force
     counters.

   - Fix a longstanding bug where quotacheck would purge the
     administrator's default quota grace interval and warning limits.

   - Reduce memory usage when scrubbing directory and xattr trees.

   - Don't let fsfreeze race with GETFSMAP or online scrub.

   - Handle bio_add_page failures more gracefully in xlog_write_iclog"

* tag 'xfs-5.7-merge-8' of git://git.kernel.org/pub/scm/fs/xfs/xfs-linux: (108 commits)
  xfs: prohibit fs freezing when using empty transactions
  xfs: shutdown on failure to add page to log bio
  xfs: directory bestfree check should release buffers
  xfs: drop all altpath buffers at the end of the sibling check
  xfs: preserve default grace interval during quotacheck
  xfs: remove xlog_state_want_sync
  xfs: move the ioerror check out of xlog_state_clean_iclog
  xfs: refactor xlog_state_clean_iclog
  xfs: remove the aborted parameter to xlog_state_done_syncing
  xfs: simplify log shutdown checking in xfs_log_release_iclog
  xfs: simplify the xfs_log_release_iclog calling convention
  xfs: factor out a xlog_wait_on_iclog helper
  xfs: merge xlog_cil_push into xlog_cil_push_work
  xfs: remove the di_version field from struct icdinode
  xfs: simplify a check in xfs_ioctl_setattr_check_cowextsize
  xfs: simplify di_flags2 inheritance in xfs_ialloc
  xfs: only check the superblock version for dinode size calculation
  xfs: add a new xfs_sb_version_has_v3inode helper
  xfs: fix unmount hang and memory leak on shutdown during quotaoff
  xfs: factor out quotaoff intent AIL removal and memory free
  ...
parents 7db83c07 27fb5a72

fs/xfs/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -26,6 +26,7 @@ xfs-y += $(addprefix libxfs/, \ 
				   xfs_bmap.o \

				   xfs_bmap_btree.o \

				   xfs_btree.o \

				   xfs_btree_staging.o \

				   xfs_da_btree.o \

				   xfs_defer.o \

				   xfs_dir2.o \

fs/xfs/libxfs/xfs_ag.c

+8 −8
Original line number Diff line number Diff line
@@ -231,7 +231,7 @@ xfs_sbblock_init( 
	struct xfs_buf		*bp,

	struct aghdr_init_data	*id)

{

	struct xfs_dsb		*dsb = XFS_BUF_TO_SBP(bp);

	struct xfs_dsb		*dsb = bp->b_addr;



	xfs_sb_to_disk(dsb, &mp->m_sb);

	dsb->sb_inprogress = 1;
@@ -243,7 +243,7 @@ xfs_agfblock_init( 
	struct xfs_buf		*bp,

	struct aghdr_init_data	*id)

{

	struct xfs_agf		*agf = XFS_BUF_TO_AGF(bp);

	struct xfs_agf		*agf = bp->b_addr;

	xfs_extlen_t		tmpsize;



	agf->agf_magicnum = cpu_to_be32(XFS_AGF_MAGIC);
@@ -301,7 +301,7 @@ xfs_agflblock_init( 
		uuid_copy(&agfl->agfl_uuid, &mp->m_sb.sb_meta_uuid);

	}



	agfl_bno = XFS_BUF_TO_AGFL_BNO(mp, bp);

	agfl_bno = xfs_buf_to_agfl_bno(bp);

	for (bucket = 0; bucket < xfs_agfl_size(mp); bucket++)

		agfl_bno[bucket] = cpu_to_be32(NULLAGBLOCK);

}
@@ -312,7 +312,7 @@ xfs_agiblock_init( 
	struct xfs_buf		*bp,

	struct aghdr_init_data	*id)

{

	struct xfs_agi		*agi = XFS_BUF_TO_AGI(bp);

	struct xfs_agi		*agi = bp->b_addr;

	int			bucket;



	agi->agi_magicnum = cpu_to_be32(XFS_AGI_MAGIC);
@@ -502,7 +502,7 @@ xfs_ag_extend_space( 
	if (error)

		return error;



	agi = XFS_BUF_TO_AGI(bp);

	agi = bp->b_addr;

	be32_add_cpu(&agi->agi_length, len);

	ASSERT(id->agno == mp->m_sb.sb_agcount - 1 ||

	       be32_to_cpu(agi->agi_length) == mp->m_sb.sb_agblocks);
@@ -515,7 +515,7 @@ xfs_ag_extend_space( 
	if (error)

		return error;



	agf = XFS_BUF_TO_AGF(bp);

	agf = bp->b_addr;

	be32_add_cpu(&agf->agf_length, len);

	ASSERT(agf->agf_length == agi->agi_length);

	xfs_alloc_log_agf(tp, bp, XFS_AGF_LENGTH);
@@ -569,11 +569,11 @@ xfs_ag_get_geometry( 
	memset(ageo, 0, sizeof(*ageo));

	ageo->ag_number = agno;



	agi = XFS_BUF_TO_AGI(agi_bp);

	agi = agi_bp->b_addr;

	ageo->ag_icount = be32_to_cpu(agi->agi_count);

	ageo->ag_ifree = be32_to_cpu(agi->agi_freecount);



	agf = XFS_BUF_TO_AGF(agf_bp);

	agf = agf_bp->b_addr;

	ageo->ag_length = be32_to_cpu(agf->agf_length);

	freeblks = pag->pagf_freeblks +

		   pag->pagf_flcount +

fs/xfs/libxfs/xfs_alloc.c

+55 −44
Original line number Diff line number Diff line
@@ -151,7 +151,7 @@ xfs_alloc_lookup_eq( 
	cur->bc_rec.a.ar_startblock = bno;

	cur->bc_rec.a.ar_blockcount = len;

	error = xfs_btree_lookup(cur, XFS_LOOKUP_EQ, stat);

	cur->bc_private.a.priv.abt.active = (*stat == 1);

	cur->bc_ag.abt.active = (*stat == 1);

	return error;

}
@@ -171,7 +171,7 @@ xfs_alloc_lookup_ge( 
	cur->bc_rec.a.ar_startblock = bno;

	cur->bc_rec.a.ar_blockcount = len;

	error = xfs_btree_lookup(cur, XFS_LOOKUP_GE, stat);

	cur->bc_private.a.priv.abt.active = (*stat == 1);

	cur->bc_ag.abt.active = (*stat == 1);

	return error;

}
@@ -190,7 +190,7 @@ xfs_alloc_lookup_le( 
	cur->bc_rec.a.ar_startblock = bno;

	cur->bc_rec.a.ar_blockcount = len;

	error = xfs_btree_lookup(cur, XFS_LOOKUP_LE, stat);

	cur->bc_private.a.priv.abt.active = (*stat == 1);

	cur->bc_ag.abt.active = (*stat == 1);

	return error;

}
@@ -198,7 +198,7 @@ static inline bool 
xfs_alloc_cur_active(

	struct xfs_btree_cur	*cur)

{

	return cur && cur->bc_private.a.priv.abt.active;

	return cur && cur->bc_ag.abt.active;

}



/*
@@ -230,7 +230,7 @@ xfs_alloc_get_rec( 
	int			*stat)	/* output: success/failure */

{

	struct xfs_mount	*mp = cur->bc_mp;

	xfs_agnumber_t		agno = cur->bc_private.a.agno;

	xfs_agnumber_t		agno = cur->bc_ag.agno;

	union xfs_btree_rec	*rec;

	int			error;
@@ -589,6 +589,7 @@ xfs_agfl_verify( 
{

	struct xfs_mount *mp = bp->b_mount;

	struct xfs_agfl	*agfl = XFS_BUF_TO_AGFL(bp);

	__be32		*agfl_bno = xfs_buf_to_agfl_bno(bp);

	int		i;



	/*
@@ -614,8 +615,8 @@ xfs_agfl_verify( 
		return __this_address;



	for (i = 0; i < xfs_agfl_size(mp); i++) {

		if (be32_to_cpu(agfl->agfl_bno[i]) != NULLAGBLOCK &&

		    be32_to_cpu(agfl->agfl_bno[i]) >= mp->m_sb.sb_agblocks)

		if (be32_to_cpu(agfl_bno[i]) != NULLAGBLOCK &&

		    be32_to_cpu(agfl_bno[i]) >= mp->m_sb.sb_agblocks)

			return __this_address;

	}
@@ -713,7 +714,7 @@ xfs_alloc_update_counters( 
	struct xfs_buf		*agbp,

	long			len)

{

	struct xfs_agf		*agf = XFS_BUF_TO_AGF(agbp);

	struct xfs_agf		*agf = agbp->b_addr;



	pag->pagf_freeblks += len;

	be32_add_cpu(&agf->agf_freeblks, len);
@@ -721,7 +722,7 @@ xfs_alloc_update_counters( 
	xfs_trans_agblocks_delta(tp, len);

	if (unlikely(be32_to_cpu(agf->agf_freeblks) >

		     be32_to_cpu(agf->agf_length))) {

		xfs_buf_corruption_error(agbp);

		xfs_buf_mark_corrupt(agbp);

		return -EFSCORRUPTED;

	}
@@ -907,7 +908,7 @@ xfs_alloc_cur_check( 
		deactivate = true;

out:

	if (deactivate)

		cur->bc_private.a.priv.abt.active = false;

		cur->bc_ag.abt.active = false;

	trace_xfs_alloc_cur_check(args->mp, cur->bc_btnum, bno, len, diff,

				  *new);

	return 0;
@@ -922,13 +923,13 @@ xfs_alloc_cur_finish( 
	struct xfs_alloc_arg	*args,

	struct xfs_alloc_cur	*acur)

{

	struct xfs_agf __maybe_unused *agf = args->agbp->b_addr;

	int			error;



	ASSERT(acur->cnt && acur->bnolt);

	ASSERT(acur->bno >= acur->rec_bno);

	ASSERT(acur->bno + acur->len <= acur->rec_bno + acur->rec_len);

	ASSERT(acur->rec_bno + acur->rec_len <=

	       be32_to_cpu(XFS_BUF_TO_AGF(args->agbp)->agf_length));

	ASSERT(acur->rec_bno + acur->rec_len <= be32_to_cpu(agf->agf_length));



	error = xfs_alloc_fixup_trees(acur->cnt, acur->bnolt, acur->rec_bno,

				      acur->rec_len, acur->bno, acur->len, 0);
@@ -1026,6 +1027,7 @@ xfs_alloc_ag_vextent_small( 
	xfs_extlen_t		*flenp,	/* result length */

	int			*stat)	/* status: 0-freelist, 1-normal/none */

{

	struct xfs_agf		*agf = args->agbp->b_addr;

	int			error = 0;

	xfs_agblock_t		fbno = NULLAGBLOCK;

	xfs_extlen_t		flen = 0;
@@ -1054,8 +1056,7 @@ xfs_alloc_ag_vextent_small( 


	if (args->minlen != 1 || args->alignment != 1 ||

	    args->resv == XFS_AG_RESV_AGFL ||

	    (be32_to_cpu(XFS_BUF_TO_AGF(args->agbp)->agf_flcount) <=

	     args->minleft))

	    be32_to_cpu(agf->agf_flcount) <= args->minleft)

		goto out;



	error = xfs_alloc_get_freelist(args->tp, args->agbp, &fbno, 0);
@@ -1079,9 +1080,7 @@ xfs_alloc_ag_vextent_small( 
	}

	*fbnop = args->agbno = fbno;

	*flenp = args->len = 1;

	if (XFS_IS_CORRUPT(args->mp,

			   fbno >= be32_to_cpu(

				   XFS_BUF_TO_AGF(args->agbp)->agf_length))) {

	if (XFS_IS_CORRUPT(args->mp, fbno >= be32_to_cpu(agf->agf_length))) {

		error = -EFSCORRUPTED;

		goto error;

	}
@@ -1203,6 +1202,7 @@ STATIC int /* error */ 
xfs_alloc_ag_vextent_exact(

	xfs_alloc_arg_t	*args)	/* allocation argument structure */

{

	struct xfs_agf __maybe_unused *agf = args->agbp->b_addr;

	xfs_btree_cur_t	*bno_cur;/* by block-number btree cursor */

	xfs_btree_cur_t	*cnt_cur;/* by count btree cursor */

	int		error;
@@ -1281,8 +1281,7 @@ xfs_alloc_ag_vextent_exact( 
	 */

	cnt_cur = xfs_allocbt_init_cursor(args->mp, args->tp, args->agbp,

		args->agno, XFS_BTNUM_CNT);

	ASSERT(args->agbno + args->len <=

		be32_to_cpu(XFS_BUF_TO_AGF(args->agbp)->agf_length));

	ASSERT(args->agbno + args->len <= be32_to_cpu(agf->agf_length));

	error = xfs_alloc_fixup_trees(cnt_cur, bno_cur, fbno, flen, args->agbno,

				      args->len, XFSA_FIXUP_BNO_OK);

	if (error) {
@@ -1353,7 +1352,7 @@ xfs_alloc_walk_iter( 
		if (error)

			return error;

		if (i == 0)

			cur->bc_private.a.priv.abt.active = false;

			cur->bc_ag.abt.active = false;



		if (count > 0)

			count--;
@@ -1468,7 +1467,7 @@ xfs_alloc_ag_vextent_locality( 
		if (error)

			return error;

		if (i) {

			acur->cnt->bc_private.a.priv.abt.active = true;

			acur->cnt->bc_ag.abt.active = true;

			fbcur = acur->cnt;

			fbinc = false;

		}
@@ -1515,7 +1514,7 @@ xfs_alloc_ag_vextent_lastblock( 
	 * maxlen, go to the start of this block, and skip all those smaller

	 * than minlen.

	 */

	if (len || args->alignment > 1) {

	if (*len || args->alignment > 1) {

		acur->cnt->bc_ptrs[0] = 1;

		do {

			error = xfs_alloc_get_rec(acur->cnt, bno, len, &i);
@@ -1661,6 +1660,7 @@ STATIC int /* error */ 
xfs_alloc_ag_vextent_size(

	xfs_alloc_arg_t	*args)		/* allocation argument structure */

{

	struct xfs_agf	*agf = args->agbp->b_addr;

	xfs_btree_cur_t	*bno_cur;	/* cursor for bno btree */

	xfs_btree_cur_t	*cnt_cur;	/* cursor for cnt btree */

	int		error;		/* error result */
@@ -1851,8 +1851,7 @@ restart: 
	args->agbno = rbno;

	if (XFS_IS_CORRUPT(args->mp,

			   args->agbno + args->len >

			   be32_to_cpu(

				   XFS_BUF_TO_AGF(args->agbp)->agf_length))) {

			   be32_to_cpu(agf->agf_length))) {

		error = -EFSCORRUPTED;

		goto error0;

	}
@@ -2424,7 +2423,7 @@ xfs_agfl_reset( 
	struct xfs_perag	*pag)

{

	struct xfs_mount	*mp = tp->t_mountp;

	struct xfs_agf		*agf = XFS_BUF_TO_AGF(agbp);

	struct xfs_agf		*agf = agbp->b_addr;



	ASSERT(pag->pagf_agflreset);

	trace_xfs_agfl_reset(mp, agf, 0, _RET_IP_);
@@ -2655,7 +2654,7 @@ xfs_alloc_get_freelist( 
	xfs_agblock_t	*bnop,	/* block address retrieved from freelist */

	int		btreeblk) /* destination is a AGF btree */

{

	xfs_agf_t	*agf;	/* a.g. freespace structure */

	struct xfs_agf	*agf = agbp->b_addr;

	xfs_buf_t	*agflbp;/* buffer for a.g. freelist structure */

	xfs_agblock_t	bno;	/* block number returned */

	__be32		*agfl_bno;
@@ -2667,7 +2666,6 @@ xfs_alloc_get_freelist( 
	/*

	 * Freelist is empty, give up.

	 */

	agf = XFS_BUF_TO_AGF(agbp);

	if (!agf->agf_flcount) {

		*bnop = NULLAGBLOCK;

		return 0;
@@ -2684,7 +2682,7 @@ xfs_alloc_get_freelist( 
	/*

	 * Get the block number and update the data structures.

	 */

	agfl_bno = XFS_BUF_TO_AGFL_BNO(mp, agflbp);

	agfl_bno = xfs_buf_to_agfl_bno(agflbp);

	bno = be32_to_cpu(agfl_bno[be32_to_cpu(agf->agf_flfirst)]);

	be32_add_cpu(&agf->agf_flfirst, 1);

	xfs_trans_brelse(tp, agflbp);
@@ -2745,7 +2743,7 @@ xfs_alloc_log_agf( 
		sizeof(xfs_agf_t)

	};



	trace_xfs_agf(tp->t_mountp, XFS_BUF_TO_AGF(bp), fields, _RET_IP_);

	trace_xfs_agf(tp->t_mountp, bp->b_addr, fields, _RET_IP_);



	xfs_trans_buf_set_type(tp, bp, XFS_BLFT_AGF_BUF);
@@ -2783,18 +2781,15 @@ xfs_alloc_put_freelist( 
	xfs_agblock_t		bno,	/* block being freed */

	int			btreeblk) /* block came from a AGF btree */

{

	xfs_agf_t		*agf;	/* a.g. freespace structure */

	struct xfs_mount	*mp = tp->t_mountp;

	struct xfs_agf		*agf = agbp->b_addr;

	__be32			*blockp;/* pointer to array entry */

	int			error;

	int			logflags;

	xfs_mount_t		*mp;	/* mount structure */

	xfs_perag_t		*pag;	/* per allocation group data */

	__be32			*agfl_bno;

	int			startoff;



	agf = XFS_BUF_TO_AGF(agbp);

	mp = tp->t_mountp;



	if (!agflbp && (error = xfs_alloc_read_agfl(mp, tp,

			be32_to_cpu(agf->agf_seqno), &agflbp)))

		return error;
@@ -2820,7 +2815,7 @@ xfs_alloc_put_freelist( 


	ASSERT(be32_to_cpu(agf->agf_flcount) <= xfs_agfl_size(mp));



	agfl_bno = XFS_BUF_TO_AGFL_BNO(mp, agflbp);

	agfl_bno = xfs_buf_to_agfl_bno(agflbp);

	blockp = &agfl_bno[be32_to_cpu(agf->agf_fllast)];

	*blockp = cpu_to_be32(bno);

	startoff = (char *)blockp - (char *)agflbp->b_addr;
@@ -2838,13 +2833,12 @@ xfs_agf_verify( 
	struct xfs_buf		*bp)

{

	struct xfs_mount	*mp = bp->b_mount;

	struct xfs_agf		*agf = XFS_BUF_TO_AGF(bp);

	struct xfs_agf		*agf = bp->b_addr;



	if (xfs_sb_version_hascrc(&mp->m_sb)) {

		if (!uuid_equal(&agf->agf_uuid, &mp->m_sb.sb_meta_uuid))

			return __this_address;

		if (!xfs_log_check_lsn(mp,

				be64_to_cpu(XFS_BUF_TO_AGF(bp)->agf_lsn)))

		if (!xfs_log_check_lsn(mp, be64_to_cpu(agf->agf_lsn)))

			return __this_address;

	}
@@ -2858,6 +2852,13 @@ xfs_agf_verify( 
	      be32_to_cpu(agf->agf_flcount) <= xfs_agfl_size(mp)))

		return __this_address;



	if (be32_to_cpu(agf->agf_length) > mp->m_sb.sb_dblocks)

		return __this_address;



	if (be32_to_cpu(agf->agf_freeblks) < be32_to_cpu(agf->agf_longest) ||

	    be32_to_cpu(agf->agf_freeblks) > be32_to_cpu(agf->agf_length))

		return __this_address;



	if (be32_to_cpu(agf->agf_levels[XFS_BTNUM_BNO]) < 1 ||

	    be32_to_cpu(agf->agf_levels[XFS_BTNUM_CNT]) < 1 ||

	    be32_to_cpu(agf->agf_levels[XFS_BTNUM_BNO]) > XFS_BTREE_MAXLEVELS ||
@@ -2869,6 +2870,10 @@ xfs_agf_verify( 
	     be32_to_cpu(agf->agf_levels[XFS_BTNUM_RMAP]) > XFS_BTREE_MAXLEVELS))

		return __this_address;



	if (xfs_sb_version_hasrmapbt(&mp->m_sb) &&

	    be32_to_cpu(agf->agf_rmap_blocks) > be32_to_cpu(agf->agf_length))

		return __this_address;



	/*

	 * during growfs operations, the perag is not fully initialised,

	 * so we can't use it for any useful checking. growfs ensures we can't
@@ -2882,6 +2887,11 @@ xfs_agf_verify( 
	    be32_to_cpu(agf->agf_btreeblks) > be32_to_cpu(agf->agf_length))

		return __this_address;



	if (xfs_sb_version_hasreflink(&mp->m_sb) &&

	    be32_to_cpu(agf->agf_refcount_blocks) >

	    be32_to_cpu(agf->agf_length))

		return __this_address;



	if (xfs_sb_version_hasreflink(&mp->m_sb) &&

	    (be32_to_cpu(agf->agf_refcount_level) < 1 ||

	     be32_to_cpu(agf->agf_refcount_level) > XFS_BTREE_MAXLEVELS))
@@ -2914,6 +2924,7 @@ xfs_agf_write_verify( 
{

	struct xfs_mount	*mp = bp->b_mount;

	struct xfs_buf_log_item	*bip = bp->b_log_item;

	struct xfs_agf		*agf = bp->b_addr;

	xfs_failaddr_t		fa;



	fa = xfs_agf_verify(bp);
@@ -2926,7 +2937,7 @@ xfs_agf_write_verify( 
		return;



	if (bip)

		XFS_BUF_TO_AGF(bp)->agf_lsn = cpu_to_be64(bip->bli_item.li_lsn);

		agf->agf_lsn = cpu_to_be64(bip->bli_item.li_lsn);



	xfs_buf_update_cksum(bp, XFS_AGF_CRC_OFF);

}
@@ -2994,7 +3005,7 @@ xfs_alloc_read_agf( 
		return error;

	ASSERT(!(*bpp)->b_error);



	agf = XFS_BUF_TO_AGF(*bpp);

	agf = (*bpp)->b_addr;

	pag = xfs_perag_get(mp, agno);

	if (!pag->pagf_init) {

		pag->pagf_freeblks = be32_to_cpu(agf->agf_freeblks);
@@ -3275,6 +3286,7 @@ __xfs_free_extent( 
	struct xfs_buf			*agbp;

	xfs_agnumber_t			agno = XFS_FSB_TO_AGNO(mp, bno);

	xfs_agblock_t			agbno = XFS_FSB_TO_AGBNO(mp, bno);

	struct xfs_agf			*agf;

	int				error;

	unsigned int			busy_flags = 0;
@@ -3288,6 +3300,7 @@ __xfs_free_extent( 
	error = xfs_free_extent_fix_freelist(tp, agno, &agbp);

	if (error)

		return error;

	agf = agbp->b_addr;



	if (XFS_IS_CORRUPT(mp, agbno >= mp->m_sb.sb_agblocks)) {

		error = -EFSCORRUPTED;
@@ -3295,9 +3308,7 @@ __xfs_free_extent( 
	}



	/* validate the extent size is legal now we have the agf locked */

	if (XFS_IS_CORRUPT(mp,

			   agbno + len >

			   be32_to_cpu(XFS_BUF_TO_AGF(agbp)->agf_length))) {

	if (XFS_IS_CORRUPT(mp, agbno + len > be32_to_cpu(agf->agf_length))) {

		error = -EFSCORRUPTED;

		goto err;

	}
@@ -3408,7 +3419,7 @@ xfs_agfl_walk( 
	unsigned int		i;

	int			error;



	agfl_bno = XFS_BUF_TO_AGFL_BNO(mp, agflbp);

	agfl_bno = xfs_buf_to_agfl_bno(agflbp);

	i = be32_to_cpu(agf->agf_flfirst);



	/* Nothing to walk in an empty AGFL. */

fs/xfs/libxfs/xfs_alloc.h

+9 −0
Original line number Diff line number Diff line
@@ -236,4 +236,13 @@ typedef int (*xfs_agfl_walk_fn)(struct xfs_mount *mp, xfs_agblock_t bno, 
int xfs_agfl_walk(struct xfs_mount *mp, struct xfs_agf *agf,

		struct xfs_buf *agflbp, xfs_agfl_walk_fn walk_fn, void *priv);



static inline __be32 *

xfs_buf_to_agfl_bno(

	struct xfs_buf		*bp)

{

	if (xfs_sb_version_hascrc(&bp->b_mount->m_sb))

		return bp->b_addr + sizeof(struct xfs_agfl);

	return bp->b_addr;

}



#endif	/* __XFS_ALLOC_H__ */

fs/xfs/libxfs/xfs_alloc_btree.c

+90 −29
Original line number Diff line number Diff line
@@ -12,6 +12,7 @@ 
#include "xfs_sb.h"

#include "xfs_mount.h"

#include "xfs_btree.h"

#include "xfs_btree_staging.h"

#include "xfs_alloc_btree.h"

#include "xfs_alloc.h"

#include "xfs_extent_busy.h"
@@ -25,7 +26,7 @@ xfs_allocbt_dup_cursor( 
	struct xfs_btree_cur	*cur)

{

	return xfs_allocbt_init_cursor(cur->bc_mp, cur->bc_tp,

			cur->bc_private.a.agbp, cur->bc_private.a.agno,

			cur->bc_ag.agbp, cur->bc_ag.agno,

			cur->bc_btnum);

}
@@ -35,8 +36,8 @@ xfs_allocbt_set_root( 
	union xfs_btree_ptr	*ptr,

	int			inc)

{

	struct xfs_buf		*agbp = cur->bc_private.a.agbp;

	struct xfs_agf		*agf = XFS_BUF_TO_AGF(agbp);

	struct xfs_buf		*agbp = cur->bc_ag.agbp;

	struct xfs_agf		*agf = agbp->b_addr;

	xfs_agnumber_t		seqno = be32_to_cpu(agf->agf_seqno);

	int			btnum = cur->bc_btnum;

	struct xfs_perag	*pag = xfs_perag_get(cur->bc_mp, seqno);
@@ -62,7 +63,7 @@ xfs_allocbt_alloc_block( 
	xfs_agblock_t		bno;



	/* Allocate the new block from the freelist. If we can't, give up.  */

	error = xfs_alloc_get_freelist(cur->bc_tp, cur->bc_private.a.agbp,

	error = xfs_alloc_get_freelist(cur->bc_tp, cur->bc_ag.agbp,

				       &bno, 1);

	if (error)

		return error;
@@ -72,7 +73,7 @@ xfs_allocbt_alloc_block( 
		return 0;

	}



	xfs_extent_busy_reuse(cur->bc_mp, cur->bc_private.a.agno, bno, 1, false);

	xfs_extent_busy_reuse(cur->bc_mp, cur->bc_ag.agno, bno, 1, false);



	xfs_trans_agbtree_delta(cur->bc_tp, 1);

	new->s = cpu_to_be32(bno);
@@ -86,8 +87,8 @@ xfs_allocbt_free_block( 
	struct xfs_btree_cur	*cur,

	struct xfs_buf		*bp)

{

	struct xfs_buf		*agbp = cur->bc_private.a.agbp;

	struct xfs_agf		*agf = XFS_BUF_TO_AGF(agbp);

	struct xfs_buf		*agbp = cur->bc_ag.agbp;

	struct xfs_agf		*agf = agbp->b_addr;

	xfs_agblock_t		bno;

	int			error;
@@ -113,7 +114,7 @@ xfs_allocbt_update_lastrec( 
	int			ptr,

	int			reason)

{

	struct xfs_agf		*agf = XFS_BUF_TO_AGF(cur->bc_private.a.agbp);

	struct xfs_agf		*agf = cur->bc_ag.agbp->b_addr;

	xfs_agnumber_t		seqno = be32_to_cpu(agf->agf_seqno);

	struct xfs_perag	*pag;

	__be32			len;
@@ -162,7 +163,7 @@ xfs_allocbt_update_lastrec( 
	pag = xfs_perag_get(cur->bc_mp, seqno);

	pag->pagf_longest = be32_to_cpu(len);

	xfs_perag_put(pag);

	xfs_alloc_log_agf(cur->bc_tp, cur->bc_private.a.agbp, XFS_AGF_LONGEST);

	xfs_alloc_log_agf(cur->bc_tp, cur->bc_ag.agbp, XFS_AGF_LONGEST);

}



STATIC int
@@ -226,9 +227,9 @@ xfs_allocbt_init_ptr_from_cur( 
	struct xfs_btree_cur	*cur,

	union xfs_btree_ptr	*ptr)

{

	struct xfs_agf		*agf = XFS_BUF_TO_AGF(cur->bc_private.a.agbp);

	struct xfs_agf		*agf = cur->bc_ag.agbp->b_addr;



	ASSERT(cur->bc_private.a.agno == be32_to_cpu(agf->agf_seqno));

	ASSERT(cur->bc_ag.agno == be32_to_cpu(agf->agf_seqno));



	ptr->s = agf->agf_roots[cur->bc_btnum];

}
@@ -471,18 +472,14 @@ static const struct xfs_btree_ops xfs_cntbt_ops = { 
	.recs_inorder		= xfs_cntbt_recs_inorder,

};



/*

 * Allocate a new allocation btree cursor.

 */

struct xfs_btree_cur *			/* new alloc btree cursor */

xfs_allocbt_init_cursor(

	struct xfs_mount	*mp,		/* file system mount point */

	struct xfs_trans	*tp,		/* transaction pointer */

	struct xfs_buf		*agbp,		/* buffer for agf structure */

	xfs_agnumber_t		agno,		/* allocation group number */

	xfs_btnum_t		btnum)		/* btree identifier */

/* Allocate most of a new allocation btree cursor. */

STATIC struct xfs_btree_cur *

xfs_allocbt_init_common(

	struct xfs_mount	*mp,

	struct xfs_trans	*tp,

	xfs_agnumber_t		agno,

	xfs_btnum_t		btnum)

{

	struct xfs_agf		*agf = XFS_BUF_TO_AGF(agbp);

	struct xfs_btree_cur	*cur;



	ASSERT(btnum == XFS_BTNUM_BNO || btnum == XFS_BTNUM_CNT);
@@ -495,19 +492,16 @@ xfs_allocbt_init_cursor( 
	cur->bc_blocklog = mp->m_sb.sb_blocklog;



	if (btnum == XFS_BTNUM_CNT) {

		cur->bc_statoff = XFS_STATS_CALC_INDEX(xs_abtc_2);

		cur->bc_ops = &xfs_cntbt_ops;

		cur->bc_nlevels = be32_to_cpu(agf->agf_levels[XFS_BTNUM_CNT]);

		cur->bc_statoff = XFS_STATS_CALC_INDEX(xs_abtc_2);

		cur->bc_flags = XFS_BTREE_LASTREC_UPDATE;

	} else {

		cur->bc_statoff = XFS_STATS_CALC_INDEX(xs_abtb_2);

		cur->bc_ops = &xfs_bnobt_ops;

		cur->bc_nlevels = be32_to_cpu(agf->agf_levels[XFS_BTNUM_BNO]);

		cur->bc_statoff = XFS_STATS_CALC_INDEX(xs_abtb_2);

	}



	cur->bc_private.a.agbp = agbp;

	cur->bc_private.a.agno = agno;

	cur->bc_private.a.priv.abt.active = false;

	cur->bc_ag.agno = agno;

	cur->bc_ag.abt.active = false;



	if (xfs_sb_version_hascrc(&mp->m_sb))

		cur->bc_flags |= XFS_BTREE_CRC_BLOCKS;
@@ -515,6 +509,73 @@ xfs_allocbt_init_cursor( 
	return cur;

}



/*

 * Allocate a new allocation btree cursor.

 */

struct xfs_btree_cur *			/* new alloc btree cursor */

xfs_allocbt_init_cursor(

	struct xfs_mount	*mp,		/* file system mount point */

	struct xfs_trans	*tp,		/* transaction pointer */

	struct xfs_buf		*agbp,		/* buffer for agf structure */

	xfs_agnumber_t		agno,		/* allocation group number */

	xfs_btnum_t		btnum)		/* btree identifier */

{

	struct xfs_agf		*agf = agbp->b_addr;

	struct xfs_btree_cur	*cur;



	cur = xfs_allocbt_init_common(mp, tp, agno, btnum);

	if (btnum == XFS_BTNUM_CNT)

		cur->bc_nlevels = be32_to_cpu(agf->agf_levels[XFS_BTNUM_CNT]);

	else

		cur->bc_nlevels = be32_to_cpu(agf->agf_levels[XFS_BTNUM_BNO]);



	cur->bc_ag.agbp = agbp;



	return cur;

}



/* Create a free space btree cursor with a fake root for staging. */

struct xfs_btree_cur *

xfs_allocbt_stage_cursor(

	struct xfs_mount	*mp,

	struct xbtree_afakeroot	*afake,

	xfs_agnumber_t		agno,

	xfs_btnum_t		btnum)

{

	struct xfs_btree_cur	*cur;



	cur = xfs_allocbt_init_common(mp, NULL, agno, btnum);

	xfs_btree_stage_afakeroot(cur, afake);

	return cur;

}



/*

 * Install a new free space btree root.  Caller is responsible for invalidating

 * and freeing the old btree blocks.

 */

void

xfs_allocbt_commit_staged_btree(

	struct xfs_btree_cur	*cur,

	struct xfs_trans	*tp,

	struct xfs_buf		*agbp)

{

	struct xfs_agf		*agf = agbp->b_addr;

	struct xbtree_afakeroot	*afake = cur->bc_ag.afake;



	ASSERT(cur->bc_flags & XFS_BTREE_STAGING);



	agf->agf_roots[cur->bc_btnum] = cpu_to_be32(afake->af_root);

	agf->agf_levels[cur->bc_btnum] = cpu_to_be32(afake->af_levels);

	xfs_alloc_log_agf(tp, agbp, XFS_AGF_ROOTS | XFS_AGF_LEVELS);



	if (cur->bc_btnum == XFS_BTNUM_BNO) {

		xfs_btree_commit_afakeroot(cur, tp, agbp, &xfs_bnobt_ops);

	} else {

		cur->bc_flags |= XFS_BTREE_LASTREC_UPDATE;

		xfs_btree_commit_afakeroot(cur, tp, agbp, &xfs_cntbt_ops);

	}

}



/*

 * Calculate number of records in an alloc btree block.

 */

CRA Git | Maintained and supported by SUSTech CRA and CCSE