Commit 584aa150 authored by Chandan Babu R's avatar Chandan Babu R
Browse files

Merge tag 'rmap-intent-cleanups-6.11_2024-07-02' of... 

Merge tag 'rmap-intent-cleanups-6.11_2024-07-02' of https://git.kernel.org/pub/scm/linux/kernel/git/djwong/xfs-linux

 into xfs-6.11-mergeB

xfs: rmap log intent cleanups

This series cleans up the rmap intent code before we start adding
support for realtime devices.  Similar to previous intent cleanup
patchsets, we start transforming the tracepoints so that the data
extraction are done inside the tracepoint code, and then we start
passing the intent itself to the _finish_one function.  This reduces the
boxing and unboxing of parameters.

Signed-off-by: default avatarDarrick J. Wong <djwong@kernel.org>
Signed-off-by: default avatarChandan Babu R <chandanbabu@kernel.org>

* tag 'rmap-intent-cleanups-6.11_2024-07-02' of https://git.kernel.org/pub/scm/linux/kernel/git/djwong/xfs-linux:
  xfs: move xfs_rmap_update_defer_add to xfs_rmap_item.c
  xfs: simplify usage of the rcur local variable in xfs_rmap_finish_one
  xfs: don't bother calling xfs_rmap_finish_one_cleanup in xfs_rmap_finish_one
  xfs: reuse xfs_rmap_update_cancel_item
  xfs: add a ri_entry helper
  xfs: remove xfs_trans_set_rmap_flags
  xfs: clean up rmap log intent item tracepoint callsites
  xfs: pass btree cursors to rmap btree tracepoints
  xfs: give rmap btree cursor error tracepoints their own class
parents 06e4e940 ea7b0820

fs/xfs/libxfs/xfs_rmap.c

+92 −174
Original line number Diff line number Diff line
@@ -24,6 +24,7 @@ 
#include "xfs_inode.h"

#include "xfs_ag.h"

#include "xfs_health.h"

#include "xfs_rmap_item.h"



