Re: [PATCH 08/20] xfs: add a flag to release log items on commit

[Brian Foster <bfoster@redhat.com>]

On Thu, Jun 13, 2019 at 08:02:48PM +0200, Christoph Hellwig wrote:
> We have various items that are released from ->iop_comitting.  Add a
> flag to just call ->iop_release from the commit path to avoid tons
> of boilerplate code.
> 
> Signed-off-by: Christoph Hellwig <hch@lst.de>
> ---

FYI the commit log still refers to ->iop_committing() instead of
->iop_committed(). With that fixed up:

Reviewed-by: Brian Foster <bfoster@redhat.com>

>  fs/xfs/xfs_bmap_item.c     | 27 +--------------------------
>  fs/xfs/xfs_extfree_item.c  | 27 +--------------------------
>  fs/xfs/xfs_icreate_item.c  | 18 +-----------------
>  fs/xfs/xfs_refcount_item.c | 27 +--------------------------
>  fs/xfs/xfs_rmap_item.c     | 27 +--------------------------
>  fs/xfs/xfs_trans.c         |  6 ++++++
>  fs/xfs/xfs_trans.h         |  7 +++++++
>  7 files changed, 18 insertions(+), 121 deletions(-)
> 
> diff --git a/fs/xfs/xfs_bmap_item.c b/fs/xfs/xfs_bmap_item.c
> index 56c1ab161f3b..6fb5263cb61d 100644
> --- a/fs/xfs/xfs_bmap_item.c
> +++ b/fs/xfs/xfs_bmap_item.c
> @@ -208,39 +208,14 @@ xfs_bud_item_release(
>  	kmem_zone_free(xfs_bud_zone, budp);
>  }
>  
> -/*
> - * When the bud item is committed to disk, all we need to do is delete our
> - * reference to our partner bui item and then free ourselves. Since we're
> - * freeing ourselves we must return -1 to keep the transaction code from
> - * further referencing this item.
> - */
> -STATIC xfs_lsn_t
> -xfs_bud_item_committed(
> -	struct xfs_log_item	*lip,
> -	xfs_lsn_t		lsn)
> -{
> -	struct xfs_bud_log_item	*budp = BUD_ITEM(lip);
> -
> -	/*
> -	 * Drop the BUI reference regardless of whether the BUD has been
> -	 * aborted. Once the BUD transaction is constructed, it is the sole
> -	 * responsibility of the BUD to release the BUI (even if the BUI is
> -	 * aborted due to log I/O error).
> -	 */
> -	xfs_bui_release(budp->bud_buip);
> -	kmem_zone_free(xfs_bud_zone, budp);
> -
> -	return (xfs_lsn_t)-1;
> -}
> -
>  /*
>   * This is the ops vector shared by all bud log items.
>   */
>  static const struct xfs_item_ops xfs_bud_item_ops = {
> +	.flags		= XFS_ITEM_RELEASE_WHEN_COMMITTED,
>  	.iop_size	= xfs_bud_item_size,
>  	.iop_format	= xfs_bud_item_format,
>  	.iop_release	= xfs_bud_item_release,
> -	.iop_committed	= xfs_bud_item_committed,
>  };
>  
>  /*
> diff --git a/fs/xfs/xfs_extfree_item.c b/fs/xfs/xfs_extfree_item.c
> index a73a3cff8502..92e182493000 100644
> --- a/fs/xfs/xfs_extfree_item.c
> +++ b/fs/xfs/xfs_extfree_item.c
> @@ -307,39 +307,14 @@ xfs_efd_item_release(
>  	xfs_efd_item_free(efdp);
>  }
>  
> -/*
> - * When the efd item is committed to disk, all we need to do is delete our
> - * reference to our partner efi item and then free ourselves. Since we're
> - * freeing ourselves we must return -1 to keep the transaction code from further
> - * referencing this item.
> - */
> -STATIC xfs_lsn_t
> -xfs_efd_item_committed(
> -	struct xfs_log_item	*lip,
> -	xfs_lsn_t		lsn)
> -{
> -	struct xfs_efd_log_item	*efdp = EFD_ITEM(lip);
> -
> -	/*
> -	 * Drop the EFI reference regardless of whether the EFD has been
> -	 * aborted. Once the EFD transaction is constructed, it is the sole
> -	 * responsibility of the EFD to release the EFI (even if the EFI is
> -	 * aborted due to log I/O error).
> -	 */
> -	xfs_efi_release(efdp->efd_efip);
> -	xfs_efd_item_free(efdp);
> -
> -	return (xfs_lsn_t)-1;
> -}
> -
>  /*
>   * This is the ops vector shared by all efd log items.
>   */
>  static const struct xfs_item_ops xfs_efd_item_ops = {
> +	.flags		= XFS_ITEM_RELEASE_WHEN_COMMITTED,
>  	.iop_size	= xfs_efd_item_size,
>  	.iop_format	= xfs_efd_item_format,
>  	.iop_release	= xfs_efd_item_release,
> -	.iop_committed	= xfs_efd_item_committed,
>  };
>  
>  /*
> diff --git a/fs/xfs/xfs_icreate_item.c b/fs/xfs/xfs_icreate_item.c
> index 9aceb35dce24..ac9918da5f4a 100644
> --- a/fs/xfs/xfs_icreate_item.c
> +++ b/fs/xfs/xfs_icreate_item.c
> @@ -63,30 +63,14 @@ xfs_icreate_item_release(
>  	kmem_zone_free(xfs_icreate_zone, ICR_ITEM(lip));
>  }
>  
> -/*
> - * Because we have ordered buffers being tracked in the AIL for the inode
> - * creation, we don't need the create item after this. Hence we can free
> - * the log item and return -1 to tell the caller we're done with the item.
> - */
> -STATIC xfs_lsn_t
> -xfs_icreate_item_committed(
> -	struct xfs_log_item	*lip,
> -	xfs_lsn_t		lsn)
> -{
> -	struct xfs_icreate_item	*icp = ICR_ITEM(lip);
> -
> -	kmem_zone_free(xfs_icreate_zone, icp);
> -	return (xfs_lsn_t)-1;
> -}
> -
>  /*
>   * This is the ops vector shared by all buf log items.
>   */
>  static const struct xfs_item_ops xfs_icreate_item_ops = {
> +	.flags		= XFS_ITEM_RELEASE_WHEN_COMMITTED,
>  	.iop_size	= xfs_icreate_item_size,
>  	.iop_format	= xfs_icreate_item_format,
>  	.iop_release	= xfs_icreate_item_release,
> -	.iop_committed	= xfs_icreate_item_committed,
>  };
>  
>  
> diff --git a/fs/xfs/xfs_refcount_item.c b/fs/xfs/xfs_refcount_item.c
> index 9f8fb23dcc81..5b03478c5d1f 100644
> --- a/fs/xfs/xfs_refcount_item.c
> +++ b/fs/xfs/xfs_refcount_item.c
> @@ -213,39 +213,14 @@ xfs_cud_item_release(
>  	kmem_zone_free(xfs_cud_zone, cudp);
>  }
>  
> -/*
> - * When the cud item is committed to disk, all we need to do is delete our
> - * reference to our partner cui item and then free ourselves. Since we're
> - * freeing ourselves we must return -1 to keep the transaction code from
> - * further referencing this item.
> - */
> -STATIC xfs_lsn_t
> -xfs_cud_item_committed(
> -	struct xfs_log_item	*lip,
> -	xfs_lsn_t		lsn)
> -{
> -	struct xfs_cud_log_item	*cudp = CUD_ITEM(lip);
> -
> -	/*
> -	 * Drop the CUI reference regardless of whether the CUD has been
> -	 * aborted. Once the CUD transaction is constructed, it is the sole
> -	 * responsibility of the CUD to release the CUI (even if the CUI is
> -	 * aborted due to log I/O error).
> -	 */
> -	xfs_cui_release(cudp->cud_cuip);
> -	kmem_zone_free(xfs_cud_zone, cudp);
> -
> -	return (xfs_lsn_t)-1;
> -}
> -
>  /*
>   * This is the ops vector shared by all cud log items.
>   */
>  static const struct xfs_item_ops xfs_cud_item_ops = {
> +	.flags		= XFS_ITEM_RELEASE_WHEN_COMMITTED,
>  	.iop_size	= xfs_cud_item_size,
>  	.iop_format	= xfs_cud_item_format,
>  	.iop_release	= xfs_cud_item_release,
> -	.iop_committed	= xfs_cud_item_committed,
>  };
>  
>  /*
> diff --git a/fs/xfs/xfs_rmap_item.c b/fs/xfs/xfs_rmap_item.c
> index e907bd169de5..3fbc7c5ffa96 100644
> --- a/fs/xfs/xfs_rmap_item.c
> +++ b/fs/xfs/xfs_rmap_item.c
> @@ -234,39 +234,14 @@ xfs_rud_item_release(
>  	kmem_zone_free(xfs_rud_zone, rudp);
>  }
>  
> -/*
> - * When the rud item is committed to disk, all we need to do is delete our
> - * reference to our partner rui item and then free ourselves. Since we're
> - * freeing ourselves we must return -1 to keep the transaction code from
> - * further referencing this item.
> - */
> -STATIC xfs_lsn_t
> -xfs_rud_item_committed(
> -	struct xfs_log_item	*lip,
> -	xfs_lsn_t		lsn)
> -{
> -	struct xfs_rud_log_item	*rudp = RUD_ITEM(lip);
> -
> -	/*
> -	 * Drop the RUI reference regardless of whether the RUD has been
> -	 * aborted. Once the RUD transaction is constructed, it is the sole
> -	 * responsibility of the RUD to release the RUI (even if the RUI is
> -	 * aborted due to log I/O error).
> -	 */
> -	xfs_rui_release(rudp->rud_ruip);
> -	kmem_zone_free(xfs_rud_zone, rudp);
> -
> -	return (xfs_lsn_t)-1;
> -}
> -
>  /*
>   * This is the ops vector shared by all rud log items.
>   */
>  static const struct xfs_item_ops xfs_rud_item_ops = {
> +	.flags		= XFS_ITEM_RELEASE_WHEN_COMMITTED,
>  	.iop_size	= xfs_rud_item_size,
>  	.iop_format	= xfs_rud_item_format,
>  	.iop_release	= xfs_rud_item_release,
> -	.iop_committed	= xfs_rud_item_committed,
>  };
>  
>  /*
> diff --git a/fs/xfs/xfs_trans.c b/fs/xfs/xfs_trans.c
> index 5fe69ea07367..942de9bd9f59 100644
> --- a/fs/xfs/xfs_trans.c
> +++ b/fs/xfs/xfs_trans.c
> @@ -851,6 +851,12 @@ xfs_trans_committed_bulk(
>  
>  		if (aborted)
>  			set_bit(XFS_LI_ABORTED, &lip->li_flags);
> +
> +		if (lip->li_ops->flags & XFS_ITEM_RELEASE_WHEN_COMMITTED) {
> +			lip->li_ops->iop_release(lip);
> +			continue;
> +		}
> +
>  		if (lip->li_ops->iop_committed)
>  			item_lsn = lip->li_ops->iop_committed(lip, commit_lsn);
>  		else
> diff --git a/fs/xfs/xfs_trans.h b/fs/xfs/xfs_trans.h
> index 7bd1867613c2..1eeaefd3c65d 100644
> --- a/fs/xfs/xfs_trans.h
> +++ b/fs/xfs/xfs_trans.h
> @@ -67,6 +67,7 @@ typedef struct xfs_log_item {
>  	{ (1 << XFS_LI_DIRTY),		"DIRTY" }
>  
>  struct xfs_item_ops {
> +	unsigned flags;
>  	void (*iop_size)(xfs_log_item_t *, int *, int *);
>  	void (*iop_format)(xfs_log_item_t *, struct xfs_log_vec *);
>  	void (*iop_pin)(xfs_log_item_t *);
> @@ -78,6 +79,12 @@ struct xfs_item_ops {
>  	void (*iop_error)(xfs_log_item_t *, xfs_buf_t *);
>  };
>  
> +/*
> + * Release the log item as soon as committed.  This is for items just logging
> + * intents that never need to be written back in place.
> + */
> +#define XFS_ITEM_RELEASE_WHEN_COMMITTED	(1 << 0)
> +
>  void	xfs_log_item_init(struct xfs_mount *mp, struct xfs_log_item *item,
>  			  int type, const struct xfs_item_ops *ops);
>  
> -- 
> 2.20.1
>