Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 166d1368 authored by Dave Chinner's avatar Dave Chinner Committed by Ben Myers
Browse files

xfs: return log item size in IOP_SIZE 



To begin optimising the CIL commit process, we need to have IOP_SIZE
return both the number of vectors and the size of the data pointed
to by the vectors. This enables us to calculate the size ofthe
memory allocation needed before the formatting step and reduces the
number of memory allocations per item by one.

While there, kill the IOP_SIZE macro.

Signed-off-by: default avatarDave Chinner <dchinner@redhat.com>
Reviewed-by: default avatarMark Tinguely <tinguely@sgi.com>
Signed-off-by: default avatarBen Myers <bpm@sgi.com>
parent 050a1952

fs/xfs/xfs_buf_item.c

+32 −20
Original line number Diff line number Diff line
@@ -39,6 +39,14 @@ static inline struct xfs_buf_log_item *BUF_ITEM(struct xfs_log_item *lip) 


STATIC void	xfs_buf_do_callbacks(struct xfs_buf *bp);



static inline int

xfs_buf_log_format_size(

	struct xfs_buf_log_format *blfp)

{

	return offsetof(struct xfs_buf_log_format, blf_data_map) +

			(blfp->blf_map_size * sizeof(blfp->blf_data_map[0]));

}



/*

 * This returns the number of log iovecs needed to log the

 * given buf log item.
@@ -49,25 +57,27 @@ STATIC void xfs_buf_do_callbacks(struct xfs_buf *bp); 
 *

 * If the XFS_BLI_STALE flag has been set, then log nothing.

 */

STATIC uint

STATIC void

xfs_buf_item_size_segment(

	struct xfs_buf_log_item	*bip,

	struct xfs_buf_log_format *blfp)

	struct xfs_buf_log_format *blfp,

	int			*nvecs,

	int			*nbytes)

{

	struct xfs_buf		*bp = bip->bli_buf;

	uint			nvecs;

	int			next_bit;

	int			last_bit;



	last_bit = xfs_next_bit(blfp->blf_data_map, blfp->blf_map_size, 0);

	if (last_bit == -1)

		return 0;

		return;



	/*

	 * initial count for a dirty buffer is 2 vectors - the format structure

	 * and the first dirty region.

	 */

	nvecs = 2;

	*nvecs += 2;

	*nbytes += xfs_buf_log_format_size(blfp) + XFS_BLF_CHUNK;



	while (last_bit != -1) {

		/*
@@ -87,18 +97,17 @@ xfs_buf_item_size_segment( 
			break;

		} else if (next_bit != last_bit + 1) {

			last_bit = next_bit;

			nvecs++;

			(*nvecs)++;

		} else if (xfs_buf_offset(bp, next_bit * XFS_BLF_CHUNK) !=

			   (xfs_buf_offset(bp, last_bit * XFS_BLF_CHUNK) +

			    XFS_BLF_CHUNK)) {

			last_bit = next_bit;

			nvecs++;

			(*nvecs)++;

		} else {

			last_bit++;

		}

		*nbytes += XFS_BLF_CHUNK;

	}



	return nvecs;

}



/*
@@ -118,12 +127,13 @@ xfs_buf_item_size_segment( 
 * If the XFS_BLI_STALE flag has been set, then log nothing but the buf log

 * format structures.

 */

STATIC uint

STATIC void

xfs_buf_item_size(

	struct xfs_log_item	*lip)

	struct xfs_log_item	*lip,

	int			*nvecs,

	int			*nbytes)

{

	struct xfs_buf_log_item	*bip = BUF_ITEM(lip);

	uint			nvecs;

	int			i;



	ASSERT(atomic_read(&bip->bli_refcount) > 0);
@@ -135,7 +145,11 @@ xfs_buf_item_size( 
		 */

		trace_xfs_buf_item_size_stale(bip);

		ASSERT(bip->__bli_format.blf_flags & XFS_BLF_CANCEL);

		return bip->bli_format_count;

		*nvecs += bip->bli_format_count;

		for (i = 0; i < bip->bli_format_count; i++) {

			*nbytes += xfs_buf_log_format_size(&bip->bli_formats[i]);

		}

		return;

	}



	ASSERT(bip->bli_flags & XFS_BLI_LOGGED);
@@ -147,7 +161,8 @@ xfs_buf_item_size( 
		 * commit, so no vectors are used at all.

		 */

		trace_xfs_buf_item_size_ordered(bip);

		return XFS_LOG_VEC_ORDERED;

		*nvecs = XFS_LOG_VEC_ORDERED;

		return;

	}



	/*
@@ -159,13 +174,11 @@ xfs_buf_item_size( 
	 * count for the extra buf log format structure that will need to be

	 * written.

	 */

	nvecs = 0;

	for (i = 0; i < bip->bli_format_count; i++) {

		nvecs += xfs_buf_item_size_segment(bip, &bip->bli_formats[i]);

		xfs_buf_item_size_segment(bip, &bip->bli_formats[i],

					  nvecs, nbytes);

	}



	trace_xfs_buf_item_size(bip);

	return nvecs;

}



static struct xfs_log_iovec *
@@ -192,8 +205,7 @@ xfs_buf_item_format_segment( 
	 * the actual size of the dirty bitmap rather than the size of the in

	 * memory structure.

	 */

	base_size = offsetof(struct xfs_buf_log_format, blf_data_map) +

			(blfp->blf_map_size * sizeof(blfp->blf_data_map[0]));

	base_size = xfs_buf_log_format_size(blfp);



	nvecs = 0;

	first_bit = xfs_next_bit(blfp->blf_data_map, blfp->blf_map_size, 0);

fs/xfs/xfs_dquot_item.c

+13 −9
Original line number Diff line number Diff line
@@ -44,14 +44,15 @@ static inline struct xfs_dq_logitem *DQUOT_ITEM(struct xfs_log_item *lip) 
/*

 * returns the number of iovecs needed to log the given dquot item.

 */

STATIC uint

STATIC void

xfs_qm_dquot_logitem_size(

	struct xfs_log_item	*lip)

	struct xfs_log_item	*lip,

	int			*nvecs,

	int			*nbytes)

{

	/*

	 * we need only two iovecs, one for the format, one for the real thing

	 */

	return 2;

	*nvecs += 2;

	*nbytes += sizeof(struct xfs_dq_logformat) +

		   sizeof(struct xfs_disk_dquot);

}



/*
@@ -286,11 +287,14 @@ static inline struct xfs_qoff_logitem *QOFF_ITEM(struct xfs_log_item *lip) 
 * We only need 1 iovec for an quotaoff item.  It just logs the

 * quotaoff_log_format structure.

 */

STATIC uint

STATIC void

xfs_qm_qoff_logitem_size(

	struct xfs_log_item	*lip)

	struct xfs_log_item	*lip,

	int			*nvecs,

	int			*nbytes)

