mirror of
https://mirrors.bfsu.edu.cn/git/linux.git
synced 2024-11-24 12:44:11 +08:00
xfs: don't require log items to implement optional methods
Just check if they are present first. Signed-off-by: Christoph Hellwig <hch@lst.de> Reviewed-by: Brian Foster <bfoster@redhat.com> Reviewed-by: Darrick J. Wong <darrick.wong@oracle.com> Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
This commit is contained in:
parent
d15cbf2f38
commit
e8b78db77d
@ -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,
|
||||
};
|
||||
|
||||
/*
|
||||
|
@ -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
|
||||
|
@ -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
|
||||
};
|
||||
|
||||
/*
|
||||
|
@ -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
|
||||
};
|
||||
|
||||
/*
|
||||
|
@ -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,
|
||||
};
|
||||
|
||||
|
||||
|
@ -246,7 +246,8 @@ xfs_cil_prepare_item(
|
||||
* shadow buffer, so update the the pointer to it appropriately.
|
||||
*/
|
||||
if (!old_lv) {
|
||||
lv->lv_item->li_ops->iop_pin(lv->lv_item);
|
||||
if (lv->lv_item->li_ops->iop_pin)
|
||||
lv->lv_item->li_ops->iop_pin(lv->lv_item);
|
||||
lv->lv_item->li_lv_shadow = NULL;
|
||||
} else if (old_lv != lv) {
|
||||
ASSERT(lv->lv_buf_len != XFS_LOG_VEC_ORDERED);
|
||||
|
@ -94,15 +94,6 @@ xfs_cui_item_format(
|
||||
xfs_cui_log_format_sizeof(cuip->cui_format.cui_nextents));
|
||||
}
|
||||
|
||||
/*
|
||||
* Pinning has no meaning for an cui item, so just return.
|
||||
*/
|
||||
STATIC void
|
||||
xfs_cui_item_pin(
|
||||
struct xfs_log_item *lip)
|
||||
{
|
||||
}
|
||||
|
||||
/*
|
||||
* The unpin operation is the last place an CUI is manipulated in the log. It is
|
||||
* either inserted in the AIL or aborted in the event of a log I/O error. In
|
||||
@ -121,21 +112,6 @@ xfs_cui_item_unpin(
|
||||
xfs_cui_release(cuip);
|
||||
}
|
||||
|
||||
/*
|
||||
* CUI items have no locking or pushing. However, since CUIs are pulled from
|
||||
* the AIL when their corresponding CUDs 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 CUI out of
|
||||
* the AIL.
|
||||
*/
|
||||
STATIC uint
|
||||
xfs_cui_item_push(
|
||||
struct xfs_log_item *lip,
|
||||
struct list_head *buffer_list)
|
||||
{
|
||||
return XFS_ITEM_PINNED;
|
||||
}
|
||||
|
||||
/*
|
||||
* The CUI has been either committed or aborted if the transaction has been
|
||||
* cancelled. If the transaction was cancelled, an CUD isn't going to be
|
||||
@ -149,44 +125,14 @@ xfs_cui_item_unlock(
|
||||
xfs_cui_release(CUI_ITEM(lip));
|
||||
}
|
||||
|
||||
/*
|
||||
* The CUI 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_cui_item_committed(
|
||||
struct xfs_log_item *lip,
|
||||
xfs_lsn_t lsn)
|
||||
{
|
||||
return lsn;
|
||||
}
|
||||
|
||||
/*
|
||||
* The CUI 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_cui_item_committing(
|
||||
struct xfs_log_item *lip,
|
||||
xfs_lsn_t lsn)
|
||||
{
|
||||
}
|
||||
|
||||
/*
|
||||
* This is the ops vector shared by all cui log items.
|
||||
*/
|
||||
static const struct xfs_item_ops xfs_cui_item_ops = {
|
||||
.iop_size = xfs_cui_item_size,
|
||||
.iop_format = xfs_cui_item_format,
|
||||
.iop_pin = xfs_cui_item_pin,
|
||||
.iop_unpin = xfs_cui_item_unpin,
|
||||
.iop_unlock = xfs_cui_item_unlock,
|
||||
.iop_committed = xfs_cui_item_committed,
|
||||
.iop_push = xfs_cui_item_push,
|
||||
.iop_committing = xfs_cui_item_committing,
|
||||
};
|
||||
|
||||
/*
|
||||
@ -253,38 +199,6 @@ xfs_cud_item_format(
|
||||
sizeof(struct xfs_cud_log_format));
|
||||
}
|
||||
|
||||
/*
|
||||
* Pinning has no meaning for an cud item, so just return.
|
||||
*/
|
||||
STATIC void
|
||||
xfs_cud_item_pin(
|
||||
struct xfs_log_item *lip)
|
||||
{
|
||||
}
|
||||
|
||||
/*
|
||||
* Since pinning has no meaning for an cud item, unpinning does
|
||||
* not either.
|
||||
*/
|
||||
STATIC void
|
||||
xfs_cud_item_unpin(
|
||||
struct xfs_log_item *lip,
|
||||
int remove)
|
||||
{
|
||||
}
|
||||
|
||||
/*
|
||||
* There isn't much you can do to push on an cud item. It is simply stuck
|
||||
* waiting for the log to be flushed to disk.
|
||||
*/
|
||||
STATIC uint
|
||||
xfs_cud_item_push(
|
||||
struct xfs_log_item *lip,
|
||||
struct list_head *buffer_list)
|
||||
{
|
||||
return XFS_ITEM_PINNED;
|
||||
}
|
||||
|
||||
/*
|
||||
* The CUD is either committed or aborted if the transaction is cancelled. If
|
||||
* the transaction is cancelled, drop our reference to the CUI and free the
|
||||
@ -327,32 +241,14 @@ xfs_cud_item_committed(
|
||||
return (xfs_lsn_t)-1;
|
||||
}
|
||||
|
||||
/*
|
||||
* The CUD 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_cud_item_committing(
|
||||
struct xfs_log_item *lip,
|
||||
xfs_lsn_t lsn)
|
||||
{
|
||||
}
|
||||
|
||||
/*
|
||||
* This is the ops vector shared by all cud log items.
|
||||
*/
|
||||
static const struct xfs_item_ops xfs_cud_item_ops = {
|
||||
.iop_size = xfs_cud_item_size,
|
||||
.iop_format = xfs_cud_item_format,
|
||||
.iop_pin = xfs_cud_item_pin,
|
||||
.iop_unpin = xfs_cud_item_unpin,
|
||||
.iop_unlock = xfs_cud_item_unlock,
|
||||
.iop_committed = xfs_cud_item_committed,
|
||||
.iop_push = xfs_cud_item_push,
|
||||
.iop_committing = xfs_cud_item_committing,
|
||||
};
|
||||
|
||||
/*
|
||||
|
@ -93,15 +93,6 @@ xfs_rui_item_format(
|
||||
xfs_rui_log_format_sizeof(ruip->rui_format.rui_nextents));
|
||||
}
|
||||
|
||||
/*
|
||||
* Pinning has no meaning for an rui item, so just return.
|
||||
*/
|
||||
STATIC void
|
||||
xfs_rui_item_pin(
|
||||
struct xfs_log_item *lip)
|
||||
{
|
||||
}
|
||||
|
||||
/*
|
||||
* The unpin operation is the last place an RUI is manipulated in the log. It is
|
||||
* either inserted in the AIL or aborted in the event of a log I/O error. In
|
||||
@ -120,21 +111,6 @@ xfs_rui_item_unpin(
|
||||
xfs_rui_release(ruip);
|
||||
}
|
||||
|
||||
/*
|
||||
* RUI items have no locking or pushing. However, since RUIs are pulled from
|
||||
* the AIL when their corresponding RUDs 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 RUI out of
|
||||
* the AIL.
|
||||
*/
|
||||
STATIC uint
|
||||
xfs_rui_item_push(
|
||||
struct xfs_log_item *lip,
|
||||
struct list_head *buffer_list)
|
||||
{
|
||||
return XFS_ITEM_PINNED;
|
||||
}
|
||||
|
||||
/*
|
||||
* The RUI has been either committed or aborted if the transaction has been
|
||||
* cancelled. If the transaction was cancelled, an RUD isn't going to be
|
||||
@ -148,44 +124,14 @@ xfs_rui_item_unlock(
|
||||
xfs_rui_release(RUI_ITEM(lip));
|
||||
}
|
||||
|
||||
/*
|
||||
* The RUI 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_rui_item_committed(
|
||||
struct xfs_log_item *lip,
|
||||
xfs_lsn_t lsn)
|
||||
{
|
||||
return lsn;
|
||||
}
|
||||
|
||||
/*
|
||||
* The RUI 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_rui_item_committing(
|
||||
struct xfs_log_item *lip,
|
||||
xfs_lsn_t lsn)
|
||||
{
|
||||
}
|
||||
|
||||
/*
|
||||
* This is the ops vector shared by all rui log items.
|
||||
*/
|
||||
static const struct xfs_item_ops xfs_rui_item_ops = {
|
||||
.iop_size = xfs_rui_item_size,
|
||||
.iop_format = xfs_rui_item_format,
|
||||
.iop_pin = xfs_rui_item_pin,
|
||||
.iop_unpin = xfs_rui_item_unpin,
|
||||
.iop_unlock = xfs_rui_item_unlock,
|
||||
.iop_committed = xfs_rui_item_committed,
|
||||
.iop_push = xfs_rui_item_push,
|
||||
.iop_committing = xfs_rui_item_committing,
|
||||
};
|
||||
|
||||
/*
|
||||
@ -274,38 +220,6 @@ xfs_rud_item_format(
|
||||
sizeof(struct xfs_rud_log_format));
|
||||
}
|
||||
|
||||
/*
|
||||
* Pinning has no meaning for an rud item, so just return.
|
||||
*/
|
||||
STATIC void
|
||||
xfs_rud_item_pin(
|
||||
struct xfs_log_item *lip)
|
||||
{
|
||||
}
|
||||
|
||||
/*
|
||||
* Since pinning has no meaning for an rud item, unpinning does
|
||||
* not either.
|
||||
*/
|
||||
STATIC void
|
||||
xfs_rud_item_unpin(
|
||||
struct xfs_log_item *lip,
|
||||
int remove)
|
||||
{
|
||||
}
|
||||
|
||||
/*
|
||||
* There isn't much you can do to push on an rud item. It is simply stuck
|
||||
* waiting for the log to be flushed to disk.
|
||||
*/
|
||||
STATIC uint
|
||||
xfs_rud_item_push(
|
||||
struct xfs_log_item *lip,
|
||||
struct list_head *buffer_list)
|
||||
{
|
||||
return XFS_ITEM_PINNED;
|
||||
}
|
||||
|
||||
/*
|
||||
* The RUD is either committed or aborted if the transaction is cancelled. If
|
||||
* the transaction is cancelled, drop our reference to the RUI and free the
|
||||
@ -348,32 +262,14 @@ xfs_rud_item_committed(
|
||||
return (xfs_lsn_t)-1;
|
||||
}
|
||||
|
||||
/*
|
||||
* The RUD 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_rud_item_committing(
|
||||
struct xfs_log_item *lip,
|
||||
xfs_lsn_t lsn)
|
||||
{
|
||||
}
|
||||
|
||||
/*
|
||||
* This is the ops vector shared by all rud log items.
|
||||
*/
|
||||
static const struct xfs_item_ops xfs_rud_item_ops = {
|
||||
.iop_size = xfs_rud_item_size,
|
||||
.iop_format = xfs_rud_item_format,
|
||||
.iop_pin = xfs_rud_item_pin,
|
||||
.iop_unpin = xfs_rud_item_unpin,
|
||||
.iop_unlock = xfs_rud_item_unlock,
|
||||
.iop_committed = xfs_rud_item_committed,
|
||||
.iop_push = xfs_rud_item_push,
|
||||
.iop_committing = xfs_rud_item_committing,
|
||||
};
|
||||
|
||||
/*
|
||||
|
@ -779,11 +779,14 @@ xfs_trans_free_items(
|
||||
|
||||
list_for_each_entry_safe(lip, next, &tp->t_items, li_trans) {
|
||||
xfs_trans_del_item(lip);
|
||||
if (commit_lsn != NULLCOMMITLSN)
|
||||
if (commit_lsn != NULLCOMMITLSN &&
|
||||
lip->li_ops->iop_committing)
|
||||
lip->li_ops->iop_committing(lip, commit_lsn);
|
||||
if (abort)
|
||||
set_bit(XFS_LI_ABORTED, &lip->li_flags);
|
||||
lip->li_ops->iop_unlock(lip);
|
||||
|
||||
if (lip->li_ops->iop_unlock)
|
||||
lip->li_ops->iop_unlock(lip);
|
||||
}
|
||||
}
|
||||
|
||||
@ -804,7 +807,8 @@ xfs_log_item_batch_insert(
|
||||
for (i = 0; i < nr_items; i++) {
|
||||
struct xfs_log_item *lip = log_items[i];
|
||||
|
||||
lip->li_ops->iop_unpin(lip, 0);
|
||||
if (lip->li_ops->iop_unpin)
|
||||
lip->li_ops->iop_unpin(lip, 0);
|
||||
}
|
||||
}
|
||||
|
||||
@ -852,7 +856,10 @@ xfs_trans_committed_bulk(
|
||||
|
||||
if (aborted)
|
||||
set_bit(XFS_LI_ABORTED, &lip->li_flags);
|
||||
item_lsn = lip->li_ops->iop_committed(lip, commit_lsn);
|
||||
if (lip->li_ops->iop_committed)
|
||||
item_lsn = lip->li_ops->iop_committed(lip, commit_lsn);
|
||||
else
|
||||
item_lsn = commit_lsn;
|
||||
|
||||
/* item_lsn of -1 means the item needs no further processing */
|
||||
if (XFS_LSN_CMP(item_lsn, (xfs_lsn_t)-1) == 0)
|
||||
@ -864,7 +871,8 @@ xfs_trans_committed_bulk(
|
||||
*/
|
||||
if (aborted) {
|
||||
ASSERT(XFS_FORCED_SHUTDOWN(ailp->ail_mount));
|
||||
lip->li_ops->iop_unpin(lip, 1);
|
||||
if (lip->li_ops->iop_unpin)
|
||||
lip->li_ops->iop_unpin(lip, 1);
|
||||
continue;
|
||||
}
|
||||
|
||||
@ -882,7 +890,8 @@ xfs_trans_committed_bulk(
|
||||
xfs_trans_ail_update(ailp, lip, item_lsn);
|
||||
else
|
||||
spin_unlock(&ailp->ail_lock);
|
||||
lip->li_ops->iop_unpin(lip, 0);
|
||||
if (lip->li_ops->iop_unpin)
|
||||
lip->li_ops->iop_unpin(lip, 0);
|
||||
continue;
|
||||
}
|
||||
|
||||
|
@ -348,6 +348,14 @@ xfsaild_push_item(
|
||||
if (XFS_TEST_ERROR(false, ailp->ail_mount, XFS_ERRTAG_LOG_ITEM_PIN))
|
||||
return XFS_ITEM_PINNED;
|
||||
|
||||
/*
|
||||
* Consider the item pinned if a push callback is not defined so the
|
||||
* caller will force the log. This should only happen for intent items
|
||||
* as they are unpinned once the associated done item is committed to
|
||||
* the on-disk log.
|
||||
*/
|
||||
if (!lip->li_ops->iop_push)
|
||||
return XFS_ITEM_PINNED;
|
||||
return lip->li_ops->iop_push(lip, &ailp->ail_buf_list);
|
||||
}
|
||||
|
||||
|
Loading…
Reference in New Issue
Block a user