dect
/
linux-2.6
Archived
13
0
Fork 0
Code Releases Activity

xfs: pass shutdown method into xfs_trans_ail_delete_bulk 

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>
This commit is contained in:
Dave Chinner 2012-04-23 15:58:41 +10:00 committed by Ben Myers
parent a8569171ba
commit 04913fdd91
11 changed files with 35 additions and 26 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
fs/xfs/xfs_buf_item.c
View File

@ -454,7 +454,7 @@ xfs_buf_item_unpin(
bp->b_iodone = NULL; bp->b_iodone = NULL;
} else { } else {
spin_lock(&ailp->xa_lock); 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); xfs_buf_item_relse(bp);
ASSERT(bp->b_fspriv == NULL); ASSERT(bp->b_fspriv == NULL);
} }
@ -1006,6 +1006,6 @@ xfs_buf_iodone(
* Either way, AIL is useless if we're forcing a shutdown. * Either way, AIL is useless if we're forcing a shutdown.
*/ */
spin_lock(&ailp->xa_lock); 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)); xfs_buf_item_free(BUF_ITEM(lip));
} }

5
fs/xfs/xfs_dquot.c
View File

@ -857,7 +857,7 @@ xfs_qm_dqflush_done(
/* xfs_trans_ail_delete() drops the AIL lock. */ /* xfs_trans_ail_delete() drops the AIL lock. */
spin_lock(&ailp->xa_lock); spin_lock(&ailp->xa_lock);
if (lip->li_lsn == qip->qli_flush_lsn) if (lip->li_lsn == qip->qli_flush_lsn)
xfs_trans_ail_delete(ailp, lip); xfs_trans_ail_delete(ailp, lip, SHUTDOWN_CORRUPT_INCORE);
else else
spin_unlock(&ailp->xa_lock); spin_unlock(&ailp->xa_lock);
} }
@ -909,7 +909,8 @@ xfs_qm_dqflush(
spin_lock(&mp->m_ail->xa_lock); spin_lock(&mp->m_ail->xa_lock);
if (lip->li_flags & XFS_LI_IN_AIL) 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 else
spin_unlock(&mp->m_ail->xa_lock); spin_unlock(&mp->m_ail->xa_lock);
error = XFS_ERROR(EIO); error = XFS_ERROR(EIO);

2
fs/xfs/xfs_dquot_item.c
View File

@ -384,7 +384,7 @@ xfs_qm_qoffend_logitem_committed(
* xfs_trans_ail_delete() drops the AIL lock. * xfs_trans_ail_delete() drops the AIL lock.
*/ */
spin_lock(&ailp->xa_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(qfs);
kmem_free(qfe); kmem_free(qfe);

3
fs/xfs/xfs_extfree_item.c
View File

@ -64,7 +64,8 @@ __xfs_efi_release(
if (!test_and_clear_bit(XFS_EFI_COMMITTED, &efip->efi_flags)) { if (!test_and_clear_bit(XFS_EFI_COMMITTED, &efip->efi_flags)) {
spin_lock(&ailp->xa_lock); spin_lock(&ailp->xa_lock);
/* xfs_trans_ail_delete() drops the AIL 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); xfs_efi_item_free(efip);
} }
} }

4
fs/xfs/xfs_inode.c
View File

@ -2377,7 +2377,7 @@ cluster_corrupt_out:
/* /*
* Unlocks the flush lock * Unlocks the flush lock
*/ */
xfs_iflush_abort(iq); xfs_iflush_abort(iq, false);
kmem_free(ilist); kmem_free(ilist);
xfs_perag_put(pag); xfs_perag_put(pag);
return XFS_ERROR(EFSCORRUPTED); return XFS_ERROR(EFSCORRUPTED);
@ -2482,7 +2482,7 @@ abort_out:
/* /*
* Unlocks the flush lock * Unlocks the flush lock
*/ */
xfs_iflush_abort(ip); xfs_iflush_abort(ip, false);
return error; return error;
} }

23
fs/xfs/xfs_inode_item.c
View File

@ -777,7 +777,8 @@ xfs_iflush_done(
ASSERT(i <= need_ail); ASSERT(i <= need_ail);
} }
/* xfs_trans_ail_delete_bulk() drops the AIL lock. */ /* 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 * This is the inode flushing abort routine. It is called from xfs_iflush when
* from xfs_iflush when the filesystem is shutting down to clean * the filesystem is shutting down to clean up the inode state. It is
* up the inode state. * responsible for removing the inode item from the AIL if it has not been
* It is responsible for removing the inode item * re-logged, and unlocking the inode's flush lock.
* from the AIL if it has not been re-logged, and unlocking the inode's
* flush lock.
*/ */
void void
xfs_iflush_abort( xfs_iflush_abort(
xfs_inode_t *ip) xfs_inode_t *ip,
bool stale)
{ {
xfs_inode_log_item_t *iip = ip->i_itemp; xfs_inode_log_item_t *iip = ip->i_itemp;
@ -817,7 +817,10 @@ xfs_iflush_abort(
spin_lock(&ailp->xa_lock); spin_lock(&ailp->xa_lock);
if (iip->ili_item.li_flags & XFS_LI_IN_AIL) { if (iip->ili_item.li_flags & XFS_LI_IN_AIL) {
/* xfs_trans_ail_delete() drops the AIL lock. */ /* 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 } else
spin_unlock(&ailp->xa_lock); spin_unlock(&ailp->xa_lock);
} }
@ -844,7 +847,7 @@ xfs_istale_done(
struct xfs_buf *bp, struct xfs_buf *bp,
struct xfs_log_item *lip) struct xfs_log_item *lip)
{ {
xfs_iflush_abort(INODE_ITEM(lip)->ili_inode); xfs_iflush_abort(INODE_ITEM(lip)->ili_inode, true);
} }
/* /*

2
fs/xfs/xfs_inode_item.h
View 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_inode_item_destroy(struct xfs_inode *);
extern void xfs_iflush_done(struct xfs_buf *, struct xfs_log_item *); 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_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 *, extern int xfs_inode_item_format_convert(xfs_log_iovec_t *,
xfs_inode_log_format_t *); xfs_inode_log_format_t *);

3
fs/xfs/xfs_log_recover.c
View File

@ -2645,7 +2645,8 @@ xlog_recover_efd_pass2(
* xfs_trans_ail_delete() drops the * xfs_trans_ail_delete() drops the
* AIL lock. * AIL lock.
*/ */
xfs_trans_ail_delete(ailp, lip); xfs_trans_ail_delete(ailp, lip,
SHUTDOWN_CORRUPT_INCORE);
xfs_efi_item_free(efip); xfs_efi_item_free(efip);
spin_lock(&ailp->xa_lock); spin_lock(&ailp->xa_lock);
break; break;

2
fs/xfs/xfs_sync.c
View File

@ -684,7 +684,7 @@ restart:
goto reclaim; goto reclaim;
if (XFS_FORCED_SHUTDOWN(ip->i_mount)) { if (XFS_FORCED_SHUTDOWN(ip->i_mount)) {
xfs_iunpin_wait(ip); xfs_iunpin_wait(ip);
xfs_iflush_abort(ip); xfs_iflush_abort(ip, false);
goto reclaim; goto reclaim;
} }
if (xfs_ipincount(ip)) { if (xfs_ipincount(ip)) {

5
fs/xfs/xfs_trans_ail.c
View File

@ -707,7 +707,8 @@ void
xfs_trans_ail_delete_bulk( xfs_trans_ail_delete_bulk(
struct xfs_ail *ailp, struct xfs_ail *ailp,
struct xfs_log_item **log_items, 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; xfs_log_item_t *mlip;
int mlip_changed = 0; int mlip_changed = 0;
@ -725,7 +726,7 @@ xfs_trans_ail_delete_bulk(
xfs_alert_tag(mp, XFS_PTAG_AILDELETE, xfs_alert_tag(mp, XFS_PTAG_AILDELETE,
"%s: attempting to delete a log item that is not in the AIL", "%s: attempting to delete a log item that is not in the AIL",
__func__); __func__);
xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE); xfs_force_shutdown(mp, shutdown_type);
} }
return; return;
} }

8
fs/xfs/xfs_trans_priv.h
View File

@ -92,14 +92,16 @@ xfs_trans_ail_update(
} }
void xfs_trans_ail_delete_bulk(struct xfs_ail *ailp, 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); __releases(ailp->xa_lock);
static inline void static inline void
xfs_trans_ail_delete( xfs_trans_ail_delete(
struct xfs_ail *ailp, 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); void xfs_ail_push(struct xfs_ail *, xfs_lsn_t);