{

	return 1;

	*nvecs += 1;

	*nbytes += sizeof(struct xfs_qoff_logitem);

}



/*

fs/xfs/xfs_extfree_item.c

+32 −18
Original line number Diff line number Diff line
@@ -73,11 +73,22 @@ __xfs_efi_release( 
 * We only need 1 iovec for an efi item.  It just logs the efi_log_format

 * structure.

 */

STATIC uint

static inline int

xfs_efi_item_sizeof(

	struct xfs_efi_log_item *efip)

{

	return sizeof(struct xfs_efi_log_format) +

	       (efip->efi_format.efi_nextents - 1) * sizeof(xfs_extent_t);

}



STATIC void

xfs_efi_item_size(

	struct xfs_log_item	*lip)

	struct xfs_log_item	*lip,

	int			*nvecs,

	int			*nbytes)

{

	return 1;

	*nvecs += 1;

	*nbytes += xfs_efi_item_sizeof(EFI_ITEM(lip));

}



/*
@@ -93,21 +104,17 @@ xfs_efi_item_format( 
	struct xfs_log_iovec	*log_vector)

{

	struct xfs_efi_log_item	*efip = EFI_ITEM(lip);

	uint			size;



	ASSERT(atomic_read(&efip->efi_next_extent) ==

				efip->efi_format.efi_nextents);



	efip->efi_format.efi_type = XFS_LI_EFI;



	size = sizeof(xfs_efi_log_format_t);

	size += (efip->efi_format.efi_nextents - 1) * sizeof(xfs_extent_t);

	efip->efi_format.efi_size = 1;



	log_vector->i_addr = &efip->efi_format;

	log_vector->i_len = size;

	log_vector->i_len = xfs_efi_item_sizeof(efip);

	log_vector->i_type = XLOG_REG_TYPE_EFI_FORMAT;

	ASSERT(size >= sizeof(xfs_efi_log_format_t));

	ASSERT(log_vector->i_len >= sizeof(xfs_efi_log_format_t));

}
@@ -333,11 +340,22 @@ xfs_efd_item_free(struct xfs_efd_log_item *efdp) 
 * We only need 1 iovec for an efd item.  It just logs the efd_log_format

 * structure.

 */

STATIC uint

static inline int

xfs_efd_item_sizeof(

	struct xfs_efd_log_item *efdp)

{

	return sizeof(xfs_efd_log_format_t) +

	       (efdp->efd_format.efd_nextents - 1) * sizeof(xfs_extent_t);

}



STATIC void

xfs_efd_item_size(

	struct xfs_log_item	*lip)

	struct xfs_log_item	*lip,

	int			*nvecs,

	int			*nbytes)

{

	return 1;

	*nvecs += 1;

	*nbytes += xfs_efd_item_sizeof(EFD_ITEM(lip));

}



