Commit 0370f9bb authored by Chandan Babu R's avatar Chandan Babu R
Browse files

Merge tag 'xfs-cleanups-6.10_2024-05-02' of... 

Merge tag 'xfs-cleanups-6.10_2024-05-02' of https://git.kernel.org/pub/scm/linux/kernel/git/djwong/xfs-linux

 into xfs-6.10-mergeF

xfs: last round of cleanups for 6.10

Here are the reviewed cleanups at the head of the fsverity series.
Apparently there's other work that could use some of these things, so
let's try to get it in for 6.10.

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

* tag 'xfs-cleanups-6.10_2024-05-02' of https://git.kernel.org/pub/scm/linux/kernel/git/djwong/xfs-linux:
  xfs: widen flags argument to the xfs_iflags_* helpers
  xfs: minor cleanups of xfs_attr3_rmt_blocks
  xfs: create a helper to compute the blockcount of a max sized remote value
  xfs: turn XFS_ATTR3_RMT_BUF_SPACE into a function
  xfs: use unsigned ints for non-negative quantities in xfs_attr_remote.c
parents 21255afd 1a3f1afb

fs/xfs/libxfs/xfs_attr.c

+1 −1
Original line number Diff line number Diff line
@@ -1036,7 +1036,7 @@ xfs_attr_set( 
		break;

	case XFS_ATTRUPDATE_REMOVE:

		XFS_STATS_INC(mp, xs_attr_remove);

		rmt_blks = xfs_attr3_rmt_blocks(mp, XFS_XATTR_SIZE_MAX);

		rmt_blks = xfs_attr3_max_rmt_blocks(mp);

		break;

	}

fs/xfs/libxfs/xfs_attr_remote.c

+50 −38
Original line number Diff line number Diff line
@@ -43,19 +43,32 @@ 
 * the logging system and therefore never have a log item.

 */



/*

 * Each contiguous block has a header, so it is not just a simple attribute

 * length to FSB conversion.

 */

int

/* How many bytes can be stored in a remote value buffer? */

inline unsigned int

xfs_attr3_rmt_buf_space(

	struct xfs_mount	*mp)

{

	unsigned int		blocksize = mp->m_attr_geo->blksize;



	if (xfs_has_crc(mp))

		return blocksize - sizeof(struct xfs_attr3_rmt_hdr);



	return blocksize;

}



/* Compute number of fsblocks needed to store a remote attr value */

unsigned int

xfs_attr3_rmt_blocks(

	struct xfs_mount	*mp,

	int		attrlen)

	unsigned int		attrlen)

{

	if (xfs_has_crc(mp)) {

		int buflen = XFS_ATTR3_RMT_BUF_SPACE(mp, mp->m_sb.sb_blocksize);

		return (attrlen + buflen - 1) / buflen;

	}

	/*

	 * Each contiguous block has a header, so it is not just a simple

	 * attribute length to FSB conversion.

	 */

	if (xfs_has_crc(mp))

		return howmany(attrlen, xfs_attr3_rmt_buf_space(mp));



	return XFS_B_TO_FSB(mp, attrlen);

}
@@ -92,7 +105,6 @@ xfs_attr3_rmt_verify( 
	struct xfs_mount	*mp,

	struct xfs_buf		*bp,

	void			*ptr,

	int			fsbsize,

	xfs_daddr_t		bno)

