xfs: pass shutdown method into xfs_trans_ail_delete_bulk
authorDave Chinner <dchinner@redhat.com>
Mon, 23 Apr 2012 05:58:41 +0000 (15:58 +1000)
committerBen Myers <bpm@sgi.com>
Mon, 14 May 2012 21:20:33 +0000 (16:20 -0500)
xfs_trans_ail_delete_bulk() can be called from different contexts so
if the item is not in the AIL we need different shutdown for each
context.  Pass in the shutdown method needed so the correct action
can be taken.

Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
fs/xfs/xfs_buf_item.c
fs/xfs/xfs_dquot.c
fs/xfs/xfs_dquot_item.c
fs/xfs/xfs_extfree_item.c
fs/xfs/xfs_inode.c
fs/xfs/xfs_inode_item.c
fs/xfs/xfs_inode_item.h
fs/xfs/xfs_log_recover.c
fs/xfs/xfs_sync.c
fs/xfs/xfs_trans_ail.c
fs/xfs/xfs_trans_priv.h

index fb20f384b566e96407d3bea15bc22d16af63e54f..7f0abeaf919cc91dc1b0200276e4fd178c81c22a 100644 (file)
@@ -454,7 +454,7 @@ xfs_buf_item_unpin(
                        bp->b_iodone = NULL;
                } else {
                        spin_lock(&ailp->xa_lock);
-                       xfs_trans_ail_delete(ailp, (xfs_log_item_t *)bip);
+                       xfs_trans_ail_delete(ailp, lip, SHUTDOWN_LOG_IO_ERROR);
                        xfs_buf_item_relse(bp);
                        ASSERT(bp->b_fspriv == NULL);
                }
@@ -1006,6 +1006,6 @@ xfs_buf_iodone(
         * Either way, AIL is useless if we're forcing a shutdown.
         */
        spin_lock(&ailp->xa_lock);
-       xfs_trans_ail_delete(ailp, lip);
+       xfs_trans_ail_delete(ailp, lip, SHUTDOWN_CORRUPT_INCORE);
        xfs_buf_item_free(BUF_ITEM(lip));
 }
index 65b8aa37622eeb78462676a7a900dbfcc4cc6e6f..7bf38556254eaa5c26547859a9a5e84b2948d26a 100644 (file)
@@ -857,7 +857,7 @@ xfs_qm_dqflush_done(
                /* xfs_trans_ail_delete() drops the AIL lock. */
                spin_lock(&ailp->xa_lock);
                if (lip->li_lsn == qip->qli_flush_lsn)
-                       xfs_trans_ail_delete(ailp, lip);
+                       xfs_trans_ail_delete(ailp, lip, SHUTDOWN_CORRUPT_INCORE);
                else
                        spin_unlock(&ailp->xa_lock);
        }
