openkylin
/
linux
mirror of https://gitee.com/openkylin/linux.git
9
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge branch 'xfs-misc-fixes-for-4.5-2' into for-next

This commit is contained in:
Dave Chinner 2016-01-12 07:04:30 +11:00
parent 4922be51ef 7d6a13f023
commit dde7f55bd0
18 changed files with 159 additions and 234 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

141
fs/xfs/libxfs/xfs_attr.c
View File

@ -207,7 +207,7 @@ xfs_attr_set(
struct xfs_trans_res tres; struct xfs_trans_res tres;
xfs_fsblock_t firstblock; xfs_fsblock_t firstblock;
int rsvd = (flags & ATTR_ROOT) != 0; int rsvd = (flags & ATTR_ROOT) != 0;
int error, err2, committed, local; int error, err2, local;
XFS_STATS_INC(mp, xs_attr_set); XFS_STATS_INC(mp, xs_attr_set);
@ -334,24 +334,14 @@ xfs_attr_set(
*/ */
xfs_bmap_init(args.flist, args.firstblock); xfs_bmap_init(args.flist, args.firstblock);
error = xfs_attr_shortform_to_leaf(&args); error = xfs_attr_shortform_to_leaf(&args);
if (!error) { if (!error)
error = xfs_bmap_finish(&args.trans, args.flist, error = xfs_bmap_finish(&args.trans, args.flist, dp);
&committed);
}
if (error) { if (error) {
ASSERT(committed);
args.trans = NULL; args.trans = NULL;
xfs_bmap_cancel(&flist); xfs_bmap_cancel(&flist);
goto out; goto out;
} }
/*
* bmap_finish() may have committed the last trans and started
* a new one. We need the inode to be in all transactions.
*/
if (committed)
xfs_trans_ijoin(args.trans, dp, 0);
/* /*
* Commit the leaf transformation. We'll need another (linked) * Commit the leaf transformation. We'll need another (linked)
* transaction to add the new attribute to the leaf. * transaction to add the new attribute to the leaf.
@ -568,7 +558,7 @@ xfs_attr_leaf_addname(xfs_da_args_t *args)
{ {
xfs_inode_t *dp; xfs_inode_t *dp;
struct xfs_buf *bp; struct xfs_buf *bp;
int retval, error, committed, forkoff; int retval, error, forkoff;
trace_xfs_attr_leaf_addname(args); trace_xfs_attr_leaf_addname(args);
@ -628,24 +618,14 @@ xfs_attr_leaf_addname(xfs_da_args_t *args)
*/ */
xfs_bmap_init(args->flist, args->firstblock); xfs_bmap_init(args->flist, args->firstblock);
error = xfs_attr3_leaf_to_node(args); error = xfs_attr3_leaf_to_node(args);
if (!error) { if (!error)
error = xfs_bmap_finish(&args->trans, args->flist, error = xfs_bmap_finish(&args->trans, args->flist, dp);
&committed);
}
if (error) { if (error) {
ASSERT(committed);
args->trans = NULL; args->trans = NULL;
xfs_bmap_cancel(args->flist); xfs_bmap_cancel(args->flist);
return error; return error;
} }
/*
* bmap_finish() may have committed the last trans and started
* a new one. We need the inode to be in all transactions.
*/
if (committed)
xfs_trans_ijoin(args->trans, dp, 0);
/* /*
* Commit the current trans (including the inode) and start * Commit the current trans (including the inode) and start
* a new one. * a new one.
@ -729,25 +709,14 @@ xfs_attr_leaf_addname(xfs_da_args_t *args)
xfs_bmap_init(args->flist, args->firstblock); xfs_bmap_init(args->flist, args->firstblock);
error = xfs_attr3_leaf_to_shortform(bp, args, forkoff); error = xfs_attr3_leaf_to_shortform(bp, args, forkoff);
/* bp is gone due to xfs_da_shrink_inode */ /* bp is gone due to xfs_da_shrink_inode */
if (!error) { if (!error)
error = xfs_bmap_finish(&args->trans, error = xfs_bmap_finish(&args->trans,
args->flist, args->flist, dp);
&committed);
}
if (error) { if (error) {
ASSERT(committed);
args->trans = NULL; args->trans = NULL;
xfs_bmap_cancel(args->flist); xfs_bmap_cancel(args->flist);
return error; return error;
} }
/*
* bmap_finish() may have committed the last trans
* and started a new one. We need the inode to be
* in all transactions.
*/
if (committed)
xfs_trans_ijoin(args->trans, dp, 0);
} }
/* /*
@ -775,7 +744,7 @@ xfs_attr_leaf_removename(xfs_da_args_t *args)
{ {
xfs_inode_t *dp; xfs_inode_t *dp;
struct xfs_buf *bp; struct xfs_buf *bp;
int error, committed, forkoff; int error, forkoff;
trace_xfs_attr_leaf_removename(args); trace_xfs_attr_leaf_removename(args);
@ -803,23 +772,13 @@ xfs_attr_leaf_removename(xfs_da_args_t *args)
xfs_bmap_init(args->flist, args->firstblock); xfs_bmap_init(args->flist, args->firstblock);
error = xfs_attr3_leaf_to_shortform(bp, args, forkoff); error = xfs_attr3_leaf_to_shortform(bp, args, forkoff);
/* bp is gone due to xfs_da_shrink_inode */ /* bp is gone due to xfs_da_shrink_inode */
if (!error) { if (!error)
error = xfs_bmap_finish(&args->trans, args->flist, error = xfs_bmap_finish(&args->trans, args->flist, dp);
&committed);
}
if (error) { if (error) {
ASSERT(committed);
args->trans = NULL; args->trans = NULL;
xfs_bmap_cancel(args->flist); xfs_bmap_cancel(args->flist);
return error; return error;
} }
/*
* bmap_finish() may have committed the last trans and started
* a new one. We need the inode to be in all transactions.
*/
if (committed)
xfs_trans_ijoin(args->trans, dp, 0);
} }
return 0; return 0;
} }
@ -877,7 +836,7 @@ xfs_attr_node_addname(xfs_da_args_t *args)
xfs_da_state_blk_t *blk; xfs_da_state_blk_t *blk;
xfs_inode_t *dp; xfs_inode_t *dp;
xfs_mount_t *mp; xfs_mount_t *mp;
int committed, retval, error; int retval, error;
trace_xfs_attr_node_addname(args); trace_xfs_attr_node_addname(args);
@ -938,26 +897,15 @@ xfs_attr_node_addname(xfs_da_args_t *args)
state = NULL; state = NULL;
xfs_bmap_init(args->flist, args->firstblock); xfs_bmap_init(args->flist, args->firstblock);
error = xfs_attr3_leaf_to_node(args); error = xfs_attr3_leaf_to_node(args);
if (!error) { if (!error)
error = xfs_bmap_finish(&args->trans, error = xfs_bmap_finish(&args->trans,
args->flist, args->flist, dp);
&committed);
}
if (error) { if (error) {
ASSERT(committed);
args->trans = NULL; args->trans = NULL;
xfs_bmap_cancel(args->flist); xfs_bmap_cancel(args->flist);
goto out; goto out;
} }
/*
* bmap_finish() may have committed the last trans
* and started a new one. We need the inode to be
* in all transactions.
*/
if (committed)
xfs_trans_ijoin(args->trans, dp, 0);
/* /*
* Commit the node conversion and start the next * Commit the node conversion and start the next
* trans in the chain. * trans in the chain.
@ -977,23 +925,13 @@ xfs_attr_node_addname(xfs_da_args_t *args)
*/ */
xfs_bmap_init(args->flist, args->firstblock); xfs_bmap_init(args->flist, args->firstblock);
error = xfs_da3_split(state); error = xfs_da3_split(state);
if (!error) { if (!error)
error = xfs_bmap_finish(&args->trans, args->flist, error = xfs_bmap_finish(&args->trans, args->flist, dp);
&committed);
}
if (error) { if (error) {
ASSERT(committed);
args->trans = NULL; args->trans = NULL;
xfs_bmap_cancel(args->flist); xfs_bmap_cancel(args->flist);
goto out; goto out;
} }
/*
* bmap_finish() may have committed the last trans and started
* a new one. We need the inode to be in all transactions.
*/
if (committed)
xfs_trans_ijoin(args->trans, dp, 0);
} else { } else {
/* /*
* Addition succeeded, update Btree hashvals. * Addition succeeded, update Btree hashvals.
@ -1086,25 +1024,14 @@ xfs_attr_node_addname(xfs_da_args_t *args)
if (retval && (state->path.active > 1)) { if (retval && (state->path.active > 1)) {
xfs_bmap_init(args->flist, args->firstblock); xfs_bmap_init(args->flist, args->firstblock);
error = xfs_da3_join(state); error = xfs_da3_join(state);
if (!error) { if (!error)
error = xfs_bmap_finish(&args->trans, error = xfs_bmap_finish(&args->trans,
args->flist, args->flist, dp);
&committed);
}
if (error) { if (error) {
ASSERT(committed);
args->trans = NULL; args->trans = NULL;
xfs_bmap_cancel(args->flist); xfs_bmap_cancel(args->flist);
goto out; goto out;
} }
/*
* bmap_finish() may have committed the last trans
* and started a new one. We need the inode to be
* in all transactions.
*/
if (committed)
xfs_trans_ijoin(args->trans, dp, 0);
} }
/* /*
@ -1146,7 +1073,7 @@ xfs_attr_node_removename(xfs_da_args_t *args)
xfs_da_state_blk_t *blk; xfs_da_state_blk_t *blk;
xfs_inode_t *dp; xfs_inode_t *dp;
struct xfs_buf *bp; struct xfs_buf *bp;
int retval, error, committed, forkoff; int retval, error, forkoff;
trace_xfs_attr_node_removename(args); trace_xfs_attr_node_removename(args);
@ -1220,24 +1147,13 @@ xfs_attr_node_removename(xfs_da_args_t *args)
if (retval && (state->path.active > 1)) { if (retval && (state->path.active > 1)) {
xfs_bmap_init(args->flist, args->firstblock); xfs_bmap_init(args->flist, args->firstblock);
error = xfs_da3_join(state); error = xfs_da3_join(state);
if (!error) { if (!error)
error = xfs_bmap_finish(&args->trans, args->flist, error = xfs_bmap_finish(&args->trans, args->flist, dp);
&committed);
}
if (error) { if (error) {
ASSERT(committed);
args->trans = NULL; args->trans = NULL;
xfs_bmap_cancel(args->flist); xfs_bmap_cancel(args->flist);
goto out; goto out;
} }
/*
* bmap_finish() may have committed the last trans and started
* a new one. We need the inode to be in all transactions.
*/
if (committed)
xfs_trans_ijoin(args->trans, dp, 0);
/* /*
* Commit the Btree join operation and start a new trans. * Commit the Btree join operation and start a new trans.
*/ */
@ -1265,25 +1181,14 @@ xfs_attr_node_removename(xfs_da_args_t *args)
xfs_bmap_init(args->flist, args->firstblock); xfs_bmap_init(args->flist, args->firstblock);
error = xfs_attr3_leaf_to_shortform(bp, args, forkoff); error = xfs_attr3_leaf_to_shortform(bp, args, forkoff);
/* bp is gone due to xfs_da_shrink_inode */ /* bp is gone due to xfs_da_shrink_inode */
if (!error) { if (!error)
error = xfs_bmap_finish(&args->trans, error = xfs_bmap_finish(&args->trans,
args->flist, args->flist, dp);
&committed);
}
if (error) { if (error) {
ASSERT(committed);
args->trans = NULL; args->trans = NULL;
xfs_bmap_cancel(args->flist); xfs_bmap_cancel(args->flist);
goto out; goto out;
} }
/*
* bmap_finish() may have committed the last trans
* and started a new one. We need the inode to be
* in all transactions.
*/
if (committed)
xfs_trans_ijoin(args->trans, dp, 0);
} else } else
xfs_trans_brelse(args->trans, bp); xfs_trans_brelse(args->trans, bp);
} }

