xfs: don't require log items to implement optional methods (e8b78db7) · Commits · e / devices / android_kernel_fairphone_FP5

fs/xfs/xfs_bmap_item.c

+0 −104

Original line number	Diff line number	Diff line
		@@ -96,15 +96,6 @@ xfs_bui_item_format(
		xfs_bui_log_format_sizeof(buip->bui_format.bui_nextents));
		}

		/*
		* Pinning has no meaning for an bui item, so just return.
		*/
		STATIC void
		xfs_bui_item_pin(
		struct xfs_log_item *lip)
		{
		}

		/*
		* The unpin operation is the last place an BUI is manipulated in the log. It is
		* either inserted in the AIL or aborted in the event of a log I/O error. In
		@@ -123,21 +114,6 @@ xfs_bui_item_unpin(
		xfs_bui_release(buip);
		}

		/*
		* BUI items have no locking or pushing. However, since BUIs are pulled from
		* the AIL when their corresponding BUDs are committed to disk, their situation
		* is very similar to being pinned. Return XFS_ITEM_PINNED so that the caller
		* will eventually flush the log. This should help in getting the BUI out of
		* the AIL.
		*/
		STATIC uint
		xfs_bui_item_push(
		struct xfs_log_item *lip,
		struct list_head *buffer_list)
		{
		return XFS_ITEM_PINNED;
		}

		/*
		* The BUI has been either committed or aborted if the transaction has been
		* cancelled. If the transaction was cancelled, an BUD isn't going to be
		@@ -151,44 +127,14 @@ xfs_bui_item_unlock(
		xfs_bui_release(BUI_ITEM(lip));
		}

		/*
		* The BUI is logged only once and cannot be moved in the log, so simply return
		* the lsn at which it's been logged.
		*/
		STATIC xfs_lsn_t
		xfs_bui_item_committed(
		struct xfs_log_item *lip,
		xfs_lsn_t lsn)
		{
		return lsn;
		}

		/*
		* The BUI dependency tracking op doesn't do squat. It can't because
		* it doesn't know where the free extent is coming from. The dependency
		* tracking has to be handled by the "enclosing" metadata object. For
		* example, for inodes, the inode is locked throughout the extent freeing
		* so the dependency should be recorded there.
		*/
		STATIC void
		xfs_bui_item_committing(
		struct xfs_log_item *lip,
		xfs_lsn_t lsn)
		{
		}

		/*
		* This is the ops vector shared by all bui log items.
		*/
		static const struct xfs_item_ops xfs_bui_item_ops = {
		.iop_size = xfs_bui_item_size,
		.iop_format = xfs_bui_item_format,
		.iop_pin = xfs_bui_item_pin,
		.iop_unpin = xfs_bui_item_unpin,
		.iop_unlock = xfs_bui_item_unlock,
		.iop_committed = xfs_bui_item_committed,
		.iop_push = xfs_bui_item_push,
		.iop_committing = xfs_bui_item_committing,
		};

		/*
		@@ -249,38 +195,6 @@ xfs_bud_item_format(
		sizeof(struct xfs_bud_log_format));
		}

		/*
		* Pinning has no meaning for an bud item, so just return.
		*/
		STATIC void
		xfs_bud_item_pin(
		struct xfs_log_item *lip)
		{
		}

		/*
		* Since pinning has no meaning for an bud item, unpinning does
		* not either.
		*/
		STATIC void
		xfs_bud_item_unpin(
		struct xfs_log_item *lip,
		int remove)
		{
		}

		/*
		* There isn't much you can do to push on an bud item. It is simply stuck
		* waiting for the log to be flushed to disk.
		*/
		STATIC uint
		xfs_bud_item_push(
		struct xfs_log_item *lip,
		struct list_head *buffer_list)
		{
		return XFS_ITEM_PINNED;
		}

		/*
		* The BUD is either committed or aborted if the transaction is cancelled. If
		* the transaction is cancelled, drop our reference to the BUI and free the
		@@ -323,32 +237,14 @@ xfs_bud_item_committed(
		return (xfs_lsn_t)-1;
		}

		/*
		* The BUD dependency tracking op doesn't do squat. It can't because
		* it doesn't know where the free extent is coming from. The dependency
		* tracking has to be handled by the "enclosing" metadata object. For
		* example, for inodes, the inode is locked throughout the extent freeing
		* so the dependency should be recorded there.
		*/
		STATIC void
		xfs_bud_item_committing(
		struct xfs_log_item *lip,
		xfs_lsn_t lsn)
		{
		}

		/*
		* This is the ops vector shared by all bud log items.
		*/
		static const struct xfs_item_ops xfs_bud_item_ops = {
		.iop_size = xfs_bud_item_size,
		.iop_format = xfs_bud_item_format,
		.iop_pin = xfs_bud_item_pin,
		.iop_unpin = xfs_bud_item_unpin,
		.iop_unlock = xfs_bud_item_unlock,
		.iop_committed = xfs_bud_item_committed,
		.iop_push = xfs_bud_item_push,
		.iop_committing = xfs_bud_item_committing,
		};

		/*

fs/xfs/xfs_buf_item.c

+0 −8

Original line number	Diff line number	Diff line
		@@ -672,13 +672,6 @@ xfs_buf_item_committed(
		return lsn;
		}

		STATIC void
		xfs_buf_item_committing(
		struct xfs_log_item *lip,
		xfs_lsn_t commit_lsn)
		{
		}

		/*
		* This is the ops vector shared by all buf log items.
		*/
		@@ -690,7 +683,6 @@ static const struct xfs_item_ops xfs_buf_item_ops = {
		.iop_unlock = xfs_buf_item_unlock,
		.iop_committed = xfs_buf_item_committed,
		.iop_push = xfs_buf_item_push,
		.iop_committing = xfs_buf_item_committing
		};

		STATIC int

