| Message ID | 20190613180300.30447-4-hch@lst.de (mailing list archive) |
|---|---|
| State | Accepted |
| Headers | show |
| Series | [01/20] xfs: fix a trivial comment typo in xfs_trans_committed_bulk | expand |
On Thu, Jun 13, 2019 at 08:02:43PM +0200, Christoph Hellwig wrote: > Just check if they are present first. > > Signed-off-by: Christoph Hellwig <hch@lst.de> > --- Looks good, thanks for the comment update: Reviewed-by: Brian Foster <bfoster@redhat.com> > fs/xfs/xfs_bmap_item.c | 104 ------------------------------------- > fs/xfs/xfs_buf_item.c | 8 --- > fs/xfs/xfs_dquot_item.c | 98 ---------------------------------- > fs/xfs/xfs_extfree_item.c | 104 ------------------------------------- > fs/xfs/xfs_icreate_item.c | 28 ---------- > fs/xfs/xfs_log_cil.c | 3 +- > fs/xfs/xfs_refcount_item.c | 104 ------------------------------------- > fs/xfs/xfs_rmap_item.c | 104 ------------------------------------- > fs/xfs/xfs_trans.c | 21 +++++--- > fs/xfs/xfs_trans_ail.c | 8 +++ > 10 files changed, 25 insertions(+), 557 deletions(-) > > diff --git a/fs/xfs/xfs_bmap_item.c b/fs/xfs/xfs_bmap_item.c > index ce45f066995e..8e57df6d5581 100644 > --- a/fs/xfs/xfs_bmap_item.c > +++ b/fs/xfs/xfs_bmap_item.c > @@ -95,15 +95,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 > @@ -122,21 +113,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 > @@ -150,44 +126,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, > }; > > /* > @@ -248,38 +194,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 > @@ -322,32 +236,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, > }; > > /* > diff --git a/fs/xfs/xfs_buf_item.c b/fs/xfs/xfs_buf_item.c > index f3d814dc7518..423f1a042ed8 100644 > --- a/fs/xfs/xfs_buf_item.c > +++ b/fs/xfs/xfs_buf_item.c > @@ -671,13 +671,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. > */ > @@ -689,7 +682,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 > diff --git a/fs/xfs/xfs_dquot_item.c b/fs/xfs/xfs_dquot_item.c > index 87b23ae44397..486eea151fdb 100644 > --- a/fs/xfs/xfs_dquot_item.c > +++ b/fs/xfs/xfs_dquot_item.c > @@ -94,18 +94,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. > @@ -232,18 +220,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 > */ > @@ -253,9 +229,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 > }; > > @@ -314,26 +288,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. > @@ -346,28 +300,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, > @@ -391,36 +323,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 > }; > > /* > @@ -429,12 +336,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 > }; > > /* > diff --git a/fs/xfs/xfs_extfree_item.c b/fs/xfs/xfs_extfree_item.c > index 74ddf66f4cfe..655ed0445750 100644 > --- a/fs/xfs/xfs_extfree_item.c > +++ b/fs/xfs/xfs_extfree_item.c > @@ -106,15 +106,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 > @@ -132,21 +123,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 > @@ -160,44 +136,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 > }; > > > @@ -348,38 +294,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. > @@ -421,32 +335,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 > }; > > /* > diff --git a/fs/xfs/xfs_icreate_item.c b/fs/xfs/xfs_icreate_item.c > index 8381d34cb102..03c174ff1ab3 100644 > --- a/fs/xfs/xfs_icreate_item.c > +++ b/fs/xfs/xfs_icreate_item.c > @@ -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, > }; > > > diff --git a/fs/xfs/xfs_log_cil.c b/fs/xfs/xfs_log_cil.c > index 1b54002d3874..49f37905c7a7 100644 > --- a/fs/xfs/xfs_log_cil.c > +++ b/fs/xfs/xfs_log_cil.c > @@ -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); > diff --git a/fs/xfs/xfs_refcount_item.c b/fs/xfs/xfs_refcount_item.c > index fce38b56b962..03a61886fe2a 100644 > --- a/fs/xfs/xfs_refcount_item.c > +++ b/fs/xfs/xfs_refcount_item.c > @@ -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, > }; > > /* > diff --git a/fs/xfs/xfs_rmap_item.c b/fs/xfs/xfs_rmap_item.c > index 127dc9c32a54..df9f2505c5f3 100644 > --- a/fs/xfs/xfs_rmap_item.c > +++ b/fs/xfs/xfs_rmap_item.c > @@ -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, > }; > > /* > diff --git a/fs/xfs/xfs_trans.c b/fs/xfs/xfs_trans.c > index fa62d40d7ad9..d4fbde493de8 100644 > --- a/fs/xfs/xfs_trans.c > +++ b/fs/xfs/xfs_trans.c > @@ -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; > } > > diff --git a/fs/xfs/xfs_trans_ail.c b/fs/xfs/xfs_trans_ail.c > index d3a4e89bf4a0..a3ea5d25b0f9 100644 > --- a/fs/xfs/xfs_trans_ail.c > +++ b/fs/xfs/xfs_trans_ail.c > @@ -347,6 +347,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); > } > > -- > 2.20.1 >
diff --git a/fs/xfs/xfs_bmap_item.c b/fs/xfs/xfs_bmap_item.c index ce45f066995e..8e57df6d5581 100644 --- a/fs/xfs/xfs_bmap_item.c +++ b/fs/xfs/xfs_bmap_item.c @@ -95,15 +95,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 @@ -122,21 +113,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 @@ -150,44 +126,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, }; /* @@ -248,38 +194,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 @@ -322,32 +236,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, }; /* diff --git a/fs/xfs/xfs_buf_item.c b/fs/xfs/xfs_buf_item.c index f3d814dc7518..423f1a042ed8 100644 --- a/fs/xfs/xfs_buf_item.c +++ b/fs/xfs/xfs_buf_item.c @@ -671,13 +671,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. */ @@ -689,7 +682,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 diff --git a/fs/xfs/xfs_dquot_item.c b/fs/xfs/xfs_dquot_item.c index 87b23ae44397..486eea151fdb 100644 --- a/fs/xfs/xfs_dquot_item.c +++ b/fs/xfs/xfs_dquot_item.c @@ -94,18 +94,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. @@ -232,18 +220,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 */ @@ -253,9 +229,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 }; @@ -314,26 +288,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. @@ -346,28 +300,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, @@ -391,36 +323,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 }; /* @@ -429,12 +336,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 }; /* diff --git a/fs/xfs/xfs_extfree_item.c b/fs/xfs/xfs_extfree_item.c index 74ddf66f4cfe..655ed0445750 100644 --- a/fs/xfs/xfs_extfree_item.c +++ b/fs/xfs/xfs_extfree_item.c @@ -106,15 +106,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 @@ -132,21 +123,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 @@ -160,44 +136,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 }; @@ -348,38 +294,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. @@ -421,32 +335,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 }; /* diff --git a/fs/xfs/xfs_icreate_item.c b/fs/xfs/xfs_icreate_item.c index 8381d34cb102..03c174ff1ab3 100644 --- a/fs/xfs/xfs_icreate_item.c +++ b/fs/xfs/xfs_icreate_item.c @@ -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, }; diff --git a/fs/xfs/xfs_log_cil.c b/fs/xfs/xfs_log_cil.c index 1b54002d3874..49f37905c7a7 100644 --- a/fs/xfs/xfs_log_cil.c +++ b/fs/xfs/xfs_log_cil.c @@ -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); diff --git a/fs/xfs/xfs_refcount_item.c b/fs/xfs/xfs_refcount_item.c index fce38b56b962..03a61886fe2a 100644 --- a/fs/xfs/xfs_refcount_item.c +++ b/fs/xfs/xfs_refcount_item.c @@ -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, }; /* diff --git a/fs/xfs/xfs_rmap_item.c b/fs/xfs/xfs_rmap_item.c index 127dc9c32a54..df9f2505c5f3 100644 --- a/fs/xfs/xfs_rmap_item.c +++ b/fs/xfs/xfs_rmap_item.c @@ -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, }; /* diff --git a/fs/xfs/xfs_trans.c b/fs/xfs/xfs_trans.c index fa62d40d7ad9..d4fbde493de8 100644 --- a/fs/xfs/xfs_trans.c +++ b/fs/xfs/xfs_trans.c @@ -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; } diff --git a/fs/xfs/xfs_trans_ail.c b/fs/xfs/xfs_trans_ail.c index d3a4e89bf4a0..a3ea5d25b0f9 100644 --- a/fs/xfs/xfs_trans_ail.c +++ b/fs/xfs/xfs_trans_ail.c @@ -347,6 +347,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); }
Just check if they are present first. Signed-off-by: Christoph Hellwig <hch@lst.de> --- fs/xfs/xfs_bmap_item.c | 104 ------------------------------------- fs/xfs/xfs_buf_item.c | 8 --- fs/xfs/xfs_dquot_item.c | 98 ---------------------------------- fs/xfs/xfs_extfree_item.c | 104 ------------------------------------- fs/xfs/xfs_icreate_item.c | 28 ---------- fs/xfs/xfs_log_cil.c | 3 +- fs/xfs/xfs_refcount_item.c | 104 ------------------------------------- fs/xfs/xfs_rmap_item.c | 104 ------------------------------------- fs/xfs/xfs_trans.c | 21 +++++--- fs/xfs/xfs_trans_ail.c | 8 +++ 10 files changed, 25 insertions(+), 557 deletions(-)