{

	struct xfs_attr3_rmt_hdr *rmt = ptr;
@@ -103,7 +115,7 @@ xfs_attr3_rmt_verify( 
		return __this_address;

	if (be64_to_cpu(rmt->rm_blkno) != bno)

		return __this_address;

	if (be32_to_cpu(rmt->rm_bytes) > fsbsize - sizeof(*rmt))

	if (be32_to_cpu(rmt->rm_bytes) > mp->m_attr_geo->blksize - sizeof(*rmt))

		return __this_address;

	if (be32_to_cpu(rmt->rm_offset) +

				be32_to_cpu(rmt->rm_bytes) > XFS_XATTR_SIZE_MAX)
@@ -122,9 +134,9 @@ __xfs_attr3_rmt_read_verify( 
{

	struct xfs_mount *mp = bp->b_mount;

	char		*ptr;

	int		len;

	unsigned int	len;

	xfs_daddr_t	bno;

	int		blksize = mp->m_attr_geo->blksize;

	unsigned int	blksize = mp->m_attr_geo->blksize;



	/* no verification of non-crc buffers */

	if (!xfs_has_crc(mp))
@@ -141,7 +153,7 @@ __xfs_attr3_rmt_read_verify( 
			*failaddr = __this_address;

			return -EFSBADCRC;

		}

		*failaddr = xfs_attr3_rmt_verify(mp, bp, ptr, blksize, bno);

		*failaddr = xfs_attr3_rmt_verify(mp, bp, ptr, bno);

		if (*failaddr)

			return -EFSCORRUPTED;

		len -= blksize;
@@ -186,7 +198,7 @@ xfs_attr3_rmt_write_verify( 
{

	struct xfs_mount *mp = bp->b_mount;

	xfs_failaddr_t	fa;

	int		blksize = mp->m_attr_geo->blksize;

	unsigned int	blksize = mp->m_attr_geo->blksize;

	char		*ptr;

	int		len;

	xfs_daddr_t	bno;
@@ -203,7 +215,7 @@ xfs_attr3_rmt_write_verify( 
	while (len > 0) {

		struct xfs_attr3_rmt_hdr *rmt = (struct xfs_attr3_rmt_hdr *)ptr;



		fa = xfs_attr3_rmt_verify(mp, bp, ptr, blksize, bno);

		fa = xfs_attr3_rmt_verify(mp, bp, ptr, bno);

		if (fa) {

			xfs_verifier_error(bp, -EFSCORRUPTED, fa);

			return;
@@ -281,20 +293,20 @@ xfs_attr_rmtval_copyout( 
	struct xfs_buf		*bp,

	struct xfs_inode	*dp,

	xfs_ino_t		owner,

	int			*offset,

	int			*valuelen,

	unsigned int		*offset,

	unsigned int		*valuelen,

	uint8_t			**dst)

{

	char			*src = bp->b_addr;

	xfs_daddr_t		bno = xfs_buf_daddr(bp);

	int			len = BBTOB(bp->b_length);

	int			blksize = mp->m_attr_geo->blksize;

	unsigned int		len = BBTOB(bp->b_length);

	unsigned int		blksize = mp->m_attr_geo->blksize;



	ASSERT(len >= blksize);



	while (len > 0 && *valuelen > 0) {

		int hdr_size = 0;

		int byte_cnt = XFS_ATTR3_RMT_BUF_SPACE(mp, blksize);

		unsigned int hdr_size = 0;

		unsigned int byte_cnt = xfs_attr3_rmt_buf_space(mp);



		byte_cnt = min(*valuelen, byte_cnt);
@@ -330,20 +342,20 @@ xfs_attr_rmtval_copyin( 
	struct xfs_mount *mp,

	struct xfs_buf	*bp,

	xfs_ino_t	ino,

	int		*offset,

	int		*valuelen,

	unsigned int	*offset,

	unsigned int	*valuelen,

	uint8_t		**src)

{

	char		*dst = bp->b_addr;

	xfs_daddr_t	bno = xfs_buf_daddr(bp);

	int		len = BBTOB(bp->b_length);

	int		blksize = mp->m_attr_geo->blksize;

	unsigned int	len = BBTOB(bp->b_length);

	unsigned int	blksize = mp->m_attr_geo->blksize;



	ASSERT(len >= blksize);



	while (len > 0 && *valuelen > 0) {

		int hdr_size;

		int byte_cnt = XFS_ATTR3_RMT_BUF_SPACE(mp, blksize);

		unsigned int hdr_size;

		unsigned int byte_cnt = xfs_attr3_rmt_buf_space(mp);



		byte_cnt = min(*valuelen, byte_cnt);

		hdr_size = xfs_attr3_rmt_hdr_set(mp, dst, ino, *offset,
@@ -389,12 +401,12 @@ xfs_attr_rmtval_get( 
	struct xfs_buf		*bp;

	xfs_dablk_t		lblkno = args->rmtblkno;

	uint8_t			*dst = args->value;

	int			valuelen;

	unsigned int		valuelen;

	int			nmap;

	int			error;

	int			blkcnt = args->rmtblkcnt;

	unsigned int		blkcnt = args->rmtblkcnt;

	int			i;

	int			offset = 0;

	unsigned int		offset = 0;



	trace_xfs_attr_rmtval_get(args);
@@ -452,7 +464,7 @@ xfs_attr_rmt_find_hole( 
	struct xfs_inode	*dp = args->dp;

	struct xfs_mount	*mp = dp->i_mount;

	int			error;

	int			blkcnt;

	unsigned int		blkcnt;

	xfs_fileoff_t		lfileoff = 0;



	/*
@@ -481,11 +493,11 @@ xfs_attr_rmtval_set_value( 
	struct xfs_bmbt_irec	map;

	xfs_dablk_t		lblkno;

	uint8_t			*src = args->value;

	int			blkcnt;

	int			valuelen;

	unsigned int		blkcnt;

	unsigned int		valuelen;

	int			nmap;

	int			error;

	int			offset = 0;

	unsigned int		offset = 0;



	/*

	 * Roll through the "value", copying the attribute value to the
@@ -644,7 +656,7 @@ xfs_attr_rmtval_invalidate( 
	struct xfs_da_args	*args)

{

	xfs_dablk_t		lblkno;

	int			blkcnt;

	unsigned int		blkcnt;

	int			error;



	/*

fs/xfs/libxfs/xfs_attr_remote.h

+7 −1
Original line number Diff line number Diff line
@@ -6,7 +6,13 @@ 
#ifndef __XFS_ATTR_REMOTE_H__

#define	__XFS_ATTR_REMOTE_H__



int xfs_attr3_rmt_blocks(struct xfs_mount *mp, int attrlen);

unsigned int xfs_attr3_rmt_blocks(struct xfs_mount *mp, unsigned int attrlen);



/* Number of rmt blocks needed to store the maximally sized attr value */

static inline unsigned int xfs_attr3_max_rmt_blocks(struct xfs_mount *mp)

{

	return xfs_attr3_rmt_blocks(mp, XFS_XATTR_SIZE_MAX);

}



int xfs_attr_rmtval_get(struct xfs_da_args *args);

int xfs_attr_rmtval_stale(struct xfs_inode *ip, struct xfs_bmbt_irec *map,

fs/xfs/libxfs/xfs_da_format.h

+1 −3
Original line number Diff line number Diff line
@@ -880,9 +880,7 @@ struct xfs_attr3_rmt_hdr { 


#define XFS_ATTR3_RMT_CRC_OFF	offsetof(struct xfs_attr3_rmt_hdr, rm_crc)



#define XFS_ATTR3_RMT_BUF_SPACE(mp, bufsize)	\

	((bufsize) - (xfs_has_crc((mp)) ? \

			sizeof(struct xfs_attr3_rmt_hdr) : 0))

unsigned int xfs_attr3_rmt_buf_space(struct xfs_mount *mp);



/* Number of bytes in a directory block. */

static inline unsigned int xfs_dir2_dirblock_bytes(struct xfs_sb *sbp)

fs/xfs/scrub/reap.c

+2 −2
Original line number Diff line number Diff line
@@ -223,7 +223,7 @@ xrep_bufscan_max_sectors( 
	int			max_fsbs;



	/* Remote xattr values are the largest buffers that we support. */

	max_fsbs = xfs_attr3_rmt_blocks(mp, XFS_XATTR_SIZE_MAX);

	max_fsbs = xfs_attr3_max_rmt_blocks(mp);



	return XFS_FSB_TO_BB(mp, min_t(xfs_extlen_t, fsblocks, max_fsbs));

}
@@ -806,7 +806,7 @@ xreap_bmapi_binval( 
	 * of the next hole.

	 */

	off = imap->br_startoff + imap->br_blockcount;

	max_off = off + xfs_attr3_rmt_blocks(mp, XFS_XATTR_SIZE_MAX);

	max_off = off + xfs_attr3_max_rmt_blocks(mp);

	while (off < max_off) {

		struct xfs_bmbt_irec	hmap;

		int			nhmaps = 1;