4 files changed, 43 insertions, 26 deletions

diff --git a/fs/xfs/xfs_iops.c b/fs/xfs/xfs_iops.c
index f35d5c953ff9..9ddfb8190ca1 100644
--- a/fs/xfs/xfs_iops.c
+++ b/fs/xfs/xfs_iops.c
@@ -705,7 +705,6 @@ xfs_setattr_size(
 {
         struct xfs_mount        *mp = ip->i_mount;
         struct inode            *inode = VFS_I(ip);
-        int                     mask = iattr->ia_valid;
         xfs_off_t               oldsize, newsize;
         struct xfs_trans        *tp;
         int                     error;
@@ -726,8 +725,8 @@ xfs_setattr_size(
 
         ASSERT(xfs_isilocked(ip, XFS_IOLOCK_EXCL));
         ASSERT(S_ISREG(ip->i_d.di_mode));
-        ASSERT((mask & (ATTR_UID|ATTR_GID|ATTR_ATIME|ATTR_ATIME_SET|
-                        ATTR_MTIME_SET|ATTR_KILL_PRIV|ATTR_TIMES_SET)) == 0);
+        ASSERT((iattr->ia_valid & (ATTR_UID|ATTR_GID|ATTR_ATIME|ATTR_ATIME_SET|
+                ATTR_MTIME_SET|ATTR_KILL_PRIV|ATTR_TIMES_SET)) == 0);
 
         oldsize = inode->i_size;
         newsize = iattr->ia_size;
@@ -736,7 +735,7 @@ xfs_setattr_size(
          * Short circuit the truncate case for zero length files.
          */
         if (newsize == 0 && oldsize == 0 && ip->i_d.di_nextents == 0) {
-                if (!(mask & (ATTR_CTIME|ATTR_MTIME)))
+                if (!(iattr->ia_valid & (ATTR_CTIME|ATTR_MTIME)))
                         return 0;
 
                 /*
@@ -824,10 +823,11 @@ xfs_setattr_size(
          * these flags set.  For all other operations the VFS set these flags
          * explicitly if it wants a timestamp update.
          */
-        if (newsize != oldsize && (!(mask & (ATTR_CTIME | ATTR_MTIME)))) {
+        if (newsize != oldsize &&
+            !(iattr->ia_valid & (ATTR_CTIME | ATTR_MTIME))) {
                 iattr->ia_ctime = iattr->ia_mtime =
                         current_fs_time(inode->i_sb);
-                mask |= ATTR_CTIME | ATTR_MTIME;
+                iattr->ia_valid |= ATTR_CTIME | ATTR_MTIME;
         }
 
         /*
@@ -863,9 +863,9 @@ xfs_setattr_size(
                 xfs_inode_clear_eofblocks_tag(ip);
         }
 
-        if (mask & ATTR_MODE)
+        if (iattr->ia_valid & ATTR_MODE)
                 xfs_setattr_mode(ip, iattr);
-        if (mask & (ATTR_ATIME|ATTR_CTIME|ATTR_MTIME))
+        if (iattr->ia_valid & (ATTR_ATIME|ATTR_CTIME|ATTR_MTIME))
                 xfs_setattr_time(ip, iattr);
 
         xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
diff --git a/fs/xfs/xfs_log_cil.c b/fs/xfs/xfs_log_cil.c
index f034cbd958e4..b57a8e08b3d1 100644
--- a/fs/xfs/xfs_log_cil.c
+++ b/fs/xfs/xfs_log_cil.c
@@ -205,16 +205,25 @@ xlog_cil_insert_format_items(
                 /*
                  * We 64-bit align the length of each iovec so that the start
                  * of the next one is naturally aligned.  We'll need to
-                 * account for that slack space here.
+                 * account for that slack space here. Then round nbytes up
+                 * to 64-bit alignment so that the initial buffer alignment is
+                 * easy to calculate and verify.
                  */
                 nbytes += niovecs * sizeof(uint64_t);
+                nbytes = round_up(nbytes, sizeof(uint64_t));
 
                 /* grab the old item if it exists for reservation accounting */
                 old_lv = lip->li_lv;
 
-                /* calc buffer size */
-                buf_size = sizeof(struct xfs_log_vec) + nbytes +
-                                niovecs * sizeof(struct xfs_log_iovec);
+                /*
+                 * The data buffer needs to start 64-bit aligned, so round up
+                 * that space to ensure we can align it appropriately and not
+                 * overrun the buffer.
+                 */
+                buf_size = nbytes +
+                           round_up((sizeof(struct xfs_log_vec) +
+                                     niovecs * sizeof(struct xfs_log_iovec)),
+                                    sizeof(uint64_t));
 
                 /* compare to existing item size */
                 if (lip->li_lv && buf_size <= lip->li_lv->lv_size) {
@@ -251,6 +260,8 @@ xlog_cil_insert_format_items(
                 /* The allocated data region lies beyond the iovec region */
                 lv->lv_buf_len = 0;
                 lv->lv_buf = (char *)lv + buf_size - nbytes;
+                ASSERT(IS_ALIGNED((unsigned long)lv->lv_buf, sizeof(uint64_t)));
+
                 lip->li_ops->iop_format(lip, lv);
 insert:
                 ASSERT(lv->lv_buf_len <= nbytes);
diff --git a/fs/xfs/xfs_mount.c b/fs/xfs/xfs_mount.c
index 02df7b408a26..f96c05669a9e 100644
--- a/fs/xfs/xfs_mount.c
+++ b/fs/xfs/xfs_mount.c
@@ -282,22 +282,29 @@ xfs_readsb(
         struct xfs_sb   *sbp = &mp->m_sb;
         int             error;
         int             loud = !(flags & XFS_MFSI_QUIET);
+        const struct xfs_buf_ops *buf_ops;
 
         ASSERT(mp->m_sb_bp == NULL);
         ASSERT(mp->m_ddev_targp != NULL);
 
         /*
+         * For the initial read, we must guess at the sector
+         * size based on the block device.  It's enough to
+         * get the sb_sectsize out of the superblock and
+         * then reread with the proper length.
+         * We don't verify it yet, because it may not be complete.
+         */
+        sector_size = xfs_getsize_buftarg(mp->m_ddev_targp);
+        buf_ops = NULL;
+
+        /*
          * Allocate a (locked) buffer to hold the superblock.
          * This will be kept around at all times to optimize
          * access to the superblock.
          */
-        sector_size = xfs_getsize_buftarg(mp->m_ddev_targp);
-
 reread:
         bp = xfs_buf_read_uncached(mp->m_ddev_targp, XFS_SB_DADDR,
-                                   BTOBB(sector_size), 0,
-                                   loud ? &xfs_sb_buf_ops
-                                        : &xfs_sb_quiet_buf_ops);
+                                   BTOBB(sector_size), 0, buf_ops);
         if (!bp) {
                 if (loud)
                         xfs_warn(mp, "SB buffer read failed");
@@ -328,12 +335,13 @@ reread:
         }
 
         /*
-         * If device sector size is smaller than the superblock size,
-         * re-read the superblock so the buffer is correctly sized.
+         * Re-read the superblock so the buffer is correctly sized,
+         * and properly verified.
          */
-        if (sector_size < sbp->sb_sectsize) {
+        if (buf_ops == NULL) {
                 xfs_buf_relse(bp);
                 sector_size = sbp->sb_sectsize;
+                buf_ops = loud ? &xfs_sb_buf_ops : &xfs_sb_quiet_buf_ops;
                 goto reread;
         }
 
diff --git a/fs/xfs/xfs_sb.c b/fs/xfs/xfs_sb.c
index 511cce9359bb..75161a2060fb 100644
--- a/fs/xfs/xfs_sb.c
+++ b/fs/xfs/xfs_sb.c
@@ -296,8 +296,7 @@ xfs_mount_validate_sb(
             sbp->sb_dblocks == 0                                        ||
             sbp->sb_dblocks > XFS_MAX_DBLOCKS(sbp)                      ||
             sbp->sb_dblocks < XFS_MIN_DBLOCKS(sbp))) {
-                XFS_CORRUPTION_ERROR("SB sanity check failed",
-                                XFS_ERRLEVEL_LOW, mp, sbp);
+                xfs_notice(mp, "SB sanity check failed");
                 return XFS_ERROR(EFSCORRUPTED);
         }
 
@@ -612,10 +611,10 @@ xfs_sb_read_verify(
                                                 XFS_SB_VERSION_5) ||
              dsb->sb_crc != 0)) {
 
-                if (!xfs_verify_cksum(bp->b_addr, be16_to_cpu(dsb->sb_sectsize),
+                if (!xfs_verify_cksum(bp->b_addr, BBTOB(bp->b_length),
                                       offsetof(struct xfs_sb, sb_crc))) {
                         /* Only fail bad secondaries on a known V5 filesystem */
-                        if (bp->b_bn != XFS_SB_DADDR &&
+                        if (bp->b_bn == XFS_SB_DADDR ||
                             xfs_sb_version_hascrc(&mp->m_sb)) {
                                 error = EFSCORRUPTED;
                                 goto out_error;
@@ -626,7 +625,7 @@ xfs_sb_read_verify(
 
 out_error:
         if (error) {
-                if (error != EWRONGFS)
+                if (error == EFSCORRUPTED)
                         XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW,
                                              mp, bp->b_addr);
                 xfs_buf_ioerror(bp, error);
@@ -645,7 +644,6 @@ xfs_sb_quiet_read_verify(
 {
         struct xfs_dsb  *dsb = XFS_BUF_TO_SBP(bp);
 
-
         if (dsb->sb_magicnum == cpu_to_be32(XFS_SB_MAGIC)) {
                 /* XFS filesystem, verify noisily! */
                 xfs_sb_read_verify(bp);