/*
@@ -353,20 +371,16 @@ xfs_efd_item_format( 
	struct xfs_log_iovec	*log_vector)

{

	struct xfs_efd_log_item	*efdp = EFD_ITEM(lip);

	uint			size;



	ASSERT(efdp->efd_next_extent == efdp->efd_format.efd_nextents);



	efdp->efd_format.efd_type = XFS_LI_EFD;



	size = sizeof(xfs_efd_log_format_t);

	size += (efdp->efd_format.efd_nextents - 1) * sizeof(xfs_extent_t);

	efdp->efd_format.efd_size = 1;



	log_vector->i_addr = &efdp->efd_format;

	log_vector->i_len = size;

	log_vector->i_len = xfs_efd_item_sizeof(efdp);

	log_vector->i_type = XLOG_REG_TYPE_EFD_FORMAT;

	ASSERT(size >= sizeof(xfs_efd_log_format_t));

	ASSERT(log_vector->i_len >= sizeof(xfs_efd_log_format_t));

}



/*

fs/xfs/xfs_icreate_item.c

+6 −3
Original line number Diff line number Diff line
@@ -40,11 +40,14 @@ static inline struct xfs_icreate_item *ICR_ITEM(struct xfs_log_item *lip) 
 *

 * We only need one iovec for the icreate log structure.

 */

STATIC uint

STATIC void

xfs_icreate_item_size(

	struct xfs_log_item	*lip)

	struct xfs_log_item	*lip,

	int			*nvecs,

	int			*nbytes)

{

	return 1;

	*nvecs += 1;

	*nbytes += sizeof(struct xfs_icreate_log);

}



/*

fs/xfs/xfs_inode_item.c

+35 −18
Original line number Diff line number Diff line
@@ -47,32 +47,44 @@ static inline struct xfs_inode_log_item *INODE_ITEM(struct xfs_log_item *lip) 
 * inode core, and possibly one for the inode data/extents/b-tree root

 * and one for the inode attribute data/extents/b-tree root.

 */

STATIC uint

STATIC void

xfs_inode_item_size(

	struct xfs_log_item	*lip)

	struct xfs_log_item	*lip,

	int			*nvecs,

	int			*nbytes)

{

	struct xfs_inode_log_item *iip = INODE_ITEM(lip);

	struct xfs_inode	*ip = iip->ili_inode;

	uint			nvecs = 2;



	*nvecs += 2;

	*nbytes += sizeof(struct xfs_inode_log_format) +

		   xfs_icdinode_size(ip->i_d.di_version);



	switch (ip->i_d.di_format) {

	case XFS_DINODE_FMT_EXTENTS:

		if ((iip->ili_fields & XFS_ILOG_DEXT) &&

		    ip->i_d.di_nextents > 0 &&

		    ip->i_df.if_bytes > 0)

			nvecs++;

		    ip->i_df.if_bytes > 0) {

			/* worst case, doesn't subtract delalloc extents */

			*nbytes += XFS_IFORK_DSIZE(ip);

			*nvecs += 1;

		}

		break;



	case XFS_DINODE_FMT_BTREE:

		if ((iip->ili_fields & XFS_ILOG_DBROOT) &&

		    ip->i_df.if_broot_bytes > 0)

			nvecs++;

		    ip->i_df.if_broot_bytes > 0) {

			*nbytes += ip->i_df.if_broot_bytes;

			*nvecs += 1;

		}

		break;



	case XFS_DINODE_FMT_LOCAL:

		if ((iip->ili_fields & XFS_ILOG_DDATA) &&

		    ip->i_df.if_bytes > 0)

			nvecs++;

		    ip->i_df.if_bytes > 0) {

			*nbytes += roundup(ip->i_df.if_bytes, 4);

			*nvecs += 1;

		}

		break;



	case XFS_DINODE_FMT_DEV:
@@ -85,7 +97,7 @@ xfs_inode_item_size( 
	}



	if (!XFS_IFORK_Q(ip))

		return nvecs;

		return;





	/*
@@ -95,28 +107,33 @@ xfs_inode_item_size( 
	case XFS_DINODE_FMT_EXTENTS:

		if ((iip->ili_fields & XFS_ILOG_AEXT) &&

		    ip->i_d.di_anextents > 0 &&

		    ip->i_afp->if_bytes > 0)

			nvecs++;

		    ip->i_afp->if_bytes > 0) {

			/* worst case, doesn't subtract unused space */

			*nbytes += XFS_IFORK_ASIZE(ip);

			*nvecs += 1;

		}

		break;



	case XFS_DINODE_FMT_BTREE:

		if ((iip->ili_fields & XFS_ILOG_ABROOT) &&

		    ip->i_afp->if_broot_bytes > 0)

			nvecs++;

		    ip->i_afp->if_broot_bytes > 0) {

			*nbytes += ip->i_afp->if_broot_bytes;

			*nvecs += 1;

		}

		break;



	case XFS_DINODE_FMT_LOCAL:

		if ((iip->ili_fields & XFS_ILOG_ADATA) &&

		    ip->i_afp->if_bytes > 0)

			nvecs++;

		    ip->i_afp->if_bytes > 0) {

			*nbytes += roundup(ip->i_afp->if_bytes, 4);

			*nvecs += 1;

		}

		break;



	default:

		ASSERT(0);

		break;

	}



	return nvecs;

}



/*