@@ -909,7 +909,8 @@ xfs_qm_dqflush(
 
                spin_lock(&mp->m_ail->xa_lock);
                if (lip->li_flags & XFS_LI_IN_AIL)
-                       xfs_trans_ail_delete(mp->m_ail, lip);
+                       xfs_trans_ail_delete(mp->m_ail, lip,
+                                            SHUTDOWN_CORRUPT_INCORE);
                else
                        spin_unlock(&mp->m_ail->xa_lock);
                error = XFS_ERROR(EIO);
index 9c5d58d24e5455aa15eae9f64006f491670f6af3..aa6a2a6bd9a8624eec1f942cccb4463c7a2660bf 100644 (file)
@@ -384,7 +384,7 @@ xfs_qm_qoffend_logitem_committed(
         * xfs_trans_ail_delete() drops the AIL lock.
         */
        spin_lock(&ailp->xa_lock);
-       xfs_trans_ail_delete(ailp, (xfs_log_item_t *)qfs);
+       xfs_trans_ail_delete(ailp, &qfs->qql_item, SHUTDOWN_LOG_IO_ERROR);
 
        kmem_free(qfs);
        kmem_free(qfe);
index 9549ef179e064186670bf39b55eba8fb90ff58c1..2960fc104cb751f3caf98b73c49622654a4dc5ec 100644 (file)
@@ -64,7 +64,8 @@ __xfs_efi_release(
        if (!test_and_clear_bit(XFS_EFI_COMMITTED, &efip->efi_flags)) {
                spin_lock(&ailp->xa_lock);
                /* xfs_trans_ail_delete() drops the AIL lock. */
-               xfs_trans_ail_delete(ailp, &efip->efi_item);
+               xfs_trans_ail_delete(ailp, &efip->efi_item,
+                                    SHUTDOWN_LOG_IO_ERROR);
                xfs_efi_item_free(efip);
        }
 }
index acd846d808b262c2211344ecd2827670828186a6..65d7d994d499ac43faebd0268e23dd0b621fe356 100644 (file)
@@ -2377,7 +2377,7 @@ cluster_corrupt_out:
        /*
         * Unlocks the flush lock
         */
-       xfs_iflush_abort(iq);
+       xfs_iflush_abort(iq, false);
        kmem_free(ilist);
        xfs_perag_put(pag);
        return XFS_ERROR(EFSCORRUPTED);
@@ -2482,7 +2482,7 @@ abort_out:
        /*
         * Unlocks the flush lock
         */
-       xfs_iflush_abort(ip);
+       xfs_iflush_abort(ip, false);
        return error;
 }
 
index 8aaebb2f9efaeff733c6dcc51d5c560a4751e15a..3f96a949d9635e2e93e18e295569fcf9d9fa169c 100644 (file)
@@ -777,7 +777,8 @@ xfs_iflush_done(
                        ASSERT(i <= need_ail);
                }
                /* xfs_trans_ail_delete_bulk() drops the AIL lock. */
-               xfs_trans_ail_delete_bulk(ailp, log_items, i);
+               xfs_trans_ail_delete_bulk(ailp, log_items, i,
+                                         SHUTDOWN_CORRUPT_INCORE);
        }
 
 
