12 files changed, 217 insertions, 202 deletions

diff --git a/fs/xfs/linux-2.6/xfs_vnode.h b/fs/xfs/linux-2.6/xfs_vnode.h
index ea4675c48209..ad7fbead4c97 100644
--- a/fs/xfs/linux-2.6/xfs_vnode.h
+++ b/fs/xfs/linux-2.6/xfs_vnode.h
@@ -50,33 +50,6 @@ struct attrlist_cursor_kern;
                                            the operation completes. */
 
 /*
- * Dealing with bad inodes
- */
-static inline int VN_BAD(struct inode *vp)
-{
-        return is_bad_inode(vp);
-}
-
-/*
- * Extracting atime values in various formats
- */
-static inline void vn_atime_to_bstime(struct inode *vp, xfs_bstime_t *bs_atime)
-{
-        bs_atime->tv_sec = vp->i_atime.tv_sec;
-        bs_atime->tv_nsec = vp->i_atime.tv_nsec;
-}
-
-static inline void vn_atime_to_timespec(struct inode *vp, struct timespec *ts)
-{
-        *ts = vp->i_atime;
-}
-
-static inline void vn_atime_to_time_t(struct inode *vp, time_t *tt)
-{
-        *tt = vp->i_atime.tv_sec;
-}
-
-/*
  * Some useful predicates.
  */
 #define VN_MAPPED(vp)   mapping_mapped(vp->i_mapping)
diff --git a/fs/xfs/xfs_alloc.c b/fs/xfs/xfs_alloc.c
index 028e44e58ea9..2cf944eb796d 100644
--- a/fs/xfs/xfs_alloc.c
+++ b/fs/xfs/xfs_alloc.c
@@ -1872,6 +1872,25 @@ xfs_alloc_compute_maxlevels(
 }
 
 /*
+ * Find the length of the longest extent in an AG.
+ */
+xfs_extlen_t
+xfs_alloc_longest_free_extent(
+        struct xfs_mount        *mp,
+        struct xfs_perag        *pag)
+{
+        xfs_extlen_t            need, delta = 0;
+
+        need = XFS_MIN_FREELIST_PAG(pag, mp);
+        if (need > pag->pagf_flcount)
+                delta = need - pag->pagf_flcount;
+
+        if (pag->pagf_longest > delta)
+                return pag->pagf_longest - delta;
+        return pag->pagf_flcount > 0 || pag->pagf_longest > 0;
+}
+
+/*
  * Decide whether to use this allocation group for this allocation.
  * If so, fix up the btree freelist's size.
  */