fs/xfs/xfs_dquot_item.c

+0 −98

Original line number	Diff line number	Diff line
		@@ -95,18 +95,6 @@ xfs_qm_dquot_logitem_unpin(
		wake_up(&dqp->q_pinwait);
		}

		STATIC xfs_lsn_t
		xfs_qm_dquot_logitem_committed(
		struct xfs_log_item *lip,
		xfs_lsn_t lsn)
		{
		/*
		* We always re-log the entire dquot when it becomes dirty,
		* so, the latest copy _is_ the only one that matters.
		*/
		return lsn;
		}

		/*
		* This is called to wait for the given dquot to be unpinned.
		* Most of these pin/unpin routines are plagiarized from inode code.
		@@ -233,18 +221,6 @@ xfs_qm_dquot_logitem_unlock(
		xfs_dqunlock(dqp);
		}

		/*
		* this needs to stamp an lsn into the dquot, I think.
		* rpc's that look at user dquot's would then have to
		* push on the dependency recorded in the dquot
		*/
		STATIC void
		xfs_qm_dquot_logitem_committing(
		struct xfs_log_item *lip,
		xfs_lsn_t lsn)
		{
		}

		/*
		* This is the ops vector for dquots
		*/
		@@ -254,9 +230,7 @@ static const struct xfs_item_ops xfs_dquot_item_ops = {
		.iop_pin = xfs_qm_dquot_logitem_pin,
		.iop_unpin = xfs_qm_dquot_logitem_unpin,
		.iop_unlock = xfs_qm_dquot_logitem_unlock,
		.iop_committed = xfs_qm_dquot_logitem_committed,
		.iop_push = xfs_qm_dquot_logitem_push,
		.iop_committing = xfs_qm_dquot_logitem_committing,
		.iop_error = xfs_dquot_item_error
		};

		@@ -315,26 +289,6 @@ xfs_qm_qoff_logitem_format(
		xlog_finish_iovec(lv, vecp, sizeof(struct xfs_qoff_logitem));
		}

		/*
		* Pinning has no meaning for an quotaoff item, so just return.
		*/
		STATIC void
		xfs_qm_qoff_logitem_pin(
		struct xfs_log_item *lip)
		{
		}

		/*
		* Since pinning has no meaning for an quotaoff item, unpinning does
		* not either.
		*/
		STATIC void
		xfs_qm_qoff_logitem_unpin(
		struct xfs_log_item *lip,
		int remove)
		{
		}

		/*
		* There isn't much you can do to push a quotaoff item. It is simply
		* stuck waiting for the log to be flushed to disk.
		@@ -347,28 +301,6 @@ xfs_qm_qoff_logitem_push(
		return XFS_ITEM_LOCKED;
		}

		/*
		* Quotaoff items have no locking or pushing, so return failure
		* so that the caller doesn't bother with us.
		*/
		STATIC void
		xfs_qm_qoff_logitem_unlock(
		struct xfs_log_item *lip)
		{
		}

		/*
		* The quotaoff-start-item is logged only once and cannot be moved in the log,
		* so simply return the lsn at which it's been logged.
		*/
		STATIC xfs_lsn_t
		xfs_qm_qoff_logitem_committed(
		struct xfs_log_item *lip,
		xfs_lsn_t lsn)
		{
		return lsn;
		}

		STATIC xfs_lsn_t
		xfs_qm_qoffend_logitem_committed(
		struct xfs_log_item *lip,
		@@ -392,36 +324,11 @@ xfs_qm_qoffend_logitem_committed(
		return (xfs_lsn_t)-1;
		}

		/*
		* XXX rcc - don't know quite what to do with this. I think we can
		* just ignore it. The only time that isn't the case is if we allow
		* the client to somehow see that quotas have been turned off in which
		* we can't allow that to get back until the quotaoff hits the disk.
		* So how would that happen? Also, do we need different routines for
		* quotaoff start and quotaoff end? I suspect the answer is yes but
		* to be sure, I need to look at the recovery code and see how quota off
		* recovery is handled (do we roll forward or back or do something else).
		* If we roll forwards or backwards, then we need two separate routines,
		* one that does nothing and one that stamps in the lsn that matters
		* (truly makes the quotaoff irrevocable). If we do something else,
		* then maybe we don't need two.
		*/
		STATIC void
		xfs_qm_qoff_logitem_committing(
		struct xfs_log_item *lip,
		xfs_lsn_t commit_lsn)
		{
		}

		static const struct xfs_item_ops xfs_qm_qoffend_logitem_ops = {
		.iop_size = xfs_qm_qoff_logitem_size,
		.iop_format = xfs_qm_qoff_logitem_format,
		.iop_pin = xfs_qm_qoff_logitem_pin,
		.iop_unpin = xfs_qm_qoff_logitem_unpin,
		.iop_unlock = xfs_qm_qoff_logitem_unlock,
		.iop_committed = xfs_qm_qoffend_logitem_committed,
		.iop_push = xfs_qm_qoff_logitem_push,
		.iop_committing = xfs_qm_qoff_logitem_committing
		};

		/*
		@@ -430,12 +337,7 @@ static const struct xfs_item_ops xfs_qm_qoffend_logitem_ops = {
		static const struct xfs_item_ops xfs_qm_qoff_logitem_ops = {
		.iop_size = xfs_qm_qoff_logitem_size,
		.iop_format = xfs_qm_qoff_logitem_format,
		.iop_pin = xfs_qm_qoff_logitem_pin,
		.iop_unpin = xfs_qm_qoff_logitem_unpin,
		.iop_unlock = xfs_qm_qoff_logitem_unlock,
		.iop_committed = xfs_qm_qoff_logitem_committed,
		.iop_push = xfs_qm_qoff_logitem_push,
		.iop_committing = xfs_qm_qoff_logitem_committing
		};

		/*

fs/xfs/xfs_extfree_item.c

+0 −104

Original line number	Diff line number	Diff line
		@@ -107,15 +107,6 @@ xfs_efi_item_format(
		}


		/*
		* Pinning has no meaning for an efi item, so just return.
		*/
		STATIC void
		xfs_efi_item_pin(
		struct xfs_log_item *lip)
		{
		}

		/*
		* The unpin operation is the last place an EFI is manipulated in the log. It is
		* either inserted in the AIL or aborted in the event of a log I/O error. In
		@@ -133,21 +124,6 @@ xfs_efi_item_unpin(
		xfs_efi_release(efip);
		}

		/*
		* Efi items have no locking or pushing. However, since EFIs are pulled from
		* the AIL when their corresponding EFDs are committed to disk, their situation
		* is very similar to being pinned. Return XFS_ITEM_PINNED so that the caller
		* will eventually flush the log. This should help in getting the EFI out of
		* the AIL.
		*/
		STATIC uint
		xfs_efi_item_push(
		struct xfs_log_item *lip,
		struct list_head *buffer_list)
		{
		return XFS_ITEM_PINNED;
		}

		/*
		* The EFI has been either committed or aborted if the transaction has been
		* cancelled. If the transaction was cancelled, an EFD isn't going to be
		@@ -161,44 +137,14 @@ xfs_efi_item_unlock(
		xfs_efi_release(EFI_ITEM(lip));
		}

		/*
		* The EFI is logged only once and cannot be moved in the log, so simply return
		* the lsn at which it's been logged.
		*/
		STATIC xfs_lsn_t
		xfs_efi_item_committed(
		struct xfs_log_item *lip,
		xfs_lsn_t lsn)
		{
		return lsn;
		}

		/*
		* The EFI dependency tracking op doesn't do squat. It can't because
		* it doesn't know where the free extent is coming from. The dependency
		* tracking has to be handled by the "enclosing" metadata object. For
		* example, for inodes, the inode is locked throughout the extent freeing
		* so the dependency should be recorded there.
		*/
		STATIC void
		xfs_efi_item_committing(
		struct xfs_log_item *lip,
		xfs_lsn_t lsn)
		{
		}

		/*
		* This is the ops vector shared by all efi log items.
		*/
		static const struct xfs_item_ops xfs_efi_item_ops = {
		.iop_size = xfs_efi_item_size,
		.iop_format = xfs_efi_item_format,
		.iop_pin = xfs_efi_item_pin,
		.iop_unpin = xfs_efi_item_unpin,
		.iop_unlock = xfs_efi_item_unlock,
		.iop_committed = xfs_efi_item_committed,
		.iop_push = xfs_efi_item_push,
		.iop_committing = xfs_efi_item_committing
		};


		@@ -349,38 +295,6 @@ xfs_efd_item_format(
		xfs_efd_item_sizeof(efdp));
		}

		/*
		* Pinning has no meaning for an efd item, so just return.
		*/
		STATIC void
		xfs_efd_item_pin(
		struct xfs_log_item *lip)
		{
		}

		/*
		* Since pinning has no meaning for an efd item, unpinning does
		* not either.
		*/
		STATIC void
		xfs_efd_item_unpin(
		struct xfs_log_item *lip,
		int remove)
		{
		}

		/*
		* There isn't much you can do to push on an efd item. It is simply stuck
		* waiting for the log to be flushed to disk.
		*/
		STATIC uint
		xfs_efd_item_push(
		struct xfs_log_item *lip,
		struct list_head *buffer_list)
		{
		return XFS_ITEM_PINNED;
		}

		/*
		* The EFD is either committed or aborted if the transaction is cancelled. If
		* the transaction is cancelled, drop our reference to the EFI and free the EFD.
		@@ -422,32 +336,14 @@ xfs_efd_item_committed(
		return (xfs_lsn_t)-1;
		}

		/*
		* The EFD dependency tracking op doesn't do squat. It can't because
		* it doesn't know where the free extent is coming from. The dependency
		* tracking has to be handled by the "enclosing" metadata object. For
		* example, for inodes, the inode is locked throughout the extent freeing
		* so the dependency should be recorded there.
		*/
		STATIC void
		xfs_efd_item_committing(
		struct xfs_log_item *lip,
		xfs_lsn_t lsn)
		{
		}

		/*
		* This is the ops vector shared by all efd log items.
		*/
		static const struct xfs_item_ops xfs_efd_item_ops = {
		.iop_size = xfs_efd_item_size,
		.iop_format = xfs_efd_item_format,
		.iop_pin = xfs_efd_item_pin,
		.iop_unpin = xfs_efd_item_unpin,
		.iop_unlock = xfs_efd_item_unlock,
		.iop_committed = xfs_efd_item_committed,
		.iop_push = xfs_efd_item_push,
		.iop_committing = xfs_efd_item_committing
		};

		/*

fs/xfs/xfs_icreate_item.c

+0 −28

Original line number	Diff line number	Diff line
		@@ -56,23 +56,6 @@ xfs_icreate_item_format(
		sizeof(struct xfs_icreate_log));
		}


		/* Pinning has no meaning for the create item, so just return. */
		STATIC void
		xfs_icreate_item_pin(
		struct xfs_log_item *lip)
		{
		}


		/* pinning has no meaning for the create item, so just return. */
		STATIC void
		xfs_icreate_item_unpin(
		struct xfs_log_item *lip,
		int remove)
		{
		}

		STATIC void
		xfs_icreate_item_unlock(
		struct xfs_log_item *lip)
		@@ -110,26 +93,15 @@ xfs_icreate_item_push(
		return XFS_ITEM_SUCCESS;
		}

		/* Ordered buffers do the dependency tracking here, so this does nothing. */
		STATIC void
		xfs_icreate_item_committing(
		struct xfs_log_item *lip,
		xfs_lsn_t lsn)
		{
		}

		/*
		* This is the ops vector shared by all buf log items.
		*/
		static const struct xfs_item_ops xfs_icreate_item_ops = {
		.iop_size = xfs_icreate_item_size,
		.iop_format = xfs_icreate_item_format,
		.iop_pin = xfs_icreate_item_pin,
		.iop_unpin = xfs_icreate_item_unpin,
		.iop_push = xfs_icreate_item_push,
		.iop_unlock = xfs_icreate_item_unlock,
		.iop_committed = xfs_icreate_item_committed,
		.iop_committing = xfs_icreate_item_committing,
		};