xfs: const-ify xfs_owner_info arguments

Only certain functions actually change the contents of an
xfs_owner_info; the rest can accept a const struct pointer.  This will
enable us to save stack space by hoisting static owner info types to
be const global variables.

Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>

fs/xfs/libxfs/xfs_alloc.c

@@ -1694,28 +1694,28 @@ error0:
  */
 STATIC int
 xfs_free_ag_extent(
-	xfs_trans_t		*tp,
+	struct xfs_trans		*tp,
-	xfs_buf_t		*agbp,
+	struct xfs_buf			*agbp,
-	xfs_agnumber_t		agno,
+	xfs_agnumber_t			agno,
-	xfs_agblock_t		bno,
+	xfs_agblock_t			bno,
-	xfs_extlen_t		len,
+	xfs_extlen_t			len,
-	struct xfs_owner_info	*oinfo,
+	const struct xfs_owner_info	*oinfo,
-	enum xfs_ag_resv_type	type)
+	enum xfs_ag_resv_type		type)
 {
-	xfs_btree_cur_t	*bno_cur;	/* cursor for by-block btree */
+	struct xfs_mount		*mp;
-	xfs_btree_cur_t	*cnt_cur;	/* cursor for by-size btree */
+	struct xfs_perag		*pag;
-	int		error;		/* error return value */
+	struct xfs_btree_cur		*bno_cur;
-	xfs_agblock_t	gtbno;		/* start of right neighbor block */
+	struct xfs_btree_cur		*cnt_cur;
-	xfs_extlen_t	gtlen;		/* length of right neighbor block */
+	xfs_agblock_t			gtbno; /* start of right neighbor */
-	int		haveleft;	/* have a left neighbor block */
+	xfs_extlen_t			gtlen; /* length of right neighbor */
-	int		haveright;	/* have a right neighbor block */
+	xfs_agblock_t			ltbno; /* start of left neighbor */
-	int		i;		/* temp, result code */
+	xfs_extlen_t			ltlen; /* length of left neighbor */
-	xfs_agblock_t	ltbno;		/* start of left neighbor block */
+	xfs_agblock_t			nbno; /* new starting block of freesp */
-	xfs_extlen_t	ltlen;		/* length of left neighbor block */
+	xfs_extlen_t			nlen; /* new length of freespace */
-	xfs_mount_t	*mp;		/* mount point struct for filesystem */
+	int				haveleft; /* have a left neighbor */
-	xfs_agblock_t	nbno;		/* new starting block of freespace */
+	int				haveright; /* have a right neighbor */
-	xfs_extlen_t	nlen;		/* new length of freespace */
+	int				i;
-	xfs_perag_t	*pag;		/* per allocation group data */
+	int				error;
 
 	bno_cur = cnt_cur = NULL;
 	mp = tp->t_mountp;
@@ -3008,21 +3008,21 @@ out:
  * Just break up the extent address and hand off to xfs_free_ag_extent
  * after fixing up the freelist.
  */
-int				/* error */
+int
 __xfs_free_extent(
-	struct xfs_trans	*tp,	/* transaction pointer */
+	struct xfs_trans		*tp,
-	xfs_fsblock_t		bno,	/* starting block number of extent */
+	xfs_fsblock_t			bno,
-	xfs_extlen_t		len,	/* length of extent */
+	xfs_extlen_t			len,
-	struct xfs_owner_info	*oinfo,	/* extent owner */
+	const struct xfs_owner_info	*oinfo,
-	enum xfs_ag_resv_type	type,	/* block reservation type */
+	enum xfs_ag_resv_type		type,
-	bool			skip_discard)
+	bool				skip_discard)
 {
-	struct xfs_mount	*mp = tp->t_mountp;
+	struct xfs_mount		*mp = tp->t_mountp;
-	struct xfs_buf		*agbp;
+	struct xfs_buf			*agbp;
-	xfs_agnumber_t		agno = XFS_FSB_TO_AGNO(mp, bno);
+	xfs_agnumber_t			agno = XFS_FSB_TO_AGNO(mp, bno);
-	xfs_agblock_t		agbno = XFS_FSB_TO_AGBNO(mp, bno);
+	xfs_agblock_t			agbno = XFS_FSB_TO_AGBNO(mp, bno);
-	int			error;
+	int				error;
-	unsigned int		busy_flags = 0;
+	unsigned int			busy_flags = 0;
 
 	ASSERT(len != 0);
 	ASSERT(type != XFS_AG_RESV_AGFL);

fs/xfs/libxfs/xfs_alloc.h

@@ -182,7 +182,7 @@ __xfs_free_extent(
 	struct xfs_trans	*tp,	/* transaction pointer */
 	xfs_fsblock_t		bno,	/* starting block number of extent */
 	xfs_extlen_t		len,	/* length of extent */
-	struct xfs_owner_info	*oinfo,	/* extent owner */
+	const struct xfs_owner_info	*oinfo,	/* extent owner */
 	enum xfs_ag_resv_type	type,	/* block reservation type */
 	bool			skip_discard);
 
@@ -191,7 +191,7 @@ xfs_free_extent(
 	struct xfs_trans	*tp,
 	xfs_fsblock_t		bno,
 	xfs_extlen_t		len,
-	struct xfs_owner_info	*oinfo,
+	const struct xfs_owner_info	*oinfo,
 	enum xfs_ag_resv_type	type)
 {
 	return __xfs_free_extent(tp, bno, len, oinfo, type, false);

fs/xfs/libxfs/xfs_bmap.c

@@ -536,7 +536,7 @@ __xfs_bmap_add_free(
 	struct xfs_trans		*tp,
 	xfs_fsblock_t			bno,
 	xfs_filblks_t			len,
-	struct xfs_owner_info		*oinfo,
+	const struct xfs_owner_info	*oinfo,
 	bool				skip_discard)
 {
 	struct xfs_extent_free_item	*new;		/* new element */

fs/xfs/libxfs/xfs_bmap.h

@@ -186,7 +186,7 @@ int	xfs_bmap_add_attrfork(struct xfs_inode *ip, int size, int rsvd);
 int	xfs_bmap_set_attrforkoff(struct xfs_inode *ip, int size, int *version);
 void	xfs_bmap_local_to_extents_empty(struct xfs_inode *ip, int whichfork);
 void	__xfs_bmap_add_free(struct xfs_trans *tp, xfs_fsblock_t bno,
-		xfs_filblks_t len, struct xfs_owner_info *oinfo,
+		xfs_filblks_t len, const struct xfs_owner_info *oinfo,
 		bool skip_discard);
 void	xfs_bmap_compute_maxlevels(struct xfs_mount *mp, int whichfork);
 int	xfs_bmap_first_unused(struct xfs_trans *tp, struct xfs_inode *ip,
@@ -234,7 +234,7 @@ xfs_bmap_add_free(
 	struct xfs_trans		*tp,
 	xfs_fsblock_t			bno,
 	xfs_filblks_t			len,
-	struct xfs_owner_info		*oinfo)
+	const struct xfs_owner_info	*oinfo)
 {
 	__xfs_bmap_add_free(tp, bno, len, oinfo, false);
 }

fs/xfs/libxfs/xfs_rmap.c

@@ -458,21 +458,21 @@ out:
  */
 STATIC int
 xfs_rmap_unmap(
-	struct xfs_btree_cur	*cur,
+	struct xfs_btree_cur		*cur,
-	xfs_agblock_t		bno,
+	xfs_agblock_t			bno,
-	xfs_extlen_t		len,
+	xfs_extlen_t			len,
-	bool			unwritten,
+	bool				unwritten,
-	struct xfs_owner_info	*oinfo)
+	const struct xfs_owner_info	*oinfo)
 {
-	struct xfs_mount	*mp = cur->bc_mp;
+	struct xfs_mount		*mp = cur->bc_mp;
-	struct xfs_rmap_irec	ltrec;
+	struct xfs_rmap_irec		ltrec;
-	uint64_t		ltoff;
+	uint64_t			ltoff;
-	int			error = 0;
+	int				error = 0;
-	int			i;
+	int				i;
-	uint64_t		owner;
+	uint64_t			owner;
-	uint64_t		offset;
+	uint64_t			offset;
-	unsigned int		flags;
+	unsigned int			flags;
-	bool			ignore_off;
+	bool				ignore_off;
 
 	xfs_owner_info_unpack(oinfo, &owner, &offset, &flags);
 	ignore_off = XFS_RMAP_NON_INODE_OWNER(owner) ||
@@ -653,16 +653,16 @@ out_error:
  */
 int
 xfs_rmap_free(
-	struct xfs_trans	*tp,
+	struct xfs_trans		*tp,
-	struct xfs_buf		*agbp,
+	struct xfs_buf			*agbp,
-	xfs_agnumber_t		agno,
+	xfs_agnumber_t			agno,
-	xfs_agblock_t		bno,
+	xfs_agblock_t			bno,
-	xfs_extlen_t		len,
+	xfs_extlen_t			len,
-	struct xfs_owner_info	*oinfo)
+	const struct xfs_owner_info	*oinfo)
 {
-	struct xfs_mount	*mp = tp->t_mountp;
+	struct xfs_mount		*mp = tp->t_mountp;
-	struct xfs_btree_cur	*cur;
+	struct xfs_btree_cur		*cur;
-	int			error;
+	int				error;
 
 	if (!xfs_sb_version_hasrmapbt(&mp->m_sb))
 		return 0;
@@ -710,23 +710,23 @@ xfs_rmap_is_mergeable(
  */
 STATIC int
 xfs_rmap_map(
-	struct xfs_btree_cur	*cur,
+	struct xfs_btree_cur		*cur,
-	xfs_agblock_t		bno,
+	xfs_agblock_t			bno,
-	xfs_extlen_t		len,
+	xfs_extlen_t			len,
-	bool			unwritten,
+	bool				unwritten,
-	struct xfs_owner_info	*oinfo)
+	const struct xfs_owner_info	*oinfo)
 {
-	struct xfs_mount	*mp = cur->bc_mp;
+	struct xfs_mount		*mp = cur->bc_mp;
-	struct xfs_rmap_irec	ltrec;
+	struct xfs_rmap_irec		ltrec;
-	struct xfs_rmap_irec	gtrec;
+	struct xfs_rmap_irec		gtrec;
-	int			have_gt;
+	int				have_gt;
-	int			have_lt;
+	int				have_lt;
-	int			error = 0;
+	int				error = 0;
-	int			i;
+	int				i;
-	uint64_t		owner;
+	uint64_t			owner;
-	uint64_t		offset;
+	uint64_t			offset;
-	unsigned int		flags = 0;
+	unsigned int			flags = 0;
-	bool			ignore_off;
+	bool				ignore_off;
 
 	xfs_owner_info_unpack(oinfo, &owner, &offset, &flags);
 	ASSERT(owner != 0);
@@ -890,16 +890,16 @@ out_error:
  */
 int
 xfs_rmap_alloc(
-	struct xfs_trans	*tp,
+	struct xfs_trans		*tp,
-	struct xfs_buf		*agbp,
+	struct xfs_buf			*agbp,
-	xfs_agnumber_t		agno,
+	xfs_agnumber_t			agno,
-	xfs_agblock_t		bno,
+	xfs_agblock_t			bno,
-	xfs_extlen_t		len,
+	xfs_extlen_t			len,
-	struct xfs_owner_info	*oinfo)
+	const struct xfs_owner_info	*oinfo)
 {
-	struct xfs_mount	*mp = tp->t_mountp;
+	struct xfs_mount		*mp = tp->t_mountp;
-	struct xfs_btree_cur	*cur;
+	struct xfs_btree_cur		*cur;
-	int			error;
+	int				error;
 
 	if (!xfs_sb_version_hasrmapbt(&mp->m_sb))
 		return 0;
@@ -929,16 +929,16 @@ xfs_rmap_alloc(
  */
 STATIC int
 xfs_rmap_convert(
-	struct xfs_btree_cur	*cur,
+	struct xfs_btree_cur		*cur,
-	xfs_agblock_t		bno,
+	xfs_agblock_t			bno,
-	xfs_extlen_t		len,
+	xfs_extlen_t			len,
-	bool			unwritten,
+	bool				unwritten,
-	struct xfs_owner_info	*oinfo)
+	const struct xfs_owner_info	*oinfo)
 {
-	struct xfs_mount	*mp = cur->bc_mp;
+	struct xfs_mount		*mp = cur->bc_mp;
-	struct xfs_rmap_irec	r[4];	/* neighbor extent entries */
+	struct xfs_rmap_irec		r[4];	/* neighbor extent entries */
-					/* left is 0, right is 1, prev is 2 */
+						/* left is 0, right is 1, */
-					/* new is 3 */
+						/* prev is 2, new is 3 */
 	uint64_t		owner;
 	uint64_t		offset;
 	uint64_t		new_endoff;
@@ -1354,16 +1354,16 @@ done:
  */
 STATIC int
 xfs_rmap_convert_shared(
-	struct xfs_btree_cur	*cur,
+	struct xfs_btree_cur		*cur,
-	xfs_agblock_t		bno,
+	xfs_agblock_t			bno,
-	xfs_extlen_t		len,
+	xfs_extlen_t			len,
-	bool			unwritten,
+	bool				unwritten,
-	struct xfs_owner_info	*oinfo)
+	const struct xfs_owner_info	*oinfo)
 {
-	struct xfs_mount	*mp = cur->bc_mp;
+	struct xfs_mount		*mp = cur->bc_mp;
-	struct xfs_rmap_irec	r[4];	/* neighbor extent entries */
+	struct xfs_rmap_irec		r[4];	/* neighbor extent entries */
-					/* left is 0, right is 1, prev is 2 */
+						/* left is 0, right is 1, */
-					/* new is 3 */
+						/* prev is 2, new is 3 */
 	uint64_t		owner;
 	uint64_t		offset;
 	uint64_t		new_endoff;
@@ -1743,20 +1743,20 @@ done:
  */
 STATIC int
 xfs_rmap_unmap_shared(
-	struct xfs_btree_cur	*cur,
+	struct xfs_btree_cur		*cur,
-	xfs_agblock_t		bno,
+	xfs_agblock_t			bno,
-	xfs_extlen_t		len,
+	xfs_extlen_t			len,
-	bool			unwritten,
+	bool				unwritten,
-	struct xfs_owner_info	*oinfo)
+	const struct xfs_owner_info	*oinfo)
 {
-	struct xfs_mount	*mp = cur->bc_mp;
+	struct xfs_mount		*mp = cur->bc_mp;
-	struct xfs_rmap_irec	ltrec;
+	struct xfs_rmap_irec		ltrec;
-	uint64_t		ltoff;
+	uint64_t			ltoff;
-	int			error = 0;
+	int				error = 0;
-	int			i;
+	int				i;
-	uint64_t		owner;
+	uint64_t			owner;
-	uint64_t		offset;
+	uint64_t			offset;
-	unsigned int		flags;
+	unsigned int			flags;
 
 	xfs_owner_info_unpack(oinfo, &owner, &offset, &flags);
 	if (unwritten)
@@ -1905,22 +1905,22 @@ out_error:
  */
 STATIC int
 xfs_rmap_map_shared(
-	struct xfs_btree_cur	*cur,
+	struct xfs_btree_cur		*cur,
-	xfs_agblock_t		bno,
+	xfs_agblock_t			bno,
-	xfs_extlen_t		len,
+	xfs_extlen_t			len,
-	bool			unwritten,
+	bool				unwritten,
-	struct xfs_owner_info	*oinfo)
+	const struct xfs_owner_info	*oinfo)
 {
-	struct xfs_mount	*mp = cur->bc_mp;
+	struct xfs_mount		*mp = cur->bc_mp;
-	struct xfs_rmap_irec	ltrec;
+	struct xfs_rmap_irec		ltrec;
-	struct xfs_rmap_irec	gtrec;
+	struct xfs_rmap_irec		gtrec;
-	int			have_gt;
+	int				have_gt;
-	int			have_lt;
+	int				have_lt;
-	int			error = 0;
+	int				error = 0;
-	int			i;
+	int				i;
-	uint64_t		owner;
+	uint64_t			owner;
-	uint64_t		offset;
+	uint64_t			offset;
-	unsigned int		flags = 0;
+	unsigned int			flags = 0;
 
 	xfs_owner_info_unpack(oinfo, &owner, &offset, &flags);
 	if (unwritten)
@@ -2459,18 +2459,18 @@ xfs_rmap_has_record(
  */
 int
 xfs_rmap_record_exists(
-	struct xfs_btree_cur	*cur,
+	struct xfs_btree_cur		*cur,
-	xfs_agblock_t		bno,
+	xfs_agblock_t			bno,
-	xfs_extlen_t		len,
+	xfs_extlen_t			len,
-	struct xfs_owner_info	*oinfo,
+	const struct xfs_owner_info	*oinfo,
-	bool			*has_rmap)
+	bool				*has_rmap)
 {
-	uint64_t		owner;
+	uint64_t			owner;
-	uint64_t		offset;
+	uint64_t			offset;
-	unsigned int		flags;
+	unsigned int			flags;
-	int			has_record;
+	int				has_record;
-	struct xfs_rmap_irec	irec;
+	struct xfs_rmap_irec		irec;
-	int			error;
+	int				error;
 
 	xfs_owner_info_unpack(oinfo, &owner, &offset, &flags);
 	ASSERT(XFS_RMAP_NON_INODE_OWNER(owner) ||
@@ -2530,7 +2530,7 @@ xfs_rmap_has_other_keys(
 	struct xfs_btree_cur		*cur,
 	xfs_agblock_t			bno,
 	xfs_extlen_t			len,
-	struct xfs_owner_info		*oinfo,
+	const struct xfs_owner_info	*oinfo,
 	bool				*has_rmap)
 {
 	struct xfs_rmap_irec		low = {0};

fs/xfs/libxfs/xfs_rmap.h

@@ -52,7 +52,7 @@ xfs_rmap_skip_owner_update(
 
 static inline bool
 xfs_rmap_should_skip_owner_update(
-	struct xfs_owner_info	*oi)
+	const struct xfs_owner_info	*oi)
 {
 	return oi->oi_owner == XFS_RMAP_OWN_NULL;
 }
@@ -103,12 +103,12 @@ xfs_rmap_irec_offset_unpack(
 
 static inline void
 xfs_owner_info_unpack(
-	struct xfs_owner_info	*oinfo,
+	const struct xfs_owner_info	*oinfo,
-	uint64_t		*owner,
+	uint64_t			*owner,
-	uint64_t		*offset,
+	uint64_t			*offset,
-	unsigned int		*flags)
+	unsigned int			*flags)
 {
-	unsigned int		r = 0;
+	unsigned int			r = 0;
 
 	*owner = oinfo->oi_owner;
 	*offset = oinfo->oi_offset;
@@ -137,10 +137,10 @@ xfs_owner_info_pack(
 
 int xfs_rmap_alloc(struct xfs_trans *tp, struct xfs_buf *agbp,
 		   xfs_agnumber_t agno, xfs_agblock_t bno, xfs_extlen_t len,
-		   struct xfs_owner_info *oinfo);
+		   const struct xfs_owner_info *oinfo);
 int xfs_rmap_free(struct xfs_trans *tp, struct xfs_buf *agbp,
 		  xfs_agnumber_t agno, xfs_agblock_t bno, xfs_extlen_t len,
-		  struct xfs_owner_info *oinfo);
+		  const struct xfs_owner_info *oinfo);
 
 int xfs_rmap_lookup_le(struct xfs_btree_cur *cur, xfs_agblock_t bno,
 		xfs_extlen_t len, uint64_t owner, uint64_t offset,
@@ -218,10 +218,10 @@ int xfs_rmap_btrec_to_irec(union xfs_btree_rec *rec,
 int xfs_rmap_has_record(struct xfs_btree_cur *cur, xfs_agblock_t bno,
 		xfs_extlen_t len, bool *exists);
 int xfs_rmap_record_exists(struct xfs_btree_cur *cur, xfs_agblock_t bno,
-		xfs_extlen_t len, struct xfs_owner_info *oinfo,
+		xfs_extlen_t len, const struct xfs_owner_info *oinfo,
 		bool *has_rmap);
 int xfs_rmap_has_other_keys(struct xfs_btree_cur *cur, xfs_agblock_t bno,
-		xfs_extlen_t len, struct xfs_owner_info *oinfo,
+		xfs_extlen_t len, const struct xfs_owner_info *oinfo,
 		bool *has_rmap);
 int xfs_rmap_map_raw(struct xfs_btree_cur *cur, struct xfs_rmap_irec *rmap);
 

fs/xfs/scrub/btree.c

@@ -583,31 +583,32 @@ xchk_btree_block_keys(
  */
 int
 xchk_btree(
-	struct xfs_scrub	*sc,
+	struct xfs_scrub		*sc,
-	struct xfs_btree_cur	*cur,
+	struct xfs_btree_cur		*cur,
-	xchk_btree_rec_fn	scrub_fn,
+	xchk_btree_rec_fn		scrub_fn,
-	struct xfs_owner_info	*oinfo,
+	const struct xfs_owner_info	*oinfo,
-	void			*private)
+	void				*private)
 {
-	struct xchk_btree	bs = { NULL };
+	struct xchk_btree		bs = {
-	union xfs_btree_ptr	ptr;
+		.cur			= cur,
-	union xfs_btree_ptr	*pp;
+		.scrub_rec		= scrub_fn,
-	union xfs_btree_rec	*recp;
+		.oinfo			= oinfo,
-	struct xfs_btree_block	*block;
+		.firstrec		= true,
-	int			level;
+		.private		= private,
-	struct xfs_buf		*bp;
+		.sc			= sc,
-	struct check_owner	*co;
+	};
-	struct check_owner	*n;
+	union xfs_btree_ptr		ptr;
-	int			i;
+	union xfs_btree_ptr		*pp;
-	int			error = 0;
+	union xfs_btree_rec		*recp;
+	struct xfs_btree_block		*block;
+	int				level;
+	struct xfs_buf			*bp;
+	struct check_owner		*co;
+	struct check_owner		*n;
+	int				i;
+	int				error = 0;
 
 	/* Initialize scrub state */
-	bs.cur = cur;
-	bs.scrub_rec = scrub_fn;
-	bs.oinfo = oinfo;
-	bs.firstrec = true;
-	bs.private = private;
-	bs.sc = sc;
 	for (i = 0; i < XFS_BTREE_MAXLEVELS; i++)
 		bs.firstkey[i] = true;
 	INIT_LIST_HEAD(&bs.to_check);

fs/xfs/scrub/btree.h

@@ -31,21 +31,21 @@ typedef int (*xchk_btree_rec_fn)(
 
 struct xchk_btree {
 	/* caller-provided scrub state */
-	struct xfs_scrub	*sc;
+	struct xfs_scrub		*sc;
-	struct xfs_btree_cur	*cur;
+	struct xfs_btree_cur		*cur;
-	xchk_btree_rec_fn	scrub_rec;
+	xchk_btree_rec_fn		scrub_rec;
-	struct xfs_owner_info	*oinfo;
+	const struct xfs_owner_info	*oinfo;
-	void			*private;
+	void				*private;
 
 	/* internal scrub state */
-	union xfs_btree_rec	lastrec;
+	union xfs_btree_rec		lastrec;
-	bool			firstrec;
+	bool				firstrec;
-	union xfs_btree_key	lastkey[XFS_BTREE_MAXLEVELS];
+	union xfs_btree_key		lastkey[XFS_BTREE_MAXLEVELS];
-	bool			firstkey[XFS_BTREE_MAXLEVELS];
+	bool				firstkey[XFS_BTREE_MAXLEVELS];
-	struct list_head	to_check;
+	struct list_head		to_check;
 };
 int xchk_btree(struct xfs_scrub *sc, struct xfs_btree_cur *cur,
-		xchk_btree_rec_fn scrub_fn, struct xfs_owner_info *oinfo,
+		xchk_btree_rec_fn scrub_fn, const struct xfs_owner_info *oinfo,
 		void *private);
 
 #endif /* __XFS_SCRUB_BTREE_H__ */

fs/xfs/scrub/common.c

@@ -313,8 +313,8 @@ xchk_set_incomplete(
  */
 
 struct xchk_rmap_ownedby_info {
-	struct xfs_owner_info	*oinfo;
+	const struct xfs_owner_info	*oinfo;
-	xfs_filblks_t		*blocks;
+	xfs_filblks_t			*blocks;
 };
 
 STATIC int
@@ -347,15 +347,15 @@ int
 xchk_count_rmap_ownedby_ag(
 	struct xfs_scrub		*sc,
 	struct xfs_btree_cur		*cur,
-	struct xfs_owner_info		*oinfo,
+	const struct xfs_owner_info	*oinfo,
 	xfs_filblks_t			*blocks)
 {
-	struct xchk_rmap_ownedby_info	sroi;
+	struct xchk_rmap_ownedby_info	sroi = {
+		.oinfo			= oinfo,
+		.blocks			= blocks,
+	};
 
-	sroi.oinfo = oinfo;
 	*blocks = 0;
-	sroi.blocks = blocks;
-
 	return xfs_rmap_query_all(cur, xchk_count_rmap_ownedby_irec,
 			&sroi);
 }

fs/xfs/scrub/common.h

@@ -116,7 +116,7 @@ int xchk_ag_read_headers(struct xfs_scrub *sc, xfs_agnumber_t agno,
 void xchk_ag_btcur_free(struct xchk_ag *sa);
 int xchk_ag_btcur_init(struct xfs_scrub *sc, struct xchk_ag *sa);
 int xchk_count_rmap_ownedby_ag(struct xfs_scrub *sc, struct xfs_btree_cur *cur,
-		struct xfs_owner_info *oinfo, xfs_filblks_t *blocks);
+		const struct xfs_owner_info *oinfo, xfs_filblks_t *blocks);
 
 int xchk_setup_ag_btree(struct xfs_scrub *sc, struct xfs_inode *ip,
 		bool force_log);

fs/xfs/scrub/refcount.c

@@ -383,9 +383,9 @@ xchk_refcountbt_rec(
 STATIC void
 xchk_refcount_xref_rmap(
 	struct xfs_scrub	*sc,
-	struct xfs_owner_info	*oinfo,
 	xfs_filblks_t		cow_blocks)
 {
+	struct xfs_owner_info	oinfo;
 	xfs_extlen_t		refcbt_blocks = 0;
 	xfs_filblks_t		blocks;
 	int			error;
@@ -394,10 +394,11 @@ xchk_refcount_xref_rmap(
 		return;
 
 	/* Check that we saw as many refcbt blocks as the rmap knows about. */
+	xfs_rmap_ag_owner(&oinfo, XFS_RMAP_OWN_REFC);
 	error = xfs_btree_count_blocks(sc->sa.refc_cur, &refcbt_blocks);
 	if (!xchk_btree_process_error(sc, sc->sa.refc_cur, 0, &error))
 		return;
-	error = xchk_count_rmap_ownedby_ag(sc, sc->sa.rmap_cur, oinfo,
+	error = xchk_count_rmap_ownedby_ag(sc, sc->sa.rmap_cur, &oinfo,
 			&blocks);
 	if (!xchk_should_check_xref(sc, &error, &sc->sa.rmap_cur))
 		return;
@@ -405,8 +406,8 @@ xchk_refcount_xref_rmap(
 		xchk_btree_xref_set_corrupt(sc, sc->sa.rmap_cur, 0);
 
 	/* Check that we saw as many cow blocks as the rmap knows about. */
-	xfs_rmap_ag_owner(oinfo, XFS_RMAP_OWN_COW);
+	xfs_rmap_ag_owner(&oinfo, XFS_RMAP_OWN_COW);
-	error = xchk_count_rmap_ownedby_ag(sc, sc->sa.rmap_cur, oinfo,
+	error = xchk_count_rmap_ownedby_ag(sc, sc->sa.rmap_cur, &oinfo,
 			&blocks);
 	if (!xchk_should_check_xref(sc, &error, &sc->sa.rmap_cur))
 		return;
@@ -429,7 +430,7 @@ xchk_refcountbt(
 	if (error)
 		return error;
 
-	xchk_refcount_xref_rmap(sc, &oinfo, cow_blocks);
+	xchk_refcount_xref_rmap(sc, cow_blocks);
 
 	return 0;
 }

fs/xfs/scrub/repair.c

@@ -299,14 +299,14 @@ xrep_calc_ag_resblks(
 /* Allocate a block in an AG. */
 int
 xrep_alloc_ag_block(
-	struct xfs_scrub	*sc,
+	struct xfs_scrub		*sc,
-	struct xfs_owner_info	*oinfo,
+	const struct xfs_owner_info	*oinfo,
-	xfs_fsblock_t		*fsbno,
+	xfs_fsblock_t			*fsbno,
-	enum xfs_ag_resv_type	resv)
+	enum xfs_ag_resv_type		resv)
 {
-	struct xfs_alloc_arg	args = {0};
+	struct xfs_alloc_arg		args = {0};
-	xfs_agblock_t		bno;
+	xfs_agblock_t			bno;
-	int			error;
+	int				error;
 
 	switch (resv) {
 	case XFS_AG_RESV_AGFL:
@@ -538,17 +538,17 @@ xrep_put_freelist(
 /* Dispose of a single block. */
 STATIC int
 xrep_reap_block(
-	struct xfs_scrub	*sc,
+	struct xfs_scrub		*sc,
-	xfs_fsblock_t		fsbno,
+	xfs_fsblock_t			fsbno,
-	struct xfs_owner_info	*oinfo,
+	const struct xfs_owner_info	*oinfo,
-	enum xfs_ag_resv_type	resv)
+	enum xfs_ag_resv_type		resv)
 {
-	struct xfs_btree_cur	*cur;
+	struct xfs_btree_cur		*cur;
-	struct xfs_buf		*agf_bp = NULL;
+	struct xfs_buf			*agf_bp = NULL;
-	xfs_agnumber_t		agno;
+	xfs_agnumber_t			agno;
-	xfs_agblock_t		agbno;
+	xfs_agblock_t			agbno;
-	bool			has_other_rmap;
+	bool				has_other_rmap;
-	int			error;
+	int				error;
 
 	agno = XFS_FSB_TO_AGNO(sc->mp, fsbno);
 	agbno = XFS_FSB_TO_AGBNO(sc->mp, fsbno);
@@ -612,15 +612,15 @@ out_free:
 /* Dispose of every block of every extent in the bitmap. */
 int
 xrep_reap_extents(
-	struct xfs_scrub	*sc,
+	struct xfs_scrub		*sc,
-	struct xfs_bitmap	*bitmap,
+	struct xfs_bitmap		*bitmap,
-	struct xfs_owner_info	*oinfo,
+	const struct xfs_owner_info	*oinfo,
-	enum xfs_ag_resv_type	type)
+	enum xfs_ag_resv_type		type)
 {
-	struct xfs_bitmap_range	*bmr;
+	struct xfs_bitmap_range		*bmr;
-	struct xfs_bitmap_range	*n;
+	struct xfs_bitmap_range		*n;
-	xfs_fsblock_t		fsbno;
+	xfs_fsblock_t			fsbno;
-	int			error = 0;
+	int				error = 0;
 
 	ASSERT(xfs_sb_version_hasrmapbt(&sc->mp->m_sb));
 

fs/xfs/scrub/repair.h

@@ -21,8 +21,9 @@ int xrep_roll_ag_trans(struct xfs_scrub *sc);
 bool xrep_ag_has_space(struct xfs_perag *pag, xfs_extlen_t nr_blocks,
 		enum xfs_ag_resv_type type);
 xfs_extlen_t xrep_calc_ag_resblks(struct xfs_scrub *sc);
-int xrep_alloc_ag_block(struct xfs_scrub *sc, struct xfs_owner_info *oinfo,
+int xrep_alloc_ag_block(struct xfs_scrub *sc,
-		xfs_fsblock_t *fsbno, enum xfs_ag_resv_type resv);
+		const struct xfs_owner_info *oinfo, xfs_fsblock_t *fsbno,
+		enum xfs_ag_resv_type resv);
 int xrep_init_btblock(struct xfs_scrub *sc, xfs_fsblock_t fsb,
 		struct xfs_buf **bpp, xfs_btnum_t btnum,
 		const struct xfs_buf_ops *ops);
@@ -32,7 +33,7 @@ struct xfs_bitmap;
 int xrep_fix_freelist(struct xfs_scrub *sc, bool can_shrink);
 int xrep_invalidate_blocks(struct xfs_scrub *sc, struct xfs_bitmap *btlist);
 int xrep_reap_extents(struct xfs_scrub *sc, struct xfs_bitmap *exlist,
-		struct xfs_owner_info *oinfo, enum xfs_ag_resv_type type);
+		const struct xfs_owner_info *oinfo, enum xfs_ag_resv_type type);
 
 struct xrep_find_ag_btree {
 	/* in: rmap owner of the btree we're looking for */

fs/xfs/scrub/rmap.c

@@ -184,14 +184,14 @@ xchk_rmapbt(
 /* xref check that the extent is owned by a given owner */
 static inline void
 xchk_xref_check_owner(
-	struct xfs_scrub	*sc,
+	struct xfs_scrub		*sc,
-	xfs_agblock_t		bno,
+	xfs_agblock_t			bno,
-	xfs_extlen_t		len,
+	xfs_extlen_t			len,
-	struct xfs_owner_info	*oinfo,
+	const struct xfs_owner_info	*oinfo,
-	bool			should_have_rmap)
+	bool				should_have_rmap)
 {
-	bool			has_rmap;
+	bool				has_rmap;
-	int			error;
+	int				error;
 
 	if (!sc->sa.rmap_cur || xchk_skip_xref(sc->sm))
 		return;
@@ -207,10 +207,10 @@ xchk_xref_check_owner(
 /* xref check that the extent is owned by a given owner */
 void
 xchk_xref_is_owned_by(
-	struct xfs_scrub	*sc,
+	struct xfs_scrub		*sc,
-	xfs_agblock_t		bno,
+	xfs_agblock_t			bno,
-	xfs_extlen_t		len,
+	xfs_extlen_t			len,
-	struct xfs_owner_info	*oinfo)
+	const struct xfs_owner_info	*oinfo)
 {
 	xchk_xref_check_owner(sc, bno, len, oinfo, true);
 }
@@ -218,10 +218,10 @@ xchk_xref_is_owned_by(
 /* xref check that the extent is not owned by a given owner */
 void
 xchk_xref_is_not_owned_by(
-	struct xfs_scrub	*sc,
+	struct xfs_scrub		*sc,
-	xfs_agblock_t		bno,
+	xfs_agblock_t			bno,
-	xfs_extlen_t		len,
+	xfs_extlen_t			len,
-	struct xfs_owner_info	*oinfo)
+	const struct xfs_owner_info	*oinfo)
 {
 	xchk_xref_check_owner(sc, bno, len, oinfo, false);
 }

fs/xfs/scrub/scrub.h

@@ -122,9 +122,9 @@ void xchk_xref_is_not_inode_chunk(struct xfs_scrub *sc, xfs_agblock_t agbno,
 void xchk_xref_is_inode_chunk(struct xfs_scrub *sc, xfs_agblock_t agbno,
 		xfs_extlen_t len);
 void xchk_xref_is_owned_by(struct xfs_scrub *sc, xfs_agblock_t agbno,
-		xfs_extlen_t len, struct xfs_owner_info *oinfo);
+		xfs_extlen_t len, const struct xfs_owner_info *oinfo);
 void xchk_xref_is_not_owned_by(struct xfs_scrub *sc, xfs_agblock_t agbno,
-		xfs_extlen_t len, struct xfs_owner_info *oinfo);
+		xfs_extlen_t len, const struct xfs_owner_info *oinfo);
 void xchk_xref_has_no_owner(struct xfs_scrub *sc, xfs_agblock_t agbno,
 		xfs_extlen_t len);
 void xchk_xref_is_cow_staging(struct xfs_scrub *sc, xfs_agblock_t bno,

fs/xfs/xfs_trace.h

@@ -2405,7 +2405,7 @@ DEFINE_BMAP_FREE_DEFERRED_EVENT(xfs_agfl_free_deferred);
 DECLARE_EVENT_CLASS(xfs_rmap_class,
 	TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno,
 		 xfs_agblock_t agbno, xfs_extlen_t len, bool unwritten,
-		 struct xfs_owner_info *oinfo),
+		 const struct xfs_owner_info *oinfo),
 	TP_ARGS(mp, agno, agbno, len, unwritten, oinfo),
 	TP_STRUCT__entry(
 		__field(dev_t, dev)
@@ -2440,7 +2440,7 @@ DECLARE_EVENT_CLASS(xfs_rmap_class,
 DEFINE_EVENT(xfs_rmap_class, name, \
 	TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, \
 		 xfs_agblock_t agbno, xfs_extlen_t len, bool unwritten, \
-		 struct xfs_owner_info *oinfo), \
+		 const struct xfs_owner_info *oinfo), \
 	TP_ARGS(mp, agno, agbno, len, unwritten, oinfo))
 
 /* simple AG-based error/%ip tracepoint class */

fs/xfs/xfs_trans.h

@@ -228,7 +228,8 @@ struct xfs_efd_log_item	*xfs_trans_get_efd(struct xfs_trans *,
 				  uint);
 int		xfs_trans_free_extent(struct xfs_trans *,
 				      struct xfs_efd_log_item *, xfs_fsblock_t,
-				      xfs_extlen_t, struct xfs_owner_info *,
+				      xfs_extlen_t,
+				      const struct xfs_owner_info *,
 				      bool);
 int		xfs_trans_commit(struct xfs_trans *);
 int		xfs_trans_roll(struct xfs_trans **);

fs/xfs/xfs_trans_extfree.c

@@ -53,19 +53,20 @@ xfs_trans_get_efd(struct xfs_trans		*tp,
  */
 int
 xfs_trans_free_extent(
-	struct xfs_trans	*tp,
+	struct xfs_trans		*tp,
-	struct xfs_efd_log_item	*efdp,
+	struct xfs_efd_log_item		*efdp,
-	xfs_fsblock_t		start_block,
+	xfs_fsblock_t			start_block,
-	xfs_extlen_t		ext_len,
+	xfs_extlen_t			ext_len,
-	struct xfs_owner_info	*oinfo,
+	const struct xfs_owner_info	*oinfo,
-	bool			skip_discard)
+	bool				skip_discard)
 {
-	struct xfs_mount	*mp = tp->t_mountp;
+	struct xfs_mount		*mp = tp->t_mountp;
-	uint			next_extent;
+	struct xfs_extent		*extp;
-	xfs_agnumber_t		agno = XFS_FSB_TO_AGNO(mp, start_block);
+	uint				next_extent;
-	xfs_agblock_t		agbno = XFS_FSB_TO_AGBNO(mp, start_block);
+	xfs_agnumber_t			agno = XFS_FSB_TO_AGNO(mp, start_block);
-	struct xfs_extent	*extp;
+	xfs_agblock_t			agbno = XFS_FSB_TO_AGBNO(mp,
-	int			error;
+								start_block);
+	int				error;
 
 	trace_xfs_bmap_free_deferred(tp->t_mountp, agno, 0, agbno, ext_len);