korg/linux
0
0
Fork 0
mirror of https://mirrors.bfsu.edu.cn/git/linux.git synced 2024-11-11 12:28:41 +08:00
Code Issues Packages Projects Releases Wiki Activity

xfs: don't require log items to implement optional methods

Browse Source 
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:
Christoph Hellwig 2019-06-28 19:27:30 -07:00 committed by Darrick J. Wong
parent d15cbf2f38
commit e8b78db77d
10 changed files with 25 additions and 557 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

104
fs/xfs/xfs_bmap_item.c
View File

@ -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,
};
/*

8
fs/xfs/xfs_buf_item.c
View File

@ -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

98
fs/xfs/xfs_dquot_item.c
View File

@ -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
};
/*

104
fs/xfs/xfs_extfree_item.c
View File

@ -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
};
/*

28
fs/xfs/xfs_icreate_item.c
View File

@ -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,
};

3
fs/xfs/xfs_log_cil.c
View File

@ -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);

104
fs/xfs/xfs_refcount_item.c
View File

@ -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,
};
/*

104
fs/xfs/xfs_rmap_item.c
View File

@ -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,
};
/*

21
fs/xfs/xfs_trans.c
View File

@ -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;
}

8
fs/xfs/xfs_trans_ail.c
View File

@ -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);
}