hollalinux
/
linux-sg2042
mirror of https://github.com/sophgo/linux-riscv.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

xfs: give li_cb callbacks the correct prototype 

Stop the function pointer casting madness and give all the li_cb instances
correct prototype.

Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
This commit is contained in:
Christoph Hellwig 2010-06-23 18:11:15 +10:00 committed by Alex Elder
parent 7bfa31d8e0
commit ca30b2a7b7
7 changed files with 68 additions and 82 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

91
fs/xfs/quota/xfs_dquot.c
View File

@ -54,8 +54,6 @@
flush lock - ditto. flush lock - ditto.
*/ */
STATIC void xfs_qm_dqflush_done(xfs_buf_t *, xfs_dq_logitem_t *);
#ifdef DEBUG #ifdef DEBUG
xfs_buftarg_t *xfs_dqerror_target; xfs_buftarg_t *xfs_dqerror_target;
int xfs_do_dqerror; int xfs_do_dqerror;
@ -1131,6 +1129,46 @@ xfs_qm_dqrele(
xfs_qm_dqput(dqp); xfs_qm_dqput(dqp);
} }
/*
* This is the dquot flushing I/O completion routine. It is called
* from interrupt level when the buffer containing the dquot is
* flushed to disk. It is responsible for removing the dquot logitem
* from the AIL if it has not been re-logged, and unlocking the dquot's
* flush lock. This behavior is very similar to that of inodes..
*/
STATIC void
xfs_qm_dqflush_done(
struct xfs_buf *bp,
struct xfs_log_item *lip)
{
xfs_dq_logitem_t *qip = (struct xfs_dq_logitem *)lip;
xfs_dquot_t *dqp = qip->qli_dquot;
struct xfs_ail *ailp = lip->li_ailp;
/*
* We only want to pull the item from the AIL if its
* location in the log has not changed since we started the flush.
* Thus, we only bother if the dquot's lsn has
* not changed. First we check the lsn outside the lock
* since it's cheaper, and then we recheck while
* holding the lock before removing the dquot from the AIL.
*/
if ((lip->li_flags & XFS_LI_IN_AIL) &&
lip->li_lsn == qip->qli_flush_lsn) {
/* 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);
else
spin_unlock(&ailp->xa_lock);
}
/*
* Release the dq's flush lock since we're done with it.
*/
xfs_dqfunlock(dqp);
}
/* /*
* Write a modified dquot to disk. * Write a modified dquot to disk.
@ -1212,8 +1250,9 @@ xfs_qm_dqflush(
* Attach an iodone routine so that we can remove this dquot from the * Attach an iodone routine so that we can remove this dquot from the
* AIL and release the flush lock once the dquot is synced to disk. * AIL and release the flush lock once the dquot is synced to disk.
*/ */
xfs_buf_attach_iodone(bp, (void(*)(xfs_buf_t *, xfs_log_item_t *)) xfs_buf_attach_iodone(bp, xfs_qm_dqflush_done,
xfs_qm_dqflush_done, &(dqp->q_logitem.qli_item)); &dqp->q_logitem.qli_item);
/* /*
* If the buffer is pinned then push on the log so we won't * If the buffer is pinned then push on the log so we won't
* get stuck waiting in the write for too long. * get stuck waiting in the write for too long.
@ -1237,50 +1276,6 @@ xfs_qm_dqflush(
} }
/*
* This is the dquot flushing I/O completion routine. It is called
* from interrupt level when the buffer containing the dquot is
* flushed to disk. It is responsible for removing the dquot logitem
* from the AIL if it has not been re-logged, and unlocking the dquot's
* flush lock. This behavior is very similar to that of inodes..
*/
/*ARGSUSED*/
STATIC void
xfs_qm_dqflush_done(
xfs_buf_t *bp,
xfs_dq_logitem_t *qip)
{
xfs_dquot_t *dqp;
struct xfs_ail *ailp;
dqp = qip->qli_dquot;
ailp = qip->qli_item.li_ailp;
/*
* We only want to pull the item from the AIL if its
* location in the log has not changed since we started the flush.
* Thus, we only bother if the dquot's lsn has
* not changed. First we check the lsn outside the lock
* since it's cheaper, and then we recheck while
* holding the lock before removing the dquot from the AIL.
*/
if ((qip->qli_item.li_flags & XFS_LI_IN_AIL) &&
qip->qli_item.li_lsn == qip->qli_flush_lsn) {
/* xfs_trans_ail_delete() drops the AIL lock. */
spin_lock(&ailp->xa_lock);
if (qip->qli_item.li_lsn == qip->qli_flush_lsn)
xfs_trans_ail_delete(ailp, (xfs_log_item_t*)qip);
else
spin_unlock(&ailp->xa_lock);
}
/*
* Release the dq's flush lock since we're done with it.
*/
xfs_dqfunlock(dqp);
}
int int
xfs_qm_dqlock_nowait( xfs_qm_dqlock_nowait(
xfs_dquot_t *dqp) xfs_dquot_t *dqp)

13
fs/xfs/xfs_buf_item.c
View File

@ -1079,15 +1079,14 @@ xfs_buf_error_relse(
* It is called by xfs_buf_iodone_callbacks() above which will take * It is called by xfs_buf_iodone_callbacks() above which will take
* care of cleaning up the buffer itself. * care of cleaning up the buffer itself.
*/ */
/* ARGSUSED */
void void
xfs_buf_iodone( xfs_buf_iodone(
xfs_buf_t *bp, struct xfs_buf *bp,
xfs_buf_log_item_t *bip) struct xfs_log_item *lip)
{ {
struct xfs_ail *ailp = bip->bli_item.li_ailp; struct xfs_ail *ailp = lip->li_ailp;
ASSERT(bip->bli_buf == bp); ASSERT(BUF_ITEM(lip)->bli_buf == bp);
xfs_buf_rele(bp); xfs_buf_rele(bp);
@ -1101,6 +1100,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, (xfs_log_item_t *)bip); xfs_trans_ail_delete(ailp, lip);
xfs_buf_item_free(bip); xfs_buf_item_free(BUF_ITEM(lip));
} }

2
fs/xfs/xfs_buf_item.h
View File

@ -124,7 +124,7 @@ void xfs_buf_attach_iodone(struct xfs_buf *,
void(*)(struct xfs_buf *, xfs_log_item_t *), void(*)(struct xfs_buf *, xfs_log_item_t *),
xfs_log_item_t *); xfs_log_item_t *);
void xfs_buf_iodone_callbacks(struct xfs_buf *); void xfs_buf_iodone_callbacks(struct xfs_buf *);
void xfs_buf_iodone(struct xfs_buf *, xfs_buf_log_item_t *); void xfs_buf_iodone(struct xfs_buf *, struct xfs_log_item *);
#ifdef XFS_TRANS_DEBUG #ifdef XFS_TRANS_DEBUG
void void

