1 files changed, 53 insertions, 44 deletions

diff --git a/fs/xfs/xfs_log_recover.c b/fs/xfs/xfs_log_recover.c
index be5568839442..396565f43247 100644
--- a/fs/xfs/xfs_log_recover.c
+++ b/fs/xfs/xfs_log_recover.c
@@ -190,7 +190,7 @@ xlog_bread_noalign(
         ASSERT(nbblks <= bp->b_length);
 
         XFS_BUF_SET_ADDR(bp, log->l_logBBstart + blk_no);
-        XFS_BUF_READ(bp);
+        bp->b_flags |= XBF_READ;
         bp->b_io_length = nbblks;
         bp->b_error = 0;
 
@@ -275,7 +275,6 @@ xlog_bwrite(
         ASSERT(nbblks <= bp->b_length);
 
         XFS_BUF_SET_ADDR(bp, log->l_logBBstart + blk_no);
-        XFS_BUF_ZEROFLAGS(bp);
         xfs_buf_hold(bp);
         xfs_buf_lock(bp);
         bp->b_io_length = nbblks;
@@ -2538,6 +2537,13 @@ xlog_recover_validate_buf_type(
                 }
                 bp->b_ops = &xfs_sb_buf_ops;
                 break;
+#ifdef CONFIG_XFS_RT
+        case XFS_BLFT_RTBITMAP_BUF:
+        case XFS_BLFT_RTSUMMARY_BUF:
+                /* no magic numbers for verification of RT buffers */
+                bp->b_ops = &xfs_rtbuf_ops;
+                break;
+#endif /* CONFIG_XFS_RT */
         default:
                 xfs_warn(mp, "Unknown buffer type %d!",
                          xfs_blft_from_flags(buf_f));
@@ -2858,7 +2864,7 @@ xfs_recover_inode_owner_change(
                 return -ENOMEM;
 
         /* instantiate the inode */
-        xfs_dinode_from_disk(&ip->i_d, dip);
+        xfs_inode_from_disk(ip, dip);
         ASSERT(ip->i_d.di_version >= 3);
 
         error = xfs_iformat_fork(ip, dip);
@@ -2904,7 +2910,7 @@ xlog_recover_inode_pass2(
         int                     error;
         int                     attr_index;
         uint                    fields;
-        xfs_icdinode_t          *dicp;
+        struct xfs_log_dinode   *ldip;
         uint                    isize;
         int                     need_free = 0;
 
@@ -2957,8 +2963,8 @@ xlog_recover_inode_pass2(
                 error = -EFSCORRUPTED;
                 goto out_release;
         }
-        dicp = item->ri_buf[1].i_addr;
-        if (unlikely(dicp->di_magic != XFS_DINODE_MAGIC)) {
+        ldip = item->ri_buf[1].i_addr;
+        if (unlikely(ldip->di_magic != XFS_DINODE_MAGIC)) {
                 xfs_alert(mp,
                         "%s: Bad inode log record, rec ptr 0x%p, ino %Ld",
                         __func__, item, in_f->ilf_ino);
@@ -2994,13 +3000,13 @@ xlog_recover_inode_pass2(
          * to skip replay when the on disk inode is newer than the log one
          */
         if (!xfs_sb_version_hascrc(&mp->m_sb) &&
-            dicp->di_flushiter < be16_to_cpu(dip->di_flushiter)) {
+            ldip->di_flushiter < be16_to_cpu(dip->di_flushiter)) {
                 /*
                  * Deal with the wrap case, DI_MAX_FLUSH is less
                  * than smaller numbers
                  */
                 if (be16_to_cpu(dip->di_flushiter) == DI_MAX_FLUSH &&
-                    dicp->di_flushiter < (DI_MAX_FLUSH >> 1)) {
+                    ldip->di_flushiter < (DI_MAX_FLUSH >> 1)) {
                         /* do nothing */
                 } else {
                         trace_xfs_log_recover_inode_skip(log, in_f);
@@ -3010,13 +3016,13 @@ xlog_recover_inode_pass2(
         }
 
         /* Take the opportunity to reset the flush iteration count */
-        dicp->di_flushiter = 0;
+        ldip->di_flushiter = 0;
 
-        if (unlikely(S_ISREG(dicp->di_mode))) {
-                if ((dicp->di_format != XFS_DINODE_FMT_EXTENTS) &&
-                    (dicp->di_format != XFS_DINODE_FMT_BTREE)) {
+        if (unlikely(S_ISREG(ldip->di_mode))) {
+                if ((ldip->di_format != XFS_DINODE_FMT_EXTENTS) &&
+                    (ldip->di_format != XFS_DINODE_FMT_BTREE)) {
                         XFS_CORRUPTION_ERROR("xlog_recover_inode_pass2(3)",
-                                         XFS_ERRLEVEL_LOW, mp, dicp);
+                                         XFS_ERRLEVEL_LOW, mp, ldip);
                         xfs_alert(mp,
                 "%s: Bad regular inode log record, rec ptr 0x%p, "
                 "ino ptr = 0x%p, ino bp = 0x%p, ino %Ld",
@@ -3024,12 +3030,12 @@ xlog_recover_inode_pass2(
                         error = -EFSCORRUPTED;
                         goto out_release;
                 }
-        } else if (unlikely(S_ISDIR(dicp->di_mode))) {
-                if ((dicp->di_format != XFS_DINODE_FMT_EXTENTS) &&
-                    (dicp->di_format != XFS_DINODE_FMT_BTREE) &&
-                    (dicp->di_format != XFS_DINODE_FMT_LOCAL)) {
+        } else if (unlikely(S_ISDIR(ldip->di_mode))) {
+                if ((ldip->di_format != XFS_DINODE_FMT_EXTENTS) &&
+                    (ldip->di_format != XFS_DINODE_FMT_BTREE) &&
+                    (ldip->di_format != XFS_DINODE_FMT_LOCAL)) {
                         XFS_CORRUPTION_ERROR("xlog_recover_inode_pass2(4)",
-                                             XFS_ERRLEVEL_LOW, mp, dicp);
+                                             XFS_ERRLEVEL_LOW, mp, ldip);
                         xfs_alert(mp,
                 "%s: Bad dir inode log record, rec ptr 0x%p, "
                 "ino ptr = 0x%p, ino bp = 0x%p, ino %Ld",
@@ -3038,32 +3044,32 @@ xlog_recover_inode_pass2(
                         goto out_release;
                 }
         }
-        if (unlikely(dicp->di_nextents + dicp->di_anextents > dicp->di_nblocks)){
+        if (unlikely(ldip->di_nextents + ldip->di_anextents > ldip->di_nblocks)){
                 XFS_CORRUPTION_ERROR("xlog_recover_inode_pass2(5)",
-                                     XFS_ERRLEVEL_LOW, mp, dicp);
+                                     XFS_ERRLEVEL_LOW, mp, ldip);
                 xfs_alert(mp,
         "%s: Bad inode log record, rec ptr 0x%p, dino ptr 0x%p, "
         "dino bp 0x%p, ino %Ld, total extents = %d, nblocks = %Ld",
                         __func__, item, dip, bp, in_f->ilf_ino,
-                        dicp->di_nextents + dicp->di_anextents,
-                        dicp->di_nblocks);
+                        ldip->di_nextents + ldip->di_anextents,
+                        ldip->di_nblocks);
                 error = -EFSCORRUPTED;
                 goto out_release;
         }
-        if (unlikely(dicp->di_forkoff > mp->m_sb.sb_inodesize)) {
+        if (unlikely(ldip->di_forkoff > mp->m_sb.sb_inodesize)) {
                 XFS_CORRUPTION_ERROR("xlog_recover_inode_pass2(6)",
-                                     XFS_ERRLEVEL_LOW, mp, dicp);
+                                     XFS_ERRLEVEL_LOW, mp, ldip);
                 xfs_alert(mp,
         "%s: Bad inode log record, rec ptr 0x%p, dino ptr 0x%p, "
         "dino bp 0x%p, ino %Ld, forkoff 0x%x", __func__,
-                        item, dip, bp, in_f->ilf_ino, dicp->di_forkoff);
+                        item, dip, bp, in_f->ilf_ino, ldip->di_forkoff);
                 error = -EFSCORRUPTED;
                 goto out_release;
         }
-        isize = xfs_icdinode_size(dicp->di_version);
+        isize = xfs_log_dinode_size(ldip->di_version);
         if (unlikely(item->ri_buf[1].i_len > isize)) {
                 XFS_CORRUPTION_ERROR("xlog_recover_inode_pass2(7)",
-                                     XFS_ERRLEVEL_LOW, mp, dicp);
+                                     XFS_ERRLEVEL_LOW, mp, ldip);
                 xfs_alert(mp,
                         "%s: Bad inode log record length %d, rec ptr 0x%p",
                         __func__, item->ri_buf[1].i_len, item);
@@ -3071,8 +3077,8 @@ xlog_recover_inode_pass2(
                 goto out_release;
         }
 
-        /* The core is in in-core format */
-        xfs_dinode_to_disk(dip, dicp);
+        /* recover the log dinode inode into the on disk inode */
+        xfs_log_dinode_to_disk(ldip, dip);
 
         /* the rest is in on-disk format */
         if (item->ri_buf[1].i_len > isize) {
@@ -4402,8 +4408,8 @@ xlog_recover_process_one_iunlink(
         if (error)
                 goto fail_iput;
 
-        ASSERT(ip->i_d.di_nlink == 0);
-        ASSERT(ip->i_d.di_mode != 0);
+        ASSERT(VFS_I(ip)->i_nlink == 0);
+        ASSERT(VFS_I(ip)->i_mode != 0);
 
         /* setup for the next pass */
         agino = be32_to_cpu(dip->di_next_unlinked);
@@ -4957,6 +4963,7 @@ xlog_do_recover(
         xfs_daddr_t     head_blk,
         xfs_daddr_t     tail_blk)
 {
+        struct xfs_mount *mp = log->l_mp;
         int             error;
         xfs_buf_t       *bp;
         xfs_sb_t        *sbp;
@@ -4971,7 +4978,7 @@ xlog_do_recover(
         /*
          * If IO errors happened during recovery, bail out.
          */
-        if (XFS_FORCED_SHUTDOWN(log->l_mp)) {
+        if (XFS_FORCED_SHUTDOWN(mp)) {
                 return -EIO;
         }
 
@@ -4984,22 +4991,21 @@ xlog_do_recover(
          * or iunlinks they will have some entries in the AIL; so we look at
          * the AIL to determine how to set the tail_lsn.
          */
-        xlog_assign_tail_lsn(log->l_mp);
+        xlog_assign_tail_lsn(mp);
 
         /*
          * Now that we've finished replaying all buffer and inode
          * updates, re-read in the superblock and reverify it.
          */
-        bp = xfs_getsb(log->l_mp, 0);
-        XFS_BUF_UNDONE(bp);
-        ASSERT(!(XFS_BUF_ISWRITE(bp)));
-        XFS_BUF_READ(bp);
-        XFS_BUF_UNASYNC(bp);
+        bp = xfs_getsb(mp, 0);
+        bp->b_flags &= ~(XBF_DONE | XBF_ASYNC);
+        ASSERT(!(bp->b_flags & XBF_WRITE));
+        bp->b_flags |= XBF_READ;
         bp->b_ops = &xfs_sb_buf_ops;
 
         error = xfs_buf_submit_wait(bp);
         if (error) {
-                if (!XFS_FORCED_SHUTDOWN(log->l_mp)) {
+                if (!XFS_FORCED_SHUTDOWN(mp)) {
                         xfs_buf_ioerror_alert(bp, __func__);
                         ASSERT(0);
                 }
@@ -5008,14 +5014,17 @@ xlog_do_recover(
         }
 
         /* Convert superblock from on-disk format */
-        sbp = &log->l_mp->m_sb;
+        sbp = &mp->m_sb;
         xfs_sb_from_disk(sbp, XFS_BUF_TO_SBP(bp));
-        ASSERT(sbp->sb_magicnum == XFS_SB_MAGIC);
-        ASSERT(xfs_sb_good_version(sbp));
-        xfs_reinit_percpu_counters(log->l_mp);
-
         xfs_buf_relse(bp);
 
+        /* re-initialise in-core superblock and geometry structures */
+        xfs_reinit_percpu_counters(mp);
+        error = xfs_initialize_perag(mp, sbp->sb_agcount, &mp->m_maxagi);
+        if (error) {
+                xfs_warn(mp, "Failed post-recovery per-ag init: %d", error);
+                return error;
+        }
 
         xlog_recover_check_summary(log);