@@ -16,6 +16,7 @@
#include "xfs_inode.h"
#include "xfs_inode_item.h"
#include "xfs_trace.h"
+#include "xfs_icache.h"
/*
* Deferred Operations in XFS
@@ -555,6 +556,18 @@ xfs_defer_move(
xfs_defer_reset(stp);
}
+/* Unlock the inodes attached to this dfops capture device. */
+static void
+xfs_defer_capture_iunlock(
+ struct xfs_defer_capture *dfc)
+{
+ unsigned int i;
+
+ for (i = 0; i < XFS_DEFER_OPS_NR_INODES && dfc->dfc_inodes[i]; i++)
+ xfs_iunlock(dfc->dfc_inodes[i], XFS_ILOCK_EXCL);
+ dfc->dfc_ilocked = false;
+}
+
/*
* Prepare a chain of fresh deferred ops work items to be completed later. Log
* recovery requires the ability to put off until later the actual finishing
@@ -568,17 +581,26 @@ xfs_defer_move(
* transaction is committed.
*
* Note that the capture state is passed up to the caller and must be freed
- * even if the transaction commit returns error.
+ * even if the transaction commit returns error. If inodes were passed in and
+ * a state capture structure was returned, the inodes are now owned by the
+ * state capture structure and the caller must not touch the inodes.
+ *
+ * If *ipp1 or *ipp2 remain set, the caller still owns the inodes.
*/
int
xfs_defer_capture(
struct xfs_trans *tp,
- struct list_head *capture_list)
+ struct list_head *capture_list,
+ struct xfs_inode **ipp1,
+ struct xfs_inode **ipp2)
{
struct xfs_defer_capture *dfc;
struct xfs_mount *mp = tp->t_mountp;
int error;
+ /* Do not pass in an ipp2 without an ipp1. */
+ ASSERT(ipp1 || !ipp2);
+
if (list_empty(&tp->t_dfops))
return xfs_trans_commit(tp);
@@ -600,6 +622,21 @@ xfs_defer_capture(
dfc->dfc_tres.tr_logflags = XFS_TRANS_PERM_LOG_RES;
xfs_defer_reset(tp);
+ /*
+ * Transfer responsibility for unlocking and releasing the inodes to
+ * the capture structure.
+ */
+ dfc->dfc_ilocked = true;
+ if (ipp1) {
+ dfc->dfc_inodes[0] = *ipp1;
+ *ipp1 = NULL;
+ }
+ if (ipp2) {
+ if (*ipp2 != dfc->dfc_inodes[0])
+ dfc->dfc_inodes[1] = *ipp2;
+ *ipp2 = NULL;
+ }
+
/*
* Commit the transaction. If that fails, clean up the defer ops and
* the dfc that we just created. Otherwise, add the dfc to the list.
@@ -610,6 +647,12 @@ xfs_defer_capture(
return error;
}
+ /*
+ * Now that we've committed the transaction, it's safe to unlock the
+ * inodes that were passed in if we've taken over their ownership.
+ */
+ xfs_defer_capture_iunlock(dfc);
+
list_add_tail(&dfc->dfc_list, capture_list);
return 0;
}
@@ -623,6 +666,13 @@ xfs_defer_continue(
ASSERT(tp->t_flags & XFS_TRANS_PERM_LOG_RES);
ASSERT(!(tp->t_flags & XFS_TRANS_DIRTY));
+ /* Lock and join the inodes to the new transaction. */
+ xfs_defer_continue_inodes(dfc, tp);
+ if (dfc->dfc_inodes[0])
+ xfs_trans_ijoin(tp, dfc->dfc_inodes[0], 0);
+ if (dfc->dfc_inodes[1])
+ xfs_trans_ijoin(tp, dfc->dfc_inodes[1], 0);
+
/* Move captured dfops chain and state to the transaction. */
list_splice_init(&dfc->dfc_dfops, &tp->t_dfops);
tp->t_flags |= dfc->dfc_tpflags;
@@ -638,5 +688,8 @@ xfs_defer_capture_free(
struct xfs_defer_capture *dfc)
{
xfs_defer_cancel_list(mp, &dfc->dfc_dfops);
+ if (dfc->dfc_ilocked)
+ xfs_defer_capture_iunlock(dfc);
+ xfs_defer_capture_irele(dfc);
kmem_free(dfc);
}
@@ -10,6 +10,12 @@ struct xfs_btree_cur;
struct xfs_defer_op_type;
struct xfs_defer_capture;
+/*
+ * Deferred operation item relogging limits.
+ */
+#define XFS_DEFER_OPS_NR_INODES 2 /* join up to two inodes */
+#define XFS_DEFER_OPS_NR_BUFS 2 /* join up to two buffers */
+
/*
* Header for deferred operation list.
*/
@@ -78,15 +84,28 @@ struct xfs_defer_capture {
unsigned int dfc_tpflags;
unsigned int dfc_blkres;
struct xfs_trans_res dfc_tres;
+
+ /*
+ * Inodes to hold when we want to finish the deferred work items.
+ * Always set the first element before setting the second.
+ */
+ bool dfc_ilocked;
+ struct xfs_inode *dfc_inodes[XFS_DEFER_OPS_NR_INODES];
};
/*
* Functions to capture a chain of deferred operations and continue them later.
* This doesn't normally happen except log recovery.
*/
-int xfs_defer_capture(struct xfs_trans *tp, struct list_head *capture_list);
+int xfs_defer_capture(struct xfs_trans *tp, struct list_head *capture_list,
+ struct xfs_inode **ipp1, struct xfs_inode **ipp2);
void xfs_defer_continue(struct xfs_defer_capture *dfc, struct xfs_trans *tp);
void xfs_defer_capture_free(struct xfs_mount *mp,
struct xfs_defer_capture *dfc);
+/* These functions must be provided by the xfs implementation. */
+void xfs_defer_continue_inodes(struct xfs_defer_capture *dfc,
+ struct xfs_trans *tp);
+void xfs_defer_capture_irele(struct xfs_defer_capture *dfc);
+
#endif /* __XFS_DEFER_H__ */
@@ -125,7 +125,14 @@ void xlog_recover_iodone(struct xfs_buf *bp);
void xlog_recover_release_intent(struct xlog *log, unsigned short intent_type,
uint64_t intent_id);
-int xlog_recover_trans_commit(struct xfs_trans *tp,
- struct list_head *capture_list);
+int xlog_recover_trans_commit_inodes(struct xfs_trans *tp,
+ struct list_head *capture_list, struct xfs_inode *ip1,
+ struct xfs_inode *ip2);
+
+static inline int
+xlog_recover_trans_commit(struct xfs_trans *tp, struct list_head *capture_list)
+{
+ return xlog_recover_trans_commit_inodes(tp, capture_list, NULL, NULL);
+}
#endif /* __XFS_LOG_RECOVER_H__ */
@@ -513,15 +513,11 @@ xfs_bui_item_recover(
xfs_bmap_unmap_extent(tp, ip, &irec);
}
- /* Commit transaction, which frees tp. */
- error = xlog_recover_trans_commit(tp, capture_list);
- if (error)
- goto err_unlock;
- return 0;
+ /* Commit transaction, which frees the transaction and the inode. */
+ return xlog_recover_trans_commit_inodes(tp, capture_list, ip, NULL);
err_cancel:
xfs_trans_cancel(tp);
-err_unlock:
xfs_iunlock(ip, XFS_ILOCK_EXCL);
err_rele:
xfs_irele(ip);
@@ -12,6 +12,7 @@
#include "xfs_sb.h"
#include "xfs_mount.h"
#include "xfs_inode.h"
+#include "xfs_defer.h"
#include "xfs_trans.h"
#include "xfs_trans_priv.h"
#include "xfs_inode_item.h"
@@ -1692,3 +1693,43 @@ xfs_start_block_reaping(
xfs_queue_eofblocks(mp);
xfs_queue_cowblocks(mp);
}
+
+/*
+ * Prepare the inodes to participate in further log intent item recovery.
+ * For now, that means attaching dquots and locking them, since libxfs doesn't
+ * know how to do that.
+ */
+void
+xfs_defer_continue_inodes(
+ struct xfs_defer_capture *dfc,
+ struct xfs_trans *tp)
+{
+ int i;
+ int error;
+
+ for (i = 0; i < XFS_DEFER_OPS_NR_INODES && dfc->dfc_inodes[i]; i++) {
+ error = xfs_qm_dqattach(dfc->dfc_inodes[i]);
+ if (error)
+ tp->t_mountp->m_qflags &= ~XFS_ALL_QUOTA_CHKD;
+ }
+
+ if (dfc->dfc_inodes[1])
+ xfs_lock_two_inodes(dfc->dfc_inodes[0], XFS_ILOCK_EXCL,
+ dfc->dfc_inodes[1], XFS_ILOCK_EXCL);
+ else if (dfc->dfc_inodes[0])
+ xfs_ilock(dfc->dfc_inodes[0], XFS_ILOCK_EXCL);
+ dfc->dfc_ilocked = true;
+}
+
+/* Release all the inodes attached to this dfops capture device. */
+void
+xfs_defer_capture_irele(
+ struct xfs_defer_capture *dfc)
+{
+ unsigned int i;
+
+ for (i = 0; i < XFS_DEFER_OPS_NR_INODES && dfc->dfc_inodes[i]; i++) {
+ xfs_irele(dfc->dfc_inodes[i]);
+ dfc->dfc_inodes[i] = NULL;
+ }
+}
@@ -1791,17 +1791,42 @@ xlog_recover_release_intent(
spin_unlock(&ailp->ail_lock);
}
+static inline void
+xlog_recover_irele(
+ struct xfs_inode *ip)
+{
+ xfs_iunlock(ip, XFS_ILOCK_EXCL);
+ xfs_irele(ip);
+}
+
/*
* Freeze any deferred ops and commit the transaction. This is the last step
* needed to finish a log intent item that we recovered from the log, and will
- * take care of releasing all the relevant resources.
+ * take care of releasing all the relevant resources. If we captured deferred
+ * ops, the inodes are attached to it and must not be touched. If not, we have
+ * to unlock and free them ourselves.
*/
int
-xlog_recover_trans_commit(
+xlog_recover_trans_commit_inodes(
struct xfs_trans *tp,
- struct list_head *capture_list)
+ struct list_head *capture_list,
+ struct xfs_inode *ip1,
+ struct xfs_inode *ip2)
{
- return xfs_defer_capture(tp, capture_list);
+ int error;
+
+ error = xfs_defer_capture(tp, capture_list, &ip1, &ip2);
+
+ /*
+ * If we still have references to the inodes, either the capture
+ * process did nothing or it failed; either way, we still own the
+ * inodes, so unlock and release them.
+ */
+ if (ip2 && ip2 != ip1)
+ xlog_recover_irele(ip2);
+ if (ip1)
+ xlog_recover_irele(ip1);
+ return error;
}
/******************************************************************************
@@ -96,12 +96,6 @@ void xfs_log_item_init(struct xfs_mount *mp, struct xfs_log_item *item,
#define XFS_ITEM_LOCKED 2
#define XFS_ITEM_FLUSHING 3
-/*
- * Deferred operation item relogging limits.
- */
-#define XFS_DEFER_OPS_NR_INODES 2 /* join up to two inodes */
-#define XFS_DEFER_OPS_NR_BUFS 2 /* join up to two buffers */
-
/*
* This is the structure maintained for every active transaction.
*/