Re: [PATCH 20/63] xfs: log bmap intent items

["Darrick J. Wong" <darrick.wong@oracle.com>]

On Fri, Sep 30, 2016 at 03:22:14PM -0400, Brian Foster wrote:
> On Thu, Sep 29, 2016 at 08:07:45PM -0700, Darrick J. Wong wrote:
> > Provide a mechanism for higher levels to create BUI/BUD items, submit
> > them to the log, and a stub function to deal with recovered BUI items.
> > These parts will be connected to the rmapbt in a later patch.
> > 
> > Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
> > ---
> > v2: Only support one item per BUI.
> > ---
> >  fs/xfs/Makefile          |    1 
> >  fs/xfs/libxfs/xfs_bmap.h |   14 ++++
> >  fs/xfs/xfs_bmap_item.c   |   69 ++++++++++++++++++
> >  fs/xfs/xfs_bmap_item.h   |    1 
> >  fs/xfs/xfs_log_recover.c |  177 ++++++++++++++++++++++++++++++++++++++++++++++
> >  fs/xfs/xfs_trans.h       |   13 +++
> >  fs/xfs/xfs_trans_bmap.c  |   84 ++++++++++++++++++++++
> >  7 files changed, 359 insertions(+)
> >  create mode 100644 fs/xfs/xfs_trans_bmap.c
> > 
> > 
> ...
> > diff --git a/fs/xfs/xfs_bmap_item.c b/fs/xfs/xfs_bmap_item.c
> > index ea736af..4e46b63 100644
> > --- a/fs/xfs/xfs_bmap_item.c
> > +++ b/fs/xfs/xfs_bmap_item.c
> ...
> > @@ -372,3 +378,66 @@ xfs_bud_init(
> >  
> >  	return budp;
> >  }
> > +
> > +/*
> > + * Process a bmap update intent item that was recovered from the log.
> > + * We need to update some inode's bmbt.
> > + */
> > +int
> > +xfs_bui_recover(
> > +	struct xfs_mount		*mp,
> > +	struct xfs_bui_log_item		*buip)
> > +{
> > +	int				error = 0;
> > +	struct xfs_map_extent		*bmap;
> > +	xfs_fsblock_t			startblock_fsb;
> > +	xfs_fsblock_t			inode_fsb;
> > +	bool				op_ok;
> > +
> > +	ASSERT(!test_bit(XFS_BUI_RECOVERED, &buip->bui_flags));
> > +
> > +	/* Only one mapping operation per BUI... */
> > +	if (buip->bui_format.bui_nextents != XFS_BUI_MAX_FAST_EXTENTS) {
> > +		set_bit(XFS_BUI_RECOVERED, &buip->bui_flags);
> > +		xfs_bui_release(buip);
> > +		return -EIO;
> > +	}
> > +
> > +	/*
> > +	 * First check the validity of the extent described by the
> > +	 * BUI.  If anything is bad, then toss the BUI.
> > +	 */
> > +	bmap = &buip->bui_format.bui_extents[0];
> > +	startblock_fsb = XFS_BB_TO_FSB(mp,
> > +			   XFS_FSB_TO_DADDR(mp, bmap->me_startblock));
> > +	inode_fsb = XFS_BB_TO_FSB(mp, XFS_FSB_TO_DADDR(mp,
> > +			XFS_INO_TO_FSB(mp, bmap->me_owner)));
> > +	switch (bmap->me_flags & XFS_BMAP_EXTENT_TYPE_MASK) {
> > +	case XFS_BMAP_MAP:
> > +	case XFS_BMAP_UNMAP:
> > +		op_ok = true;
> > +		break;
> > +	default:
> > +		op_ok = false;
> > +		break;
> > +	}
> > +	if (!op_ok || startblock_fsb == 0 ||
> > +	    bmap->me_len == 0 ||
> > +	    inode_fsb == 0 ||
> > +	    startblock_fsb >= mp->m_sb.sb_dblocks ||
> > +	    bmap->me_len >= mp->m_sb.sb_agblocks ||
> > +	    inode_fsb >= mp->m_sb.sb_agblocks ||
> 
> Did you mean sb_dblocks here?

Yes, thank you.  I'll fix that.

--D

> 
> Brian
> 
> > +	    (bmap->me_flags & ~XFS_BMAP_EXTENT_FLAGS)) {
> > +		/*
> > +		 * This will pull the BUI from the AIL and
> > +		 * free the memory associated with it.
> > +		 */
> > +		set_bit(XFS_BUI_RECOVERED, &buip->bui_flags);
> > +		xfs_bui_release(buip);
> > +		return -EIO;
> > +	}
> > +
> > +	set_bit(XFS_BUI_RECOVERED, &buip->bui_flags);
> > +	xfs_bui_release(buip);
> > +	return error;
> > +}
> > diff --git a/fs/xfs/xfs_bmap_item.h b/fs/xfs/xfs_bmap_item.h
> > index 57c13d3..c867daa 100644
> > --- a/fs/xfs/xfs_bmap_item.h
> > +++ b/fs/xfs/xfs_bmap_item.h
> > @@ -93,5 +93,6 @@ struct xfs_bud_log_item *xfs_bud_init(struct xfs_mount *,
> >  		struct xfs_bui_log_item *);
> >  void xfs_bui_item_free(struct xfs_bui_log_item *);
> >  void xfs_bui_release(struct xfs_bui_log_item *);
> > +int xfs_bui_recover(struct xfs_mount *mp, struct xfs_bui_log_item *buip);
> >  
> >  #endif	/* __XFS_BMAP_ITEM_H__ */
> > diff --git a/fs/xfs/xfs_log_recover.c b/fs/xfs/xfs_log_recover.c
> > index 622881a..9697e94 100644
> > --- a/fs/xfs/xfs_log_recover.c
> > +++ b/fs/xfs/xfs_log_recover.c
> > @@ -46,6 +46,7 @@
> >  #include "xfs_rmap_item.h"
> >  #include "xfs_buf_item.h"
> >  #include "xfs_refcount_item.h"
> > +#include "xfs_bmap_item.h"
> >  
> >  #define BLK_AVG(blk1, blk2)	((blk1+blk2) >> 1)
> >  
> > @@ -1927,6 +1928,8 @@ xlog_recover_reorder_trans(
> >  		case XFS_LI_RUD:
> >  		case XFS_LI_CUI:
> >  		case XFS_LI_CUD:
> > +		case XFS_LI_BUI:
> > +		case XFS_LI_BUD:
> >  			trace_xfs_log_recover_item_reorder_tail(log,
> >  							trans, item, pass);
> >  			list_move_tail(&item->ri_list, &inode_list);
> > @@ -3671,6 +3674,125 @@ xlog_recover_cud_pass2(
> >  }
> >  
> >  /*
> > + * Copy an BUI format buffer from the given buf, and into the destination
> > + * BUI format structure.  The BUI/BUD items were designed not to need any
> > + * special alignment handling.
> > + */
> > +static int
> > +xfs_bui_copy_format(
> > +	struct xfs_log_iovec		*buf,
> > +	struct xfs_bui_log_format	*dst_bui_fmt)
> > +{
> > +	struct xfs_bui_log_format	*src_bui_fmt;
> > +	uint				len;
> > +
> > +	src_bui_fmt = buf->i_addr;
> > +	len = xfs_bui_log_format_sizeof(src_bui_fmt->bui_nextents);
> > +
> > +	if (buf->i_len == len) {
> > +		memcpy(dst_bui_fmt, src_bui_fmt, len);
> > +		return 0;
> > +	}
> > +	return -EFSCORRUPTED;
> > +}
> > +
> > +/*
> > + * This routine is called to create an in-core extent bmap update
> > + * item from the bui format structure which was logged on disk.
> > + * It allocates an in-core bui, copies the extents from the format
> > + * structure into it, and adds the bui to the AIL with the given
> > + * LSN.
> > + */
> > +STATIC int
> > +xlog_recover_bui_pass2(
> > +	struct xlog			*log,
> > +	struct xlog_recover_item	*item,
> > +	xfs_lsn_t			lsn)
> > +{
> > +	int				error;
> > +	struct xfs_mount		*mp = log->l_mp;
> > +	struct xfs_bui_log_item		*buip;
> > +	struct xfs_bui_log_format	*bui_formatp;
> > +
> > +	bui_formatp = item->ri_buf[0].i_addr;
> > +
> > +	if (bui_formatp->bui_nextents != XFS_BUI_MAX_FAST_EXTENTS)
> > +		return -EFSCORRUPTED;
> > +	buip = xfs_bui_init(mp);
> > +	error = xfs_bui_copy_format(&item->ri_buf[0], &buip->bui_format);
> > +	if (error) {
> > +		xfs_bui_item_free(buip);
> > +		return error;
> > +	}
> > +	atomic_set(&buip->bui_next_extent, bui_formatp->bui_nextents);
> > +
> > +	spin_lock(&log->l_ailp->xa_lock);
> > +	/*
> > +	 * The RUI has two references. One for the RUD and one for RUI to ensure
> > +	 * it makes it into the AIL. Insert the RUI into the AIL directly and
> > +	 * drop the RUI reference. Note that xfs_trans_ail_update() drops the
> > +	 * AIL lock.
> > +	 */
> > +	xfs_trans_ail_update(log->l_ailp, &buip->bui_item, lsn);
> > +	xfs_bui_release(buip);
> > +	return 0;
> > +}
> > +
> > +
> > +/*
> > + * This routine is called when an BUD format structure is found in a committed
> > + * transaction in the log. Its purpose is to cancel the corresponding BUI if it
> > + * was still in the log. To do this it searches the AIL for the BUI with an id
> > + * equal to that in the BUD format structure. If we find it we drop the BUD
> > + * reference, which removes the BUI from the AIL and frees it.
> > + */
> > +STATIC int
> > +xlog_recover_bud_pass2(
> > +	struct xlog			*log,
> > +	struct xlog_recover_item	*item)
> > +{
> > +	struct xfs_bud_log_format	*bud_formatp;
> > +	struct xfs_bui_log_item		*buip = NULL;
> > +	struct xfs_log_item		*lip;
> > +	__uint64_t			bui_id;
> > +	struct xfs_ail_cursor		cur;
> > +	struct xfs_ail			*ailp = log->l_ailp;
> > +
> > +	bud_formatp = item->ri_buf[0].i_addr;
> > +	if (item->ri_buf[0].i_len != sizeof(struct xfs_bud_log_format))
> > +		return -EFSCORRUPTED;
> > +	bui_id = bud_formatp->bud_bui_id;
> > +
> > +	/*
> > +	 * Search for the BUI with the id in the BUD format structure in the
> > +	 * AIL.
> > +	 */
> > +	spin_lock(&ailp->xa_lock);
> > +	lip = xfs_trans_ail_cursor_first(ailp, &cur, 0);
> > +	while (lip != NULL) {
> > +		if (lip->li_type == XFS_LI_BUI) {
> > +			buip = (struct xfs_bui_log_item *)lip;
> > +			if (buip->bui_format.bui_id == bui_id) {
> > +				/*
> > +				 * Drop the BUD reference to the BUI. This
> > +				 * removes the BUI from the AIL and frees it.
> > +				 */
> > +				spin_unlock(&ailp->xa_lock);
> > +				xfs_bui_release(buip);
> > +				spin_lock(&ailp->xa_lock);
> > +				break;
> > +			}
> > +		}
> > +		lip = xfs_trans_ail_cursor_next(ailp, &cur);
> > +	}
> > +
> > +	xfs_trans_ail_cursor_done(&cur);
> > +	spin_unlock(&ailp->xa_lock);
> > +
> > +	return 0;
> > +}
> > +
> > +/*
> >   * This routine is called when an inode create format structure is found in a
> >   * committed transaction in the log.  It's purpose is to initialise the inodes
> >   * being allocated on disk. This requires us to get inode cluster buffers that
> > @@ -3899,6 +4021,8 @@ xlog_recover_ra_pass2(
> >  	case XFS_LI_RUD:
> >  	case XFS_LI_CUI:
> >  	case XFS_LI_CUD:
> > +	case XFS_LI_BUI:
> > +	case XFS_LI_BUD:
> >  	default:
> >  		break;
> >  	}
> > @@ -3926,6 +4050,8 @@ xlog_recover_commit_pass1(
> >  	case XFS_LI_RUD:
> >  	case XFS_LI_CUI:
> >  	case XFS_LI_CUD:
> > +	case XFS_LI_BUI:
> > +	case XFS_LI_BUD:
> >  		/* nothing to do in pass 1 */
> >  		return 0;
> >  	default:
> > @@ -3964,6 +4090,10 @@ xlog_recover_commit_pass2(
> >  		return xlog_recover_cui_pass2(log, item, trans->r_lsn);
> >  	case XFS_LI_CUD:
> >  		return xlog_recover_cud_pass2(log, item);
> > +	case XFS_LI_BUI:
> > +		return xlog_recover_bui_pass2(log, item, trans->r_lsn);
> > +	case XFS_LI_BUD:
> > +		return xlog_recover_bud_pass2(log, item);
> >  	case XFS_LI_DQUOT:
> >  		return xlog_recover_dquot_pass2(log, buffer_list, item,
> >  						trans->r_lsn);
> > @@ -4591,6 +4721,46 @@ xlog_recover_cancel_cui(
> >  	spin_lock(&ailp->xa_lock);
> >  }
> >  
> > +/* Recover the BUI if necessary. */
> > +STATIC int
> > +xlog_recover_process_bui(
> > +	struct xfs_mount		*mp,
> > +	struct xfs_ail			*ailp,
> > +	struct xfs_log_item		*lip)
> > +{
> > +	struct xfs_bui_log_item		*buip;
> > +	int				error;
> > +
> > +	/*
> > +	 * Skip BUIs that we've already processed.
> > +	 */
> > +	buip = container_of(lip, struct xfs_bui_log_item, bui_item);
> > +	if (test_bit(XFS_BUI_RECOVERED, &buip->bui_flags))
> > +		return 0;
> > +
> > +	spin_unlock(&ailp->xa_lock);
> > +	error = xfs_bui_recover(mp, buip);
> > +	spin_lock(&ailp->xa_lock);
> > +
> > +	return error;
> > +}
> > +
> > +/* Release the BUI since we're cancelling everything. */
> > +STATIC void
> > +xlog_recover_cancel_bui(
> > +	struct xfs_mount		*mp,
> > +	struct xfs_ail			*ailp,
> > +	struct xfs_log_item		*lip)
> > +{
> > +	struct xfs_bui_log_item		*buip;
> > +
> > +	buip = container_of(lip, struct xfs_bui_log_item, bui_item);
> > +
> > +	spin_unlock(&ailp->xa_lock);
> > +	xfs_bui_release(buip);
> > +	spin_lock(&ailp->xa_lock);
> > +}
> > +
> >  /* Is this log item a deferred action intent? */
> >  static inline bool xlog_item_is_intent(struct xfs_log_item *lip)
> >  {
> > @@ -4598,6 +4768,7 @@ static inline bool xlog_item_is_intent(struct xfs_log_item *lip)
> >  	case XFS_LI_EFI:
> >  	case XFS_LI_RUI:
> >  	case XFS_LI_CUI:
> > +	case XFS_LI_BUI:
> >  		return true;
> >  	default:
> >  		return false;
> > @@ -4664,6 +4835,9 @@ xlog_recover_process_intents(
> >  		case XFS_LI_CUI:
> >  			error = xlog_recover_process_cui(log->l_mp, ailp, lip);
> >  			break;
> > +		case XFS_LI_BUI:
> > +			error = xlog_recover_process_bui(log->l_mp, ailp, lip);
> > +			break;
> >  		}
> >  		if (error)
> >  			goto out;
> > @@ -4714,6 +4888,9 @@ xlog_recover_cancel_intents(
> >  		case XFS_LI_CUI:
> >  			xlog_recover_cancel_cui(log->l_mp, ailp, lip);
> >  			break;
> > +		case XFS_LI_BUI:
> > +			xlog_recover_cancel_bui(log->l_mp, ailp, lip);
> > +			break;
> >  		}
> >  
> >  		lip = xfs_trans_ail_cursor_next(ailp, &cur);
> > diff --git a/fs/xfs/xfs_trans.h b/fs/xfs/xfs_trans.h
> > index a7a87d2..7cf02d3 100644
> > --- a/fs/xfs/xfs_trans.h
> > +++ b/fs/xfs/xfs_trans.h
> > @@ -39,6 +39,7 @@ struct xfs_btree_cur;
> >  struct xfs_cui_log_item;
> >  struct xfs_cud_log_item;
> >  struct xfs_defer_ops;
> > +struct xfs_bui_log_item;
> >  
> >  typedef struct xfs_log_item {
> >  	struct list_head		li_ail;		/* AIL pointers */
> > @@ -263,4 +264,16 @@ int xfs_trans_log_finish_refcount_update(struct xfs_trans *tp,
> >  		xfs_extlen_t blockcount, xfs_extlen_t *adjusted,
> >  		struct xfs_btree_cur **pcur);
> >  
> > +/* mapping updates */
> > +enum xfs_bmap_intent_type;
> > +
> > +void xfs_bmap_update_init_defer_op(void);
> > +struct xfs_bud_log_item *xfs_trans_get_bud(struct xfs_trans *tp,
> > +		struct xfs_bui_log_item *buip);
> > +int xfs_trans_log_finish_bmap_update(struct xfs_trans *tp,
> > +		struct xfs_bud_log_item *rudp, struct xfs_defer_ops *dfops,
> > +		enum xfs_bmap_intent_type type, struct xfs_inode *ip,
> > +		int whichfork, xfs_fileoff_t startoff, xfs_fsblock_t startblock,
> > +		xfs_filblks_t blockcount, xfs_exntst_t state);
> > +
> >  #endif	/* __XFS_TRANS_H__ */
> > diff --git a/fs/xfs/xfs_trans_bmap.c b/fs/xfs/xfs_trans_bmap.c
> > new file mode 100644
> > index 0000000..656d669
> > --- /dev/null
> > +++ b/fs/xfs/xfs_trans_bmap.c
> > @@ -0,0 +1,84 @@
> > +/*
> > + * Copyright (C) 2016 Oracle.  All Rights Reserved.
> > + *
> > + * Author: Darrick J. Wong <darrick.wong@oracle.com>
> > + *
> > + * This program is free software; you can redistribute it and/or
> > + * modify it under the terms of the GNU General Public License
> > + * as published by the Free Software Foundation; either version 2
> > + * of the License, or (at your option) any later version.
> > + *
> > + * This program is distributed in the hope that it would be useful,
> > + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> > + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> > + * GNU General Public License for more details.
> > + *
> > + * You should have received a copy of the GNU General Public License
> > + * along with this program; if not, write the Free Software Foundation,
> > + * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA.
> > + */
> > +#include "xfs.h"
> > +#include "xfs_fs.h"
> > +#include "xfs_shared.h"
> > +#include "xfs_format.h"
> > +#include "xfs_log_format.h"
> > +#include "xfs_trans_resv.h"
> > +#include "xfs_mount.h"
> > +#include "xfs_defer.h"
> > +#include "xfs_trans.h"
> > +#include "xfs_trans_priv.h"
> > +#include "xfs_bmap_item.h"
> > +#include "xfs_alloc.h"
> > +#include "xfs_bmap.h"
> > +#include "xfs_inode.h"
> > +
> > +/*
> > + * This routine is called to allocate a "bmap update done"
> > + * log item.
> > + */
> > +struct xfs_bud_log_item *
> > +xfs_trans_get_bud(
> > +	struct xfs_trans		*tp,
> > +	struct xfs_bui_log_item		*buip)
> > +{
> > +	struct xfs_bud_log_item		*budp;
> > +
> > +	budp = xfs_bud_init(tp->t_mountp, buip);
> > +	xfs_trans_add_item(tp, &budp->bud_item);
> > +	return budp;
> > +}
> > +
> > +/*
> > + * Finish an bmap update and log it to the BUD. Note that the
> > + * transaction is marked dirty regardless of whether the bmap update
> > + * succeeds or fails to support the BUI/BUD lifecycle rules.
> > + */
> > +int
> > +xfs_trans_log_finish_bmap_update(
> > +	struct xfs_trans		*tp,
> > +	struct xfs_bud_log_item		*budp,
> > +	struct xfs_defer_ops		*dop,
> > +	enum xfs_bmap_intent_type	type,
> > +	struct xfs_inode		*ip,
> > +	int				whichfork,
> > +	xfs_fileoff_t			startoff,
> > +	xfs_fsblock_t			startblock,
> > +	xfs_filblks_t			blockcount,
> > +	xfs_exntst_t			state)
> > +{
> > +	int				error;
> > +
> > +	error = -EFSCORRUPTED;
> > +
> > +	/*
> > +	 * Mark the transaction dirty, even on error. This ensures the
> > +	 * transaction is aborted, which:
> > +	 *
> > +	 * 1.) releases the BUI and frees the BUD
> > +	 * 2.) shuts down the filesystem
> > +	 */
> > +	tp->t_flags |= XFS_TRANS_DIRTY;
> > +	budp->bud_item.li_desc->lid_flags |= XFS_LID_DIRTY;
> > +
> > +	return error;
> > +}
> > 
> > --
> > To unsubscribe from this list: send the line "unsubscribe linux-xfs" in
> > the body of a message to majordomo@vger.kernel.org
> > More majordomo info at  http://vger.kernel.org/majordomo-info.html