31
fs/xfs/libxfs/xfs_attr_remote.c
View File

@ -448,8 +448,6 @@ xfs_attr_rmtval_set(
* Roll through the "value", allocating blocks on disk as required. * Roll through the "value", allocating blocks on disk as required.
*/ */
while (blkcnt > 0) { while (blkcnt > 0) {
int committed;
/* /*
* Allocate a single extent, up to the size of the value. * Allocate a single extent, up to the size of the value.
* *
@ -467,24 +465,14 @@ xfs_attr_rmtval_set(
error = xfs_bmapi_write(args->trans, dp, (xfs_fileoff_t)lblkno, error = xfs_bmapi_write(args->trans, dp, (xfs_fileoff_t)lblkno,
blkcnt, XFS_BMAPI_ATTRFORK, args->firstblock, blkcnt, XFS_BMAPI_ATTRFORK, args->firstblock,
args->total, &map, &nmap, args->flist); args->total, &map, &nmap, args->flist);
if (!error) { if (!error)
error = xfs_bmap_finish(&args->trans, args->flist, error = xfs_bmap_finish(&args->trans, args->flist, dp);
&committed);
}
if (error) { if (error) {
ASSERT(committed);
args->trans = NULL; args->trans = NULL;
xfs_bmap_cancel(args->flist); xfs_bmap_cancel(args->flist);
return error; return error;
} }
/*
* bmap_finish() may have committed the last trans and started
* a new one. We need the inode to be in all transactions.
*/
if (committed)
xfs_trans_ijoin(args->trans, dp, 0);
ASSERT(nmap == 1); ASSERT(nmap == 1);
ASSERT((map.br_startblock != DELAYSTARTBLOCK) && ASSERT((map.br_startblock != DELAYSTARTBLOCK) &&
(map.br_startblock != HOLESTARTBLOCK)); (map.br_startblock != HOLESTARTBLOCK));
@ -615,30 +603,19 @@ xfs_attr_rmtval_remove(
blkcnt = args->rmtblkcnt; blkcnt = args->rmtblkcnt;
done = 0; done = 0;
while (!done) { while (!done) {
int committed;
xfs_bmap_init(args->flist, args->firstblock); xfs_bmap_init(args->flist, args->firstblock);
error = xfs_bunmapi(args->trans, args->dp, lblkno, blkcnt, error = xfs_bunmapi(args->trans, args->dp, lblkno, blkcnt,
XFS_BMAPI_ATTRFORK, 1, args->firstblock, XFS_BMAPI_ATTRFORK, 1, args->firstblock,
args->flist, &done); args->flist, &done);
if (!error) { if (!error)
error = xfs_bmap_finish(&args->trans, args->flist, error = xfs_bmap_finish(&args->trans, args->flist,
&committed); args->dp);
}
if (error) { if (error) {
ASSERT(committed);
args->trans = NULL; args->trans = NULL;
xfs_bmap_cancel(args->flist); xfs_bmap_cancel(args->flist);
return error; return error;
} }
/*
* bmap_finish() may have committed the last trans and started
* a new one. We need the inode to be in all transactions.
*/
if (committed)
xfs_trans_ijoin(args->trans, args->dp, 0);
/* /*
* Close out trans and start the next one in the chain. * Close out trans and start the next one in the chain.
*/ */

16
fs/xfs/libxfs/xfs_bmap.c
View File

@ -325,9 +325,11 @@ xfs_check_block(
/* /*
* Check that the extents for the inode ip are in the right order in all * Check that the extents for the inode ip are in the right order in all
* btree leaves. * btree leaves. THis becomes prohibitively expensive for large extent count
* files, so don't bother with inodes that have more than 10,000 extents in
* them. The btree record ordering checks will still be done, so for such large
* bmapbt constructs that is going to catch most corruptions.
*/ */
STATIC void STATIC void
xfs_bmap_check_leaf_extents( xfs_bmap_check_leaf_extents(
xfs_btree_cur_t *cur, /* btree cursor or null */ xfs_btree_cur_t *cur, /* btree cursor or null */
@ -352,6 +354,10 @@ xfs_bmap_check_leaf_extents(
return; return;
} }
/* skip large extent count inodes */
if (ip->i_d.di_nextents > 10000)
return;
bno = NULLFSBLOCK; bno = NULLFSBLOCK;
mp = ip->i_mount; mp = ip->i_mount;
ifp = XFS_IFORK_PTR(ip, whichfork); ifp = XFS_IFORK_PTR(ip, whichfork);
@ -1111,7 +1117,6 @@ xfs_bmap_add_attrfork(
xfs_trans_t *tp; /* transaction pointer */ xfs_trans_t *tp; /* transaction pointer */
int blks; /* space reservation */ int blks; /* space reservation */
int version = 1; /* superblock attr version */ int version = 1; /* superblock attr version */
int committed; /* xaction was committed */
int logflags; /* logging flags */ int logflags; /* logging flags */
int error; /* error return value */ int error; /* error return value */
@ -1214,7 +1219,7 @@ xfs_bmap_add_attrfork(
xfs_log_sb(tp); xfs_log_sb(tp);
} }
error = xfs_bmap_finish(&tp, &flist, &committed); error = xfs_bmap_finish(&tp, &flist, NULL);
if (error) if (error)
goto bmap_cancel; goto bmap_cancel;
error = xfs_trans_commit(tp); error = xfs_trans_commit(tp);
@ -5951,7 +5956,6 @@ xfs_bmap_split_extent(
struct xfs_trans *tp; struct xfs_trans *tp;
struct xfs_bmap_free free_list; struct xfs_bmap_free free_list;
xfs_fsblock_t firstfsb; xfs_fsblock_t firstfsb;
int committed;
int error; int error;
tp = xfs_trans_alloc(mp, XFS_TRANS_DIOSTRAT); tp = xfs_trans_alloc(mp, XFS_TRANS_DIOSTRAT);
@ -5972,7 +5976,7 @@ xfs_bmap_split_extent(
if (error) if (error)
goto out; goto out;
error = xfs_bmap_finish(&tp, &free_list, &committed); error = xfs_bmap_finish(&tp, &free_list, NULL);
if (error) if (error)
goto out; goto out;

2
fs/xfs/libxfs/xfs_bmap.h
View File

@ -195,7 +195,7 @@ void xfs_bmap_add_free(xfs_fsblock_t bno, xfs_filblks_t len,
struct xfs_bmap_free *flist, struct xfs_mount *mp); struct xfs_bmap_free *flist, struct xfs_mount *mp);
void xfs_bmap_cancel(struct xfs_bmap_free *flist); void xfs_bmap_cancel(struct xfs_bmap_free *flist);
int xfs_bmap_finish(struct xfs_trans **tp, struct xfs_bmap_free *flist, int xfs_bmap_finish(struct xfs_trans **tp, struct xfs_bmap_free *flist,
int *committed); struct xfs_inode *ip);
void xfs_bmap_compute_maxlevels(struct xfs_mount *mp, int whichfork); void xfs_bmap_compute_maxlevels(struct xfs_mount *mp, int whichfork);
int xfs_bmap_first_unused(struct xfs_trans *tp, struct xfs_inode *ip, int xfs_bmap_first_unused(struct xfs_trans *tp, struct xfs_inode *ip,
xfs_extlen_t len, xfs_fileoff_t *unused, int whichfork); xfs_extlen_t len, xfs_fileoff_t *unused, int whichfork);

36
fs/xfs/libxfs/xfs_dquot_buf.c
View File

@ -54,7 +54,7 @@ xfs_dqcheck(
xfs_dqid_t id, xfs_dqid_t id,
uint type, /* used only when IO_dorepair is true */ uint type, /* used only when IO_dorepair is true */
uint flags, uint flags,
char *str) const char *str)
{ {
xfs_dqblk_t *d = (xfs_dqblk_t *)ddq; xfs_dqblk_t *d = (xfs_dqblk_t *)ddq;
int errs = 0; int errs = 0;
@ -207,7 +207,8 @@ xfs_dquot_buf_verify_crc(
STATIC bool STATIC bool
xfs_dquot_buf_verify( xfs_dquot_buf_verify(
struct xfs_mount *mp, struct xfs_mount *mp,
struct xfs_buf *bp) struct xfs_buf *bp,
int warn)
{ {
struct xfs_dqblk *d = (struct xfs_dqblk *)bp->b_addr; struct xfs_dqblk *d = (struct xfs_dqblk *)bp->b_addr;
xfs_dqid_t id = 0; xfs_dqid_t id = 0;
@ -240,8 +241,7 @@ xfs_dquot_buf_verify(
if (i == 0) if (i == 0)
id = be32_to_cpu(ddq->d_id); id = be32_to_cpu(ddq->d_id);
error = xfs_dqcheck(mp, ddq, id + i, 0, XFS_QMOPT_DOWARN, error = xfs_dqcheck(mp, ddq, id + i, 0, warn, __func__);
"xfs_dquot_buf_verify");
if (error) if (error)
return false; return false;
} }
@ -256,13 +256,32 @@ xfs_dquot_buf_read_verify(
if (!xfs_dquot_buf_verify_crc(mp, bp)) if (!xfs_dquot_buf_verify_crc(mp, bp))
xfs_buf_ioerror(bp, -EFSBADCRC); xfs_buf_ioerror(bp, -EFSBADCRC);
else if (!xfs_dquot_buf_verify(mp, bp)) else if (!xfs_dquot_buf_verify(mp, bp, XFS_QMOPT_DOWARN))
xfs_buf_ioerror(bp, -EFSCORRUPTED); xfs_buf_ioerror(bp, -EFSCORRUPTED);
if (bp->b_error) if (bp->b_error)
xfs_verifier_error(bp); xfs_verifier_error(bp);
} }
/*
* readahead errors are silent and simply leave the buffer as !done so a real
* read will then be run with the xfs_dquot_buf_ops verifier. See
* xfs_inode_buf_verify() for why we use EIO and ~XBF_DONE here rather than
* reporting the failure.
*/
static void
xfs_dquot_buf_readahead_verify(
struct xfs_buf *bp)
{
struct xfs_mount *mp = bp->b_target->bt_mount;
if (!xfs_dquot_buf_verify_crc(mp, bp) ||
!xfs_dquot_buf_verify(mp, bp, 0)) {
xfs_buf_ioerror(bp, -EIO);
bp->b_flags &= ~XBF_DONE;
}
}
/* /*
* we don't calculate the CRC here as that is done when the dquot is flushed to * we don't calculate the CRC here as that is done when the dquot is flushed to
* the buffer after the update is done. This ensures that the dquot in the * the buffer after the update is done. This ensures that the dquot in the
@ -274,7 +293,7 @@ xfs_dquot_buf_write_verify(
{ {
struct xfs_mount *mp = bp->b_target->bt_mount; struct xfs_mount *mp = bp->b_target->bt_mount;
if (!xfs_dquot_buf_verify(mp, bp)) { if (!xfs_dquot_buf_verify(mp, bp, XFS_QMOPT_DOWARN)) {
xfs_buf_ioerror(bp, -EFSCORRUPTED); xfs_buf_ioerror(bp, -EFSCORRUPTED);
xfs_verifier_error(bp); xfs_verifier_error(bp);
return; return;
@ -287,3 +306,8 @@ const struct xfs_buf_ops xfs_dquot_buf_ops = {
.verify_write = xfs_dquot_buf_write_verify, .verify_write = xfs_dquot_buf_write_verify,
}; };
const struct xfs_buf_ops xfs_dquot_buf_ra_ops = {
.name = "xfs_dquot_ra",
.verify_read = xfs_dquot_buf_readahead_verify,
.verify_write = xfs_dquot_buf_write_verify,
};

14
fs/xfs/libxfs/xfs_inode_buf.c
View File

@ -62,11 +62,14 @@ xfs_inobp_check(
* has not had the inode cores stamped into it. Hence for readahead, the buffer * has not had the inode cores stamped into it. Hence for readahead, the buffer
* may be potentially invalid. * may be potentially invalid.
* *
* If the readahead buffer is invalid, we don't want to mark it with an error, * If the readahead buffer is invalid, we need to mark it with an error and
* but we do want to clear the DONE status of the buffer so that a followup read * clear the DONE status of the buffer so that a followup read will re-read it
* will re-read it from disk. This will ensure that we don't get an unnecessary * from disk. We don't report the error otherwise to avoid warnings during log
* warnings during log recovery and we don't get unnecssary panics on debug * recovery and we don't get unnecssary panics on debug kernels. We use EIO here
* kernels. * because all we want to do is say readahead failed; there is no-one to report
* the error to, so this will distinguish it from a non-ra verifier failure.
* Changes to this readahead error behavour also need to be reflected in
* xfs_dquot_buf_readahead_verify().
*/ */
static void static void
xfs_inode_buf_verify( xfs_inode_buf_verify(
@ -93,6 +96,7 @@ xfs_inode_buf_verify(
XFS_RANDOM_ITOBP_INOTOBP))) { XFS_RANDOM_ITOBP_INOTOBP))) {
if (readahead) { if (readahead) {
bp->b_flags &= ~XBF_DONE; bp->b_flags &= ~XBF_DONE;
xfs_buf_ioerror(bp, -EIO);
return; return;
} }

2
fs/xfs/libxfs/xfs_quota_defs.h
View File

@ -153,7 +153,7 @@ typedef __uint16_t xfs_qwarncnt_t;
#define XFS_QMOPT_RESBLK_MASK (XFS_QMOPT_RES_REGBLKS | XFS_QMOPT_RES_RTBLKS) #define XFS_QMOPT_RESBLK_MASK (XFS_QMOPT_RES_REGBLKS | XFS_QMOPT_RES_RTBLKS)
extern int xfs_dqcheck(struct xfs_mount *mp, xfs_disk_dquot_t *ddq, extern int xfs_dqcheck(struct xfs_mount *mp, xfs_disk_dquot_t *ddq,
xfs_dqid_t id, uint type, uint flags, char *str); xfs_dqid_t id, uint type, uint flags, const char *str);
extern int xfs_calc_dquots_per_chunk(unsigned int nbblks); extern int xfs_calc_dquots_per_chunk(unsigned int nbblks);
#endif /* __XFS_QUOTA_H__ */ #endif /* __XFS_QUOTA_H__ */

1
fs/xfs/libxfs/xfs_shared.h
View File

@ -49,6 +49,7 @@ extern const struct xfs_buf_ops xfs_inobt_buf_ops;
extern const struct xfs_buf_ops xfs_inode_buf_ops; extern const struct xfs_buf_ops xfs_inode_buf_ops;
extern const struct xfs_buf_ops xfs_inode_buf_ra_ops; extern const struct xfs_buf_ops xfs_inode_buf_ra_ops;
extern const struct xfs_buf_ops xfs_dquot_buf_ops; extern const struct xfs_buf_ops xfs_dquot_buf_ops;
extern const struct xfs_buf_ops xfs_dquot_buf_ra_ops;
extern const struct xfs_buf_ops xfs_sb_buf_ops; extern const struct xfs_buf_ops xfs_sb_buf_ops;
extern const struct xfs_buf_ops xfs_sb_quiet_buf_ops; extern const struct xfs_buf_ops xfs_sb_quiet_buf_ops;
extern const struct xfs_buf_ops xfs_symlink_buf_ops; extern const struct xfs_buf_ops xfs_symlink_buf_ops;

2
fs/xfs/xfs_aops.c
View File

@ -1917,6 +1917,7 @@ xfs_vm_readpage(
struct file *unused, struct file *unused,
struct page *page) struct page *page)
{ {
trace_xfs_vm_readpage(page->mapping->host, 1);
return mpage_readpage(page, xfs_get_blocks); return mpage_readpage(page, xfs_get_blocks);
} }
@ -1927,6 +1928,7 @@ xfs_vm_readpages(
struct list_head *pages, struct list_head *pages,
unsigned nr_pages) unsigned nr_pages)
{ {
trace_xfs_vm_readpages(mapping->host, nr_pages);
return mpage_readpages(mapping, pages, nr_pages, xfs_get_blocks); return mpage_readpages(mapping, pages, nr_pages, xfs_get_blocks);
} }

43
fs/xfs/xfs_bmap_util.c
View File

@ -91,32 +91,32 @@ xfs_zero_extent(
* last due to locking considerations. We never free any extents in * last due to locking considerations. We never free any extents in
* the first transaction. * the first transaction.
* *
* Return 1 if the given transaction was committed and a new one * If an inode *ip is provided, rejoin it to the transaction if
* started, and 0 otherwise in the committed parameter. * the transaction was committed.
*/ */
int /* error */ int /* error */
xfs_bmap_finish( xfs_bmap_finish(
struct xfs_trans **tp, /* transaction pointer addr */ struct xfs_trans **tp, /* transaction pointer addr */
struct xfs_bmap_free *flist, /* i/o: list extents to free */ struct xfs_bmap_free *flist, /* i/o: list extents to free */
int *committed)/* xact committed or not */ struct xfs_inode *ip)
{ {
struct xfs_efd_log_item *efd; /* extent free data */ struct xfs_efd_log_item *efd; /* extent free data */
struct xfs_efi_log_item *efi; /* extent free intention */ struct xfs_efi_log_item *efi; /* extent free intention */
int error; /* error return value */ int error; /* error return value */
int committed;/* xact committed or not */
struct xfs_bmap_free_item *free; /* free extent item */ struct xfs_bmap_free_item *free; /* free extent item */
struct xfs_bmap_free_item *next; /* next item on free list */ struct xfs_bmap_free_item *next; /* next item on free list */
ASSERT((*tp)->t_flags & XFS_TRANS_PERM_LOG_RES); ASSERT((*tp)->t_flags & XFS_TRANS_PERM_LOG_RES);
if (flist->xbf_count == 0) { if (flist->xbf_count == 0)
*committed = 0;
return 0; return 0;
}
efi = xfs_trans_get_efi(*tp, flist->xbf_count); efi = xfs_trans_get_efi(*tp, flist->xbf_count);
for (free = flist->xbf_first; free; free = free->xbfi_next) for (free = flist->xbf_first; free; free = free->xbfi_next)
xfs_trans_log_efi_extent(*tp, efi, free->xbfi_startblock, xfs_trans_log_efi_extent(*tp, efi, free->xbfi_startblock,
free->xbfi_blockcount); free->xbfi_blockcount);
error = __xfs_trans_roll(tp, NULL, committed); error = __xfs_trans_roll(tp, ip, &committed);
if (error) { if (error) {
/* /*
* If the transaction was committed, drop the EFD reference * If the transaction was committed, drop the EFD reference
@ -128,16 +128,13 @@ xfs_bmap_finish(
* transaction so we should return committed=1 even though we're * transaction so we should return committed=1 even though we're
* returning an error. * returning an error.
*/ */
if (*committed) { if (committed) {
xfs_efi_release(efi); xfs_efi_release(efi);
xfs_force_shutdown((*tp)->t_mountp, xfs_force_shutdown((*tp)->t_mountp,
(error == -EFSCORRUPTED) ? (error == -EFSCORRUPTED) ?
SHUTDOWN_CORRUPT_INCORE : SHUTDOWN_CORRUPT_INCORE :
SHUTDOWN_META_IO_ERROR); SHUTDOWN_META_IO_ERROR);
} else {
*committed = 1;
} }
return error; return error;
} }
@ -969,7 +966,6 @@ xfs_alloc_file_space(
xfs_bmbt_irec_t imaps[1], *imapp; xfs_bmbt_irec_t imaps[1], *imapp;
xfs_bmap_free_t free_list; xfs_bmap_free_t free_list;
uint qblocks, resblks, resrtextents; uint qblocks, resblks, resrtextents;
int committed;
int error; int error;
trace_xfs_alloc_file_space(ip); trace_xfs_alloc_file_space(ip);
@ -1064,23 +1060,20 @@ xfs_alloc_file_space(
error = xfs_bmapi_write(tp, ip, startoffset_fsb, error = xfs_bmapi_write(tp, ip, startoffset_fsb,
allocatesize_fsb, alloc_type, &firstfsb, allocatesize_fsb, alloc_type, &firstfsb,
resblks, imapp, &nimaps, &free_list); resblks, imapp, &nimaps, &free_list);
if (error) { if (error)
goto error0; goto error0;
}
/* /*
* Complete the transaction * Complete the transaction
*/ */
error = xfs_bmap_finish(&tp, &free_list, &committed); error = xfs_bmap_finish(&tp, &free_list, NULL);
if (error) { if (error)
goto error0; goto error0;
}
error = xfs_trans_commit(tp); error = xfs_trans_commit(tp);
xfs_iunlock(ip, XFS_ILOCK_EXCL); xfs_iunlock(ip, XFS_ILOCK_EXCL);
if (error) { if (error)
break; break;
}
allocated_fsb = imapp->br_blockcount; allocated_fsb = imapp->br_blockcount;
@ -1206,7 +1199,6 @@ xfs_free_file_space(
xfs_off_t offset, xfs_off_t offset,
xfs_off_t len) xfs_off_t len)
{ {
int committed;
int done; int done;
xfs_fileoff_t endoffset_fsb; xfs_fileoff_t endoffset_fsb;
int error; int error;
@ -1346,17 +1338,15 @@ xfs_free_file_space(
error = xfs_bunmapi(tp, ip, startoffset_fsb, error = xfs_bunmapi(tp, ip, startoffset_fsb,
endoffset_fsb - startoffset_fsb, endoffset_fsb - startoffset_fsb,
0, 2, &firstfsb, &free_list, &done); 0, 2, &firstfsb, &free_list, &done);
if (error) { if (error)
goto error0; goto error0;
}
/* /*
* complete the transaction * complete the transaction
*/ */
error = xfs_bmap_finish(&tp, &free_list, &committed); error = xfs_bmap_finish(&tp, &free_list, NULL);
if (error) { if (error)
goto error0; goto error0;
}
error = xfs_trans_commit(tp); error = xfs_trans_commit(tp);
xfs_iunlock(ip, XFS_ILOCK_EXCL); xfs_iunlock(ip, XFS_ILOCK_EXCL);
@ -1434,7 +1424,6 @@ xfs_shift_file_space(
int error; int error;
struct xfs_bmap_free free_list; struct xfs_bmap_free free_list;
xfs_fsblock_t first_block; xfs_fsblock_t first_block;
int committed;
xfs_fileoff_t stop_fsb; xfs_fileoff_t stop_fsb;
xfs_fileoff_t next_fsb; xfs_fileoff_t next_fsb;
xfs_fileoff_t shift_fsb; xfs_fileoff_t shift_fsb;
@ -1526,7 +1515,7 @@ xfs_shift_file_space(
if (error) if (error)
goto out_bmap_cancel; goto out_bmap_cancel;
error = xfs_bmap_finish(&tp, &free_list, &committed); error = xfs_bmap_finish(&tp, &free_list, NULL);
if (error) if (error)
goto out_bmap_cancel; goto out_bmap_cancel;

7
fs/xfs/xfs_buf.c
View File

@ -604,6 +604,13 @@ xfs_buf_get_map(
} }
} }
/*
* Clear b_error if this is a lookup from a caller that doesn't expect
* valid data to be found in the buffer.
*/
if (!(flags & XBF_READ))
xfs_buf_ioerror(bp, 0);
XFS_STATS_INC(target->bt_mount, xb_get); XFS_STATS_INC(target->bt_mount, xb_get);
trace_xfs_buf_get(bp, flags, _RET_IP_); trace_xfs_buf_get(bp, flags, _RET_IP_);
return bp; return bp;

13
fs/xfs/xfs_dquot.c
View File

@ -306,7 +306,7 @@ xfs_qm_dqalloc(
xfs_fsblock_t firstblock; xfs_fsblock_t firstblock;
xfs_bmap_free_t flist; xfs_bmap_free_t flist;
xfs_bmbt_irec_t map; xfs_bmbt_irec_t map;
int nmaps, error, committed; int nmaps, error;
xfs_buf_t *bp; xfs_buf_t *bp;
xfs_trans_t *tp = *tpp; xfs_trans_t *tp = *tpp;
@ -379,11 +379,12 @@ xfs_qm_dqalloc(
xfs_trans_bhold(tp, bp); xfs_trans_bhold(tp, bp);
if ((error = xfs_bmap_finish(tpp, &flist, &committed))) { error = xfs_bmap_finish(tpp, &flist, NULL);
if (error)
goto error1; goto error1;
}
if (committed) { /* Transaction was committed? */
if (*tpp != tp) {
tp = *tpp; tp = *tpp;
xfs_trans_bjoin(tp, bp); xfs_trans_bjoin(tp, bp);
} else { } else {
@ -393,9 +394,9 @@ xfs_qm_dqalloc(
*O_bpp = bp; *O_bpp = bp;
return 0; return 0;
error1: error1:
xfs_bmap_cancel(&flist); xfs_bmap_cancel(&flist);
error0: error0:
xfs_iunlock(quotip, XFS_ILOCK_EXCL); xfs_iunlock(quotip, XFS_ILOCK_EXCL);
return error; return error;

25
fs/xfs/xfs_inode.c
View File

@ -1143,7 +1143,6 @@ xfs_create(
xfs_bmap_free_t free_list; xfs_bmap_free_t free_list;
xfs_fsblock_t first_block; xfs_fsblock_t first_block;
bool unlock_dp_on_error = false; bool unlock_dp_on_error = false;
int committed;
prid_t prid; prid_t prid;
struct xfs_dquot *udqp = NULL; struct xfs_dquot *udqp = NULL;
struct xfs_dquot *gdqp = NULL; struct xfs_dquot *gdqp = NULL;
@ -1226,7 +1225,7 @@ xfs_create(
* pointing to itself. * pointing to itself.
*/ */
error = xfs_dir_ialloc(&tp, dp, mode, is_dir ? 2 : 1, rdev, error = xfs_dir_ialloc(&tp, dp, mode, is_dir ? 2 : 1, rdev,
prid, resblks > 0, &ip, &committed); prid, resblks > 0, &ip, NULL);
if (error) if (error)
goto out_trans_cancel; goto out_trans_cancel;
@ -1275,7 +1274,7 @@ xfs_create(
*/ */
xfs_qm_vop_create_dqattach(tp, ip, udqp, gdqp, pdqp); xfs_qm_vop_create_dqattach(tp, ip, udqp, gdqp, pdqp);
error = xfs_bmap_finish(&tp, &free_list, &committed); error = xfs_bmap_finish(&tp, &free_list, NULL);
if (error) if (error)
goto out_bmap_cancel; goto out_bmap_cancel;
@ -1427,7 +1426,6 @@ xfs_link(
int error; int error;
xfs_bmap_free_t free_list; xfs_bmap_free_t free_list;
xfs_fsblock_t first_block; xfs_fsblock_t first_block;
int committed;
int resblks; int resblks;
trace_xfs_link(tdp, target_name); trace_xfs_link(tdp, target_name);
@ -1502,11 +1500,10 @@ xfs_link(
* link transaction goes to disk before returning to * link transaction goes to disk before returning to
* the user. * the user.
*/ */
if (mp->m_flags & (XFS_MOUNT_WSYNC|XFS_MOUNT_DIRSYNC)) { if (mp->m_flags & (XFS_MOUNT_WSYNC|XFS_MOUNT_DIRSYNC))
xfs_trans_set_sync(tp); xfs_trans_set_sync(tp);
}
error = xfs_bmap_finish (&tp, &free_list, &committed); error = xfs_bmap_finish(&tp, &free_list, NULL);
if (error) { if (error) {
xfs_bmap_cancel(&free_list); xfs_bmap_cancel(&free_list);
goto error_return; goto error_return;
@ -1555,7 +1552,6 @@ xfs_itruncate_extents(
xfs_fileoff_t first_unmap_block; xfs_fileoff_t first_unmap_block;
xfs_fileoff_t last_block; xfs_fileoff_t last_block;
xfs_filblks_t unmap_len; xfs_filblks_t unmap_len;
int committed;
int error = 0; int error = 0;
int done = 0; int done = 0;
@ -1601,9 +1597,7 @@ xfs_itruncate_extents(
* Duplicate the transaction that has the permanent * Duplicate the transaction that has the permanent
* reservation and commit the old transaction. * reservation and commit the old transaction.
*/ */
error = xfs_bmap_finish(&tp, &free_list, &committed); error = xfs_bmap_finish(&tp, &free_list, ip);
if (committed)
xfs_trans_ijoin(tp, ip, 0);
if (error) if (error)
goto out_bmap_cancel; goto out_bmap_cancel;
@ -1774,7 +1768,6 @@ xfs_inactive_ifree(
{ {
xfs_bmap_free_t free_list; xfs_bmap_free_t free_list;
xfs_fsblock_t first_block; xfs_fsblock_t first_block;
int committed;
struct xfs_mount *mp = ip->i_mount; struct xfs_mount *mp = ip->i_mount;
struct xfs_trans *tp; struct xfs_trans *tp;
int error; int error;
@ -1841,7 +1834,7 @@ xfs_inactive_ifree(
* Just ignore errors at this point. There is nothing we can do except * Just ignore errors at this point. There is nothing we can do except
* to try to keep going. Make sure it's not a silent error. * to try to keep going. Make sure it's not a silent error.
*/ */
error = xfs_bmap_finish(&tp, &free_list, &committed); error = xfs_bmap_finish(&tp, &free_list, NULL);
if (error) { if (error) {
xfs_notice(mp, "%s: xfs_bmap_finish returned error %d", xfs_notice(mp, "%s: xfs_bmap_finish returned error %d",
__func__, error); __func__, error);
@ -2523,7 +2516,6 @@ xfs_remove(
int error = 0; int error = 0;
xfs_bmap_free_t free_list; xfs_bmap_free_t free_list;
xfs_fsblock_t first_block; xfs_fsblock_t first_block;
int committed;
uint resblks; uint resblks;
trace_xfs_remove(dp, name); trace_xfs_remove(dp, name);
@ -2624,7 +2616,7 @@ xfs_remove(
if (mp->m_flags & (XFS_MOUNT_WSYNC|XFS_MOUNT_DIRSYNC)) if (mp->m_flags & (XFS_MOUNT_WSYNC|XFS_MOUNT_DIRSYNC))
xfs_trans_set_sync(tp); xfs_trans_set_sync(tp);
error = xfs_bmap_finish(&tp, &free_list, &committed); error = xfs_bmap_finish(&tp, &free_list, NULL);
if (error) if (error)
goto out_bmap_cancel; goto out_bmap_cancel;
@ -2701,7 +2693,6 @@ xfs_finish_rename(
struct xfs_trans *tp, struct xfs_trans *tp,
struct xfs_bmap_free *free_list) struct xfs_bmap_free *free_list)
{ {
int committed = 0;
int error; int error;
/* /*
@ -2711,7 +2702,7 @@ xfs_finish_rename(
if (tp->t_mountp->m_flags & (XFS_MOUNT_WSYNC|XFS_MOUNT_DIRSYNC)) if (tp->t_mountp->m_flags & (XFS_MOUNT_WSYNC|XFS_MOUNT_DIRSYNC))
xfs_trans_set_sync(tp); xfs_trans_set_sync(tp);
error = xfs_bmap_finish(&tp, free_list, &committed); error = xfs_bmap_finish(&tp, free_list, NULL);
if (error) { if (error) {
xfs_bmap_cancel(free_list); xfs_bmap_cancel(free_list);
xfs_trans_cancel(tp); xfs_trans_cancel(tp);

10
fs/xfs/xfs_iomap.c
View File

@ -129,7 +129,6 @@ xfs_iomap_write_direct(
xfs_trans_t *tp; xfs_trans_t *tp;
xfs_bmap_free_t free_list; xfs_bmap_free_t free_list;
uint qblocks, resblks, resrtextents; uint qblocks, resblks, resrtextents;
int committed;
int error; int error;
int lockmode; int lockmode;
int bmapi_flags = XFS_BMAPI_PREALLOC; int bmapi_flags = XFS_BMAPI_PREALLOC;
@ -252,7 +251,7 @@ xfs_iomap_write_direct(
/* /*
* Complete the transaction * Complete the transaction
*/ */
error = xfs_bmap_finish(&tp, &free_list, &committed); error = xfs_bmap_finish(&tp, &free_list, NULL);
if (error) if (error)
goto out_bmap_cancel; goto out_bmap_cancel;
@ -698,7 +697,7 @@ xfs_iomap_write_allocate(
xfs_bmap_free_t free_list; xfs_bmap_free_t free_list;
xfs_filblks_t count_fsb; xfs_filblks_t count_fsb;
xfs_trans_t *tp; xfs_trans_t *tp;
int nimaps, committed; int nimaps;
int error = 0; int error = 0;
int nres; int nres;
@ -799,7 +798,7 @@ xfs_iomap_write_allocate(
if (error) if (error)
goto trans_cancel; goto trans_cancel;
error = xfs_bmap_finish(&tp, &free_list, &committed); error = xfs_bmap_finish(&tp, &free_list, NULL);
if (error) if (error)
goto trans_cancel; goto trans_cancel;
@ -857,7 +856,6 @@ xfs_iomap_write_unwritten(
xfs_bmap_free_t free_list; xfs_bmap_free_t free_list;
xfs_fsize_t i_size; xfs_fsize_t i_size;
uint resblks; uint resblks;
int committed;
int error; int error;
trace_xfs_unwritten_convert(ip, offset, count); trace_xfs_unwritten_convert(ip, offset, count);
@ -929,7 +927,7 @@ xfs_iomap_write_unwritten(
xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE); xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
} }
error = xfs_bmap_finish(&tp, &free_list, &committed); error = xfs_bmap_finish(&tp, &free_list, NULL);
if (error) if (error)
goto error_on_bmapi_transaction; goto error_on_bmapi_transaction;

9
fs/xfs/xfs_log_recover.c
View File

@ -3521,6 +3521,7 @@ xlog_recover_dquot_ra_pass2(
struct xfs_disk_dquot *recddq; struct xfs_disk_dquot *recddq;
struct xfs_dq_logformat *dq_f; struct xfs_dq_logformat *dq_f;
uint type; uint type;
int len;
if (mp->m_qflags == 0) if (mp->m_qflags == 0)
@ -3541,8 +3542,12 @@ xlog_recover_dquot_ra_pass2(
ASSERT(dq_f); ASSERT(dq_f);
ASSERT(dq_f->qlf_len == 1); ASSERT(dq_f->qlf_len == 1);
xfs_buf_readahead(mp->m_ddev_targp, dq_f->qlf_blkno, len = XFS_FSB_TO_BB(mp, dq_f->qlf_len);
XFS_FSB_TO_BB(mp, dq_f->qlf_len), NULL); if (xlog_peek_buffer_cancelled(log, dq_f->qlf_blkno, len, 0))
return;
xfs_buf_readahead(mp->m_ddev_targp, dq_f->qlf_blkno, len,
&xfs_dquot_buf_ra_ops);
} }
STATIC void STATIC void

3
fs/xfs/xfs_rtalloc.c
View File

@ -766,7 +766,6 @@ xfs_growfs_rt_alloc(
{ {
xfs_fileoff_t bno; /* block number in file */ xfs_fileoff_t bno; /* block number in file */
struct xfs_buf *bp; /* temporary buffer for zeroing */ struct xfs_buf *bp; /* temporary buffer for zeroing */
int committed; /* transaction committed flag */
xfs_daddr_t d; /* disk block address */ xfs_daddr_t d; /* disk block address */
int error; /* error return value */ int error; /* error return value */
xfs_fsblock_t firstblock;/* first block allocated in xaction */ xfs_fsblock_t firstblock;/* first block allocated in xaction */
@ -811,7 +810,7 @@ xfs_growfs_rt_alloc(
/* /*
* Free any blocks freed up in the transaction, then commit. * Free any blocks freed up in the transaction, then commit.
*/ */
error = xfs_bmap_finish(&tp, &flist, &committed); error = xfs_bmap_finish(&tp, &flist, NULL);
if (error) if (error)
goto out_bmap_cancel; goto out_bmap_cancel;
error = xfs_trans_commit(tp); error = xfs_trans_commit(tp);

12
fs/xfs/xfs_symlink.c
View File

@ -178,7 +178,6 @@ xfs_symlink(
struct xfs_bmap_free free_list; struct xfs_bmap_free free_list;
xfs_fsblock_t first_block; xfs_fsblock_t first_block;
bool unlock_dp_on_error = false; bool unlock_dp_on_error = false;
int committed;
xfs_fileoff_t first_fsb; xfs_fileoff_t first_fsb;
xfs_filblks_t fs_blocks; xfs_filblks_t fs_blocks;
int nmaps; int nmaps;
@ -387,7 +386,7 @@ xfs_symlink(
xfs_trans_set_sync(tp); xfs_trans_set_sync(tp);
} }
error = xfs_bmap_finish(&tp, &free_list, &committed); error = xfs_bmap_finish(&tp, &free_list, NULL);
if (error) if (error)
goto out_bmap_cancel; goto out_bmap_cancel;
@ -434,7 +433,6 @@ xfs_inactive_symlink_rmt(
struct xfs_inode *ip) struct xfs_inode *ip)
{ {
xfs_buf_t *bp; xfs_buf_t *bp;
int committed;
int done; int done;
int error; int error;
xfs_fsblock_t first_block; xfs_fsblock_t first_block;
@ -510,15 +508,9 @@ xfs_inactive_symlink_rmt(
/* /*
* Commit the first transaction. This logs the EFI and the inode. * Commit the first transaction. This logs the EFI and the inode.
*/ */
error = xfs_bmap_finish(&tp, &free_list, &committed); error = xfs_bmap_finish(&tp, &free_list, ip);
if (error) if (error)
goto error_bmap_cancel; goto error_bmap_cancel;
/*
* The transaction must have been committed, since there were
* actually extents freed by xfs_bunmapi. See xfs_bmap_finish.
* The new tp has the extent freeing and EFDs.
*/
ASSERT(committed);
/* /*
* The first xact was committed, so add the inode to the new one. * The first xact was committed, so add the inode to the new one.
* Mark it dirty so it will be logged and moved forward in the log as * Mark it dirty so it will be logged and moved forward in the log as

26
fs/xfs/xfs_trace.h
View File

@ -1222,6 +1222,32 @@ DEFINE_PAGE_EVENT(xfs_writepage);
DEFINE_PAGE_EVENT(xfs_releasepage); DEFINE_PAGE_EVENT(xfs_releasepage);
DEFINE_PAGE_EVENT(xfs_invalidatepage); DEFINE_PAGE_EVENT(xfs_invalidatepage);
DECLARE_EVENT_CLASS(xfs_readpage_class,
TP_PROTO(struct inode *inode, int nr_pages),
TP_ARGS(inode, nr_pages),
TP_STRUCT__entry(
__field(dev_t, dev)
__field(xfs_ino_t, ino)
__field(int, nr_pages)
),
TP_fast_assign(
__entry->dev = inode->i_sb->s_dev;
__entry->ino = inode->i_ino;
__entry->nr_pages = nr_pages;
),
TP_printk("dev %d:%d ino 0x%llx nr_pages %d",
MAJOR(__entry->dev), MINOR(__entry->dev),
__entry->ino,
__entry->nr_pages)
)
#define DEFINE_READPAGE_EVENT(name) \
DEFINE_EVENT(xfs_readpage_class, name, \
TP_PROTO(struct inode *inode, int nr_pages), \
TP_ARGS(inode, nr_pages))
DEFINE_READPAGE_EVENT(xfs_vm_readpage);
DEFINE_READPAGE_EVENT(xfs_vm_readpages);
DECLARE_EVENT_CLASS(xfs_imap_class, DECLARE_EVENT_CLASS(xfs_imap_class,
TP_PROTO(struct xfs_inode *ip, xfs_off_t offset, ssize_t count, TP_PROTO(struct xfs_inode *ip, xfs_off_t offset, ssize_t count,
int type, struct xfs_bmbt_irec *irec), int type, struct xfs_bmbt_irec *irec),