10
fs/xfs/xfs_inode.c
View File

@ -1981,7 +1981,7 @@ xfs_ifree_cluster(
if (lip->li_type == XFS_LI_INODE) { if (lip->li_type == XFS_LI_INODE) {
iip = (xfs_inode_log_item_t *)lip; iip = (xfs_inode_log_item_t *)lip;
ASSERT(iip->ili_logged == 1); ASSERT(iip->ili_logged == 1);
lip->li_cb = (void(*)(xfs_buf_t*,xfs_log_item_t*)) xfs_istale_done; lip->li_cb = xfs_istale_done;
xfs_trans_ail_copy_lsn(mp->m_ail, xfs_trans_ail_copy_lsn(mp->m_ail,
&iip->ili_flush_lsn, &iip->ili_flush_lsn,
&iip->ili_item.li_lsn); &iip->ili_item.li_lsn);
@ -2051,9 +2051,8 @@ xfs_ifree_cluster(
xfs_trans_ail_copy_lsn(mp->m_ail, &iip->ili_flush_lsn, xfs_trans_ail_copy_lsn(mp->m_ail, &iip->ili_flush_lsn,
&iip->ili_item.li_lsn); &iip->ili_item.li_lsn);
xfs_buf_attach_iodone(bp, xfs_buf_attach_iodone(bp, xfs_istale_done,
(void(*)(xfs_buf_t*,xfs_log_item_t*)) &iip->ili_item);
xfs_istale_done, (xfs_log_item_t *)iip);
if (ip != free_ip) if (ip != free_ip)
xfs_iunlock(ip, XFS_ILOCK_EXCL); xfs_iunlock(ip, XFS_ILOCK_EXCL);
@ -3065,8 +3064,7 @@ xfs_iflush_int(
* and unlock the inode's flush lock when the inode is * and unlock the inode's flush lock when the inode is
* completely written to disk. * completely written to disk.
*/ */
xfs_buf_attach_iodone(bp, (void(*)(xfs_buf_t*,xfs_log_item_t*)) xfs_buf_attach_iodone(bp, xfs_iflush_done, &iip->ili_item);
xfs_iflush_done, (xfs_log_item_t *)iip);
ASSERT(XFS_BUF_FSPRIVATE(bp, void *) != NULL); ASSERT(XFS_BUF_FSPRIVATE(bp, void *) != NULL);
ASSERT(XFS_BUF_IODONE_FUNC(bp) != NULL); ASSERT(XFS_BUF_IODONE_FUNC(bp) != NULL);

23
fs/xfs/xfs_inode_item.c
View File

@ -867,14 +867,14 @@ xfs_inode_item_destroy(
* from the AIL if it has not been re-logged, and unlocking the inode's * from the AIL if it has not been re-logged, and unlocking the inode's
* flush lock. * flush lock.
*/ */
/*ARGSUSED*/
void void
xfs_iflush_done( xfs_iflush_done(
xfs_buf_t *bp, struct xfs_buf *bp,
xfs_inode_log_item_t *iip) struct xfs_log_item *lip)
{ {
struct xfs_inode_log_item *iip = INODE_ITEM(lip);
xfs_inode_t *ip = iip->ili_inode; xfs_inode_t *ip = iip->ili_inode;
struct xfs_ail *ailp = iip->ili_item.li_ailp; struct xfs_ail *ailp = lip->li_ailp;
/* /*
* We only want to pull the item from the AIL if it is * We only want to pull the item from the AIL if it is
@ -885,12 +885,11 @@ xfs_iflush_done(
* the lock since it's cheaper, and then we recheck while * the lock since it's cheaper, and then we recheck while
* holding the lock before removing the inode from the AIL. * holding the lock before removing the inode from the AIL.
*/ */
if (iip->ili_logged && if (iip->ili_logged && lip->li_lsn == iip->ili_flush_lsn) {
(iip->ili_item.li_lsn == iip->ili_flush_lsn)) {
spin_lock(&ailp->xa_lock); spin_lock(&ailp->xa_lock);
if (iip->ili_item.li_lsn == iip->ili_flush_lsn) { if (lip->li_lsn == iip->ili_flush_lsn) {
/* 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, lip);
} else { } else {
spin_unlock(&ailp->xa_lock); spin_unlock(&ailp->xa_lock);
} }
@ -908,8 +907,6 @@ xfs_iflush_done(
* Release the inode's flush lock since we're done with it. * Release the inode's flush lock since we're done with it.
*/ */
xfs_ifunlock(ip); xfs_ifunlock(ip);
return;
} }
/* /*
@ -959,10 +956,10 @@ xfs_iflush_abort(
void void
xfs_istale_done( xfs_istale_done(
xfs_buf_t *bp, struct xfs_buf *bp,
xfs_inode_log_item_t *iip) struct xfs_log_item *lip)
{ {
xfs_iflush_abort(iip->ili_inode); xfs_iflush_abort(INODE_ITEM(lip)->ili_inode);
} }
/* /*

4
fs/xfs/xfs_inode_item.h
View File

@ -161,8 +161,8 @@ static inline int xfs_inode_clean(xfs_inode_t *ip)
extern void xfs_inode_item_init(struct xfs_inode *, struct xfs_mount *); 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 *, xfs_inode_log_item_t *); extern void xfs_iflush_done(struct xfs_buf *, struct xfs_log_item *);
extern void xfs_istale_done(struct xfs_buf *, xfs_inode_log_item_t *); 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 *);
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 *);

7
fs/xfs/xfs_trans_buf.c
View File

@ -658,7 +658,7 @@ xfs_trans_log_buf(xfs_trans_t *tp,
bip = XFS_BUF_FSPRIVATE(bp, xfs_buf_log_item_t *); bip = XFS_BUF_FSPRIVATE(bp, xfs_buf_log_item_t *);
ASSERT(atomic_read(&bip->bli_refcount) > 0); ASSERT(atomic_read(&bip->bli_refcount) > 0);
XFS_BUF_SET_IODONE_FUNC(bp, xfs_buf_iodone_callbacks); XFS_BUF_SET_IODONE_FUNC(bp, xfs_buf_iodone_callbacks);
bip->bli_item.li_cb = (void(*)(xfs_buf_t*,xfs_log_item_t*))xfs_buf_iodone; bip->bli_item.li_cb = xfs_buf_iodone;
trace_xfs_trans_log_buf(bip); trace_xfs_trans_log_buf(bip);
@ -815,12 +815,9 @@ xfs_trans_stale_inode_buf(
ASSERT(atomic_read(&bip->bli_refcount) > 0); ASSERT(atomic_read(&bip->bli_refcount) > 0);
bip->bli_flags |= XFS_BLI_STALE_INODE; bip->bli_flags |= XFS_BLI_STALE_INODE;
bip->bli_item.li_cb = (void(*)(xfs_buf_t*,xfs_log_item_t*)) bip->bli_item.li_cb = xfs_buf_iodone;
xfs_buf_iodone;
} }
/* /*
* Mark the buffer as being one which contains newly allocated * Mark the buffer as being one which contains newly allocated
* inodes. We need to make sure that even if this buffer is * inodes. We need to make sure that even if this buffer is