@@ -798,16 +799,15 @@ xfs_iflush_done(
 }
 
 /*
- * This is the inode flushing abort routine.  It is called
- * from xfs_iflush when the filesystem is shutting down to clean
- * up the inode state.
- * It is responsible for removing the inode item
- * from the AIL if it has not been re-logged, and unlocking the inode's
- * flush lock.
+ * This is the inode flushing abort routine.  It is called from xfs_iflush when
+ * the filesystem is shutting down to clean up the inode state.  It is
+ * responsible for removing the inode item from the AIL if it has not been
+ * re-logged, and unlocking the inode's flush lock.
  */
 void
 xfs_iflush_abort(
-       xfs_inode_t             *ip)
+       xfs_inode_t             *ip,
+       bool                    stale)
 {
        xfs_inode_log_item_t    *iip = ip->i_itemp;
 
@@ -817,7 +817,10 @@ xfs_iflush_abort(
                        spin_lock(&ailp->xa_lock);
                        if (iip->ili_item.li_flags & XFS_LI_IN_AIL) {
                                /* xfs_trans_ail_delete() drops the AIL lock. */
-                               xfs_trans_ail_delete(ailp, (xfs_log_item_t *)iip);
+                               xfs_trans_ail_delete(ailp, &iip->ili_item,
+                                               stale ?
+                                                    SHUTDOWN_LOG_IO_ERROR :
+                                                    SHUTDOWN_CORRUPT_INCORE);
                        } else
                                spin_unlock(&ailp->xa_lock);
                }
@@ -844,7 +847,7 @@ xfs_istale_done(
        struct xfs_buf          *bp,
        struct xfs_log_item     *lip)
 {
-       xfs_iflush_abort(INODE_ITEM(lip)->ili_inode);
+       xfs_iflush_abort(INODE_ITEM(lip)->ili_inode, true);
 }
 
 /*
index 41d61c3b7a36e249028d34c505e941636f5c9e68..376d4d0b2635c54748ee79f1fb47f83a86353d4e 100644 (file)
@@ -165,7 +165,7 @@ extern void xfs_inode_item_init(struct xfs_inode *, struct xfs_mount *);
 extern void xfs_inode_item_destroy(struct xfs_inode *);
 extern void xfs_iflush_done(struct xfs_buf *, struct xfs_log_item *);
 extern void xfs_istale_done(struct xfs_buf *, struct xfs_log_item *);
-extern void xfs_iflush_abort(struct xfs_inode *);
+extern void xfs_iflush_abort(struct xfs_inode *, bool);
 extern int xfs_inode_item_format_convert(xfs_log_iovec_t *,
                                         xfs_inode_log_format_t *);
 
index 5e864a9c0ccfc119ee52b55714451862fc168826..396e3bfd04961fe6840d41e1f293846b40defa01 100644 (file)
@@ -2645,7 +2645,8 @@ xlog_recover_efd_pass2(
                                 * xfs_trans_ail_delete() drops the
                                 * AIL lock.
                                 */
-                               xfs_trans_ail_delete(ailp, lip);
+                               xfs_trans_ail_delete(ailp, lip,
+                                                    SHUTDOWN_CORRUPT_INCORE);
                                xfs_efi_item_free(efip);
                                spin_lock(&ailp->xa_lock);
                                break;
index cdb644fd0bd1b68938d02d92a96a9f07a273996a..24180cd862640f5e666c727e09a5043db7653a30 100644 (file)
@@ -684,7 +684,7 @@ restart:
                goto reclaim;
        if (XFS_FORCED_SHUTDOWN(ip->i_mount)) {
                xfs_iunpin_wait(ip);
-               xfs_iflush_abort(ip);
+               xfs_iflush_abort(ip, false);
                goto reclaim;
        }
        if (xfs_ipincount(ip)) {
index 959374a0d02811aac7019aae45993d48d0a5ffe0..2c0db81f035da86cbb0b4cb9411001c3310f34bd 100644 (file)
@@ -707,7 +707,8 @@ void
 xfs_trans_ail_delete_bulk(
        struct xfs_ail          *ailp,
        struct xfs_log_item     **log_items,
-       int                     nr_items) __releases(ailp->xa_lock)
+       int                     nr_items,
+       int                     shutdown_type) __releases(ailp->xa_lock)
 {
        xfs_log_item_t          *mlip;
        int                     mlip_changed = 0;
@@ -725,7 +726,7 @@ xfs_trans_ail_delete_bulk(
                                xfs_alert_tag(mp, XFS_PTAG_AILDELETE,
                "%s: attempting to delete a log item that is not in the AIL",
                                                __func__);
-                               xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
+                               xfs_force_shutdown(mp, shutdown_type);
                        }
                        return;
                }
index f72bdd48a5c13396ea7d3f03696ab395704cf1e7..fb62377d1cbc73305ab84afc360afb6eb24c9d9c 100644 (file)
@@ -92,14 +92,16 @@ xfs_trans_ail_update(
 }
 
 void   xfs_trans_ail_delete_bulk(struct xfs_ail *ailp,
-                               struct xfs_log_item **log_items, int nr_items)
+                               struct xfs_log_item **log_items, int nr_items,
+                               int shutdown_type)
                                __releases(ailp->xa_lock);
 static inline void
 xfs_trans_ail_delete(
        struct xfs_ail  *ailp,
-       xfs_log_item_t  *lip) __releases(ailp->xa_lock)
+       xfs_log_item_t  *lip,
+       int             shutdown_type) __releases(ailp->xa_lock)
 {
-       xfs_trans_ail_delete_bulk(ailp, &lip, 1);
+       xfs_trans_ail_delete_bulk(ailp, &lip, 1, shutdown_type);
 }
 
 void                   xfs_ail_push(struct xfs_ail *, xfs_lsn_t);