xfs: log refcount intent items (f997ee21) · Commits · e / devices / android_kernel_fairphone_FP3

fs/xfs/Makefile

+1 −0

Original line number	Original line	Diff line number	Diff line
	@@ -113,6 +113,7 @@ xfs-y += xfs_log.o \
	xfs_trans_buf.o \		xfs_trans_buf.o \
	xfs_trans_extfree.o \		xfs_trans_extfree.o \
	xfs_trans_inode.o \		xfs_trans_inode.o \
			xfs_trans_refcount.o \
	xfs_trans_rmap.o \		xfs_trans_rmap.o \

	# optional features		# optional features

fs/xfs/libxfs/xfs_refcount.h

+14 −0

Original line number	Original line	Diff line number	Diff line
	@@ -27,4 +27,18 @@ extern int xfs_refcount_lookup_ge(struct xfs_btree_cur *cur,
	extern int xfs_refcount_get_rec(struct xfs_btree_cur *cur,		extern int xfs_refcount_get_rec(struct xfs_btree_cur *cur,
	struct xfs_refcount_irec irec, int stat);		struct xfs_refcount_irec irec, int stat);

			enum xfs_refcount_intent_type {
			XFS_REFCOUNT_INCREASE = 1,
			XFS_REFCOUNT_DECREASE,
			XFS_REFCOUNT_ALLOC_COW,
			XFS_REFCOUNT_FREE_COW,
			};

			struct xfs_refcount_intent {
			struct list_head ri_list;
			enum xfs_refcount_intent_type ri_type;
			xfs_fsblock_t ri_startblock;
			xfs_extlen_t ri_blockcount;
			};

	#endif /* __XFS_REFCOUNT_H__ */		#endif /* __XFS_REFCOUNT_H__ */

fs/xfs/xfs_log_recover.c

+175 −0

Original line number	Original line	Diff line number	Diff line
	@@ -45,6 +45,7 @@
	#include "xfs_dir2.h"		#include "xfs_dir2.h"
	#include "xfs_rmap_item.h"		#include "xfs_rmap_item.h"
	#include "xfs_buf_item.h"		#include "xfs_buf_item.h"
			#include "xfs_refcount_item.h"

	#define BLK_AVG(blk1, blk2) ((blk1+blk2) >> 1)		#define BLK_AVG(blk1, blk2) ((blk1+blk2) >> 1)

	@@ -1924,6 +1925,8 @@ xlog_recover_reorder_trans(
	case XFS_LI_EFI:		case XFS_LI_EFI:
	case XFS_LI_RUI:		case XFS_LI_RUI:
	case XFS_LI_RUD:		case XFS_LI_RUD:
			case XFS_LI_CUI:
			case XFS_LI_CUD:
	trace_xfs_log_recover_item_reorder_tail(log,		trace_xfs_log_recover_item_reorder_tail(log,
	trans, item, pass);		trans, item, pass);
	list_move_tail(&item->ri_list, &inode_list);		list_move_tail(&item->ri_list, &inode_list);
	@@ -3546,6 +3549,123 @@ xlog_recover_rud_pass2(
	return 0;		return 0;
	}		}

			/*
			* Copy an CUI format buffer from the given buf, and into the destination
			* CUI format structure. The CUI/CUD items were designed not to need any
			* special alignment handling.
			*/
			static int
			xfs_cui_copy_format(
			struct xfs_log_iovec *buf,
			struct xfs_cui_log_format *dst_cui_fmt)
			{
			struct xfs_cui_log_format *src_cui_fmt;
			uint len;

			src_cui_fmt = buf->i_addr;
			len = xfs_cui_log_format_sizeof(src_cui_fmt->cui_nextents);

			if (buf->i_len == len) {
			memcpy(dst_cui_fmt, src_cui_fmt, len);
			return 0;
			}
			return -EFSCORRUPTED;
			}

			/*
			* This routine is called to create an in-core extent refcount update
			* item from the cui format structure which was logged on disk.
			* It allocates an in-core cui, copies the extents from the format
			* structure into it, and adds the cui to the AIL with the given
			* LSN.
			*/
			STATIC int
			xlog_recover_cui_pass2(
			struct xlog *log,
			struct xlog_recover_item *item,
			xfs_lsn_t lsn)
			{
			int error;
			struct xfs_mount *mp = log->l_mp;
			struct xfs_cui_log_item *cuip;
			struct xfs_cui_log_format *cui_formatp;

			cui_formatp = item->ri_buf[0].i_addr;

			cuip = xfs_cui_init(mp, cui_formatp->cui_nextents);
			error = xfs_cui_copy_format(&item->ri_buf[0], &cuip->cui_format);
			if (error) {
			xfs_cui_item_free(cuip);
			return error;
			}
			atomic_set(&cuip->cui_next_extent, cui_formatp->cui_nextents);

			spin_lock(&log->l_ailp->xa_lock);
			/*
			* The CUI has two references. One for the CUD and one for CUI to ensure
			* it makes it into the AIL. Insert the CUI into the AIL directly and
			* drop the CUI reference. Note that xfs_trans_ail_update() drops the
			* AIL lock.
			*/
			xfs_trans_ail_update(log->l_ailp, &cuip->cui_item, lsn);
			xfs_cui_release(cuip);
			return 0;
			}


			/*
			* This routine is called when an CUD format structure is found in a committed
			* transaction in the log. Its purpose is to cancel the corresponding CUI if it
			* was still in the log. To do this it searches the AIL for the CUI with an id
			* equal to that in the CUD format structure. If we find it we drop the CUD
			* reference, which removes the CUI from the AIL and frees it.
			*/
			STATIC int
			xlog_recover_cud_pass2(
			struct xlog *log,
			struct xlog_recover_item *item)
			{
			struct xfs_cud_log_format *cud_formatp;
			struct xfs_cui_log_item *cuip = NULL;
			struct xfs_log_item *lip;
			__uint64_t cui_id;
			struct xfs_ail_cursor cur;
			struct xfs_ail *ailp = log->l_ailp;

			cud_formatp = item->ri_buf[0].i_addr;
			if (item->ri_buf[0].i_len != sizeof(struct xfs_cud_log_format))
			return -EFSCORRUPTED;
			cui_id = cud_formatp->cud_cui_id;

			/*
			* Search for the CUI with the id in the CUD 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_CUI) {
			cuip = (struct xfs_cui_log_item *)lip;
			if (cuip->cui_format.cui_id == cui_id) {
			/*
			* Drop the CUD reference to the CUI. This
			* removes the CUI from the AIL and frees it.
			*/
			spin_unlock(&ailp->xa_lock);
			xfs_cui_release(cuip);
			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		* 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		* committed transaction in the log. It's purpose is to initialise the inodes
	@@ -3773,6 +3893,8 @@ xlog_recover_ra_pass2(
	case XFS_LI_QUOTAOFF:		case XFS_LI_QUOTAOFF:
	case XFS_LI_RUI:		case XFS_LI_RUI:
	case XFS_LI_RUD:		case XFS_LI_RUD:
			case XFS_LI_CUI:
			case XFS_LI_CUD:
	default:		default:
	break;		break;
	}		}
	@@ -3798,6 +3920,8 @@ xlog_recover_commit_pass1(
	case XFS_LI_ICREATE:		case XFS_LI_ICREATE:
	case XFS_LI_RUI:		case XFS_LI_RUI:
	case XFS_LI_RUD:		case XFS_LI_RUD:
			case XFS_LI_CUI:
			case XFS_LI_CUD:
	/* nothing to do in pass 1 */		/* nothing to do in pass 1 */
	return 0;		return 0;
	default:		default:
	@@ -3832,6 +3956,10 @@ xlog_recover_commit_pass2(
	return xlog_recover_rui_pass2(log, item, trans->r_lsn);		return xlog_recover_rui_pass2(log, item, trans->r_lsn);
	case XFS_LI_RUD:		case XFS_LI_RUD:
	return xlog_recover_rud_pass2(log, item);		return xlog_recover_rud_pass2(log, item);
			case XFS_LI_CUI:
			return xlog_recover_cui_pass2(log, item, trans->r_lsn);
			case XFS_LI_CUD:
			return xlog_recover_cud_pass2(log, item);
	case XFS_LI_DQUOT:		case XFS_LI_DQUOT:
	return xlog_recover_dquot_pass2(log, buffer_list, item,		return xlog_recover_dquot_pass2(log, buffer_list, item,
	trans->r_lsn);		trans->r_lsn);
	@@ -4419,12 +4547,53 @@ xlog_recover_cancel_rui(
	spin_lock(&ailp->xa_lock);		spin_lock(&ailp->xa_lock);
	}		}

			/* Recover the CUI if necessary. */
			STATIC int
			xlog_recover_process_cui(
			struct xfs_mount *mp,
			struct xfs_ail *ailp,
			struct xfs_log_item *lip)
			{
			struct xfs_cui_log_item *cuip;
			int error;

			/*
			* Skip CUIs that we've already processed.
			*/
			cuip = container_of(lip, struct xfs_cui_log_item, cui_item);
			if (test_bit(XFS_CUI_RECOVERED, &cuip->cui_flags))
			return 0;

			spin_unlock(&ailp->xa_lock);
			error = xfs_cui_recover(mp, cuip);
			spin_lock(&ailp->xa_lock);

			return error;
			}

			/* Release the CUI since we're cancelling everything. */
			STATIC void
			xlog_recover_cancel_cui(
			struct xfs_mount *mp,
			struct xfs_ail *ailp,
			struct xfs_log_item *lip)
			{
			struct xfs_cui_log_item *cuip;

			cuip = container_of(lip, struct xfs_cui_log_item, cui_item);

			spin_unlock(&ailp->xa_lock);
			xfs_cui_release(cuip);
			spin_lock(&ailp->xa_lock);
			}

	/* Is this log item a deferred action intent? */		/* Is this log item a deferred action intent? */
	static inline bool xlog_item_is_intent(struct xfs_log_item *lip)		static inline bool xlog_item_is_intent(struct xfs_log_item *lip)
	{		{
	switch (lip->li_type) {		switch (lip->li_type) {
	case XFS_LI_EFI:		case XFS_LI_EFI:
	case XFS_LI_RUI:		case XFS_LI_RUI:
			case XFS_LI_CUI:
	return true;		return true;
	default:		default:
	return false;		return false;
	@@ -4488,6 +4657,9 @@ xlog_recover_process_intents(
	case XFS_LI_RUI:		case XFS_LI_RUI:
	error = xlog_recover_process_rui(log->l_mp, ailp, lip);		error = xlog_recover_process_rui(log->l_mp, ailp, lip);
	break;		break;
			case XFS_LI_CUI:
			error = xlog_recover_process_cui(log->l_mp, ailp, lip);
			break;
	}		}
	if (error)		if (error)
	goto out;		goto out;
	@@ -4535,6 +4707,9 @@ xlog_recover_cancel_intents(
	case XFS_LI_RUI:		case XFS_LI_RUI:
	xlog_recover_cancel_rui(log->l_mp, ailp, lip);		xlog_recover_cancel_rui(log->l_mp, ailp, lip);
	break;		break;
			case XFS_LI_CUI:
			xlog_recover_cancel_cui(log->l_mp, ailp, lip);
			break;
	}		}

	lip = xfs_trans_ail_cursor_next(ailp, &cur);		lip = xfs_trans_ail_cursor_next(ailp, &cur);

fs/xfs/xfs_refcount_item.c

+60 −0

Original line number	Original line	Diff line number	Diff line
	@@ -22,12 +22,15 @@
	#include "xfs_format.h"		#include "xfs_format.h"
	#include "xfs_log_format.h"		#include "xfs_log_format.h"
	#include "xfs_trans_resv.h"		#include "xfs_trans_resv.h"
			#include "xfs_bit.h"
	#include "xfs_mount.h"		#include "xfs_mount.h"
			#include "xfs_defer.h"
	#include "xfs_trans.h"		#include "xfs_trans.h"
	#include "xfs_trans_priv.h"		#include "xfs_trans_priv.h"
	#include "xfs_buf_item.h"		#include "xfs_buf_item.h"
	#include "xfs_refcount_item.h"		#include "xfs_refcount_item.h"
	#include "xfs_log.h"		#include "xfs_log.h"
			#include "xfs_refcount.h"


	kmem_zone_t *xfs_cui_zone;		kmem_zone_t *xfs_cui_zone;
	@@ -381,3 +384,60 @@ xfs_cud_init(

	return cudp;		return cudp;
	}		}

			/*
			* Process a refcount update intent item that was recovered from the log.
			* We need to update the refcountbt.
			*/
			int
			xfs_cui_recover(
			struct xfs_mount *mp,
			struct xfs_cui_log_item *cuip)
			{
			int i;
			int error = 0;
			struct xfs_phys_extent *refc;
			xfs_fsblock_t startblock_fsb;
			bool op_ok;

			ASSERT(!test_bit(XFS_CUI_RECOVERED, &cuip->cui_flags));

			/*
			* First check the validity of the extents described by the
			* CUI. If any are bad, then assume that all are bad and
			* just toss the CUI.
			*/
			for (i = 0; i < cuip->cui_format.cui_nextents; i++) {
			refc = &cuip->cui_format.cui_extents[i];
			startblock_fsb = XFS_BB_TO_FSB(mp,
			XFS_FSB_TO_DADDR(mp, refc->pe_startblock));
			switch (refc->pe_flags & XFS_REFCOUNT_EXTENT_TYPE_MASK) {
			case XFS_REFCOUNT_INCREASE:
			case XFS_REFCOUNT_DECREASE:
			case XFS_REFCOUNT_ALLOC_COW:
			case XFS_REFCOUNT_FREE_COW:
			op_ok = true;
			break;
			default:
			op_ok = false;
			break;
			}
			if (!op_ok \|\| startblock_fsb == 0 \|\|
			refc->pe_len == 0 \|\|
			startblock_fsb >= mp->m_sb.sb_dblocks \|\|
			refc->pe_len >= mp->m_sb.sb_agblocks \|\|
			(refc->pe_flags & ~XFS_REFCOUNT_EXTENT_FLAGS)) {
			/*
			* This will pull the CUI from the AIL and
			* free the memory associated with it.
			*/
			set_bit(XFS_CUI_RECOVERED, &cuip->cui_flags);
			xfs_cui_release(cuip);
			return -EIO;
			}
			}

			set_bit(XFS_CUI_RECOVERED, &cuip->cui_flags);
			xfs_cui_release(cuip);
			return error;
			}

fs/xfs/xfs_refcount_item.h

+1 −0

Original line number	Original line	Diff line number	Diff line
	@@ -96,5 +96,6 @@ struct xfs_cud_log_item xfs_cud_init(struct xfs_mount ,
	struct xfs_cui_log_item *);		struct xfs_cui_log_item *);
	void xfs_cui_item_free(struct xfs_cui_log_item *);		void xfs_cui_item_free(struct xfs_cui_log_item *);
	void xfs_cui_release(struct xfs_cui_log_item *);		void xfs_cui_release(struct xfs_cui_log_item *);
			int xfs_cui_recover(struct xfs_mount mp, struct xfs_cui_log_item cuip);

	#endif /* __XFS_REFCOUNT_ITEM_H__ */		#endif /* __XFS_REFCOUNT_ITEM_H__ */