@@ -1923,15 +1942,12 @@ xfs_alloc_fix_freelist(
         }
 
         if (!(flags & XFS_ALLOC_FLAG_FREEING)) {
-                need = XFS_MIN_FREELIST_PAG(pag, mp);
-                delta = need > pag->pagf_flcount ? need - pag->pagf_flcount : 0;
                 /*
                  * If it looks like there isn't a long enough extent, or enough
                  * total blocks, reject it.
                  */
-                longest = (pag->pagf_longest > delta) ?
-                        (pag->pagf_longest - delta) :
-                        (pag->pagf_flcount > 0 || pag->pagf_longest > 0);
+                need = XFS_MIN_FREELIST_PAG(pag, mp);
+                longest = xfs_alloc_longest_free_extent(mp, pag);
                 if ((args->minlen + args->alignment + args->minalignslop - 1) >
                                 longest ||
                     ((int)(pag->pagf_freeblks + pag->pagf_flcount -
diff --git a/fs/xfs/xfs_alloc.h b/fs/xfs/xfs_alloc.h
index 588172796f7b..e704caee10df 100644
--- a/fs/xfs/xfs_alloc.h
+++ b/fs/xfs/xfs_alloc.h
@@ -100,6 +100,12 @@ typedef struct xfs_alloc_arg {
 #define XFS_ALLOC_USERDATA              1       /* allocation is for user data*/
 #define XFS_ALLOC_INITIAL_USER_DATA     2       /* special case start of file */
 
+/*
+ * Find the length of the longest extent in an AG.
+ */
+xfs_extlen_t
+xfs_alloc_longest_free_extent(struct xfs_mount *mp,
+                struct xfs_perag *pag);
 
 #ifdef __KERNEL__
 
diff --git a/fs/xfs/xfs_bmap.c b/fs/xfs/xfs_bmap.c
index 27062d0a879d..07b7d0d59d88 100644
--- a/fs/xfs/xfs_bmap.c
+++ b/fs/xfs/xfs_bmap.c
@@ -2712,9 +2712,6 @@ xfs_bmap_btalloc(
         xfs_agnumber_t  startag;
         xfs_alloc_arg_t args;
         xfs_extlen_t    blen;
-        xfs_extlen_t    delta;
-        xfs_extlen_t    longest;
-        xfs_extlen_t    need;
         xfs_extlen_t    nextminlen = 0;
         xfs_perag_t     *pag;
         int             nullfb;         /* true if ap->firstblock isn't set */
@@ -2796,13 +2793,8 @@ xfs_bmap_btalloc(
                          * See xfs_alloc_fix_freelist...
                          */
                         if (pag->pagf_init) {
-                                need = XFS_MIN_FREELIST_PAG(pag, mp);
-                                delta = need > pag->pagf_flcount ?
-                                        need - pag->pagf_flcount : 0;
-                                longest = (pag->pagf_longest > delta) ?
-                                        (pag->pagf_longest - delta) :
-                                        (pag->pagf_flcount > 0 ||
-                                         pag->pagf_longest > 0);
+                                xfs_extlen_t    longest;
+                                longest = xfs_alloc_longest_free_extent(mp, pag);
                                 if (blen < longest)
                                         blen = longest;
                         } else
diff --git a/fs/xfs/xfs_filestream.c b/fs/xfs/xfs_filestream.c
index f3bb75da384e..6c87c8f304ef 100644
--- a/fs/xfs/xfs_filestream.c
+++ b/fs/xfs/xfs_filestream.c
@@ -140,7 +140,7 @@ _xfs_filestream_pick_ag(
         xfs_extlen_t    minlen)
 {
         int             err, trylock, nscan;
-        xfs_extlen_t    delta, longest, need, free, minfree, maxfree = 0;
+        xfs_extlen_t    longest, free, minfree, maxfree = 0;
         xfs_agnumber_t  ag, max_ag = NULLAGNUMBER;
         struct xfs_perag *pag;
 
@@ -186,12 +186,7 @@ _xfs_filestream_pick_ag(
                         goto next_ag;
                 }
 
-                need = XFS_MIN_FREELIST_PAG(pag, mp);
-                delta = need > pag->pagf_flcount ? need - pag->pagf_flcount : 0;
-                longest = (pag->pagf_longest > delta) ?
-                          (pag->pagf_longest - delta) :
-                          (pag->pagf_flcount > 0 || pag->pagf_longest > 0);
-
+                longest = xfs_alloc_longest_free_extent(mp, pag);
                 if (((minlen && longest >= minlen) ||
                      (!minlen && pag->pagf_freeblks >= minfree)) &&
                     (!pag->pagf_metadata || !(flags & XFS_PICK_USERDATA) ||
diff --git a/fs/xfs/xfs_itable.c b/fs/xfs/xfs_itable.c
index cf98a805ec90..24f1d139a636 100644
--- a/fs/xfs/xfs_itable.c
+++ b/fs/xfs/xfs_itable.c
@@ -83,7 +83,12 @@ xfs_bulkstat_one_iget(
         buf->bs_uid = dic->di_uid;
         buf->bs_gid = dic->di_gid;
         buf->bs_size = dic->di_size;
-        vn_atime_to_bstime(VFS_I(ip), &buf->bs_atime);
+        /*
+         * We are reading the atime from the Linux inode because the
+         * dinode might not be uptodate.
+         */
+        buf->bs_atime.tv_sec = VFS_I(ip)->i_atime.tv_sec;
+        buf->bs_atime.tv_nsec = VFS_I(ip)->i_atime.tv_nsec;
         buf->bs_mtime.tv_sec = dic->di_mtime.t_sec;
         buf->bs_mtime.tv_nsec = dic->di_mtime.t_nsec;
         buf->bs_ctime.tv_sec = dic->di_ctime.t_sec;
diff --git a/fs/xfs/xfs_log.c b/fs/xfs/xfs_log.c
index c8f300897728..25faa3fe83d2 100644
--- a/fs/xfs/xfs_log.c
+++ b/fs/xfs/xfs_log.c
@@ -635,19 +635,6 @@ xfs_log_mount_finish(xfs_mount_t *mp)
 }
 
 /*
- * Unmount processing for the log.
- */
-int
-xfs_log_unmount(xfs_mount_t *mp)
-{
-        int             error;
-
-        error = xfs_log_unmount_write(mp);
-        xfs_log_unmount_dealloc(mp);
-        return error;
-}
-
-/*
  * Final log writes as part of unmount.
  *
  * Mark the filesystem clean as unmount happens.  Note that during relocation
@@ -797,7 +784,7 @@ xfs_log_unmount_write(xfs_mount_t *mp)
  * and deallocate the log as the aild references the log.
  */
 void
-xfs_log_unmount_dealloc(xfs_mount_t *mp)
+xfs_log_unmount(xfs_mount_t *mp)
 {
         xfs_trans_ail_destroy(mp);
         xlog_dealloc_log(mp->m_log);
diff --git a/fs/xfs/xfs_log.h b/fs/xfs/xfs_log.h
index 8a3e84e900a3..d0c9baa50b1a 100644
--- a/fs/xfs/xfs_log.h
+++ b/fs/xfs/xfs_log.h
@@ -170,9 +170,8 @@ int	  xfs_log_write(struct xfs_mount *mp,
                         int              nentries,
                         xfs_log_ticket_t ticket,
                         xfs_lsn_t        *start_lsn);
-int       xfs_log_unmount(struct xfs_mount *mp);
 int       xfs_log_unmount_write(struct xfs_mount *mp);
-void      xfs_log_unmount_dealloc(struct xfs_mount *mp);
+void      xfs_log_unmount(struct xfs_mount *mp);
 int       xfs_log_force_umount(struct xfs_mount *mp, int logerror);
 int       xfs_log_need_covered(struct xfs_mount *mp);
 
diff --git a/fs/xfs/xfs_log_priv.h b/fs/xfs/xfs_log_priv.h
index 3670d48fd774..bcad5f4c1fd1 100644
--- a/fs/xfs/xfs_log_priv.h
+++ b/fs/xfs/xfs_log_priv.h
@@ -455,7 +455,6 @@ extern void	 xlog_recover_process_iunlinks(xlog_t *log);
 
 extern struct xfs_buf *xlog_get_bp(xlog_t *, int);
 extern void      xlog_put_bp(struct xfs_buf *);
-extern int       xlog_bread(xlog_t *, xfs_daddr_t, int, struct xfs_buf *);
 
 extern kmem_zone_t      *xfs_log_ticket_zone;
 
diff --git a/fs/xfs/xfs_log_recover.c b/fs/xfs/xfs_log_recover.c
index ceeba45e0224..7ba450116d4f 100644
--- a/fs/xfs/xfs_log_recover.c
+++ b/fs/xfs/xfs_log_recover.c
@@ -94,12 +94,30 @@ xlog_put_bp(
         xfs_buf_free(bp);
 }
 
+STATIC xfs_caddr_t
+xlog_align(
+        xlog_t          *log,
+        xfs_daddr_t     blk_no,
+        int             nbblks,
+        xfs_buf_t       *bp)
+{
+        xfs_caddr_t     ptr;
+
+        if (!log->l_sectbb_log)
+                return XFS_BUF_PTR(bp);
+
+        ptr = XFS_BUF_PTR(bp) + BBTOB((int)blk_no & log->l_sectbb_mask);
+        ASSERT(XFS_BUF_SIZE(bp) >=
+                BBTOB(nbblks + (blk_no & log->l_sectbb_mask)));
+        return ptr;
+}
+
 
 /*
  * nbblks should be uint, but oh well.  Just want to catch that 32-bit length.
  */
-int
-xlog_bread(
+STATIC int
+xlog_bread_noalign(
         xlog_t          *log,
         xfs_daddr_t     blk_no,
         int             nbblks,
@@ -137,6 +155,24 @@ xlog_bread(
         return error;
 }
 
+STATIC int
+xlog_bread(
+        xlog_t          *log,
+        xfs_daddr_t     blk_no,
+        int             nbblks,
+        xfs_buf_t       *bp,
+        xfs_caddr_t     *offset)
+{
+        int             error;
+
+        error = xlog_bread_noalign(log, blk_no, nbblks, bp);
+        if (error)
+                return error;
+
+        *offset = xlog_align(log, blk_no, nbblks, bp);
+        return 0;
+}
+
 /*
  * Write out the buffer at the given block for the given number of blocks.
  * The buffer is kept locked across the write and is returned locked.
@@ -180,24 +216,6 @@ xlog_bwrite(
         return error;
 }
 
-STATIC xfs_caddr_t
-xlog_align(
-        xlog_t          *log,
-        xfs_daddr_t     blk_no,
-        int             nbblks,
-        xfs_buf_t       *bp)
-{
-        xfs_caddr_t     ptr;
-
-        if (!log->l_sectbb_log)
-                return XFS_BUF_PTR(bp);
-
-        ptr = XFS_BUF_PTR(bp) + BBTOB((int)blk_no & log->l_sectbb_mask);
-        ASSERT(XFS_BUF_SIZE(bp) >=
-                BBTOB(nbblks + (blk_no & log->l_sectbb_mask)));
-        return ptr;
-}
-
 #ifdef DEBUG
 /*
  * dump debug superblock and log record information
@@ -321,9 +339,9 @@ xlog_find_cycle_start(
 
         mid_blk = BLK_AVG(first_blk, *last_blk);
         while (mid_blk != first_blk && mid_blk != *last_blk) {
-                if ((error = xlog_bread(log, mid_blk, 1, bp)))
+                error = xlog_bread(log, mid_blk, 1, bp, &offset);
+                if (error)
                         return error;
-                offset = xlog_align(log, mid_blk, 1, bp);
                 mid_cycle = xlog_get_cycle(offset);
                 if (mid_cycle == cycle) {
                         *last_blk = mid_blk;
@@ -379,10 +397,10 @@ xlog_find_verify_cycle(
 
                 bcount = min(bufblks, (start_blk + nbblks - i));
 
-                if ((error = xlog_bread(log, i, bcount, bp)))
+                error = xlog_bread(log, i, bcount, bp, &buf);
+                if (error)
                         goto out;
 
-                buf = xlog_align(log, i, bcount, bp);
                 for (j = 0; j < bcount; j++) {
                         cycle = xlog_get_cycle(buf);
                         if (cycle == stop_on_cycle_no) {
@@ -436,9 +454,9 @@ xlog_find_verify_log_record(
                         return ENOMEM;
                 smallmem = 1;
         } else {
-                if ((error = xlog_bread(log, start_blk, num_blks, bp)))
+                error = xlog_bread(log, start_blk, num_blks, bp, &offset);
+                if (error)
                         goto out;
-                offset = xlog_align(log, start_blk, num_blks, bp);
                 offset += ((num_blks - 1) << BBSHIFT);
         }
 
@@ -453,9 +471,9 @@ xlog_find_verify_log_record(
                 }
 
                 if (smallmem) {
-                        if ((error = xlog_bread(log, i, 1, bp)))
+                        error = xlog_bread(log, i, 1, bp, &offset);
+                        if (error)
                                 goto out;
-                        offset = xlog_align(log, i, 1, bp);
                 }
 
                 head = (xlog_rec_header_t *)offset;
@@ -559,15 +577,18 @@ xlog_find_head(
         bp = xlog_get_bp(log, 1);
         if (!bp)
                 return ENOMEM;
-        if ((error = xlog_bread(log, 0, 1, bp)))
+
+        error = xlog_bread(log, 0, 1, bp, &offset);
+        if (error)
                 goto bp_err;
-        offset = xlog_align(log, 0, 1, bp);
+
         first_half_cycle = xlog_get_cycle(offset);
 
         last_blk = head_blk = log_bbnum - 1;    /* get cycle # of last block */
-        if ((error = xlog_bread(log, last_blk, 1, bp)))
+        error = xlog_bread(log, last_blk, 1, bp, &offset);
+        if (error)
                 goto bp_err;
-        offset = xlog_align(log, last_blk, 1, bp);
+
         last_half_cycle = xlog_get_cycle(offset);
         ASSERT(last_half_cycle != 0);
 
@@ -817,9 +838,10 @@ xlog_find_tail(
         if (!bp)
                 return ENOMEM;
         if (*head_blk == 0) {                           /* special case */
-                if ((error = xlog_bread(log, 0, 1, bp)))
+                error = xlog_bread(log, 0, 1, bp, &offset);
+                if (error)
                         goto bread_err;
-                offset = xlog_align(log, 0, 1, bp);
+
                 if (xlog_get_cycle(offset) == 0) {
                         *tail_blk = 0;
                         /* leave all other log inited values alone */
@@ -832,9 +854,10 @@ xlog_find_tail(
          */
         ASSERT(*head_blk < INT_MAX);
         for (i = (int)(*head_blk) - 1; i >= 0; i--) {
-                if ((error = xlog_bread(log, i, 1, bp)))
+                error = xlog_bread(log, i, 1, bp, &offset);
+                if (error)
                         goto bread_err;
-                offset = xlog_align(log, i, 1, bp);
+
                 if (XLOG_HEADER_MAGIC_NUM == be32_to_cpu(*(__be32 *)offset)) {
                         found = 1;
                         break;
@@ -848,9 +871,10 @@ xlog_find_tail(
          */
         if (!found) {
                 for (i = log->l_logBBsize - 1; i >= (int)(*head_blk); i--) {
-                        if ((error = xlog_bread(log, i, 1, bp)))
+                        error = xlog_bread(log, i, 1, bp, &offset);
+                        if (error)
                                 goto bread_err;
-                        offset = xlog_align(log, i, 1, bp);
+
                         if (XLOG_HEADER_MAGIC_NUM ==
                             be32_to_cpu(*(__be32 *)offset)) {
                                 found = 2;
@@ -922,10 +946,10 @@ xlog_find_tail(
         if (*head_blk == after_umount_blk &&
             be32_to_cpu(rhead->h_num_logops) == 1) {
                 umount_data_blk = (i + hblks) % log->l_logBBsize;
-                if ((error = xlog_bread(log, umount_data_blk, 1, bp))) {
+                error = xlog_bread(log, umount_data_blk, 1, bp, &offset);
+                if (error)
                         goto bread_err;
-                }
-                offset = xlog_align(log, umount_data_blk, 1, bp);
+
                 op_head = (xlog_op_header_t *)offset;
                 if (op_head->oh_flags & XLOG_UNMOUNT_TRANS) {
                         /*
@@ -1017,9 +1041,10 @@ xlog_find_zeroed(
         bp = xlog_get_bp(log, 1);
         if (!bp)
                 return ENOMEM;
-        if ((error = xlog_bread(log, 0, 1, bp)))
+        error = xlog_bread(log, 0, 1, bp, &offset);
+        if (error)
                 goto bp_err;
-        offset = xlog_align(log, 0, 1, bp);
+
         first_cycle = xlog_get_cycle(offset);
         if (first_cycle == 0) {         /* completely zeroed log */
                 *blk_no = 0;
@@ -1028,9 +1053,10 @@ xlog_find_zeroed(
         }
 
         /* check partially zeroed log */
-        if ((error = xlog_bread(log, log_bbnum-1, 1, bp)))
+        error = xlog_bread(log, log_bbnum-1, 1, bp, &offset);
+        if (error)
                 goto bp_err;
-        offset = xlog_align(log, log_bbnum-1, 1, bp);
+
         last_cycle = xlog_get_cycle(offset);
         if (last_cycle != 0) {          /* log completely written to */
                 xlog_put_bp(bp);
@@ -1152,10 +1178,10 @@ xlog_write_log_records(
          */
         balign = XLOG_SECTOR_ROUNDDOWN_BLKNO(log, start_block);
         if (balign != start_block) {
-                if ((error = xlog_bread(log, start_block, 1, bp))) {
-                        xlog_put_bp(bp);
-                        return error;
-                }
+                error = xlog_bread_noalign(log, start_block, 1, bp);
+                if (error)
+                        goto out_put_bp;
+
                 j = start_block - balign;
         }
 
@@ -1175,10 +1201,14 @@ xlog_write_log_records(
                         balign = BBTOB(ealign - start_block);
                         error = XFS_BUF_SET_PTR(bp, offset + balign,
                                                 BBTOB(sectbb));
-                        if (!error)
-                                error = xlog_bread(log, ealign, sectbb, bp);
-                        if (!error)
-                                error = XFS_BUF_SET_PTR(bp, offset, bufblks);
+                        if (error)
+                                break;
+
+                        error = xlog_bread_noalign(log, ealign, sectbb, bp);
+                        if (error)
+                                break;
+
+                        error = XFS_BUF_SET_PTR(bp, offset, bufblks);
                         if (error)
                                 break;
                 }
@@ -1195,6 +1225,8 @@ xlog_write_log_records(
                 start_block += endcount;
                 j = 0;
         }
+
+ out_put_bp:
         xlog_put_bp(bp);
         return error;
 }
@@ -2511,16 +2543,10 @@ xlog_recover_do_inode_trans(
         }
 
 write_inode_buffer:
-        if (ITEM_TYPE(item) == XFS_LI_INODE) {
-                ASSERT(bp->b_mount == NULL || bp->b_mount == mp);
-                bp->b_mount = mp;
-                XFS_BUF_SET_IODONE_FUNC(bp, xlog_recover_iodone);
-                xfs_bdwrite(mp, bp);
-        } else {
-                XFS_BUF_STALE(bp);
-                error = xfs_bwrite(mp, bp);
-        }
-
+        ASSERT(bp->b_mount == NULL || bp->b_mount == mp);
+        bp->b_mount = mp;
+        XFS_BUF_SET_IODONE_FUNC(bp, xlog_recover_iodone);
+        xfs_bdwrite(mp, bp);
 error:
         if (need_free)
                 kmem_free(in_f);
@@ -2769,51 +2795,48 @@ xlog_recover_do_trans(
         int                     error = 0;
         xlog_recover_item_t     *item, *first_item;
 
-        if ((error = xlog_recover_reorder_trans(trans)))
+        error = xlog_recover_reorder_trans(trans);
+        if (error)
                 return error;
+
         first_item = item = trans->r_itemq;
         do {
-                /*
-                 * we don't need to worry about the block number being
-                 * truncated in > 1 TB buffers because in user-land,
-                 * we're now n32 or 64-bit so xfs_daddr_t is 64-bits so
-                 * the blknos will get through the user-mode buffer
-                 * cache properly.  The only bad case is o32 kernels
-                 * where xfs_daddr_t is 32-bits but mount will warn us
-                 * off a > 1 TB filesystem before we get here.
-                 */
-                if ((ITEM_TYPE(item) == XFS_LI_BUF)) {
-                        if  ((error = xlog_recover_do_buffer_trans(log, item,
-                                                                 pass)))
-                                break;
-                } else if ((ITEM_TYPE(item) == XFS_LI_INODE)) {
-                        if ((error = xlog_recover_do_inode_trans(log, item,
-                                                                pass)))
-                                break;
-                } else if (ITEM_TYPE(item) == XFS_LI_EFI) {
-                        if ((error = xlog_recover_do_efi_trans(log, item, trans->r_lsn,
-                                                  pass)))
-                                break;
-                } else if (ITEM_TYPE(item) == XFS_LI_EFD) {
+                switch (ITEM_TYPE(item)) {
+                case XFS_LI_BUF:
+                        error = xlog_recover_do_buffer_trans(log, item, pass);
+                        break;
+                case XFS_LI_INODE:
+                        error = xlog_recover_do_inode_trans(log, item, pass);
+                        break;
+                case XFS_LI_EFI:
+                        error = xlog_recover_do_efi_trans(log, item,
+                                                          trans->r_lsn, pass);
+                        break;
+                case XFS_LI_EFD:
                         xlog_recover_do_efd_trans(log, item, pass);
-                } else if (ITEM_TYPE(item) == XFS_LI_DQUOT) {
-                        if ((error = xlog_recover_do_dquot_trans(log, item,
-                                                                   pass)))
-                                        break;
-                } else if ((ITEM_TYPE(item) == XFS_LI_QUOTAOFF)) {
-                        if ((error = xlog_recover_do_quotaoff_trans(log, item,
-                                                                   pass)))
-                                        break;
-                } else {
-                        xlog_warn("XFS: xlog_recover_do_trans");
+                        error = 0;
+                        break;
+                case XFS_LI_DQUOT:
+                        error = xlog_recover_do_dquot_trans(log, item, pass);
+                        break;
+                case XFS_LI_QUOTAOFF:
+                        error = xlog_recover_do_quotaoff_trans(log, item,
+                                                               pass);
+                        break;
+                default:
+                        xlog_warn(
+        "XFS: invalid item type (%d) xlog_recover_do_trans", ITEM_TYPE(item));
                         ASSERT(0);
                         error = XFS_ERROR(EIO);
                         break;
                 }
+
+                if (error)
+                        return error;
                 item = item->ri_next;
         } while (first_item != item);
 
-        return error;
+        return 0;
 }
 
 /*
@@ -3490,9 +3513,11 @@ xlog_do_recovery_pass(
                 hbp = xlog_get_bp(log, 1);
                 if (!hbp)
                         return ENOMEM;
-                if ((error = xlog_bread(log, tail_blk, 1, hbp)))
+
+                error = xlog_bread(log, tail_blk, 1, hbp, &offset);
+                if (error)
                         goto bread_err1;
-                offset = xlog_align(log, tail_blk, 1, hbp);
+
                 rhead = (xlog_rec_header_t *)offset;
                 error = xlog_valid_rec_header(log, rhead, tail_blk);
                 if (error)
@@ -3526,9 +3551,10 @@ xlog_do_recovery_pass(
         memset(rhash, 0, sizeof(rhash));
         if (tail_blk <= head_blk) {
                 for (blk_no = tail_blk; blk_no < head_blk; ) {
-                        if ((error = xlog_bread(log, blk_no, hblks, hbp)))
+                        error = xlog_bread(log, blk_no, hblks, hbp, &offset);
+                        if (error)
                                 goto bread_err2;
-                        offset = xlog_align(log, blk_no, hblks, hbp);
+
                         rhead = (xlog_rec_header_t *)offset;
                         error = xlog_valid_rec_header(log, rhead, blk_no);
                         if (error)
@@ -3536,10 +3562,11 @@ xlog_do_recovery_pass(
 
                         /* blocks in data section */
                         bblks = (int)BTOBB(be32_to_cpu(rhead->h_len));
-                        error = xlog_bread(log, blk_no + hblks, bblks, dbp);
+                        error = xlog_bread(log, blk_no + hblks, bblks, dbp,
+                                           &offset);
                         if (error)
                                 goto bread_err2;
-                        offset = xlog_align(log, blk_no + hblks, bblks, dbp);
+
                         xlog_unpack_data(rhead, offset, log);
                         if ((error = xlog_recover_process_data(log,
                                                 rhash, rhead, offset, pass)))
@@ -3562,10 +3589,10 @@ xlog_do_recovery_pass(
                         wrapped_hblks = 0;
                         if (blk_no + hblks <= log->l_logBBsize) {
                                 /* Read header in one read */
-                                error = xlog_bread(log, blk_no, hblks, hbp);
+                                error = xlog_bread(log, blk_no, hblks, hbp,
+                                                   &offset);
                                 if (error)
                                         goto bread_err2;
-                                offset = xlog_align(log, blk_no, hblks, hbp);
                         } else {
                                 /* This LR is split across physical log end */
                                 if (blk_no != log->l_logBBsize) {
@@ -3573,12 +3600,13 @@ xlog_do_recovery_pass(
                                         ASSERT(blk_no <= INT_MAX);
                                         split_hblks = log->l_logBBsize - (int)blk_no;
                                         ASSERT(split_hblks > 0);
-                                        if ((error = xlog_bread(log, blk_no,
-                                                        split_hblks, hbp)))
+                                        error = xlog_bread(log, blk_no,
+                                                           split_hblks, hbp,
+                                                           &offset);
+                                        if (error)
                                                 goto bread_err2;
-                                        offset = xlog_align(log, blk_no,
-                                                        split_hblks, hbp);
                                 }
+
                                 /*
                                  * Note: this black magic still works with
                                  * large sector sizes (non-512) only because:
@@ -3596,14 +3624,19 @@ xlog_do_recovery_pass(
                                 error = XFS_BUF_SET_PTR(hbp,
                                                 bufaddr + BBTOB(split_hblks),
                                                 BBTOB(hblks - split_hblks));
-                                if (!error)
-                                        error = xlog_bread(log, 0,
-                                                        wrapped_hblks, hbp);
-                                if (!error)
-                                        error = XFS_BUF_SET_PTR(hbp, bufaddr,
+                                if (error)
+                                        goto bread_err2;
+
+                                error = xlog_bread_noalign(log, 0,
+                                                           wrapped_hblks, hbp);
+                                if (error)
+                                        goto bread_err2;
+
+                                error = XFS_BUF_SET_PTR(hbp, bufaddr,
                                                         BBTOB(hblks));
                                 if (error)
                                         goto bread_err2;
+
                                 if (!offset)
                                         offset = xlog_align(log, 0,
                                                         wrapped_hblks, hbp);
@@ -3619,10 +3652,10 @@ xlog_do_recovery_pass(
 
                         /* Read in data for log record */
                         if (blk_no + bblks <= log->l_logBBsize) {
-                                error = xlog_bread(log, blk_no, bblks, dbp);
+                                error = xlog_bread(log, blk_no, bblks, dbp,
+                                                   &offset);
                                 if (error)
                                         goto bread_err2;
-                                offset = xlog_align(log, blk_no, bblks, dbp);
                         } else {
                                 /* This log record is split across the
                                  * physical end of log */
@@ -3636,12 +3669,13 @@ xlog_do_recovery_pass(
                                         split_bblks =
                                                 log->l_logBBsize - (int)blk_no;
                                         ASSERT(split_bblks > 0);
-                                        if ((error = xlog_bread(log, blk_no,
-                                                        split_bblks, dbp)))
+                                        error = xlog_bread(log, blk_no,
+                                                        split_bblks, dbp,
+                                                        &offset);
+                                        if (error)
                                                 goto bread_err2;
-                                        offset = xlog_align(log, blk_no,
-                                                        split_bblks, dbp);
                                 }
+
                                 /*
                                  * Note: this black magic still works with
                                  * large sector sizes (non-512) only because:
@@ -3658,15 +3692,19 @@ xlog_do_recovery_pass(
                                 error = XFS_BUF_SET_PTR(dbp,
                                                 bufaddr + BBTOB(split_bblks),
                                                 BBTOB(bblks - split_bblks));
-                                if (!error)
-                                        error = xlog_bread(log, wrapped_hblks,
-                                                        bblks - split_bblks,
-                                                        dbp);
-                                if (!error)
-                                        error = XFS_BUF_SET_PTR(dbp, bufaddr,
-                                                        h_size);
                                 if (error)
                                         goto bread_err2;
+
+                                error = xlog_bread_noalign(log, wrapped_hblks,
+                                                bblks - split_bblks,
+                                                dbp);
+                                if (error)
+                                        goto bread_err2;
+
+                                error = XFS_BUF_SET_PTR(dbp, bufaddr, h_size);
+                                if (error)
+                                        goto bread_err2;
+
                                 if (!offset)
                                         offset = xlog_align(log, wrapped_hblks,
                                                 bblks - split_bblks, dbp);
@@ -3683,17 +3721,21 @@ xlog_do_recovery_pass(
 
                 /* read first part of physical log */
                 while (blk_no < head_blk) {
-                        if ((error = xlog_bread(log, blk_no, hblks, hbp)))
+                        error = xlog_bread(log, blk_no, hblks, hbp, &offset);
+                        if (error)
                                 goto bread_err2;
-                        offset = xlog_align(log, blk_no, hblks, hbp);
+
                         rhead = (xlog_rec_header_t *)offset;
                         error = xlog_valid_rec_header(log, rhead, blk_no);
                         if (error)
                                 goto bread_err2;
+
                         bblks = (int)BTOBB(be32_to_cpu(rhead->h_len));
-                        if ((error = xlog_bread(log, blk_no+hblks, bblks, dbp)))
+                        error = xlog_bread(log, blk_no+hblks, bblks, dbp,
+                                           &offset);
+                        if (error)
                                 goto bread_err2;
-                        offset = xlog_align(log, blk_no+hblks, bblks, dbp);
+
                         xlog_unpack_data(rhead, offset, log);
                         if ((error = xlog_recover_process_data(log, rhash,
                                                         rhead, offset, pass)))
diff --git a/fs/xfs/xfs_mount.c b/fs/xfs/xfs_mount.c
index 664961e45e02..2549a235dad2 100644
--- a/fs/xfs/xfs_mount.c
+++ b/fs/xfs/xfs_mount.c
@@ -1194,7 +1194,7 @@ xfs_mountfs(
  out_rele_rip:
         IRELE(rip);
  out_log_dealloc:
-        xfs_log_unmount_dealloc(mp);
+        xfs_log_unmount(mp);
  out_free_perag:
         xfs_free_perag(mp);
  out_remove_uuid:
@@ -1280,7 +1280,8 @@ xfs_unmountfs(
                                 "Freespace may not be correct on next mount.");
         xfs_unmountfs_writesb(mp);
         xfs_unmountfs_wait(mp);                 /* wait for async bufs */
-        xfs_log_unmount(mp);                    /* Done! No more fs ops. */
+        xfs_log_unmount_write(mp);
+        xfs_log_unmount(mp);
 
         if ((mp->m_flags & XFS_MOUNT_NOUUID) == 0)
                 uuid_table_remove(&mp->m_sb.sb_uuid);
diff --git a/fs/xfs/xfs_vnodeops.c b/fs/xfs/xfs_vnodeops.c
index 59de04954bc8..6e28461e7611 100644
--- a/fs/xfs/xfs_vnodeops.c
+++ b/fs/xfs/xfs_vnodeops.c
@@ -1136,7 +1136,7 @@ xfs_inactive(
          * If the inode is already free, then there can be nothing
          * to clean up here.
          */
-        if (ip->i_d.di_mode == 0 || VN_BAD(VFS_I(ip))) {
+        if (ip->i_d.di_mode == 0 || is_bad_inode(VFS_I(ip))) {
                 ASSERT(ip->i_df.if_real_bytes == 0);
                 ASSERT(ip->i_df.if_broot_bytes == 0);
                 return VN_INACTIVE_CACHE;
@@ -2448,7 +2448,7 @@ xfs_reclaim(
         ASSERT(!VN_MAPPED(VFS_I(ip)));
 
         /* bad inode, get out here ASAP */
-        if (VN_BAD(VFS_I(ip))) {
+        if (is_bad_inode(VFS_I(ip))) {
                 xfs_ireclaim(ip);
                 return 0;
         }