struct kmem_cache	*xfs_rmap_intent_cache;
@@ -100,8 +101,7 @@ xfs_rmap_update( 
	union xfs_btree_rec	rec;

	int			error;



	trace_xfs_rmap_update(cur->bc_mp, cur->bc_ag.pag->pag_agno,

			irec->rm_startblock, irec->rm_blockcount,

	trace_xfs_rmap_update(cur, irec->rm_startblock, irec->rm_blockcount,

			irec->rm_owner, irec->rm_offset, irec->rm_flags);



	rec.rmap.rm_startblock = cpu_to_be32(irec->rm_startblock);
@@ -111,8 +111,7 @@ xfs_rmap_update( 
			xfs_rmap_irec_offset_pack(irec));

	error = xfs_btree_update(cur, &rec);

	if (error)

		trace_xfs_rmap_update_error(cur->bc_mp,

				cur->bc_ag.pag->pag_agno, error, _RET_IP_);

		trace_xfs_rmap_update_error(cur, error, _RET_IP_);

	return error;

}
@@ -128,8 +127,7 @@ xfs_rmap_insert( 
	int			i;

	int			error;



	trace_xfs_rmap_insert(rcur->bc_mp, rcur->bc_ag.pag->pag_agno, agbno,

			len, owner, offset, flags);

	trace_xfs_rmap_insert(rcur, agbno, len, owner, offset, flags);



	error = xfs_rmap_lookup_eq(rcur, agbno, len, owner, offset, flags, &i);

	if (error)
@@ -155,8 +153,7 @@ xfs_rmap_insert( 
	}

done:

	if (error)

		trace_xfs_rmap_insert_error(rcur->bc_mp,

				rcur->bc_ag.pag->pag_agno, error, _RET_IP_);

		trace_xfs_rmap_insert_error(rcur, error, _RET_IP_);

	return error;

}
@@ -172,8 +169,7 @@ xfs_rmap_delete( 
	int			i;

	int			error;



	trace_xfs_rmap_delete(rcur->bc_mp, rcur->bc_ag.pag->pag_agno, agbno,

			len, owner, offset, flags);

	trace_xfs_rmap_delete(rcur, agbno, len, owner, offset, flags);



	error = xfs_rmap_lookup_eq(rcur, agbno, len, owner, offset, flags, &i);

	if (error)
@@ -194,8 +190,7 @@ xfs_rmap_delete( 
	}

done:

	if (error)

		trace_xfs_rmap_delete_error(rcur->bc_mp,

				rcur->bc_ag.pag->pag_agno, error, _RET_IP_);

		trace_xfs_rmap_delete_error(rcur, error, _RET_IP_);

	return error;

}
@@ -342,8 +337,7 @@ xfs_rmap_find_left_neighbor_helper( 
{

	struct xfs_find_left_neighbor_info	*info = priv;



	trace_xfs_rmap_find_left_neighbor_candidate(cur->bc_mp,

			cur->bc_ag.pag->pag_agno, rec->rm_startblock,

	trace_xfs_rmap_find_left_neighbor_candidate(cur, rec->rm_startblock,

			rec->rm_blockcount, rec->rm_owner, rec->rm_offset,

			rec->rm_flags);
@@ -393,8 +387,8 @@ xfs_rmap_find_left_neighbor( 
	info.high.rm_blockcount = 0;

	info.irec = irec;



	trace_xfs_rmap_find_left_neighbor_query(cur->bc_mp,

			cur->bc_ag.pag->pag_agno, bno, 0, owner, offset, flags);

	trace_xfs_rmap_find_left_neighbor_query(cur, bno, 0, owner, offset,

			flags);



	/*

	 * Historically, we always used the range query to walk every reverse
@@ -425,8 +419,7 @@ xfs_rmap_find_left_neighbor( 
		return error;



	*stat = 1;

	trace_xfs_rmap_find_left_neighbor_result(cur->bc_mp,

			cur->bc_ag.pag->pag_agno, irec->rm_startblock,

	trace_xfs_rmap_find_left_neighbor_result(cur, irec->rm_startblock,

			irec->rm_blockcount, irec->rm_owner, irec->rm_offset,

			irec->rm_flags);

	return 0;
@@ -441,8 +434,7 @@ xfs_rmap_lookup_le_range_helper( 
{

	struct xfs_find_left_neighbor_info	*info = priv;



	trace_xfs_rmap_lookup_le_range_candidate(cur->bc_mp,

			cur->bc_ag.pag->pag_agno, rec->rm_startblock,

	trace_xfs_rmap_lookup_le_range_candidate(cur, rec->rm_startblock,

			rec->rm_blockcount, rec->rm_owner, rec->rm_offset,

			rec->rm_flags);
@@ -489,8 +481,7 @@ xfs_rmap_lookup_le_range( 
	*stat = 0;

	info.irec = irec;



	trace_xfs_rmap_lookup_le_range(cur->bc_mp, cur->bc_ag.pag->pag_agno,

			bno, 0, owner, offset, flags);

	trace_xfs_rmap_lookup_le_range(cur, bno, 0, owner, offset, flags);



	/*

	 * Historically, we always used the range query to walk every reverse
@@ -521,8 +512,7 @@ xfs_rmap_lookup_le_range( 
		return error;



	*stat = 1;

	trace_xfs_rmap_lookup_le_range_result(cur->bc_mp,

			cur->bc_ag.pag->pag_agno, irec->rm_startblock,

	trace_xfs_rmap_lookup_le_range_result(cur, irec->rm_startblock,

			irec->rm_blockcount, irec->rm_owner, irec->rm_offset,

			irec->rm_flags);

	return 0;
@@ -634,8 +624,7 @@ xfs_rmap_unmap( 
			(flags & XFS_RMAP_BMBT_BLOCK);

	if (unwritten)

		flags |= XFS_RMAP_UNWRITTEN;

	trace_xfs_rmap_unmap(mp, cur->bc_ag.pag->pag_agno, bno, len,

			unwritten, oinfo);

	trace_xfs_rmap_unmap(cur, bno, len, unwritten, oinfo);



	/*

	 * We should always have a left record because there's a static record
@@ -651,10 +640,9 @@ xfs_rmap_unmap( 
		goto out_error;

	}



	trace_xfs_rmap_lookup_le_range_result(cur->bc_mp,

			cur->bc_ag.pag->pag_agno, ltrec.rm_startblock,

			ltrec.rm_blockcount, ltrec.rm_owner,

			ltrec.rm_offset, ltrec.rm_flags);

	trace_xfs_rmap_lookup_le_range_result(cur, ltrec.rm_startblock,

			ltrec.rm_blockcount, ltrec.rm_owner, ltrec.rm_offset,

			ltrec.rm_flags);

	ltoff = ltrec.rm_offset;



	/*
@@ -721,10 +709,9 @@ xfs_rmap_unmap( 


	if (ltrec.rm_startblock == bno && ltrec.rm_blockcount == len) {

		/* exact match, simply remove the record from rmap tree */

		trace_xfs_rmap_delete(mp, cur->bc_ag.pag->pag_agno,

				ltrec.rm_startblock, ltrec.rm_blockcount,

				ltrec.rm_owner, ltrec.rm_offset,

				ltrec.rm_flags);

		trace_xfs_rmap_delete(cur, ltrec.rm_startblock,

				ltrec.rm_blockcount, ltrec.rm_owner,

				ltrec.rm_offset, ltrec.rm_flags);

		error = xfs_btree_delete(cur, &i);

		if (error)

			goto out_error;
@@ -800,8 +787,7 @@ xfs_rmap_unmap( 
		else

			cur->bc_rec.r.rm_offset = offset + len;

		cur->bc_rec.r.rm_flags = flags;

		trace_xfs_rmap_insert(mp, cur->bc_ag.pag->pag_agno,

				cur->bc_rec.r.rm_startblock,

		trace_xfs_rmap_insert(cur, cur->bc_rec.r.rm_startblock,

				cur->bc_rec.r.rm_blockcount,

				cur->bc_rec.r.rm_owner,

				cur->bc_rec.r.rm_offset,
@@ -812,12 +798,10 @@ xfs_rmap_unmap( 
	}



out_done:

	trace_xfs_rmap_unmap_done(mp, cur->bc_ag.pag->pag_agno, bno, len,

			unwritten, oinfo);

	trace_xfs_rmap_unmap_done(cur, bno, len, unwritten, oinfo);

out_error:

	if (error)

		trace_xfs_rmap_unmap_error(mp, cur->bc_ag.pag->pag_agno,

				error, _RET_IP_);

		trace_xfs_rmap_unmap_error(cur, error, _RET_IP_);

	return error;

}
@@ -987,8 +971,7 @@ xfs_rmap_map( 
			(flags & XFS_RMAP_BMBT_BLOCK);

	if (unwritten)

		flags |= XFS_RMAP_UNWRITTEN;

	trace_xfs_rmap_map(mp, cur->bc_ag.pag->pag_agno, bno, len,

			unwritten, oinfo);

	trace_xfs_rmap_map(cur, bno, len, unwritten, oinfo);

	ASSERT(!xfs_rmap_should_skip_owner_update(oinfo));



	/*
@@ -1001,8 +984,7 @@ xfs_rmap_map( 
	if (error)

		goto out_error;

	if (have_lt) {

		trace_xfs_rmap_lookup_le_range_result(cur->bc_mp,

				cur->bc_ag.pag->pag_agno, ltrec.rm_startblock,

		trace_xfs_rmap_lookup_le_range_result(cur, ltrec.rm_startblock,

				ltrec.rm_blockcount, ltrec.rm_owner,

				ltrec.rm_offset, ltrec.rm_flags);
@@ -1040,10 +1022,10 @@ xfs_rmap_map( 
			error = -EFSCORRUPTED;

			goto out_error;

		}

		trace_xfs_rmap_find_right_neighbor_result(cur->bc_mp,

			cur->bc_ag.pag->pag_agno, gtrec.rm_startblock,

			gtrec.rm_blockcount, gtrec.rm_owner,

			gtrec.rm_offset, gtrec.rm_flags);

		trace_xfs_rmap_find_right_neighbor_result(cur,

				gtrec.rm_startblock, gtrec.rm_blockcount,

				gtrec.rm_owner, gtrec.rm_offset,

				gtrec.rm_flags);

		if (!xfs_rmap_is_mergeable(&gtrec, owner, flags))

			have_gt = 0;

	}
@@ -1080,12 +1062,9 @@ xfs_rmap_map( 
			 * result: |rrrrrrrrrrrrrrrrrrrrrrrrrrrrr|

			 */

			ltrec.rm_blockcount += gtrec.rm_blockcount;

			trace_xfs_rmap_delete(mp, cur->bc_ag.pag->pag_agno,

					gtrec.rm_startblock,

					gtrec.rm_blockcount,

					gtrec.rm_owner,

					gtrec.rm_offset,

					gtrec.rm_flags);

			trace_xfs_rmap_delete(cur, gtrec.rm_startblock,

					gtrec.rm_blockcount, gtrec.rm_owner,

					gtrec.rm_offset, gtrec.rm_flags);

			error = xfs_btree_delete(cur, &i);

			if (error)

				goto out_error;
@@ -1132,8 +1111,7 @@ xfs_rmap_map( 
		cur->bc_rec.r.rm_owner = owner;

		cur->bc_rec.r.rm_offset = offset;

		cur->bc_rec.r.rm_flags = flags;

		trace_xfs_rmap_insert(mp, cur->bc_ag.pag->pag_agno, bno, len,

			owner, offset, flags);

		trace_xfs_rmap_insert(cur, bno, len, owner, offset, flags);

		error = xfs_btree_insert(cur, &i);

		if (error)

			goto out_error;
@@ -1144,12 +1122,10 @@ xfs_rmap_map( 
		}

	}



	trace_xfs_rmap_map_done(mp, cur->bc_ag.pag->pag_agno, bno, len,

			unwritten, oinfo);

	trace_xfs_rmap_map_done(cur, bno, len, unwritten, oinfo);

out_error:

	if (error)

		trace_xfs_rmap_map_error(mp, cur->bc_ag.pag->pag_agno,

				error, _RET_IP_);

		trace_xfs_rmap_map_error(cur, error, _RET_IP_);

	return error;

}
@@ -1223,8 +1199,7 @@ xfs_rmap_convert( 
			(flags & (XFS_RMAP_ATTR_FORK | XFS_RMAP_BMBT_BLOCK))));

	oldext = unwritten ? XFS_RMAP_UNWRITTEN : 0;

	new_endoff = offset + len;

	trace_xfs_rmap_convert(mp, cur->bc_ag.pag->pag_agno, bno, len,

			unwritten, oinfo);

	trace_xfs_rmap_convert(cur, bno, len, unwritten, oinfo);



	/*

	 * For the initial lookup, look for an exact match or the left-adjacent
@@ -1240,10 +1215,9 @@ xfs_rmap_convert( 
		goto done;

	}



	trace_xfs_rmap_lookup_le_range_result(cur->bc_mp,

			cur->bc_ag.pag->pag_agno, PREV.rm_startblock,

			PREV.rm_blockcount, PREV.rm_owner,

			PREV.rm_offset, PREV.rm_flags);

	trace_xfs_rmap_lookup_le_range_result(cur, PREV.rm_startblock,

			PREV.rm_blockcount, PREV.rm_owner, PREV.rm_offset,

			PREV.rm_flags);



	ASSERT(PREV.rm_offset <= offset);

	ASSERT(PREV.rm_offset + PREV.rm_blockcount >= new_endoff);
@@ -1284,10 +1258,9 @@ xfs_rmap_convert( 
			error = -EFSCORRUPTED;

			goto done;

		}

		trace_xfs_rmap_find_left_neighbor_result(cur->bc_mp,

				cur->bc_ag.pag->pag_agno, LEFT.rm_startblock,

				LEFT.rm_blockcount, LEFT.rm_owner,

				LEFT.rm_offset, LEFT.rm_flags);

		trace_xfs_rmap_find_left_neighbor_result(cur,

				LEFT.rm_startblock, LEFT.rm_blockcount,

				LEFT.rm_owner, LEFT.rm_offset, LEFT.rm_flags);

		if (LEFT.rm_startblock + LEFT.rm_blockcount == bno &&

		    LEFT.rm_offset + LEFT.rm_blockcount == offset &&

		    xfs_rmap_is_mergeable(&LEFT, owner, newext))
@@ -1325,10 +1298,10 @@ xfs_rmap_convert( 
			error = -EFSCORRUPTED;

			goto done;

		}

		trace_xfs_rmap_find_right_neighbor_result(cur->bc_mp,

				cur->bc_ag.pag->pag_agno, RIGHT.rm_startblock,

				RIGHT.rm_blockcount, RIGHT.rm_owner,

				RIGHT.rm_offset, RIGHT.rm_flags);

		trace_xfs_rmap_find_right_neighbor_result(cur,

				RIGHT.rm_startblock, RIGHT.rm_blockcount,

				RIGHT.rm_owner, RIGHT.rm_offset,

				RIGHT.rm_flags);

		if (bno + len == RIGHT.rm_startblock &&

		    offset + len == RIGHT.rm_offset &&

		    xfs_rmap_is_mergeable(&RIGHT, owner, newext))
@@ -1344,8 +1317,7 @@ xfs_rmap_convert( 
	     RIGHT.rm_blockcount > XFS_RMAP_LEN_MAX)

		state &= ~RMAP_RIGHT_CONTIG;



	trace_xfs_rmap_convert_state(mp, cur->bc_ag.pag->pag_agno, state,

			_RET_IP_);

	trace_xfs_rmap_convert_state(cur, state, _RET_IP_);



	/* reset the cursor back to PREV */

	error = xfs_rmap_lookup_le(cur, bno, owner, offset, oldext, NULL, &i);
@@ -1376,10 +1348,9 @@ xfs_rmap_convert( 
			error = -EFSCORRUPTED;

			goto done;

		}

		trace_xfs_rmap_delete(mp, cur->bc_ag.pag->pag_agno,

				RIGHT.rm_startblock, RIGHT.rm_blockcount,

				RIGHT.rm_owner, RIGHT.rm_offset,

				RIGHT.rm_flags);

		trace_xfs_rmap_delete(cur, RIGHT.rm_startblock,

				RIGHT.rm_blockcount, RIGHT.rm_owner,

				RIGHT.rm_offset, RIGHT.rm_flags);

		error = xfs_btree_delete(cur, &i);

		if (error)

			goto done;
@@ -1396,10 +1367,9 @@ xfs_rmap_convert( 
			error = -EFSCORRUPTED;

			goto done;

		}

		trace_xfs_rmap_delete(mp, cur->bc_ag.pag->pag_agno,

				PREV.rm_startblock, PREV.rm_blockcount,

				PREV.rm_owner, PREV.rm_offset,

				PREV.rm_flags);

		trace_xfs_rmap_delete(cur, PREV.rm_startblock,

				PREV.rm_blockcount, PREV.rm_owner,

				PREV.rm_offset, PREV.rm_flags);

		error = xfs_btree_delete(cur, &i);

		if (error)

			goto done;
@@ -1428,10 +1398,9 @@ xfs_rmap_convert( 
		 * Setting all of a previous oldext extent to newext.

		 * The left neighbor is contiguous, the right is not.

		 */

		trace_xfs_rmap_delete(mp, cur->bc_ag.pag->pag_agno,

				PREV.rm_startblock, PREV.rm_blockcount,

				PREV.rm_owner, PREV.rm_offset,

				PREV.rm_flags);

		trace_xfs_rmap_delete(cur, PREV.rm_startblock,

				PREV.rm_blockcount, PREV.rm_owner,

				PREV.rm_offset, PREV.rm_flags);

		error = xfs_btree_delete(cur, &i);

		if (error)

			goto done;
@@ -1468,10 +1437,9 @@ xfs_rmap_convert( 
			error = -EFSCORRUPTED;

			goto done;

		}

		trace_xfs_rmap_delete(mp, cur->bc_ag.pag->pag_agno,

				RIGHT.rm_startblock, RIGHT.rm_blockcount,

				RIGHT.rm_owner, RIGHT.rm_offset,

				RIGHT.rm_flags);

		trace_xfs_rmap_delete(cur, RIGHT.rm_startblock,

				RIGHT.rm_blockcount, RIGHT.rm_owner,

				RIGHT.rm_offset, RIGHT.rm_flags);

		error = xfs_btree_delete(cur, &i);

		if (error)

			goto done;
@@ -1549,8 +1517,7 @@ xfs_rmap_convert( 
		NEW.rm_blockcount = len;

		NEW.rm_flags = newext;

		cur->bc_rec.r = NEW;

		trace_xfs_rmap_insert(mp, cur->bc_ag.pag->pag_agno, bno,

				len, owner, offset, newext);

		trace_xfs_rmap_insert(cur, bno, len, owner, offset, newext);

		error = xfs_btree_insert(cur, &i);

		if (error)

			goto done;
@@ -1608,8 +1575,7 @@ xfs_rmap_convert( 
		NEW.rm_blockcount = len;

		NEW.rm_flags = newext;

		cur->bc_rec.r = NEW;

		trace_xfs_rmap_insert(mp, cur->bc_ag.pag->pag_agno, bno,

				len, owner, offset, newext);

		trace_xfs_rmap_insert(cur, bno, len, owner, offset, newext);

		error = xfs_btree_insert(cur, &i);

		if (error)

			goto done;
@@ -1640,9 +1606,8 @@ xfs_rmap_convert( 
		NEW = PREV;

		NEW.rm_blockcount = offset - PREV.rm_offset;

		cur->bc_rec.r = NEW;

		trace_xfs_rmap_insert(mp, cur->bc_ag.pag->pag_agno,

				NEW.rm_startblock, NEW.rm_blockcount,

				NEW.rm_owner, NEW.rm_offset,

		trace_xfs_rmap_insert(cur, NEW.rm_startblock,

				NEW.rm_blockcount, NEW.rm_owner, NEW.rm_offset,

				NEW.rm_flags);

		error = xfs_btree_insert(cur, &i);

		if (error)
@@ -1669,8 +1634,7 @@ xfs_rmap_convert( 
		/* new middle extent - newext */

		cur->bc_rec.r.rm_flags &= ~XFS_RMAP_UNWRITTEN;

		cur->bc_rec.r.rm_flags |= newext;

		trace_xfs_rmap_insert(mp, cur->bc_ag.pag->pag_agno, bno, len,

				owner, offset, newext);

		trace_xfs_rmap_insert(cur, bno, len, owner, offset, newext);

		error = xfs_btree_insert(cur, &i);

		if (error)

			goto done;
@@ -1694,12 +1658,10 @@ xfs_rmap_convert( 
		ASSERT(0);

	}



	trace_xfs_rmap_convert_done(mp, cur->bc_ag.pag->pag_agno, bno, len,

			unwritten, oinfo);

	trace_xfs_rmap_convert_done(cur, bno, len, unwritten, oinfo);

done:

	if (error)

		trace_xfs_rmap_convert_error(cur->bc_mp,

				cur->bc_ag.pag->pag_agno, error, _RET_IP_);

		trace_xfs_rmap_convert_error(cur, error, _RET_IP_);

	return error;

}
@@ -1735,8 +1697,7 @@ xfs_rmap_convert_shared( 
			(flags & (XFS_RMAP_ATTR_FORK | XFS_RMAP_BMBT_BLOCK))));

	oldext = unwritten ? XFS_RMAP_UNWRITTEN : 0;

	new_endoff = offset + len;

	trace_xfs_rmap_convert(mp, cur->bc_ag.pag->pag_agno, bno, len,

			unwritten, oinfo);

	trace_xfs_rmap_convert(cur, bno, len, unwritten, oinfo);



	/*

	 * For the initial lookup, look for and exact match or the left-adjacent
@@ -1805,10 +1766,10 @@ xfs_rmap_convert_shared( 
			error = -EFSCORRUPTED;

			goto done;

		}

		trace_xfs_rmap_find_right_neighbor_result(cur->bc_mp,

				cur->bc_ag.pag->pag_agno, RIGHT.rm_startblock,

				RIGHT.rm_blockcount, RIGHT.rm_owner,

				RIGHT.rm_offset, RIGHT.rm_flags);

		trace_xfs_rmap_find_right_neighbor_result(cur,

				RIGHT.rm_startblock, RIGHT.rm_blockcount,

				RIGHT.rm_owner, RIGHT.rm_offset,

				RIGHT.rm_flags);

		if (xfs_rmap_is_mergeable(&RIGHT, owner, newext))

			state |= RMAP_RIGHT_CONTIG;

	}
@@ -1822,8 +1783,7 @@ xfs_rmap_convert_shared( 
	     RIGHT.rm_blockcount > XFS_RMAP_LEN_MAX)

		state &= ~RMAP_RIGHT_CONTIG;



	trace_xfs_rmap_convert_state(mp, cur->bc_ag.pag->pag_agno, state,

			_RET_IP_);

	trace_xfs_rmap_convert_state(cur, state, _RET_IP_);

	/*

	 * Switch out based on the FILLING and CONTIG state bits.

	 */
@@ -2121,12 +2081,10 @@ xfs_rmap_convert_shared( 
		ASSERT(0);

	}



	trace_xfs_rmap_convert_done(mp, cur->bc_ag.pag->pag_agno, bno, len,

			unwritten, oinfo);

	trace_xfs_rmap_convert_done(cur, bno, len, unwritten, oinfo);

done:

	if (error)

		trace_xfs_rmap_convert_error(cur->bc_mp,

				cur->bc_ag.pag->pag_agno, error, _RET_IP_);

		trace_xfs_rmap_convert_error(cur, error, _RET_IP_);

	return error;

}
@@ -2164,8 +2122,7 @@ xfs_rmap_unmap_shared( 
	xfs_owner_info_unpack(oinfo, &owner, &offset, &flags);

	if (unwritten)

		flags |= XFS_RMAP_UNWRITTEN;

	trace_xfs_rmap_unmap(mp, cur->bc_ag.pag->pag_agno, bno, len,

			unwritten, oinfo);

	trace_xfs_rmap_unmap(cur, bno, len, unwritten, oinfo);



	/*

	 * We should always have a left record because there's a static record
@@ -2321,12 +2278,10 @@ xfs_rmap_unmap_shared( 
			goto out_error;

	}



	trace_xfs_rmap_unmap_done(mp, cur->bc_ag.pag->pag_agno, bno, len,

			unwritten, oinfo);

	trace_xfs_rmap_unmap_done(cur, bno, len, unwritten, oinfo);

out_error:

	if (error)

		trace_xfs_rmap_unmap_error(cur->bc_mp,

				cur->bc_ag.pag->pag_agno, error, _RET_IP_);

		trace_xfs_rmap_unmap_error(cur, error, _RET_IP_);

	return error;

}
@@ -2361,8 +2316,7 @@ xfs_rmap_map_shared( 
	xfs_owner_info_unpack(oinfo, &owner, &offset, &flags);

	if (unwritten)

		flags |= XFS_RMAP_UNWRITTEN;

	trace_xfs_rmap_map(mp, cur->bc_ag.pag->pag_agno, bno, len,

			unwritten, oinfo);

	trace_xfs_rmap_map(cur, bno, len, unwritten, oinfo);



	/* Is there a left record that abuts our range? */

	error = xfs_rmap_find_left_neighbor(cur, bno, owner, offset, flags,
@@ -2387,10 +2341,10 @@ xfs_rmap_map_shared( 
			error = -EFSCORRUPTED;

			goto out_error;

		}

		trace_xfs_rmap_find_right_neighbor_result(cur->bc_mp,

			cur->bc_ag.pag->pag_agno, gtrec.rm_startblock,

			gtrec.rm_blockcount, gtrec.rm_owner,

			gtrec.rm_offset, gtrec.rm_flags);

		trace_xfs_rmap_find_right_neighbor_result(cur,

				gtrec.rm_startblock, gtrec.rm_blockcount,

				gtrec.rm_owner, gtrec.rm_offset,

				gtrec.rm_flags);



		if (!xfs_rmap_is_mergeable(&gtrec, owner, flags))

			have_gt = 0;
@@ -2482,12 +2436,10 @@ xfs_rmap_map_shared( 
			goto out_error;

	}



	trace_xfs_rmap_map_done(mp, cur->bc_ag.pag->pag_agno, bno, len,

			unwritten, oinfo);

	trace_xfs_rmap_map_done(cur, bno, len, unwritten, oinfo);

out_error:

	if (error)

		trace_xfs_rmap_map_error(cur->bc_mp,

				cur->bc_ag.pag->pag_agno, error, _RET_IP_);

		trace_xfs_rmap_map_error(cur, error, _RET_IP_);

	return error;

}
@@ -2572,23 +2524,6 @@ xfs_rmap_query_all( 
	return xfs_btree_query_all(cur, xfs_rmap_query_range_helper, &query);

}



/* Clean up after calling xfs_rmap_finish_one. */

void

xfs_rmap_finish_one_cleanup(

	struct xfs_trans	*tp,

	struct xfs_btree_cur	*rcur,

	int			error)

{

	struct xfs_buf		*agbp;



	if (rcur == NULL)

		return;

	agbp = rcur->bc_ag.agbp;

	xfs_btree_del_cursor(rcur, error);

	if (error)

		xfs_trans_brelse(tp, agbp);

}



/* Commit an rmap operation into the ondisk tree. */

int

__xfs_rmap_finish_intent(
@@ -2634,20 +2569,15 @@ xfs_rmap_finish_one( 
	struct xfs_rmap_intent		*ri,

	struct xfs_btree_cur		**pcur)

{

	struct xfs_owner_info		oinfo;

	struct xfs_mount		*mp = tp->t_mountp;

	struct xfs_btree_cur		*rcur;

	struct xfs_btree_cur		*rcur = *pcur;

	struct xfs_buf			*agbp = NULL;

	int				error = 0;

	struct xfs_owner_info		oinfo;

	xfs_agblock_t			bno;

	bool				unwritten;

	int				error = 0;



	bno = XFS_FSB_TO_AGBNO(mp, ri->ri_bmap.br_startblock);



	trace_xfs_rmap_deferred(mp, ri->ri_pag->pag_agno, ri->ri_type, bno,

			ri->ri_owner, ri->ri_whichfork,

			ri->ri_bmap.br_startoff, ri->ri_bmap.br_blockcount,

			ri->ri_bmap.br_state);

	trace_xfs_rmap_deferred(mp, ri);



	if (XFS_TEST_ERROR(false, mp, XFS_ERRTAG_RMAP_FINISH_ONE))

		return -EIO;
@@ -2656,9 +2586,8 @@ xfs_rmap_finish_one( 
	 * If we haven't gotten a cursor or the cursor AG doesn't match

	 * the startblock, get one now.

	 */

	rcur = *pcur;

	if (rcur != NULL && rcur->bc_ag.pag != ri->ri_pag) {

		xfs_rmap_finish_one_cleanup(tp, rcur, 0);

		xfs_btree_del_cursor(rcur, 0);

		rcur = NULL;

		*pcur = NULL;

	}
@@ -2678,9 +2607,8 @@ xfs_rmap_finish_one( 
			return -EFSCORRUPTED;

		}



		rcur = xfs_rmapbt_init_cursor(mp, tp, agbp, ri->ri_pag);

		*pcur = rcur = xfs_rmapbt_init_cursor(mp, tp, agbp, ri->ri_pag);

	}

	*pcur = rcur;



	xfs_rmap_ino_owner(&oinfo, ri->ri_owner, ri->ri_whichfork,

			ri->ri_bmap.br_startoff);
@@ -2722,15 +2650,6 @@ __xfs_rmap_add( 
{

	struct xfs_rmap_intent		*ri;



	trace_xfs_rmap_defer(tp->t_mountp,

			XFS_FSB_TO_AGNO(tp->t_mountp, bmap->br_startblock),

			type,

			XFS_FSB_TO_AGBNO(tp->t_mountp, bmap->br_startblock),

			owner, whichfork,

			bmap->br_startoff,

			bmap->br_blockcount,

			bmap->br_state);



	ri = kmem_cache_alloc(xfs_rmap_intent_cache, GFP_KERNEL | __GFP_NOFAIL);

	INIT_LIST_HEAD(&ri->ri_list);

	ri->ri_type = type;
@@ -2738,8 +2657,7 @@ __xfs_rmap_add( 
	ri->ri_whichfork = whichfork;

	ri->ri_bmap = *bmap;



	xfs_rmap_update_get_group(tp->t_mountp, ri);

	xfs_defer_add(tp, &ri->ri_list, &xfs_rmap_update_defer_type);

	xfs_rmap_defer_add(tp, ri);

}



/* Map an extent into a file. */

fs/xfs/libxfs/xfs_rmap.h

+10 −5
Original line number Diff line number Diff line
@@ -157,6 +157,16 @@ enum xfs_rmap_intent_type { 
	XFS_RMAP_FREE,

};



#define XFS_RMAP_INTENT_STRINGS \

	{ XFS_RMAP_MAP,			"map" }, \

	{ XFS_RMAP_MAP_SHARED,		"map_shared" }, \

	{ XFS_RMAP_UNMAP,		"unmap" }, \

	{ XFS_RMAP_UNMAP_SHARED,	"unmap_shared" }, \

	{ XFS_RMAP_CONVERT,		"cvt" }, \

	{ XFS_RMAP_CONVERT_SHARED,	"cvt_shared" }, \

	{ XFS_RMAP_ALLOC,		"alloc" }, \

	{ XFS_RMAP_FREE,		"free" }



struct xfs_rmap_intent {

	struct list_head			ri_list;

	enum xfs_rmap_intent_type		ri_type;
@@ -166,9 +176,6 @@ struct xfs_rmap_intent { 
	struct xfs_perag			*ri_pag;

};



void xfs_rmap_update_get_group(struct xfs_mount *mp,

		struct xfs_rmap_intent *ri);



/* functions for updating the rmapbt based on bmbt map/unmap operations */

void xfs_rmap_map_extent(struct xfs_trans *tp, struct xfs_inode *ip,

		int whichfork, struct xfs_bmbt_irec *imap);
@@ -182,8 +189,6 @@ void xfs_rmap_alloc_extent(struct xfs_trans *tp, xfs_agnumber_t agno, 
void xfs_rmap_free_extent(struct xfs_trans *tp, xfs_agnumber_t agno,

		xfs_agblock_t bno, xfs_extlen_t len, uint64_t owner);



void xfs_rmap_finish_one_cleanup(struct xfs_trans *tp,

		struct xfs_btree_cur *rcur, int error);

int xfs_rmap_finish_one(struct xfs_trans *tp, struct xfs_rmap_intent *ri,

		struct xfs_btree_cur **pcur);

int __xfs_rmap_finish_intent(struct xfs_btree_cur *rcur,

fs/xfs/xfs_rmap_item.c

+75 −73

File changed.

Preview size limit exceeded, changes collapsed.

fs/xfs/xfs_rmap_item.h

+4 −0
Original line number Diff line number Diff line
@@ -71,4 +71,8 @@ struct xfs_rud_log_item { 
extern struct kmem_cache	*xfs_rui_cache;

extern struct kmem_cache	*xfs_rud_cache;



struct xfs_rmap_intent;



void xfs_rmap_defer_add(struct xfs_trans *tp, struct xfs_rmap_intent *ri);



#endif	/* __XFS_RMAP_ITEM_H__ */

fs/xfs/xfs_trace.c

+1 −0
Original line number Diff line number Diff line
@@ -41,6 +41,7 @@ 
#include "xfs_exchmaps.h"

#include "xfs_exchrange.h"

#include "xfs_parent.h"

#include "xfs_rmap.h"



/*

 * We include this last to have the helpers above available for the trace