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

18 files changed, 159 insertions, 234 deletions

diff --git a/fs/xfs/libxfs/xfs_attr.c b/fs/xfs/libxfs/xfs_attr.c
index f949818fa1c7..fa3b948ef9c2 100644
--- a/fs/xfs/libxfs/xfs_attr.c
+++ b/fs/xfs/libxfs/xfs_attr.c
@@ -207,7 +207,7 @@ xfs_attr_set(
         struct xfs_trans_res    tres;
         xfs_fsblock_t           firstblock;
         int                     rsvd = (flags & ATTR_ROOT) != 0;
-        int                     error, err2, committed, local;
+        int                     error, err2, local;
 
         XFS_STATS_INC(mp, xs_attr_set);
 
@@ -334,25 +334,15 @@ xfs_attr_set(
                  */
                 xfs_bmap_init(args.flist, args.firstblock);
                 error = xfs_attr_shortform_to_leaf(&args);
-                if (!error) {
-                        error = xfs_bmap_finish(&args.trans, args.flist,
-                                                &committed);
-                }
+                if (!error)
+                        error = xfs_bmap_finish(&args.trans, args.flist, dp);
                 if (error) {
-                        ASSERT(committed);
                         args.trans = NULL;
                         xfs_bmap_cancel(&flist);
                         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)
                  * 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;
         struct xfs_buf *bp;
-        int retval, error, committed, forkoff;
+        int retval, error, forkoff;
 
         trace_xfs_attr_leaf_addname(args);
 
@@ -628,25 +618,15 @@ xfs_attr_leaf_addname(xfs_da_args_t *args)
                  */
                 xfs_bmap_init(args->flist, args->firstblock);
                 error = xfs_attr3_leaf_to_node(args);
-                if (!error) {
-                        error = xfs_bmap_finish(&args->trans, args->flist,
-                                                &committed);
-                }
+                if (!error)
+                        error = xfs_bmap_finish(&args->trans, args->flist, dp);
                 if (error) {
-                        ASSERT(committed);
                         args->trans = NULL;
                         xfs_bmap_cancel(args->flist);
                         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
                  * a new one.
                  */
@@ -729,25 +709,14 @@ xfs_attr_leaf_addname(xfs_da_args_t *args)
                         xfs_bmap_init(args->flist, args->firstblock);
                         error = xfs_attr3_leaf_to_shortform(bp, args, forkoff);
                         /* bp is gone due to xfs_da_shrink_inode */
-                        if (!error) {
+                        if (!error)
                                 error = xfs_bmap_finish(&args->trans,
-                                                        args->flist,
-                                                        &committed);
-                        }
+                                                        args->flist, dp);
                         if (error) {
-                                ASSERT(committed);
                                 args->trans = NULL;
                                 xfs_bmap_cancel(args->flist);
                                 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;
         struct xfs_buf *bp;
-        int error, committed, forkoff;
+        int error, forkoff;
 
         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);
                 error = xfs_attr3_leaf_to_shortform(bp, args, forkoff);
                 /* bp is gone due to xfs_da_shrink_inode */
-                if (!error) {
-                        error = xfs_bmap_finish(&args->trans, args->flist,
-                                                &committed);
-                }
+                if (!error)
+                        error = xfs_bmap_finish(&args->trans, args->flist, dp);
                 if (error) {
-                        ASSERT(committed);
                         args->trans = NULL;
                         xfs_bmap_cancel(args->flist);
                         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;
 }
@@ -877,7 +836,7 @@ xfs_attr_node_addname(xfs_da_args_t *args)
         xfs_da_state_blk_t *blk;
         xfs_inode_t *dp;
         xfs_mount_t *mp;
-        int committed, retval, error;
+        int retval, error;
 
         trace_xfs_attr_node_addname(args);
 
@@ -938,27 +897,16 @@ restart:
                         state = NULL;
                         xfs_bmap_init(args->flist, args->firstblock);
                         error = xfs_attr3_leaf_to_node(args);
-                        if (!error) {
+                        if (!error)
                                 error = xfs_bmap_finish(&args->trans,
-                                                        args->flist,
-                                                        &committed);
-                        }
+                                                        args->flist, dp);
                         if (error) {
-                                ASSERT(committed);
                                 args->trans = NULL;
                                 xfs_bmap_cancel(args->flist);
                                 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
                          * trans in the chain.
                          */
@@ -977,23 +925,13 @@ restart:
                  */
                 xfs_bmap_init(args->flist, args->firstblock);
                 error = xfs_da3_split(state);
-                if (!error) {
-                        error = xfs_bmap_finish(&args->trans, args->flist,
-                                                &committed);
-                }
+                if (!error)
+                        error = xfs_bmap_finish(&args->trans, args->flist, dp);
                 if (error) {
-                        ASSERT(committed);
                         args->trans = NULL;
                         xfs_bmap_cancel(args->flist);
                         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 {
                 /*
                  * Addition succeeded, update Btree hashvals.
@@ -1086,25 +1024,14 @@ restart:
                 if (retval && (state->path.active > 1)) {
                         xfs_bmap_init(args->flist, args->firstblock);
                         error = xfs_da3_join(state);
-                        if (!error) {
+                        if (!error)
                                 error = xfs_bmap_finish(&args->trans,
-                                                        args->flist,
-                                                        &committed);
-                        }
+                                                        args->flist, dp);
                         if (error) {
-                                ASSERT(committed);
                                 args->trans = NULL;
                                 xfs_bmap_cancel(args->flist);
                                 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_inode_t *dp;
         struct xfs_buf *bp;
-        int retval, error, committed, forkoff;
+        int retval, error, forkoff;
 
         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)) {
                 xfs_bmap_init(args->flist, args->firstblock);
                 error = xfs_da3_join(state);
-                if (!error) {
-                        error = xfs_bmap_finish(&args->trans, args->flist,
-                                                &committed);
-                }
+                if (!error)
+                        error = xfs_bmap_finish(&args->trans, args->flist, dp);
                 if (error) {
-                        ASSERT(committed);
                         args->trans = NULL;
                         xfs_bmap_cancel(args->flist);
                         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.
                  */
@@ -1265,25 +1181,14 @@ xfs_attr_node_removename(xfs_da_args_t *args)
                         xfs_bmap_init(args->flist, args->firstblock);
                         error = xfs_attr3_leaf_to_shortform(bp, args, forkoff);
                         /* bp is gone due to xfs_da_shrink_inode */
-                        if (!error) {
+                        if (!error)
                                 error = xfs_bmap_finish(&args->trans,
-                                                        args->flist,
-                                                        &committed);
-                        }
+                                                        args->flist, dp);
                         if (error) {
-                                ASSERT(committed);
                                 args->trans = NULL;
                                 xfs_bmap_cancel(args->flist);
                                 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
                         xfs_trans_brelse(args->trans, bp);
         }
diff --git a/fs/xfs/libxfs/xfs_attr_remote.c b/fs/xfs/libxfs/xfs_attr_remote.c
index f3ed9bf0b065..a572532a55cd 100644
--- a/fs/xfs/libxfs/xfs_attr_remote.c
+++ b/fs/xfs/libxfs/xfs_attr_remote.c
@@ -448,8 +448,6 @@ xfs_attr_rmtval_set(
          * Roll through the "value", allocating blocks on disk as required.
          */
         while (blkcnt > 0) {
-                int     committed;
-
                 /*
                  * 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,
                                   blkcnt, XFS_BMAPI_ATTRFORK, args->firstblock,
                                   args->total, &map, &nmap, args->flist);
-                if (!error) {
-                        error = xfs_bmap_finish(&args->trans, args->flist,
-                                                &committed);
-                }
+                if (!error)
+                        error = xfs_bmap_finish(&args->trans, args->flist, dp);
                 if (error) {
-                        ASSERT(committed);
                         args->trans = NULL;
                         xfs_bmap_cancel(args->flist);
                         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((map.br_startblock != DELAYSTARTBLOCK) &&
                        (map.br_startblock != HOLESTARTBLOCK));
@@ -615,31 +603,20 @@ xfs_attr_rmtval_remove(
         blkcnt = args->rmtblkcnt;
         done = 0;
         while (!done) {
-                int committed;
-
                 xfs_bmap_init(args->flist, args->firstblock);
                 error = xfs_bunmapi(args->trans, args->dp, lblkno, blkcnt,
                                     XFS_BMAPI_ATTRFORK, 1, args->firstblock,
                                     args->flist, &done);
-                if (!error) {
+                if (!error)
                         error = xfs_bmap_finish(&args->trans, args->flist,
-                                                &committed);
-                }
+                                                args->dp);
                 if (error) {
-                        ASSERT(committed);
                         args->trans = NULL;
                         xfs_bmap_cancel(args->flist);
                         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.
                  */
                 error = xfs_trans_roll(&args->trans, args->dp);
diff --git a/fs/xfs/libxfs/xfs_bmap.c b/fs/xfs/libxfs/xfs_bmap.c
index 73884953b21c..ef00156f4f96 100644
--- a/fs/xfs/libxfs/xfs_bmap.c
+++ b/fs/xfs/libxfs/xfs_bmap.c
@@ -325,9 +325,11 @@ xfs_check_block(
 
 /*
  * 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
 xfs_bmap_check_leaf_extents(
         xfs_btree_cur_t         *cur,   /* btree cursor or null */
@@ -352,6 +354,10 @@ xfs_bmap_check_leaf_extents(
                 return;
         }
 
+        /* skip large extent count inodes */
+        if (ip->i_d.di_nextents > 10000)
+                return;
+
         bno = NULLFSBLOCK;
         mp = ip->i_mount;
         ifp = XFS_IFORK_PTR(ip, whichfork);
@@ -1111,7 +1117,6 @@ xfs_bmap_add_attrfork(
         xfs_trans_t             *tp;            /* transaction pointer */
         int                     blks;           /* space reservation */
         int                     version = 1;    /* superblock attr version */
-        int                     committed;      /* xaction was committed */
         int                     logflags;       /* logging flags */
         int                     error;          /* error return value */
 
@@ -1214,7 +1219,7 @@ xfs_bmap_add_attrfork(
                         xfs_log_sb(tp);
         }
 
-        error = xfs_bmap_finish(&tp, &flist, &committed);
+        error = xfs_bmap_finish(&tp, &flist, NULL);
         if (error)
                 goto bmap_cancel;
         error = xfs_trans_commit(tp);
@@ -5951,7 +5956,6 @@ xfs_bmap_split_extent(
         struct xfs_trans        *tp;
         struct xfs_bmap_free    free_list;
         xfs_fsblock_t           firstfsb;
-        int                     committed;
         int                     error;
 
         tp = xfs_trans_alloc(mp, XFS_TRANS_DIOSTRAT);
@@ -5972,7 +5976,7 @@ xfs_bmap_split_extent(
         if (error)
                 goto out;
 
-        error = xfs_bmap_finish(&tp, &free_list, &committed);
+        error = xfs_bmap_finish(&tp, &free_list, NULL);
         if (error)
                 goto out;
 
diff --git a/fs/xfs/libxfs/xfs_bmap.h b/fs/xfs/libxfs/xfs_bmap.h
index a160f8a5a3fc..423a34e832bd 100644
--- a/fs/xfs/libxfs/xfs_bmap.h
+++ b/fs/xfs/libxfs/xfs_bmap.h
@@ -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);
 void    xfs_bmap_cancel(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);
 int     xfs_bmap_first_unused(struct xfs_trans *tp, struct xfs_inode *ip,
                 xfs_extlen_t len, xfs_fileoff_t *unused, int whichfork);
diff --git a/fs/xfs/libxfs/xfs_dquot_buf.c b/fs/xfs/libxfs/xfs_dquot_buf.c
index 11cefb2a372a..3cc3cf767474 100644
--- a/fs/xfs/libxfs/xfs_dquot_buf.c
+++ b/fs/xfs/libxfs/xfs_dquot_buf.c
@@ -54,7 +54,7 @@ xfs_dqcheck(
         xfs_dqid_t       id,
         uint             type,    /* used only when IO_dorepair is true */
         uint             flags,
-        char             *str)
+        const char       *str)
 {
         xfs_dqblk_t      *d = (xfs_dqblk_t *)ddq;
         int             errs = 0;
@@ -207,7 +207,8 @@ xfs_dquot_buf_verify_crc(
 STATIC bool
 xfs_dquot_buf_verify(
         struct xfs_mount        *mp,
-        struct xfs_buf          *bp)
+        struct xfs_buf          *bp,
+        int                     warn)
 {
         struct xfs_dqblk        *d = (struct xfs_dqblk *)bp->b_addr;
         xfs_dqid_t              id = 0;
@@ -240,8 +241,7 @@ xfs_dquot_buf_verify(
                 if (i == 0)
                         id = be32_to_cpu(ddq->d_id);
 
-                error = xfs_dqcheck(mp, ddq, id + i, 0, XFS_QMOPT_DOWARN,
-                                       "xfs_dquot_buf_verify");
+                error = xfs_dqcheck(mp, ddq, id + i, 0, warn, __func__);
                 if (error)
                         return false;
         }
@@ -256,7 +256,7 @@ xfs_dquot_buf_read_verify(
 
         if (!xfs_dquot_buf_verify_crc(mp, bp))
                 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);
 
         if (bp->b_error)
@@ -264,6 +264,25 @@ xfs_dquot_buf_read_verify(
 }
 
 /*
+ * 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
  * the buffer after the update is done. This ensures that the dquot in the
  * buffer always has an up-to-date CRC value.
@@ -274,7 +293,7 @@ xfs_dquot_buf_write_verify(
 {
         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_verifier_error(bp);
                 return;
@@ -287,3 +306,8 @@ const struct xfs_buf_ops xfs_dquot_buf_ops = {
         .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,
+};
diff --git a/fs/xfs/libxfs/xfs_inode_buf.c b/fs/xfs/libxfs/xfs_inode_buf.c
index 1b8d98a915c4..1aabfda669b0 100644
--- a/fs/xfs/libxfs/xfs_inode_buf.c
+++ b/fs/xfs/libxfs/xfs_inode_buf.c
@@ -62,11 +62,14 @@ xfs_inobp_check(
  * has not had the inode cores stamped into it. Hence for readahead, the buffer
  * may be potentially invalid.
  *
- * If the readahead buffer is invalid, we don't want to mark it with an error,
- * but we do want to clear the DONE status of the buffer so that a followup read
- * will re-read it from disk. This will ensure that we don't get an unnecessary
- * warnings during log recovery and we don't get unnecssary panics on debug
- * kernels.
+ * If the readahead buffer is invalid, we need to mark it with an error and
+ * clear the DONE status of the buffer so that a followup read will re-read it
+ * from disk. We don't report the error otherwise to avoid warnings during log
+ * recovery and we don't get unnecssary panics on debug kernels. We use EIO here
+ * 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
 xfs_inode_buf_verify(
@@ -93,6 +96,7 @@ xfs_inode_buf_verify(
                                                 XFS_RANDOM_ITOBP_INOTOBP))) {
                         if (readahead) {
                                 bp->b_flags &= ~XBF_DONE;
+                                xfs_buf_ioerror(bp, -EIO);
                                 return;
                         }
 
diff --git a/fs/xfs/libxfs/xfs_quota_defs.h b/fs/xfs/libxfs/xfs_quota_defs.h
index 1b0a08379759..f51078f1e92a 100644
--- a/fs/xfs/libxfs/xfs_quota_defs.h
+++ b/fs/xfs/libxfs/xfs_quota_defs.h
@@ -153,7 +153,7 @@ typedef __uint16_t	xfs_qwarncnt_t;
 #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,
-                       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);
 
 #endif  /* __XFS_QUOTA_H__ */
diff --git a/fs/xfs/libxfs/xfs_shared.h b/fs/xfs/libxfs/xfs_shared.h
index 5be529707903..15c3ceb845b9 100644
--- a/fs/xfs/libxfs/xfs_shared.h
+++ b/fs/xfs/libxfs/xfs_shared.h
@@ -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_ra_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_quiet_buf_ops;
 extern const struct xfs_buf_ops xfs_symlink_buf_ops;
diff --git a/fs/xfs/xfs_aops.c b/fs/xfs/xfs_aops.c
index 29e7e5dd5178..379c089fb051 100644
--- a/fs/xfs/xfs_aops.c
+++ b/fs/xfs/xfs_aops.c
@@ -1917,6 +1917,7 @@ xfs_vm_readpage(
         struct file             *unused,
         struct page             *page)
 {
+        trace_xfs_vm_readpage(page->mapping->host, 1);
         return mpage_readpage(page, xfs_get_blocks);
 }
 
@@ -1927,6 +1928,7 @@ xfs_vm_readpages(
         struct list_head        *pages,
         unsigned                nr_pages)
 {
+        trace_xfs_vm_readpages(mapping->host, nr_pages);
         return mpage_readpages(mapping, pages, nr_pages, xfs_get_blocks);
 }
 
diff --git a/fs/xfs/xfs_bmap_util.c b/fs/xfs/xfs_bmap_util.c
index dbae6490a79a..45ec9e40150c 100644
--- a/fs/xfs/xfs_bmap_util.c
+++ b/fs/xfs/xfs_bmap_util.c
@@ -91,32 +91,32 @@ xfs_zero_extent(
  * last due to locking considerations.  We never free any extents in
  * the first transaction.
  *
- * Return 1 if the given transaction was committed and a new one
- * started, and 0 otherwise in the committed parameter.
+ * If an inode *ip is provided, rejoin it to the transaction if
+ * the transaction was committed.
  */
 int                                             /* error */
 xfs_bmap_finish(
         struct xfs_trans                **tp,   /* transaction pointer addr */
         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_efi_log_item         *efi;   /* extent free intention */
         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       *next;  /* next item on free list */
 
         ASSERT((*tp)->t_flags & XFS_TRANS_PERM_LOG_RES);
-        if (flist->xbf_count == 0) {
-                *committed = 0;
+        if (flist->xbf_count == 0)
                 return 0;
-        }
+
         efi = xfs_trans_get_efi(*tp, flist->xbf_count);
         for (free = flist->xbf_first; free; free = free->xbfi_next)
                 xfs_trans_log_efi_extent(*tp, efi, free->xbfi_startblock,
                         free->xbfi_blockcount);
 
-        error = __xfs_trans_roll(tp, NULL, committed);
+        error = __xfs_trans_roll(tp, ip, &committed);
         if (error) {
                 /*
                  * 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
                  * returning an error.
                  */
-                if (*committed) {
+                if (committed) {
                         xfs_efi_release(efi);
                         xfs_force_shutdown((*tp)->t_mountp,
                                 (error == -EFSCORRUPTED) ?
                                         SHUTDOWN_CORRUPT_INCORE :
                                         SHUTDOWN_META_IO_ERROR);
-                } else {
-                        *committed = 1;
                 }
-
                 return error;
         }
 
@@ -969,7 +966,6 @@ xfs_alloc_file_space(
         xfs_bmbt_irec_t         imaps[1], *imapp;
         xfs_bmap_free_t         free_list;
         uint                    qblocks, resblks, resrtextents;
-        int                     committed;
         int                     error;
 
         trace_xfs_alloc_file_space(ip);
@@ -1064,23 +1060,20 @@ xfs_alloc_file_space(
                 error = xfs_bmapi_write(tp, ip, startoffset_fsb,
                                         allocatesize_fsb, alloc_type, &firstfsb,
                                         resblks, imapp, &nimaps, &free_list);
-                if (error) {
+                if (error)
                         goto error0;
-                }
 
                 /*
                  * Complete the transaction
                  */
-                error = xfs_bmap_finish(&tp, &free_list, &committed);
-                if (error) {
+                error = xfs_bmap_finish(&tp, &free_list, NULL);
+                if (error)
                         goto error0;
-                }
 
                 error = xfs_trans_commit(tp);
                 xfs_iunlock(ip, XFS_ILOCK_EXCL);
-                if (error) {
+                if (error)
                         break;
-                }
 
                 allocated_fsb = imapp->br_blockcount;
 
@@ -1206,7 +1199,6 @@ xfs_free_file_space(
         xfs_off_t               offset,
         xfs_off_t               len)
 {
-        int                     committed;
         int                     done;
         xfs_fileoff_t           endoffset_fsb;
         int                     error;
@@ -1346,17 +1338,15 @@ xfs_free_file_space(
                 error = xfs_bunmapi(tp, ip, startoffset_fsb,
                                   endoffset_fsb - startoffset_fsb,
                                   0, 2, &firstfsb, &free_list, &done);
-                if (error) {
+                if (error)
                         goto error0;
-                }
 
                 /*
                  * complete the transaction
                  */
-                error = xfs_bmap_finish(&tp, &free_list, &committed);
-                if (error) {
+                error = xfs_bmap_finish(&tp, &free_list, NULL);
+                if (error)
                         goto error0;
-                }
 
                 error = xfs_trans_commit(tp);
                 xfs_iunlock(ip, XFS_ILOCK_EXCL);
@@ -1434,7 +1424,6 @@ xfs_shift_file_space(
         int                     error;
         struct xfs_bmap_free    free_list;
         xfs_fsblock_t           first_block;
-        int                     committed;
         xfs_fileoff_t           stop_fsb;
         xfs_fileoff_t           next_fsb;
         xfs_fileoff_t           shift_fsb;
@@ -1526,7 +1515,7 @@ xfs_shift_file_space(
                 if (error)
                         goto out_bmap_cancel;
 
-                error = xfs_bmap_finish(&tp, &free_list, &committed);
+                error = xfs_bmap_finish(&tp, &free_list, NULL);
                 if (error)
                         goto out_bmap_cancel;
 
diff --git a/fs/xfs/xfs_buf.c b/fs/xfs/xfs_buf.c
index 45a8ea7cfdb2..ae86b16f9025 100644
--- a/fs/xfs/xfs_buf.c
+++ b/fs/xfs/xfs_buf.c
@@ -604,6 +604,13 @@ found:
                 }
         }
 
+        /*
+         * 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);
         trace_xfs_buf_get(bp, flags, _RET_IP_);
         return bp;
diff --git a/fs/xfs/xfs_dquot.c b/fs/xfs/xfs_dquot.c
index 7ac6c5c586cb..9c44d38dcd1f 100644
--- a/fs/xfs/xfs_dquot.c
+++ b/fs/xfs/xfs_dquot.c
@@ -306,7 +306,7 @@ xfs_qm_dqalloc(
         xfs_fsblock_t   firstblock;
         xfs_bmap_free_t flist;
         xfs_bmbt_irec_t map;
-        int             nmaps, error, committed;
+        int             nmaps, error;
         xfs_buf_t       *bp;
         xfs_trans_t     *tp = *tpp;
 
@@ -379,11 +379,12 @@ xfs_qm_dqalloc(
 
         xfs_trans_bhold(tp, bp);
 
-        if ((error = xfs_bmap_finish(tpp, &flist, &committed))) {
+        error = xfs_bmap_finish(tpp, &flist, NULL);
+        if (error)
                 goto error1;
-        }
 
-        if (committed) {
+        /* Transaction was committed? */
+        if (*tpp != tp) {
                 tp = *tpp;
                 xfs_trans_bjoin(tp, bp);
         } else {
@@ -393,9 +394,9 @@ xfs_qm_dqalloc(
         *O_bpp = bp;
         return 0;
 
-      error1:
+error1:
         xfs_bmap_cancel(&flist);
-      error0:
+error0:
         xfs_iunlock(quotip, XFS_ILOCK_EXCL);
 
         return error;
diff --git a/fs/xfs/xfs_inode.c b/fs/xfs/xfs_inode.c
index 8ee393996b7d..ae3758a90ed6 100644
--- a/fs/xfs/xfs_inode.c
+++ b/fs/xfs/xfs_inode.c
@@ -1143,7 +1143,6 @@ xfs_create(
         xfs_bmap_free_t         free_list;
         xfs_fsblock_t           first_block;
         bool                    unlock_dp_on_error = false;
-        int                     committed;
         prid_t                  prid;
         struct xfs_dquot        *udqp = NULL;
         struct xfs_dquot        *gdqp = NULL;
@@ -1226,7 +1225,7 @@ xfs_create(
          * pointing to itself.
          */
         error = xfs_dir_ialloc(&tp, dp, mode, is_dir ? 2 : 1, rdev,
-                               prid, resblks > 0, &ip, &committed);
+                               prid, resblks > 0, &ip, NULL);
         if (error)
                 goto out_trans_cancel;
 
@@ -1275,7 +1274,7 @@ xfs_create(
          */
         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)
                 goto out_bmap_cancel;
 
@@ -1427,7 +1426,6 @@ xfs_link(
         int                     error;
         xfs_bmap_free_t         free_list;
         xfs_fsblock_t           first_block;
-        int                     committed;
         int                     resblks;
 
         trace_xfs_link(tdp, target_name);
@@ -1502,11 +1500,10 @@ xfs_link(
          * link transaction goes to disk before returning to
          * 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);
-        }
 
-        error = xfs_bmap_finish (&tp, &free_list, &committed);
+        error = xfs_bmap_finish(&tp, &free_list, NULL);
         if (error) {
                 xfs_bmap_cancel(&free_list);
                 goto error_return;
@@ -1555,7 +1552,6 @@ xfs_itruncate_extents(
         xfs_fileoff_t           first_unmap_block;
         xfs_fileoff_t           last_block;
         xfs_filblks_t           unmap_len;
-        int                     committed;
         int                     error = 0;
         int                     done = 0;
 
@@ -1601,9 +1597,7 @@ xfs_itruncate_extents(
                  * Duplicate the transaction that has the permanent
                  * reservation and commit the old transaction.
                  */
-                error = xfs_bmap_finish(&tp, &free_list, &committed);
-                if (committed)
-                        xfs_trans_ijoin(tp, ip, 0);
+                error = xfs_bmap_finish(&tp, &free_list, ip);
                 if (error)
                         goto out_bmap_cancel;
 
@@ -1774,7 +1768,6 @@ xfs_inactive_ifree(
 {
         xfs_bmap_free_t         free_list;
         xfs_fsblock_t           first_block;
-        int                     committed;
         struct xfs_mount        *mp = ip->i_mount;
         struct xfs_trans        *tp;
         int                     error;
@@ -1841,7 +1834,7 @@ xfs_inactive_ifree(
          * 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.
          */
-        error = xfs_bmap_finish(&tp,  &free_list, &committed);
+        error = xfs_bmap_finish(&tp, &free_list, NULL);
         if (error) {
                 xfs_notice(mp, "%s: xfs_bmap_finish returned error %d",
                         __func__, error);
@@ -2523,7 +2516,6 @@ xfs_remove(
         int                     error = 0;
         xfs_bmap_free_t         free_list;
         xfs_fsblock_t           first_block;
-        int                     committed;
         uint                    resblks;
 
         trace_xfs_remove(dp, name);
@@ -2624,7 +2616,7 @@ xfs_remove(
         if (mp->m_flags & (XFS_MOUNT_WSYNC|XFS_MOUNT_DIRSYNC))
                 xfs_trans_set_sync(tp);
 
-        error = xfs_bmap_finish(&tp, &free_list, &committed);
+        error = xfs_bmap_finish(&tp, &free_list, NULL);
         if (error)
                 goto out_bmap_cancel;
 
@@ -2701,7 +2693,6 @@ xfs_finish_rename(
         struct xfs_trans        *tp,
         struct xfs_bmap_free    *free_list)
 {
-        int                     committed = 0;
         int                     error;
 
         /*
@@ -2711,7 +2702,7 @@ xfs_finish_rename(
         if (tp->t_mountp->m_flags & (XFS_MOUNT_WSYNC|XFS_MOUNT_DIRSYNC))
                 xfs_trans_set_sync(tp);
 
-        error = xfs_bmap_finish(&tp, free_list, &committed);
+        error = xfs_bmap_finish(&tp, free_list, NULL);
         if (error) {
                 xfs_bmap_cancel(free_list);
                 xfs_trans_cancel(tp);
diff --git a/fs/xfs/xfs_iomap.c b/fs/xfs/xfs_iomap.c
index 9ed146b96856..d81bdc080370 100644
--- a/fs/xfs/xfs_iomap.c
+++ b/fs/xfs/xfs_iomap.c
@@ -129,7 +129,6 @@ xfs_iomap_write_direct(
         xfs_trans_t     *tp;
         xfs_bmap_free_t free_list;
         uint            qblocks, resblks, resrtextents;
-        int             committed;
         int             error;
         int             lockmode;
         int             bmapi_flags = XFS_BMAPI_PREALLOC;
@@ -252,7 +251,7 @@ xfs_iomap_write_direct(
         /*
          * Complete the transaction
          */
-        error = xfs_bmap_finish(&tp, &free_list, &committed);
+        error = xfs_bmap_finish(&tp, &free_list, NULL);
         if (error)
                 goto out_bmap_cancel;
 
@@ -698,7 +697,7 @@ xfs_iomap_write_allocate(
         xfs_bmap_free_t free_list;
         xfs_filblks_t   count_fsb;
         xfs_trans_t     *tp;
-        int             nimaps, committed;
+        int             nimaps;
         int             error = 0;
         int             nres;
 
@@ -799,7 +798,7 @@ xfs_iomap_write_allocate(
                         if (error)
                                 goto trans_cancel;
 
-                        error = xfs_bmap_finish(&tp, &free_list, &committed);
+                        error = xfs_bmap_finish(&tp, &free_list, NULL);
                         if (error)
                                 goto trans_cancel;
 
@@ -857,7 +856,6 @@ xfs_iomap_write_unwritten(
         xfs_bmap_free_t free_list;
         xfs_fsize_t     i_size;
         uint            resblks;
-        int             committed;
         int             error;
 
         trace_xfs_unwritten_convert(ip, offset, count);
@@ -929,7 +927,7 @@ xfs_iomap_write_unwritten(
                         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)
                         goto error_on_bmapi_transaction;
 
diff --git a/fs/xfs/xfs_log_recover.c b/fs/xfs/xfs_log_recover.c
index 26e67b4450cc..da37beb76f6e 100644
--- a/fs/xfs/xfs_log_recover.c
+++ b/fs/xfs/xfs_log_recover.c
@@ -3521,6 +3521,7 @@ xlog_recover_dquot_ra_pass2(
         struct xfs_disk_dquot   *recddq;
         struct xfs_dq_logformat *dq_f;
         uint                    type;
+        int                     len;
 
 
         if (mp->m_qflags == 0)
@@ -3541,8 +3542,12 @@ xlog_recover_dquot_ra_pass2(
         ASSERT(dq_f);
         ASSERT(dq_f->qlf_len == 1);
 
-        xfs_buf_readahead(mp->m_ddev_targp, dq_f->qlf_blkno,
-                          XFS_FSB_TO_BB(mp, dq_f->qlf_len), NULL);
+        len = XFS_FSB_TO_BB(mp, dq_f->qlf_len);
+        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
diff --git a/fs/xfs/xfs_rtalloc.c b/fs/xfs/xfs_rtalloc.c
index ab1bac6a3a1c..be02a68b2fe2 100644
--- a/fs/xfs/xfs_rtalloc.c
+++ b/fs/xfs/xfs_rtalloc.c
@@ -766,7 +766,6 @@ xfs_growfs_rt_alloc(
 {
         xfs_fileoff_t           bno;            /* block number in file */
         struct xfs_buf          *bp;    /* temporary buffer for zeroing */
-        int                     committed;      /* transaction committed flag */
         xfs_daddr_t             d;              /* disk block address */
         int                     error;          /* error return value */
         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.
                  */
-                error = xfs_bmap_finish(&tp, &flist, &committed);
+                error = xfs_bmap_finish(&tp, &flist, NULL);
                 if (error)
                         goto out_bmap_cancel;
                 error = xfs_trans_commit(tp);
diff --git a/fs/xfs/xfs_symlink.c b/fs/xfs/xfs_symlink.c
index 996481eeb491..b44284c1adda 100644
--- a/fs/xfs/xfs_symlink.c
+++ b/fs/xfs/xfs_symlink.c
@@ -178,7 +178,6 @@ xfs_symlink(
         struct xfs_bmap_free    free_list;
         xfs_fsblock_t           first_block;
         bool                    unlock_dp_on_error = false;
-        int                     committed;
         xfs_fileoff_t           first_fsb;
         xfs_filblks_t           fs_blocks;
         int                     nmaps;
@@ -387,7 +386,7 @@ xfs_symlink(
                 xfs_trans_set_sync(tp);
         }
 
-        error = xfs_bmap_finish(&tp, &free_list, &committed);
+        error = xfs_bmap_finish(&tp, &free_list, NULL);
         if (error)
                 goto out_bmap_cancel;
 
@@ -434,7 +433,6 @@ xfs_inactive_symlink_rmt(
         struct xfs_inode *ip)
 {
         xfs_buf_t       *bp;
-        int             committed;
         int             done;
         int             error;
         xfs_fsblock_t   first_block;
@@ -510,16 +508,10 @@ xfs_inactive_symlink_rmt(
         /*
          * 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)
                 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.
          * Mark it dirty so it will be logged and moved forward in the log as
          * part of every commit.
diff --git a/fs/xfs/xfs_trace.h b/fs/xfs/xfs_trace.h
index 877079eb0f8f..391d797cb53f 100644
--- a/fs/xfs/xfs_trace.h
+++ b/fs/xfs/xfs_trace.h
@@ -1222,6 +1222,32 @@ DEFINE_PAGE_EVENT(xfs_writepage);
 DEFINE_PAGE_EVENT(xfs_releasepage);
 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,
         TP_PROTO(struct xfs_inode *ip, xfs_off_t offset, ssize_t count,
                  int type, struct xfs_bmbt_irec *irec),