Re: [PATCH 6/8] xfs: shorten xfs_repair_ prefix to xrep_

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



On Wed, Jul 18, 2018 at 08:51:58AM -0700, Darrick J. Wong wrote:
> From: Darrick J. Wong <darrick.wong@xxxxxxxxxx>
> 
> Shorten all the metadata repair xfs_repair_* symbols to xrep_.
> Whitespace damage will be fixed by a subsequent patch.  There are no
> functional changes.
> 
> Signed-off-by: Darrick J. Wong <darrick.wong@xxxxxxxxxx>
> ---

Reviewed-by: Brian Foster <bfoster@xxxxxxxxxx>

>  fs/xfs/scrub/agheader_repair.c |    2 
>  fs/xfs/scrub/common.c          |    2 
>  fs/xfs/scrub/repair.c          |  164 ++++++++++++++++++++--------------------
>  fs/xfs/scrub/repair.h          |   74 +++++++++---------
>  fs/xfs/scrub/scrub.c           |   54 +++++++------
>  fs/xfs/scrub/trace.h           |   40 +++++-----
>  6 files changed, 168 insertions(+), 168 deletions(-)
> 
> 
> diff --git a/fs/xfs/scrub/agheader_repair.c b/fs/xfs/scrub/agheader_repair.c
> index 117eedac53df..631940f3ca4d 100644
> --- a/fs/xfs/scrub/agheader_repair.c
> +++ b/fs/xfs/scrub/agheader_repair.c
> @@ -28,7 +28,7 @@
>  
>  /* Repair the superblock. */
>  int
> -xfs_repair_superblock(
> +xrep_superblock(
>  	struct xfs_scrub_context	*sc)
>  {
>  	struct xfs_mount		*mp = sc->mp;
> diff --git a/fs/xfs/scrub/common.c b/fs/xfs/scrub/common.c
> index a4004a06f482..fa1c16063d17 100644
> --- a/fs/xfs/scrub/common.c
> +++ b/fs/xfs/scrub/common.c
> @@ -604,7 +604,7 @@ xchk_setup_fs(
>  {
>  	uint				resblks;
>  
> -	resblks = xfs_repair_calc_ag_resblks(sc);
> +	resblks = xrep_calc_ag_resblks(sc);
>  	return xchk_trans_alloc(sc, resblks);
>  }
>  
> diff --git a/fs/xfs/scrub/repair.c b/fs/xfs/scrub/repair.c
> index 5eccd89c64a8..7e6a56a5f59d 100644
> --- a/fs/xfs/scrub/repair.c
> +++ b/fs/xfs/scrub/repair.c
> @@ -41,21 +41,21 @@
>   * and will set *fixed to true if it thinks it repaired anything.
>   */
>  int
> -xfs_repair_attempt(
> +xrep_attempt(
>  	struct xfs_inode		*ip,
>  	struct xfs_scrub_context	*sc,
>  	bool				*fixed)
>  {
>  	int				error = 0;
>  
> -	trace_xfs_repair_attempt(ip, sc->sm, error);
> +	trace_xrep_attempt(ip, sc->sm, error);
>  
>  	xchk_ag_btcur_free(&sc->sa);
>  
>  	/* Repair whatever's broken. */
>  	ASSERT(sc->ops->repair);
>  	error = sc->ops->repair(sc);
> -	trace_xfs_repair_done(ip, sc->sm, error);
> +	trace_xrep_done(ip, sc->sm, error);
>  	switch (error) {
>  	case 0:
>  		/*
> @@ -93,7 +93,7 @@ xfs_repair_attempt(
>   * structure to track rate limiting information.
>   */
>  void
> -xfs_repair_failure(
> +xrep_failure(
>  	struct xfs_mount		*mp)
>  {
>  	xfs_alert_ratelimited(mp,
> @@ -105,7 +105,7 @@ xfs_repair_failure(
>   * given mountpoint.
>   */
>  int
> -xfs_repair_probe(
> +xrep_probe(
>  	struct xfs_scrub_context	*sc)
>  {
>  	int				error = 0;
> @@ -121,7 +121,7 @@ xfs_repair_probe(
>   * the btree cursors.
>   */
>  int
> -xfs_repair_roll_ag_trans(
> +xrep_roll_ag_trans(
>  	struct xfs_scrub_context	*sc)
>  {
>  	int				error;
> @@ -162,7 +162,7 @@ xfs_repair_roll_ag_trans(
>   * in AG reservations) to construct a whole btree.
>   */
>  bool
> -xfs_repair_ag_has_space(
> +xrep_ag_has_space(
>  	struct xfs_perag		*pag,
>  	xfs_extlen_t			nr_blocks,
>  	enum xfs_ag_resv_type		type)
> @@ -178,7 +178,7 @@ xfs_repair_ag_has_space(
>   * any type of per-AG btree.
>   */
>  xfs_extlen_t
> -xfs_repair_calc_ag_resblks(
> +xrep_calc_ag_resblks(
>  	struct xfs_scrub_context	*sc)
>  {
>  	struct xfs_mount		*mp = sc->mp;
> @@ -231,7 +231,7 @@ xfs_repair_calc_ag_resblks(
>  	}
>  	xfs_perag_put(pag);
>  
> -	trace_xfs_repair_calc_ag_resblks(mp, sm->sm_agno, icount, aglen,
> +	trace_xrep_calc_ag_resblks(mp, sm->sm_agno, icount, aglen,
>  			freelen, usedlen);
>  
>  	/*
> @@ -270,7 +270,7 @@ xfs_repair_calc_ag_resblks(
>  		rmapbt_sz = 0;
>  	}
>  
> -	trace_xfs_repair_calc_ag_resblks_btsize(mp, sm->sm_agno, bnobt_sz,
> +	trace_xrep_calc_ag_resblks_btsize(mp, sm->sm_agno, bnobt_sz,
>  			inobt_sz, rmapbt_sz, refcbt_sz);
>  
>  	return max(max(bnobt_sz, inobt_sz), max(rmapbt_sz, refcbt_sz));
> @@ -278,7 +278,7 @@ xfs_repair_calc_ag_resblks(
>  
>  /* Allocate a block in an AG. */
>  int
> -xfs_repair_alloc_ag_block(
> +xrep_alloc_ag_block(
>  	struct xfs_scrub_context	*sc,
>  	struct xfs_owner_info		*oinfo,
>  	xfs_fsblock_t			*fsbno,
> @@ -329,7 +329,7 @@ xfs_repair_alloc_ag_block(
>  
>  /* Initialize a new AG btree root block with zero entries. */
>  int
> -xfs_repair_init_btblock(
> +xrep_init_btblock(
>  	struct xfs_scrub_context	*sc,
>  	xfs_fsblock_t			fsb,
>  	struct xfs_buf			**bpp,
> @@ -340,7 +340,7 @@ xfs_repair_init_btblock(
>  	struct xfs_mount		*mp = sc->mp;
>  	struct xfs_buf			*bp;
>  
> -	trace_xfs_repair_init_btblock(mp, XFS_FSB_TO_AGNO(mp, fsb),
> +	trace_xrep_init_btblock(mp, XFS_FSB_TO_AGNO(mp, fsb),
>  			XFS_FSB_TO_AGBNO(mp, fsb), btnum);
>  
>  	ASSERT(XFS_FSB_TO_AGNO(mp, fsb) == sc->sa.agno);
> @@ -384,19 +384,19 @@ xfs_repair_init_btblock(
>  
>  /* Collect a dead btree extent for later disposal. */
>  int
> -xfs_repair_collect_btree_extent(
> +xrep_collect_btree_extent(
>  	struct xfs_scrub_context	*sc,
> -	struct xfs_repair_extent_list	*exlist,
> +	struct xrep_extent_list		*exlist,
>  	xfs_fsblock_t			fsbno,
>  	xfs_extlen_t			len)
>  {
> -	struct xfs_repair_extent	*rex;
> +	struct xrep_extent		*rex;
>  
> -	trace_xfs_repair_collect_btree_extent(sc->mp,
> +	trace_xrep_collect_btree_extent(sc->mp,
>  			XFS_FSB_TO_AGNO(sc->mp, fsbno),
>  			XFS_FSB_TO_AGBNO(sc->mp, fsbno), len);
>  
> -	rex = kmem_alloc(sizeof(struct xfs_repair_extent), KM_MAYFAIL);
> +	rex = kmem_alloc(sizeof(struct xrep_extent), KM_MAYFAIL);
>  	if (!rex)
>  		return -ENOMEM;
>  
> @@ -414,14 +414,14 @@ xfs_repair_collect_btree_extent(
>   * Therefore, free all the memory associated with the list so we can die.
>   */
>  void
> -xfs_repair_cancel_btree_extents(
> +xrep_cancel_btree_extents(
>  	struct xfs_scrub_context	*sc,
> -	struct xfs_repair_extent_list	*exlist)
> +	struct xrep_extent_list		*exlist)
>  {
> -	struct xfs_repair_extent	*rex;
> -	struct xfs_repair_extent	*n;
> +	struct xrep_extent		*rex;
> +	struct xrep_extent		*n;
>  
> -	for_each_xfs_repair_extent_safe(rex, n, exlist) {
> +	for_each_xrep_extent_safe(rex, n, exlist) {
>  		list_del(&rex->list);
>  		kmem_free(rex);
>  	}
> @@ -429,16 +429,16 @@ xfs_repair_cancel_btree_extents(
>  
>  /* Compare two btree extents. */
>  static int
> -xfs_repair_btree_extent_cmp(
> +xrep_btree_extent_cmp(
>  	void				*priv,
>  	struct list_head		*a,
>  	struct list_head		*b)
>  {
> -	struct xfs_repair_extent	*ap;
> -	struct xfs_repair_extent	*bp;
> +	struct xrep_extent		*ap;
> +	struct xrep_extent		*bp;
>  
> -	ap = container_of(a, struct xfs_repair_extent, list);
> -	bp = container_of(b, struct xfs_repair_extent, list);
> +	ap = container_of(a, struct xrep_extent, list);
> +	bp = container_of(b, struct xrep_extent, list);
>  
>  	if (ap->fsbno > bp->fsbno)
>  		return 1;
> @@ -462,15 +462,15 @@ xfs_repair_btree_extent_cmp(
>  #define LEFT_ALIGNED	(1 << 0)
>  #define RIGHT_ALIGNED	(1 << 1)
>  int
> -xfs_repair_subtract_extents(
> +xrep_subtract_extents(
>  	struct xfs_scrub_context	*sc,
> -	struct xfs_repair_extent_list	*exlist,
> -	struct xfs_repair_extent_list	*sublist)
> +	struct xrep_extent_list		*exlist,
> +	struct xrep_extent_list		*sublist)
>  {
>  	struct list_head		*lp;
> -	struct xfs_repair_extent	*ex;
> -	struct xfs_repair_extent	*newex;
> -	struct xfs_repair_extent	*subex;
> +	struct xrep_extent		*ex;
> +	struct xrep_extent		*newex;
> +	struct xrep_extent		*subex;
>  	xfs_fsblock_t			sub_fsb;
>  	xfs_extlen_t			sub_len;
>  	int				state;
> @@ -480,8 +480,8 @@ xfs_repair_subtract_extents(
>  		return 0;
>  	ASSERT(!list_empty(&sublist->list));
>  
> -	list_sort(NULL, &exlist->list, xfs_repair_btree_extent_cmp);
> -	list_sort(NULL, &sublist->list, xfs_repair_btree_extent_cmp);
> +	list_sort(NULL, &exlist->list, xrep_btree_extent_cmp);
> +	list_sort(NULL, &sublist->list, xrep_btree_extent_cmp);
>  
>  	/*
>  	 * Now that we've sorted both lists, we iterate exlist once, rolling
> @@ -491,11 +491,11 @@ xfs_repair_subtract_extents(
>  	 * list traversal is similar to merge sort, but we're deleting
>  	 * instead.  In this manner we avoid O(n^2) operations.
>  	 */
> -	subex = list_first_entry(&sublist->list, struct xfs_repair_extent,
> +	subex = list_first_entry(&sublist->list, struct xrep_extent,
>  			list);
>  	lp = exlist->list.next;
>  	while (lp != &exlist->list) {
> -		ex = list_entry(lp, struct xfs_repair_extent, list);
> +		ex = list_entry(lp, struct xrep_extent, list);
>  
>  		/*
>  		 * Advance subex and/or ex until we find a pair that
> @@ -548,7 +548,7 @@ xfs_repair_subtract_extents(
>  			 * Deleting from the middle: add the new right extent
>  			 * and then shrink the left extent.
>  			 */
> -			newex = kmem_alloc(sizeof(struct xfs_repair_extent),
> +			newex = kmem_alloc(sizeof(struct xrep_extent),
>  					KM_MAYFAIL);
>  			if (!newex) {
>  				error = -ENOMEM;
> @@ -619,12 +619,12 @@ xfs_repair_subtract_extents(
>   * is not intended for use with file data repairs; we have bunmapi for that.
>   */
>  int
> -xfs_repair_invalidate_blocks(
> +xrep_invalidate_blocks(
>  	struct xfs_scrub_context	*sc,
> -	struct xfs_repair_extent_list	*exlist)
> +	struct xrep_extent_list		*exlist)
>  {
> -	struct xfs_repair_extent	*rex;
> -	struct xfs_repair_extent	*n;
> +	struct xrep_extent		*rex;
> +	struct xrep_extent		*n;
>  	struct xfs_buf			*bp;
>  	xfs_fsblock_t			fsbno;
>  	xfs_agblock_t			i;
> @@ -637,7 +637,7 @@ xfs_repair_invalidate_blocks(
>  	 * because we never own those; and if we can't TRYLOCK the buffer we
>  	 * assume it's owned by someone else.
>  	 */
> -	for_each_xfs_repair_extent_safe(rex, n, exlist) {
> +	for_each_xrep_extent_safe(rex, n, exlist) {
>  		for (fsbno = rex->fsbno, i = rex->len; i > 0; fsbno++, i--) {
>  			/* Skip AG headers and post-EOFS blocks */
>  			if (!xfs_verify_fsbno(sc->mp, fsbno))
> @@ -657,7 +657,7 @@ xfs_repair_invalidate_blocks(
>  
>  /* Ensure the freelist is the correct size. */
>  int
> -xfs_repair_fix_freelist(
> +xrep_fix_freelist(
>  	struct xfs_scrub_context	*sc,
>  	bool				can_shrink)
>  {
> @@ -677,7 +677,7 @@ xfs_repair_fix_freelist(
>   * Put a block back on the AGFL.
>   */
>  STATIC int
> -xfs_repair_put_freelist(
> +xrep_put_freelist(
>  	struct xfs_scrub_context	*sc,
>  	xfs_agblock_t			agbno)
>  {
> @@ -685,7 +685,7 @@ xfs_repair_put_freelist(
>  	int				error;
>  
>  	/* Make sure there's space on the freelist. */
> -	error = xfs_repair_fix_freelist(sc, true);
> +	error = xrep_fix_freelist(sc, true);
>  	if (error)
>  		return error;
>  
> @@ -713,7 +713,7 @@ xfs_repair_put_freelist(
>  
>  /* Dispose of a single metadata block. */
>  STATIC int
> -xfs_repair_dispose_btree_block(
> +xrep_dispose_btree_block(
>  	struct xfs_scrub_context	*sc,
>  	xfs_fsblock_t			fsbno,
>  	struct xfs_owner_info		*oinfo,
> @@ -767,7 +767,7 @@ xfs_repair_dispose_btree_block(
>  	if (has_other_rmap)
>  		error = xfs_rmap_free(sc->tp, agf_bp, agno, agbno, 1, oinfo);
>  	else if (resv == XFS_AG_RESV_AGFL)
> -		error = xfs_repair_put_freelist(sc, agbno);
> +		error = xrep_put_freelist(sc, agbno);
>  	else
>  		error = xfs_free_extent(sc->tp, fsbno, 1, oinfo, resv);
>  	if (agf_bp != sc->sa.agf_bp)
> @@ -777,7 +777,7 @@ xfs_repair_dispose_btree_block(
>  
>  	if (sc->ip)
>  		return xfs_trans_roll_inode(&sc->tp, sc->ip);
> -	return xfs_repair_roll_ag_trans(sc);
> +	return xrep_roll_ag_trans(sc);
>  
>  out_free:
>  	if (agf_bp != sc->sa.agf_bp)
> @@ -787,29 +787,29 @@ xfs_repair_dispose_btree_block(
>  
>  /* Dispose of btree blocks from an old per-AG btree. */
>  int
> -xfs_repair_reap_btree_extents(
> +xrep_reap_btree_extents(
>  	struct xfs_scrub_context	*sc,
> -	struct xfs_repair_extent_list	*exlist,
> +	struct xrep_extent_list		*exlist,
>  	struct xfs_owner_info		*oinfo,
>  	enum xfs_ag_resv_type		type)
>  {
> -	struct xfs_repair_extent	*rex;
> -	struct xfs_repair_extent	*n;
> +	struct xrep_extent		*rex;
> +	struct xrep_extent		*n;
>  	int				error = 0;
>  
>  	ASSERT(xfs_sb_version_hasrmapbt(&sc->mp->m_sb));
>  
>  	/* Dispose of every block from the old btree. */
> -	for_each_xfs_repair_extent_safe(rex, n, exlist) {
> +	for_each_xrep_extent_safe(rex, n, exlist) {
>  		ASSERT(sc->ip != NULL ||
>  		       XFS_FSB_TO_AGNO(sc->mp, rex->fsbno) == sc->sa.agno);
>  
> -		trace_xfs_repair_dispose_btree_extent(sc->mp,
> +		trace_xrep_dispose_btree_extent(sc->mp,
>  				XFS_FSB_TO_AGNO(sc->mp, rex->fsbno),
>  				XFS_FSB_TO_AGBNO(sc->mp, rex->fsbno), rex->len);
>  
>  		for (; rex->len > 0; rex->len--, rex->fsbno++) {
> -			error = xfs_repair_dispose_btree_block(sc, rex->fsbno,
> +			error = xrep_dispose_btree_block(sc, rex->fsbno,
>  					oinfo, type);
>  			if (error)
>  				goto out;
> @@ -819,7 +819,7 @@ xfs_repair_reap_btree_extents(
>  	}
>  
>  out:
> -	xfs_repair_cancel_btree_extents(sc, exlist);
> +	xrep_cancel_btree_extents(sc, exlist);
>  	return error;
>  }
>  
> @@ -831,12 +831,12 @@ xfs_repair_reap_btree_extents(
>   * btree roots.  This is not guaranteed to work if the AG is heavily damaged
>   * or the rmap data are corrupt.
>   *
> - * Callers of xfs_repair_find_ag_btree_roots must lock the AGF and AGFL
> + * Callers of xrep_find_ag_btree_roots must lock the AGF and AGFL
>   * buffers if the AGF is being rebuilt; or the AGF and AGI buffers if the
>   * AGI is being rebuilt.  It must maintain these locks until it's safe for
>   * other threads to change the btrees' shapes.  The caller provides
>   * information about the btrees to look for by passing in an array of
> - * xfs_repair_find_ag_btree with the (rmap owner, buf_ops, magic) fields set.
> + * xrep_find_ag_btree with the (rmap owner, buf_ops, magic) fields set.
>   * The (root, height) fields will be set on return if anything is found.  The
>   * last element of the array should have a NULL buf_ops to mark the end of the
>   * array.
> @@ -850,16 +850,16 @@ xfs_repair_reap_btree_extents(
>   * should be the roots.
>   */
>  
> -struct xfs_repair_findroot {
> +struct xrep_findroot {
>  	struct xfs_scrub_context	*sc;
>  	struct xfs_buf			*agfl_bp;
>  	struct xfs_agf			*agf;
> -	struct xfs_repair_find_ag_btree	*btree_info;
> +	struct xrep_find_ag_btree	*btree_info;
>  };
>  
>  /* See if our block is in the AGFL. */
>  STATIC int
> -xfs_repair_findroot_agfl_walk(
> +xrep_findroot_agfl_walk(
>  	struct xfs_mount		*mp,
>  	xfs_agblock_t			bno,
>  	void				*priv)
> @@ -871,9 +871,9 @@ xfs_repair_findroot_agfl_walk(
>  
>  /* Does this block match the btree information passed in? */
>  STATIC int
> -xfs_repair_findroot_block(
> -	struct xfs_repair_findroot	*ri,
> -	struct xfs_repair_find_ag_btree	*fab,
> +xrep_findroot_block(
> +	struct xrep_findroot		*ri,
> +	struct xrep_find_ag_btree	*fab,
>  	uint64_t			owner,
>  	xfs_agblock_t			agbno,
>  	bool				*found_it)
> @@ -894,7 +894,7 @@ xfs_repair_findroot_block(
>  	 */
>  	if (owner == XFS_RMAP_OWN_AG) {
>  		error = xfs_agfl_walk(mp, ri->agf, ri->agfl_bp,
> -				xfs_repair_findroot_agfl_walk, &agbno);
> +				xrep_findroot_agfl_walk, &agbno);
>  		if (error == XFS_BTREE_QUERY_RANGE_ABORT)
>  			return 0;
>  		if (error)
> @@ -932,7 +932,7 @@ xfs_repair_findroot_block(
>  	fab->height = xfs_btree_get_level(btblock) + 1;
>  	*found_it = true;
>  
> -	trace_xfs_repair_findroot_block(mp, ri->sc->sa.agno, agbno,
> +	trace_xrep_findroot_block(mp, ri->sc->sa.agno, agbno,
>  			be32_to_cpu(btblock->bb_magic), fab->height - 1);
>  out:
>  	xfs_trans_brelse(ri->sc->tp, bp);
> @@ -944,13 +944,13 @@ xfs_repair_findroot_block(
>   * looking for?
>   */
>  STATIC int
> -xfs_repair_findroot_rmap(
> +xrep_findroot_rmap(
>  	struct xfs_btree_cur		*cur,
>  	struct xfs_rmap_irec		*rec,
>  	void				*priv)
>  {
> -	struct xfs_repair_findroot	*ri = priv;
> -	struct xfs_repair_find_ag_btree	*fab;
> +	struct xrep_findroot		*ri = priv;
> +	struct xrep_find_ag_btree	*fab;
>  	xfs_agblock_t			b;
>  	bool				found_it;
>  	int				error = 0;
> @@ -965,7 +965,7 @@ xfs_repair_findroot_rmap(
>  		for (fab = ri->btree_info; fab->buf_ops; fab++) {
>  			if (rec->rm_owner != fab->rmap_owner)
>  				continue;
> -			error = xfs_repair_findroot_block(ri, fab,
> +			error = xrep_findroot_block(ri, fab,
>  					rec->rm_owner, rec->rm_startblock + b,
>  					&found_it);
>  			if (error)
> @@ -980,15 +980,15 @@ xfs_repair_findroot_rmap(
>  
>  /* Find the roots of the per-AG btrees described in btree_info. */
>  int
> -xfs_repair_find_ag_btree_roots(
> +xrep_find_ag_btree_roots(
>  	struct xfs_scrub_context	*sc,
>  	struct xfs_buf			*agf_bp,
> -	struct xfs_repair_find_ag_btree	*btree_info,
> +	struct xrep_find_ag_btree	*btree_info,
>  	struct xfs_buf			*agfl_bp)
>  {
>  	struct xfs_mount		*mp = sc->mp;
> -	struct xfs_repair_findroot	ri;
> -	struct xfs_repair_find_ag_btree	*fab;
> +	struct xrep_findroot		ri;
> +	struct xrep_find_ag_btree	*fab;
>  	struct xfs_btree_cur		*cur;
>  	int				error;
>  
> @@ -1007,7 +1007,7 @@ xfs_repair_find_ag_btree_roots(
>  	}
>  
>  	cur = xfs_rmapbt_init_cursor(mp, sc->tp, agf_bp, sc->sa.agno);
> -	error = xfs_rmap_query_all(cur, xfs_repair_findroot_rmap, &ri);
> +	error = xfs_rmap_query_all(cur, xrep_findroot_rmap, &ri);
>  	xfs_btree_del_cursor(cur, error);
>  
>  	return error;
> @@ -1015,7 +1015,7 @@ xfs_repair_find_ag_btree_roots(
>  
>  /* Force a quotacheck the next time we mount. */
>  void
> -xfs_repair_force_quotacheck(
> +xrep_force_quotacheck(
>  	struct xfs_scrub_context	*sc,
>  	uint				dqtype)
>  {
> @@ -1043,7 +1043,7 @@ xfs_repair_force_quotacheck(
>   * repair corruptions in the quota metadata.
>   */
>  int
> -xfs_repair_ino_dqattach(
> +xrep_ino_dqattach(
>  	struct xfs_scrub_context	*sc)
>  {
>  	int				error;
> @@ -1057,11 +1057,11 @@ xfs_repair_ino_dqattach(
>  "inode %llu repair encountered quota error %d, quotacheck forced.",
>  				(unsigned long long)sc->ip->i_ino, error);
>  		if (XFS_IS_UQUOTA_ON(sc->mp) && !sc->ip->i_udquot)
> -			xfs_repair_force_quotacheck(sc, XFS_DQ_USER);
> +			xrep_force_quotacheck(sc, XFS_DQ_USER);
>  		if (XFS_IS_GQUOTA_ON(sc->mp) && !sc->ip->i_gdquot)
> -			xfs_repair_force_quotacheck(sc, XFS_DQ_GROUP);
> +			xrep_force_quotacheck(sc, XFS_DQ_GROUP);
>  		if (XFS_IS_PQUOTA_ON(sc->mp) && !sc->ip->i_pdquot)
> -			xfs_repair_force_quotacheck(sc, XFS_DQ_PROJ);
> +			xrep_force_quotacheck(sc, XFS_DQ_PROJ);
>  		/* fall through */
>  	case -ESRCH:
>  		error = 0;
> diff --git a/fs/xfs/scrub/repair.h b/fs/xfs/scrub/repair.h
> index ef47826b6725..60d81294797b 100644
> --- a/fs/xfs/scrub/repair.h
> +++ b/fs/xfs/scrub/repair.h
> @@ -6,7 +6,7 @@
>  #ifndef __XFS_SCRUB_REPAIR_H__
>  #define __XFS_SCRUB_REPAIR_H__
>  
> -static inline int xfs_repair_notsupported(struct xfs_scrub_context *sc)
> +static inline int xrep_notsupported(struct xfs_scrub_context *sc)
>  {
>  	return -EOPNOTSUPP;
>  }
> @@ -15,55 +15,55 @@ static inline int xfs_repair_notsupported(struct xfs_scrub_context *sc)
>  
>  /* Repair helpers */
>  
> -int xfs_repair_attempt(struct xfs_inode *ip, struct xfs_scrub_context *sc,
> +int xrep_attempt(struct xfs_inode *ip, struct xfs_scrub_context *sc,
>  		bool *fixed);
> -void xfs_repair_failure(struct xfs_mount *mp);
> -int xfs_repair_roll_ag_trans(struct xfs_scrub_context *sc);
> -bool xfs_repair_ag_has_space(struct xfs_perag *pag, xfs_extlen_t nr_blocks,
> +void xrep_failure(struct xfs_mount *mp);
> +int xrep_roll_ag_trans(struct xfs_scrub_context *sc);
> +bool xrep_ag_has_space(struct xfs_perag *pag, xfs_extlen_t nr_blocks,
>  		enum xfs_ag_resv_type type);
> -xfs_extlen_t xfs_repair_calc_ag_resblks(struct xfs_scrub_context *sc);
> -int xfs_repair_alloc_ag_block(struct xfs_scrub_context *sc,
> +xfs_extlen_t xrep_calc_ag_resblks(struct xfs_scrub_context *sc);
> +int xrep_alloc_ag_block(struct xfs_scrub_context *sc,
>  		struct xfs_owner_info *oinfo, xfs_fsblock_t *fsbno,
>  		enum xfs_ag_resv_type resv);
> -int xfs_repair_init_btblock(struct xfs_scrub_context *sc, xfs_fsblock_t fsb,
> +int xrep_init_btblock(struct xfs_scrub_context *sc, xfs_fsblock_t fsb,
>  		struct xfs_buf **bpp, xfs_btnum_t btnum,
>  		const struct xfs_buf_ops *ops);
>  
> -struct xfs_repair_extent {
> +struct xrep_extent {
>  	struct list_head		list;
>  	xfs_fsblock_t			fsbno;
>  	xfs_extlen_t			len;
>  };
>  
> -struct xfs_repair_extent_list {
> +struct xrep_extent_list {
>  	struct list_head		list;
>  };
>  
>  static inline void
> -xfs_repair_init_extent_list(
> -	struct xfs_repair_extent_list	*exlist)
> +xrep_init_extent_list(
> +	struct xrep_extent_list		*exlist)
>  {
>  	INIT_LIST_HEAD(&exlist->list);
>  }
>  
> -#define for_each_xfs_repair_extent_safe(rbe, n, exlist) \
> +#define for_each_xrep_extent_safe(rbe, n, exlist) \
>  	list_for_each_entry_safe((rbe), (n), &(exlist)->list, list)
> -int xfs_repair_collect_btree_extent(struct xfs_scrub_context *sc,
> -		struct xfs_repair_extent_list *btlist, xfs_fsblock_t fsbno,
> +int xrep_collect_btree_extent(struct xfs_scrub_context *sc,
> +		struct xrep_extent_list *btlist, xfs_fsblock_t fsbno,
>  		xfs_extlen_t len);
> -void xfs_repair_cancel_btree_extents(struct xfs_scrub_context *sc,
> -		struct xfs_repair_extent_list *btlist);
> -int xfs_repair_subtract_extents(struct xfs_scrub_context *sc,
> -		struct xfs_repair_extent_list *exlist,
> -		struct xfs_repair_extent_list *sublist);
> -int xfs_repair_fix_freelist(struct xfs_scrub_context *sc, bool can_shrink);
> -int xfs_repair_invalidate_blocks(struct xfs_scrub_context *sc,
> -		struct xfs_repair_extent_list *btlist);
> -int xfs_repair_reap_btree_extents(struct xfs_scrub_context *sc,
> -		struct xfs_repair_extent_list *exlist,
> +void xrep_cancel_btree_extents(struct xfs_scrub_context *sc,
> +		struct xrep_extent_list *btlist);
> +int xrep_subtract_extents(struct xfs_scrub_context *sc,
> +		struct xrep_extent_list *exlist,
> +		struct xrep_extent_list *sublist);
> +int xrep_fix_freelist(struct xfs_scrub_context *sc, bool can_shrink);
> +int xrep_invalidate_blocks(struct xfs_scrub_context *sc,
> +		struct xrep_extent_list *btlist);
> +int xrep_reap_btree_extents(struct xfs_scrub_context *sc,
> +		struct xrep_extent_list *exlist,
>  		struct xfs_owner_info *oinfo, enum xfs_ag_resv_type type);
>  
> -struct xfs_repair_find_ag_btree {
> +struct xrep_find_ag_btree {
>  	/* in: rmap owner of the btree we're looking for */
>  	uint64_t			rmap_owner;
>  
> @@ -78,21 +78,21 @@ struct xfs_repair_find_ag_btree {
>  	unsigned int			height;
>  };
>  
> -int xfs_repair_find_ag_btree_roots(struct xfs_scrub_context *sc,
> +int xrep_find_ag_btree_roots(struct xfs_scrub_context *sc,
>  		struct xfs_buf *agf_bp,
> -		struct xfs_repair_find_ag_btree *btree_info,
> +		struct xrep_find_ag_btree *btree_info,
>  		struct xfs_buf *agfl_bp);
> -void xfs_repair_force_quotacheck(struct xfs_scrub_context *sc, uint dqtype);
> -int xfs_repair_ino_dqattach(struct xfs_scrub_context *sc);
> +void xrep_force_quotacheck(struct xfs_scrub_context *sc, uint dqtype);
> +int xrep_ino_dqattach(struct xfs_scrub_context *sc);
>  
>  /* Metadata repairers */
>  
> -int xfs_repair_probe(struct xfs_scrub_context *sc);
> -int xfs_repair_superblock(struct xfs_scrub_context *sc);
> +int xrep_probe(struct xfs_scrub_context *sc);
> +int xrep_superblock(struct xfs_scrub_context *sc);
>  
>  #else
>  
> -static inline int xfs_repair_attempt(
> +static inline int xrep_attempt(
>  	struct xfs_inode		*ip,
>  	struct xfs_scrub_context	*sc,
>  	bool				*fixed)
> @@ -100,18 +100,18 @@ static inline int xfs_repair_attempt(
>  	return -EOPNOTSUPP;
>  }
>  
> -static inline void xfs_repair_failure(struct xfs_mount *mp) {}
> +static inline void xrep_failure(struct xfs_mount *mp) {}
>  
>  static inline xfs_extlen_t
> -xfs_repair_calc_ag_resblks(
> +xrep_calc_ag_resblks(
>  	struct xfs_scrub_context	*sc)
>  {
>  	ASSERT(!(sc->sm->sm_flags & XFS_SCRUB_IFLAG_REPAIR));
>  	return 0;
>  }
>  
> -#define xfs_repair_probe		xfs_repair_notsupported
> -#define xfs_repair_superblock		xfs_repair_notsupported
> +#define xrep_probe			xrep_notsupported
> +#define xrep_superblock			xrep_notsupported
>  
>  #endif /* CONFIG_XFS_ONLINE_REPAIR */
>  
> diff --git a/fs/xfs/scrub/scrub.c b/fs/xfs/scrub/scrub.c
> index ead97ab91a3c..a6efede6e430 100644
> --- a/fs/xfs/scrub/scrub.c
> +++ b/fs/xfs/scrub/scrub.c
> @@ -202,150 +202,150 @@ static const struct xchk_meta_ops meta_scrub_ops[] = {
>  		.type	= ST_NONE,
>  		.setup	= xchk_setup_fs,
>  		.scrub	= xchk_probe,
> -		.repair = xfs_repair_probe,
> +		.repair = xrep_probe,
>  	},
>  	[XFS_SCRUB_TYPE_SB] = {		/* superblock */
>  		.type	= ST_PERAG,
>  		.setup	= xchk_setup_fs,
>  		.scrub	= xchk_superblock,
> -		.repair	= xfs_repair_superblock,
> +		.repair	= xrep_superblock,
>  	},
>  	[XFS_SCRUB_TYPE_AGF] = {	/* agf */
>  		.type	= ST_PERAG,
>  		.setup	= xchk_setup_fs,
>  		.scrub	= xchk_agf,
> -		.repair	= xfs_repair_notsupported,
> +		.repair	= xrep_notsupported,
>  	},
>  	[XFS_SCRUB_TYPE_AGFL]= {	/* agfl */
>  		.type	= ST_PERAG,
>  		.setup	= xchk_setup_fs,
>  		.scrub	= xchk_agfl,
> -		.repair	= xfs_repair_notsupported,
> +		.repair	= xrep_notsupported,
>  	},
>  	[XFS_SCRUB_TYPE_AGI] = {	/* agi */
>  		.type	= ST_PERAG,
>  		.setup	= xchk_setup_fs,
>  		.scrub	= xchk_agi,
> -		.repair	= xfs_repair_notsupported,
> +		.repair	= xrep_notsupported,
>  	},
>  	[XFS_SCRUB_TYPE_BNOBT] = {	/* bnobt */
>  		.type	= ST_PERAG,
>  		.setup	= xchk_setup_ag_allocbt,
>  		.scrub	= xchk_bnobt,
> -		.repair	= xfs_repair_notsupported,
> +		.repair	= xrep_notsupported,
>  	},
>  	[XFS_SCRUB_TYPE_CNTBT] = {	/* cntbt */
>  		.type	= ST_PERAG,
>  		.setup	= xchk_setup_ag_allocbt,
>  		.scrub	= xchk_cntbt,
> -		.repair	= xfs_repair_notsupported,
> +		.repair	= xrep_notsupported,
>  	},
>  	[XFS_SCRUB_TYPE_INOBT] = {	/* inobt */
>  		.type	= ST_PERAG,
>  		.setup	= xchk_setup_ag_iallocbt,
>  		.scrub	= xchk_inobt,
> -		.repair	= xfs_repair_notsupported,
> +		.repair	= xrep_notsupported,
>  	},
>  	[XFS_SCRUB_TYPE_FINOBT] = {	/* finobt */
>  		.type	= ST_PERAG,
>  		.setup	= xchk_setup_ag_iallocbt,
>  		.scrub	= xchk_finobt,
>  		.has	= xfs_sb_version_hasfinobt,
> -		.repair	= xfs_repair_notsupported,
> +		.repair	= xrep_notsupported,
>  	},
>  	[XFS_SCRUB_TYPE_RMAPBT] = {	/* rmapbt */
>  		.type	= ST_PERAG,
>  		.setup	= xchk_setup_ag_rmapbt,
>  		.scrub	= xchk_rmapbt,
>  		.has	= xfs_sb_version_hasrmapbt,
> -		.repair	= xfs_repair_notsupported,
> +		.repair	= xrep_notsupported,
>  	},
>  	[XFS_SCRUB_TYPE_REFCNTBT] = {	/* refcountbt */
>  		.type	= ST_PERAG,
>  		.setup	= xchk_setup_ag_refcountbt,
>  		.scrub	= xchk_refcountbt,
>  		.has	= xfs_sb_version_hasreflink,
> -		.repair	= xfs_repair_notsupported,
> +		.repair	= xrep_notsupported,
>  	},
>  	[XFS_SCRUB_TYPE_INODE] = {	/* inode record */
>  		.type	= ST_INODE,
>  		.setup	= xchk_setup_inode,
>  		.scrub	= xchk_inode,
> -		.repair	= xfs_repair_notsupported,
> +		.repair	= xrep_notsupported,
>  	},
>  	[XFS_SCRUB_TYPE_BMBTD] = {	/* inode data fork */
>  		.type	= ST_INODE,
>  		.setup	= xchk_setup_inode_bmap,
>  		.scrub	= xchk_bmap_data,
> -		.repair	= xfs_repair_notsupported,
> +		.repair	= xrep_notsupported,
>  	},
>  	[XFS_SCRUB_TYPE_BMBTA] = {	/* inode attr fork */
>  		.type	= ST_INODE,
>  		.setup	= xchk_setup_inode_bmap,
>  		.scrub	= xchk_bmap_attr,
> -		.repair	= xfs_repair_notsupported,
> +		.repair	= xrep_notsupported,
>  	},
>  	[XFS_SCRUB_TYPE_BMBTC] = {	/* inode CoW fork */
>  		.type	= ST_INODE,
>  		.setup	= xchk_setup_inode_bmap,
>  		.scrub	= xchk_bmap_cow,
> -		.repair	= xfs_repair_notsupported,
> +		.repair	= xrep_notsupported,
>  	},
>  	[XFS_SCRUB_TYPE_DIR] = {	/* directory */
>  		.type	= ST_INODE,
>  		.setup	= xchk_setup_directory,
>  		.scrub	= xchk_directory,
> -		.repair	= xfs_repair_notsupported,
> +		.repair	= xrep_notsupported,
>  	},
>  	[XFS_SCRUB_TYPE_XATTR] = {	/* extended attributes */
>  		.type	= ST_INODE,
>  		.setup	= xchk_setup_xattr,
>  		.scrub	= xchk_xattr,
> -		.repair	= xfs_repair_notsupported,
> +		.repair	= xrep_notsupported,
>  	},
>  	[XFS_SCRUB_TYPE_SYMLINK] = {	/* symbolic link */
>  		.type	= ST_INODE,
>  		.setup	= xchk_setup_symlink,
>  		.scrub	= xchk_symlink,
> -		.repair	= xfs_repair_notsupported,
> +		.repair	= xrep_notsupported,
>  	},
>  	[XFS_SCRUB_TYPE_PARENT] = {	/* parent pointers */
>  		.type	= ST_INODE,
>  		.setup	= xchk_setup_parent,
>  		.scrub	= xchk_parent,
> -		.repair	= xfs_repair_notsupported,
> +		.repair	= xrep_notsupported,
>  	},
>  	[XFS_SCRUB_TYPE_RTBITMAP] = {	/* realtime bitmap */
>  		.type	= ST_FS,
>  		.setup	= xchk_setup_rt,
>  		.scrub	= xchk_rtbitmap,
>  		.has	= xfs_sb_version_hasrealtime,
> -		.repair	= xfs_repair_notsupported,
> +		.repair	= xrep_notsupported,
>  	},
>  	[XFS_SCRUB_TYPE_RTSUM] = {	/* realtime summary */
>  		.type	= ST_FS,
>  		.setup	= xchk_setup_rt,
>  		.scrub	= xchk_rtsummary,
>  		.has	= xfs_sb_version_hasrealtime,
> -		.repair	= xfs_repair_notsupported,
> +		.repair	= xrep_notsupported,
>  	},
>  	[XFS_SCRUB_TYPE_UQUOTA] = {	/* user quota */
>  		.type	= ST_FS,
>  		.setup	= xchk_setup_quota,
>  		.scrub	= xchk_quota,
> -		.repair	= xfs_repair_notsupported,
> +		.repair	= xrep_notsupported,
>  	},
>  	[XFS_SCRUB_TYPE_GQUOTA] = {	/* group quota */
>  		.type	= ST_FS,
>  		.setup	= xchk_setup_quota,
>  		.scrub	= xchk_quota,
> -		.repair	= xfs_repair_notsupported,
> +		.repair	= xrep_notsupported,
>  	},
>  	[XFS_SCRUB_TYPE_PQUOTA] = {	/* project quota */
>  		.type	= ST_FS,
>  		.setup	= xchk_setup_quota,
>  		.scrub	= xchk_quota,
> -		.repair	= xfs_repair_notsupported,
> +		.repair	= xrep_notsupported,
>  	},
>  };
>  
> @@ -457,7 +457,7 @@ static inline void xchk_postmortem(struct xfs_scrub_context *sc)
>  	if ((sc->sm->sm_flags & XFS_SCRUB_IFLAG_REPAIR) &&
>  	    (sc->sm->sm_flags & (XFS_SCRUB_OFLAG_CORRUPT |
>  				 XFS_SCRUB_OFLAG_XCORRUPT)))
> -		xfs_repair_failure(sc->mp);
> +		xrep_failure(sc->mp);
>  }
>  #else
>  static inline void xchk_postmortem(struct xfs_scrub_context *sc)
> @@ -555,13 +555,13 @@ xfs_scrub_metadata(
>  		 * If it's broken, userspace wants us to fix it, and we haven't
>  		 * already tried to fix it, then attempt a repair.
>  		 */
> -		error = xfs_repair_attempt(ip, &sc, &already_fixed);
> +		error = xrep_attempt(ip, &sc, &already_fixed);
>  		if (error == -EAGAIN) {
>  			if (sc.try_harder)
>  				try_harder = true;
>  			error = xchk_teardown(&sc, ip, 0);
>  			if (error) {
> -				xfs_repair_failure(mp);
> +				xrep_failure(mp);
>  				goto out;
>  			}
>  			goto retry_op;
> diff --git a/fs/xfs/scrub/trace.h b/fs/xfs/scrub/trace.h
> index 11967d3942ac..96f3edda3e91 100644
> --- a/fs/xfs/scrub/trace.h
> +++ b/fs/xfs/scrub/trace.h
> @@ -55,8 +55,8 @@ DEFINE_EVENT(xchk_class, name, \
>  DEFINE_SCRUB_EVENT(xchk_start);
>  DEFINE_SCRUB_EVENT(xchk_done);
>  DEFINE_SCRUB_EVENT(xchk_deadlock_retry);
> -DEFINE_SCRUB_EVENT(xfs_repair_attempt);
> -DEFINE_SCRUB_EVENT(xfs_repair_done);
> +DEFINE_SCRUB_EVENT(xrep_attempt);
> +DEFINE_SCRUB_EVENT(xrep_done);
>  
>  TRACE_EVENT(xchk_op_error,
>  	TP_PROTO(struct xfs_scrub_context *sc, xfs_agnumber_t agno,
> @@ -483,7 +483,7 @@ TRACE_EVENT(xchk_xref_error,
>  /* repair tracepoints */
>  #if IS_ENABLED(CONFIG_XFS_ONLINE_REPAIR)
>  
> -DECLARE_EVENT_CLASS(xfs_repair_extent_class,
> +DECLARE_EVENT_CLASS(xrep_extent_class,
>  	TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno,
>  		 xfs_agblock_t agbno, xfs_extlen_t len),
>  	TP_ARGS(mp, agno, agbno, len),
> @@ -506,15 +506,15 @@ DECLARE_EVENT_CLASS(xfs_repair_extent_class,
>  		  __entry->len)
>  );
>  #define DEFINE_REPAIR_EXTENT_EVENT(name) \
> -DEFINE_EVENT(xfs_repair_extent_class, name, \
> +DEFINE_EVENT(xrep_extent_class, name, \
>  	TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, \
>  		 xfs_agblock_t agbno, xfs_extlen_t len), \
>  	TP_ARGS(mp, agno, agbno, len))
> -DEFINE_REPAIR_EXTENT_EVENT(xfs_repair_dispose_btree_extent);
> -DEFINE_REPAIR_EXTENT_EVENT(xfs_repair_collect_btree_extent);
> -DEFINE_REPAIR_EXTENT_EVENT(xfs_repair_agfl_insert);
> +DEFINE_REPAIR_EXTENT_EVENT(xrep_dispose_btree_extent);
> +DEFINE_REPAIR_EXTENT_EVENT(xrep_collect_btree_extent);
> +DEFINE_REPAIR_EXTENT_EVENT(xrep_agfl_insert);
>  
> -DECLARE_EVENT_CLASS(xfs_repair_rmap_class,
> +DECLARE_EVENT_CLASS(xrep_rmap_class,
>  	TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno,
>  		 xfs_agblock_t agbno, xfs_extlen_t len,
>  		 uint64_t owner, uint64_t offset, unsigned int flags),
> @@ -547,17 +547,17 @@ DECLARE_EVENT_CLASS(xfs_repair_rmap_class,
>  		  __entry->flags)
>  );
>  #define DEFINE_REPAIR_RMAP_EVENT(name) \
> -DEFINE_EVENT(xfs_repair_rmap_class, name, \
> +DEFINE_EVENT(xrep_rmap_class, name, \
>  	TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, \
>  		 xfs_agblock_t agbno, xfs_extlen_t len, \
>  		 uint64_t owner, uint64_t offset, unsigned int flags), \
>  	TP_ARGS(mp, agno, agbno, len, owner, offset, flags))
> -DEFINE_REPAIR_RMAP_EVENT(xfs_repair_alloc_extent_fn);
> -DEFINE_REPAIR_RMAP_EVENT(xfs_repair_ialloc_extent_fn);
> -DEFINE_REPAIR_RMAP_EVENT(xfs_repair_rmap_extent_fn);
> -DEFINE_REPAIR_RMAP_EVENT(xfs_repair_bmap_extent_fn);
> +DEFINE_REPAIR_RMAP_EVENT(xrep_alloc_extent_fn);
> +DEFINE_REPAIR_RMAP_EVENT(xrep_ialloc_extent_fn);
> +DEFINE_REPAIR_RMAP_EVENT(xrep_rmap_extent_fn);
> +DEFINE_REPAIR_RMAP_EVENT(xrep_bmap_extent_fn);
>  
> -TRACE_EVENT(xfs_repair_refcount_extent_fn,
> +TRACE_EVENT(xrep_refcount_extent_fn,
>  	TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno,
>  		 struct xfs_refcount_irec *irec),
>  	TP_ARGS(mp, agno, irec),
> @@ -583,7 +583,7 @@ TRACE_EVENT(xfs_repair_refcount_extent_fn,
>  		  __entry->refcount)
>  )
>  
> -TRACE_EVENT(xfs_repair_init_btblock,
> +TRACE_EVENT(xrep_init_btblock,
>  	TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, xfs_agblock_t agbno,
>  		 xfs_btnum_t btnum),
>  	TP_ARGS(mp, agno, agbno, btnum),
> @@ -605,7 +605,7 @@ TRACE_EVENT(xfs_repair_init_btblock,
>  		  __entry->agbno,
>  		  __entry->btnum)
>  )
> -TRACE_EVENT(xfs_repair_findroot_block,
> +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),
>  	TP_ARGS(mp, agno, agbno, magic, level),
> @@ -630,7 +630,7 @@ TRACE_EVENT(xfs_repair_findroot_block,
>  		  __entry->magic,
>  		  __entry->level)
>  )
> -TRACE_EVENT(xfs_repair_calc_ag_resblks,
> +TRACE_EVENT(xrep_calc_ag_resblks,
>  	TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno,
>  		 xfs_agino_t icount, xfs_agblock_t aglen, xfs_agblock_t freelen,
>  		 xfs_agblock_t usedlen),
> @@ -659,7 +659,7 @@ TRACE_EVENT(xfs_repair_calc_ag_resblks,
>  		  __entry->freelen,
>  		  __entry->usedlen)
>  )
> -TRACE_EVENT(xfs_repair_calc_ag_resblks_btsize,
> +TRACE_EVENT(xrep_calc_ag_resblks_btsize,
>  	TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno,
>  		 xfs_agblock_t bnobt_sz, xfs_agblock_t inobt_sz,
>  		 xfs_agblock_t rmapbt_sz, xfs_agblock_t refcbt_sz),
> @@ -688,7 +688,7 @@ TRACE_EVENT(xfs_repair_calc_ag_resblks_btsize,
>  		  __entry->rmapbt_sz,
>  		  __entry->refcbt_sz)
>  )
> -TRACE_EVENT(xfs_repair_reset_counters,
> +TRACE_EVENT(xrep_reset_counters,
>  	TP_PROTO(struct xfs_mount *mp),
>  	TP_ARGS(mp),
>  	TP_STRUCT__entry(
> @@ -701,7 +701,7 @@ TRACE_EVENT(xfs_repair_reset_counters,
>  		  MAJOR(__entry->dev), MINOR(__entry->dev))
>  )
>  
> -TRACE_EVENT(xfs_repair_ialloc_insert,
> +TRACE_EVENT(xrep_ialloc_insert,
>  	TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno,
>  		 xfs_agino_t startino, uint16_t holemask, uint8_t count,
>  		 uint8_t freecount, uint64_t freemask),
> 
> --
> To unsubscribe from this list: send the line "unsubscribe linux-xfs" in
> the body of a message to majordomo@xxxxxxxxxxxxxxx
> More majordomo info at  http://vger.kernel.org/majordomo-info.html
--
To unsubscribe from this list: send the line "unsubscribe linux-xfs" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at  http://vger.kernel.org/majordomo-info.html



[Index of Archives]     [XFS Filesystem Development (older mail)]     [Linux Filesystem Development]     [Linux Audio Users]     [Yosemite Trails]     [Linux Kernel]     [Linux RAID]     [Linux SCSI]


  Powered by Linux