Merge branch 'xfs-feature-bit-cleanup' into for-next

Conflicts:
	fs/xfs/xfs_inode.c

11 files changed, 101 insertions, 327 deletions

diff --git a/fs/xfs/xfs_dir2.c b/fs/xfs/xfs_dir2.c
index e365c98c0f1e..93fcebd5edd2 100644
--- a/fs/xfs/xfs_dir2.c
+++ b/fs/xfs/xfs_dir2.c
@@ -92,7 +92,7 @@ xfs_dir_mount(
         int     nodehdr_size;
 
 
-        ASSERT(xfs_sb_version_hasdirv2(&mp->m_sb));
+        ASSERT(mp->m_sb.sb_versionnum & XFS_SB_VERSION_DIRV2BIT);
         ASSERT((1 << (mp->m_sb.sb_blocklog + mp->m_sb.sb_dirblklog)) <=
                XFS_MAX_BLOCKSIZE);
 
diff --git a/fs/xfs/xfs_fsops.c b/fs/xfs/xfs_fsops.c
index 3445ead7c1fc..97886a74e073 100644
--- a/fs/xfs/xfs_fsops.c
+++ b/fs/xfs/xfs_fsops.c
@@ -74,23 +74,18 @@ xfs_fs_geometry(
         }
         if (new_version >= 3) {
                 geo->version = XFS_FSOP_GEOM_VERSION;
-                geo->flags =
+                geo->flags = XFS_FSOP_GEOM_FLAGS_NLINK |
+                             XFS_FSOP_GEOM_FLAGS_DIRV2 |
                         (xfs_sb_version_hasattr(&mp->m_sb) ?
                                 XFS_FSOP_GEOM_FLAGS_ATTR : 0) |
-                        (xfs_sb_version_hasnlink(&mp->m_sb) ?
-                                XFS_FSOP_GEOM_FLAGS_NLINK : 0) |
                         (xfs_sb_version_hasquota(&mp->m_sb) ?
                                 XFS_FSOP_GEOM_FLAGS_QUOTA : 0) |
                         (xfs_sb_version_hasalign(&mp->m_sb) ?
                                 XFS_FSOP_GEOM_FLAGS_IALIGN : 0) |
                         (xfs_sb_version_hasdalign(&mp->m_sb) ?
                                 XFS_FSOP_GEOM_FLAGS_DALIGN : 0) |
-                        (xfs_sb_version_hasshared(&mp->m_sb) ?
-                                XFS_FSOP_GEOM_FLAGS_SHARED : 0) |
                         (xfs_sb_version_hasextflgbit(&mp->m_sb) ?
                                 XFS_FSOP_GEOM_FLAGS_EXTFLG : 0) |
-                        (xfs_sb_version_hasdirv2(&mp->m_sb) ?
-                                XFS_FSOP_GEOM_FLAGS_DIRV2 : 0) |
                         (xfs_sb_version_hassector(&mp->m_sb) ?
                                 XFS_FSOP_GEOM_FLAGS_SECTOR : 0) |
                         (xfs_sb_version_hasasciici(&mp->m_sb) ?
diff --git a/fs/xfs/xfs_ialloc.c b/fs/xfs/xfs_ialloc.c
index 1313df7ff0d8..e8dfaf039232 100644
--- a/fs/xfs/xfs_ialloc.c
+++ b/fs/xfs/xfs_ialloc.c
@@ -280,10 +280,8 @@ xfs_ialloc_inode_init(
                 if (tp)
                         xfs_icreate_log(tp, agno, agbno, mp->m_ialloc_inos,
                                         mp->m_sb.sb_inodesize, length, gen);
-        } else if (xfs_sb_version_hasnlink(&mp->m_sb))
+        } else
                 version = 2;
-        else
-                version = 1;
 
         for (j = 0; j < nbufs; j++) {
                 /*
diff --git a/fs/xfs/xfs_inode.c b/fs/xfs/xfs_inode.c
index 6d6b44a508f9..a6115fe1ac94 100644
--- a/fs/xfs/xfs_inode.c
+++ b/fs/xfs/xfs_inode.c
@@ -681,6 +681,14 @@ xfs_ialloc(
                 return error;
         ASSERT(ip != NULL);
 
+        /*
+         * We always convert v1 inodes to v2 now - we only support filesystems
+         * with >= v2 inode capability, so there is no reason for ever leaving
+         * an inode in v1 format.
+         */
+        if (ip->i_d.di_version == 1)
+                ip->i_d.di_version = 2;
+
         ip->i_d.di_mode = mode;
         ip->i_d.di_onlink = 0;
         ip->i_d.di_nlink = nlink;
@@ -690,27 +698,6 @@ xfs_ialloc(
         xfs_set_projid(ip, prid);
         memset(&(ip->i_d.di_pad[0]), 0, sizeof(ip->i_d.di_pad));
 
-        /*
-         * If the superblock version is up to where we support new format
-         * inodes and this is currently an old format inode, then change
-         * the inode version number now.  This way we only do the conversion
-         * here rather than here and in the flush/logging code.
-         */
-        if (xfs_sb_version_hasnlink(&mp->m_sb) &&
-            ip->i_d.di_version == 1) {
-                ip->i_d.di_version = 2;
-                /*
-                 * We've already zeroed the old link count, the projid field,
-                 * and the pad field.
-                 */
-        }
-
-        /*
-         * Project ids won't be stored on disk if we are using a version 1 inode.
-         */
-        if ((prid != 0) && (ip->i_d.di_version == 1))
-                xfs_bump_ino_vers2(tp, ip);
-
         if (pip && XFS_INHERIT_GID(pip)) {
                 ip->i_d.di_gid = pip->i_d.di_gid;
                 if ((pip->i_d.di_mode & S_ISGID) && S_ISDIR(mode)) {
@@ -1056,40 +1043,6 @@ xfs_droplink(
 }
 
 /*
- * This gets called when the inode's version needs to be changed from 1 to 2.
- * Currently this happens when the nlink field overflows the old 16-bit value
- * or when chproj is called to change the project for the first time.
- * As a side effect the superblock version will also get rev'd
- * to contain the NLINK bit.
- */
-void
-xfs_bump_ino_vers2(
-        xfs_trans_t     *tp,
-        xfs_inode_t     *ip)
-{
-        xfs_mount_t     *mp;
-
-        ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
-        ASSERT(ip->i_d.di_version == 1);
-
-        ip->i_d.di_version = 2;
-        ip->i_d.di_onlink = 0;
-        memset(&(ip->i_d.di_pad[0]), 0, sizeof(ip->i_d.di_pad));
-        mp = tp->t_mountp;
-        if (!xfs_sb_version_hasnlink(&mp->m_sb)) {
-                spin_lock(&mp->m_sb_lock);
-                if (!xfs_sb_version_hasnlink(&mp->m_sb)) {
-                        xfs_sb_version_addnlink(&mp->m_sb);
-                        spin_unlock(&mp->m_sb_lock);
-                        xfs_mod_sb(tp, XFS_SB_VERSIONNUM);
-                } else {
-                        spin_unlock(&mp->m_sb_lock);
-                }
-        }
-        /* Caller must log the inode */
-}
-
-/*
  * Increment the link count on an inode & log the change.
  */
 int
@@ -1099,22 +1052,10 @@ xfs_bumplink(
 {
         xfs_trans_ichgtime(tp, ip, XFS_ICHGTIME_CHG);
 
+        ASSERT(ip->i_d.di_version > 1);
         ASSERT(ip->i_d.di_nlink > 0 || (VFS_I(ip)->i_state & I_LINKABLE));
         ip->i_d.di_nlink++;
         inc_nlink(VFS_I(ip));
-        if ((ip->i_d.di_version == 1) &&
-            (ip->i_d.di_nlink > XFS_MAXLINK_1)) {
-                /*
-                 * The inode has increased its number of links beyond
-                 * what can fit in an old format inode.  It now needs
-                 * to be converted to a version 2 inode with a 32 bit
-                 * link count.  If this is the first inode in the file
-                 * system to do this, then we need to bump the superblock
-                 * version number as well.
-                 */
-                xfs_bump_ino_vers2(tp, ip);
-        }
-
         xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
         return 0;
 }
@@ -3249,6 +3190,7 @@ xfs_iflush_int(
         ASSERT(ip->i_d.di_format != XFS_DINODE_FMT_BTREE ||
                ip->i_d.di_nextents > XFS_IFORK_MAXEXT(ip, XFS_DATA_FORK));
         ASSERT(iip != NULL && iip->ili_fields != 0);
+        ASSERT(ip->i_d.di_version > 1);
 
         /* set *dip = inode's place in the buffer */
         dip = (xfs_dinode_t *)xfs_buf_offset(bp, ip->i_imap.im_boffset);
@@ -3309,7 +3251,7 @@ xfs_iflush_int(
         }
 
         /*
-         * Inode item log recovery for v1/v2 inodes are dependent on the
+         * Inode item log recovery for v2 inodes are dependent on the
          * di_flushiter count for correct sequencing. We bump the flush
          * iteration count so we can detect flushes which postdate a log record
          * during recovery. This is redundant as we now log every change and
@@ -3332,37 +3274,6 @@ xfs_iflush_int(
         if (ip->i_d.di_flushiter == DI_MAX_FLUSH)
                 ip->i_d.di_flushiter = 0;
 
-        /*
-         * If this is really an old format inode and the superblock version
-         * has not been updated to support only new format inodes, then
-         * convert back to the old inode format.  If the superblock version
-         * has been updated, then make the conversion permanent.
-         */
-        ASSERT(ip->i_d.di_version == 1 || xfs_sb_version_hasnlink(&mp->m_sb));
-        if (ip->i_d.di_version == 1) {
-                if (!xfs_sb_version_hasnlink(&mp->m_sb)) {
-                        /*
-                         * Convert it back.
-                         */
-                        ASSERT(ip->i_d.di_nlink <= XFS_MAXLINK_1);
-                        dip->di_onlink = cpu_to_be16(ip->i_d.di_nlink);
-                } else {
-                        /*
-                         * The superblock version has already been bumped,
-                         * so just make the conversion to the new inode
-                         * format permanent.
-                         */
-                        ip->i_d.di_version = 2;
-                        dip->di_version = 2;
-                        ip->i_d.di_onlink = 0;
-                        dip->di_onlink = 0;
-                        memset(&(ip->i_d.di_pad[0]), 0, sizeof(ip->i_d.di_pad));
-                        memset(&(dip->di_pad[0]), 0,
-                              sizeof(dip->di_pad));
-                        ASSERT(xfs_get_projid(ip) == 0);
-                }
-        }
-
         xfs_iflush_fork(ip, dip, iip, XFS_DATA_FORK);
         if (XFS_IFORK_Q(ip))
                 xfs_iflush_fork(ip, dip, iip, XFS_ATTR_FORK);
diff --git a/fs/xfs/xfs_inode.h b/fs/xfs/xfs_inode.h
index 13aea548206c..f72bffa67266 100644
--- a/fs/xfs/xfs_inode.h
+++ b/fs/xfs/xfs_inode.h
@@ -377,7 +377,6 @@ int		xfs_dir_ialloc(struct xfs_trans **, struct xfs_inode *, umode_t,
                                struct xfs_inode **, int *);
 int             xfs_droplink(struct xfs_trans *, struct xfs_inode *);
 int             xfs_bumplink(struct xfs_trans *, struct xfs_inode *);
-void            xfs_bump_ino_vers2(struct xfs_trans *, struct xfs_inode *);
 
 /* from xfs_file.c */
 int             xfs_zero_eof(struct xfs_inode *, xfs_off_t, xfs_fsize_t);
diff --git a/fs/xfs/xfs_inode_buf.c b/fs/xfs/xfs_inode_buf.c
index 24e993996bdc..cb35ae41d4a1 100644
--- a/fs/xfs/xfs_inode_buf.c
+++ b/fs/xfs/xfs_inode_buf.c
@@ -437,17 +437,16 @@ xfs_iread(
         }
 
         /*
-         * The inode format changed when we moved the link count and
-         * made it 32 bits long.  If this is an old format inode,
-         * convert it in memory to look like a new one.  If it gets
-         * flushed to disk we will convert back before flushing or
-         * logging it.  We zero out the new projid field and the old link
-         * count field.  We'll handle clearing the pad field (the remains
-         * of the old uuid field) when we actually convert the inode to
-         * the new format. We don't change the version number so that we
-         * can distinguish this from a real new format inode.
+         * Automatically convert version 1 inode formats in memory to version 2
+         * inode format. If the inode is modified, it will get logged and
+         * rewritten as a version 2 inode. We can do this because we set the
+         * superblock feature bit for v2 inodes unconditionally during mount
+         * and it means the reast of the code can assume the inode version is 2
+         * or higher.
          */
         if (ip->i_d.di_version == 1) {
+                ip->i_d.di_version = 2;
+                memset(&(ip->i_d.di_pad[0]), 0, sizeof(ip->i_d.di_pad));
                 ip->i_d.di_nlink = ip->i_d.di_onlink;
                 ip->i_d.di_onlink = 0;
                 xfs_set_projid(ip, 0);
diff --git a/fs/xfs/xfs_inode_item.c b/fs/xfs/xfs_inode_item.c
index 686889b4a1e5..a640137b3573 100644
--- a/fs/xfs/xfs_inode_item.c
+++ b/fs/xfs/xfs_inode_item.c
@@ -145,34 +145,6 @@ xfs_inode_item_size(
                 xfs_inode_item_attr_fork_size(iip, nvecs, nbytes);
 }
 
-/*
- * If this is a v1 format inode, then we need to log it as such.  This means
- * that we have to copy the link count from the new field to the old.  We
- * don't have to worry about the new fields, because nothing trusts them as
- * long as the old inode version number is there.
- */
-STATIC void
-xfs_inode_item_format_v1_inode(
-        struct xfs_inode        *ip)
-{
-        if (!xfs_sb_version_hasnlink(&ip->i_mount->m_sb)) {
-                /*
-                 * Convert it back.
-                 */
-                ASSERT(ip->i_d.di_nlink <= XFS_MAXLINK_1);
-                ip->i_d.di_onlink = ip->i_d.di_nlink;
-        } else {
-                /*
-                 * The superblock version has already been bumped,
-                 * so just make the conversion to the new inode
-                 * format permanent.
-                 */
-                ip->i_d.di_version = 2;
-                ip->i_d.di_onlink = 0;
-                memset(&(ip->i_d.di_pad[0]), 0, sizeof(ip->i_d.di_pad));
-        }
-}
-
 STATIC void
 xfs_inode_item_format_data_fork(
         struct xfs_inode_log_item *iip,
@@ -370,6 +342,8 @@ xfs_inode_item_format(
         struct xfs_inode_log_format *ilf;
         struct xfs_log_iovec    *vecp = NULL;
 
+        ASSERT(ip->i_d.di_version > 1);
+
         ilf = xlog_prepare_iovec(lv, &vecp, XLOG_REG_TYPE_IFORMAT);
         ilf->ilf_type = XFS_LI_INODE;
         ilf->ilf_ino = ip->i_ino;
@@ -380,8 +354,6 @@ xfs_inode_item_format(
         ilf->ilf_size = 2; /* format + core */
         xlog_finish_iovec(lv, vecp, sizeof(struct xfs_inode_log_format));
 
-        if (ip->i_d.di_version == 1)
-                xfs_inode_item_format_v1_inode(ip);
         xlog_copy_iovec(lv, &vecp, XLOG_REG_TYPE_ICORE,
                         &ip->i_d,
                         xfs_icdinode_size(ip->i_d.di_version));
diff --git a/fs/xfs/xfs_ioctl.c b/fs/xfs/xfs_ioctl.c
index 2d8f4fdf07f9..55724c8b204b 100644
--- a/fs/xfs/xfs_ioctl.c
+++ b/fs/xfs/xfs_ioctl.c
@@ -1228,15 +1228,8 @@ xfs_ioctl_setattr(
                                 olddquot = xfs_qm_vop_chown(tp, ip,
                                                         &ip->i_pdquot, pdqp);
                         }
+                        ASSERT(ip->i_d.di_version > 1);
                         xfs_set_projid(ip, fa->fsx_projid);
-
-                        /*
-                         * We may have to rev the inode as well as
-                         * the superblock version number since projids didn't
-                         * exist before DINODE_VERSION_2 and SB_VERSION_NLINK.
-                         */
-                        if (ip->i_d.di_version == 1)
-                                xfs_bump_ino_vers2(tp, ip);
                 }
 
         }
diff --git a/fs/xfs/xfs_mount.c b/fs/xfs/xfs_mount.c
index 944f3d9456a8..3f097825eff3 100644
--- a/fs/xfs/xfs_mount.c
+++ b/fs/xfs/xfs_mount.c
@@ -697,6 +697,12 @@ xfs_mountfs(
                         mp->m_update_flags |= XFS_SB_VERSIONNUM;
         }
 
+        /* always use v2 inodes by default now */
+        if (!(mp->m_sb.sb_versionnum & XFS_SB_VERSION_NLINKBIT)) {
+                mp->m_sb.sb_versionnum |= XFS_SB_VERSION_NLINKBIT;
+                mp->m_update_flags |= XFS_SB_VERSIONNUM;
+        }
+
         /*
          * Check if sb_agblocks is aligned at stripe boundary
          * If sb_agblocks is NOT aligned turn off m_dalign since
diff --git a/fs/xfs/xfs_sb.c b/fs/xfs/xfs_sb.c
index 8baf61afae1d..c3453b11f563 100644
--- a/fs/xfs/xfs_sb.c
+++ b/fs/xfs/xfs_sb.c
@@ -291,7 +291,8 @@ xfs_mount_validate_sb(
             (sbp->sb_imax_pct > 100 /* zero sb_imax_pct is valid */)    ||
             sbp->sb_dblocks == 0                                        ||
             sbp->sb_dblocks > XFS_MAX_DBLOCKS(sbp)                      ||
-            sbp->sb_dblocks < XFS_MIN_DBLOCKS(sbp))) {
+            sbp->sb_dblocks < XFS_MIN_DBLOCKS(sbp)                      ||
+            sbp->sb_shared_vn != 0)) {
                 xfs_notice(mp, "SB sanity check failed");
                 return XFS_ERROR(EFSCORRUPTED);
         }
@@ -333,15 +334,6 @@ xfs_mount_validate_sb(
                 xfs_warn(mp, "Offline file system operation in progress!");
                 return XFS_ERROR(EFSCORRUPTED);
         }
-
-        /*
-         * Version 1 directory format has never worked on Linux.
-         */
-        if (unlikely(!xfs_sb_version_hasdirv2(sbp))) {
-                xfs_warn(mp, "file system using version 1 directory format");
-                return XFS_ERROR(ENOSYS);
-        }
-
         return 0;
 }
 
diff --git a/fs/xfs/xfs_sb.h b/fs/xfs/xfs_sb.h
index 950d1ea058b2..c43c2d609a24 100644
--- a/fs/xfs/xfs_sb.h
+++ b/fs/xfs/xfs_sb.h
@@ -36,8 +36,6 @@ struct xfs_trans;
 #define XFS_SB_VERSION_5        5               /* CRC enabled filesystem */
 #define XFS_SB_VERSION_NUMBITS          0x000f
 #define XFS_SB_VERSION_ALLFBITS         0xfff0
-#define XFS_SB_VERSION_SASHFBITS        0xf000
-#define XFS_SB_VERSION_REALFBITS        0x0ff0
 #define XFS_SB_VERSION_ATTRBIT          0x0010
 #define XFS_SB_VERSION_NLINKBIT         0x0020
 #define XFS_SB_VERSION_QUOTABIT         0x0040
@@ -50,24 +48,15 @@ struct xfs_trans;
 #define XFS_SB_VERSION_DIRV2BIT         0x2000
 #define XFS_SB_VERSION_BORGBIT          0x4000  /* ASCII only case-insens. */
 #define XFS_SB_VERSION_MOREBITSBIT      0x8000
-#define XFS_SB_VERSION_OKSASHFBITS      \
-        (XFS_SB_VERSION_EXTFLGBIT | \
-         XFS_SB_VERSION_DIRV2BIT | \
-         XFS_SB_VERSION_BORGBIT)
-#define XFS_SB_VERSION_OKREALFBITS      \
-        (XFS_SB_VERSION_ATTRBIT | \
-         XFS_SB_VERSION_NLINKBIT | \
-         XFS_SB_VERSION_QUOTABIT | \
-         XFS_SB_VERSION_ALIGNBIT | \
-         XFS_SB_VERSION_DALIGNBIT | \
-         XFS_SB_VERSION_SHAREDBIT | \
-         XFS_SB_VERSION_LOGV2BIT | \
-         XFS_SB_VERSION_SECTORBIT | \
-         XFS_SB_VERSION_MOREBITSBIT)
-#define XFS_SB_VERSION_OKREALBITS       \
-        (XFS_SB_VERSION_NUMBITS | \
-         XFS_SB_VERSION_OKREALFBITS | \
-         XFS_SB_VERSION_OKSASHFBITS)
+
+/*
+ * Supported feature bit list is just all bits in the versionnum field because
+ * we've used them all up and understand them all. Except, of course, for the
+ * shared superblock bit, which nobody knows what it does and so is unsupported.
+ */
+#define XFS_SB_VERSION_OKBITS           \
+        ((XFS_SB_VERSION_NUMBITS | XFS_SB_VERSION_ALLFBITS) & \
+                ~XFS_SB_VERSION_SHAREDBIT)
 
 /*
  * There are two words to hold XFS "feature" bits: the original
@@ -76,7 +65,6 @@ struct xfs_trans;
  *
  * These defines represent bits in sb_features2.
  */
-#define XFS_SB_VERSION2_REALFBITS       0x00ffffff      /* Mask: features */
 #define XFS_SB_VERSION2_RESERVED1BIT    0x00000001
 #define XFS_SB_VERSION2_LAZYSBCOUNTBIT  0x00000002      /* Superblk counters */
 #define XFS_SB_VERSION2_RESERVED4BIT    0x00000004
@@ -86,16 +74,11 @@ struct xfs_trans;
 #define XFS_SB_VERSION2_CRCBIT          0x00000100      /* metadata CRCs */
 #define XFS_SB_VERSION2_FTYPE           0x00000200      /* inode type in dir */
 
-#define XFS_SB_VERSION2_OKREALFBITS     \
+#define XFS_SB_VERSION2_OKBITS          \
         (XFS_SB_VERSION2_LAZYSBCOUNTBIT | \
          XFS_SB_VERSION2_ATTR2BIT       | \
          XFS_SB_VERSION2_PROJID32BIT    | \
          XFS_SB_VERSION2_FTYPE)
-#define XFS_SB_VERSION2_OKSASHFBITS     \
-        (0)
-#define XFS_SB_VERSION2_OKREALBITS      \
-        (XFS_SB_VERSION2_OKREALFBITS |  \
-         XFS_SB_VERSION2_OKSASHFBITS )
 
 /*
  * Superblock - in core version.  Must match the ondisk version below.
@@ -345,214 +328,140 @@ typedef enum {
 
 #define XFS_SB_VERSION_NUM(sbp) ((sbp)->sb_versionnum & XFS_SB_VERSION_NUMBITS)
 
-static inline int xfs_sb_good_version(xfs_sb_t *sbp)
-{
-        /* We always support version 1-3 */
-        if (sbp->sb_versionnum >= XFS_SB_VERSION_1 &&
-            sbp->sb_versionnum <= XFS_SB_VERSION_3)
-                return 1;
-
-        /* We support version 4 if all feature bits are supported */
-        if (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) {
-                if ((sbp->sb_versionnum & ~XFS_SB_VERSION_OKREALBITS) ||
-                    ((sbp->sb_versionnum & XFS_SB_VERSION_MOREBITSBIT) &&
-                     (sbp->sb_features2 & ~XFS_SB_VERSION2_OKREALBITS)))
-                        return 0;
-
-                if (sbp->sb_shared_vn > XFS_SB_MAX_SHARED_VN)
-                        return 0;
-                return 1;
-        }
-        if (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_5)
-                return 1;
-
-        return 0;
-}
-
 /*
- * Detect a mismatched features2 field.  Older kernels read/wrote
- * this into the wrong slot, so to be safe we keep them in sync.
+ * The first XFS version we support is a v4 superblock with V2 directories.
  */
-static inline int xfs_sb_has_mismatched_features2(xfs_sb_t *sbp)
+static inline bool xfs_sb_good_v4_features(struct xfs_sb *sbp)
 {
-        return (sbp->sb_bad_features2 != sbp->sb_features2);
-}
+        if (!(sbp->sb_versionnum & XFS_SB_VERSION_DIRV2BIT))
+                return false;
 
-static inline unsigned xfs_sb_version_tonew(unsigned v)
-{
-        if (v == XFS_SB_VERSION_1)
-                return XFS_SB_VERSION_4;
+        /* check for unknown features in the fs */
+        if ((sbp->sb_versionnum & ~XFS_SB_VERSION_OKBITS) ||
+            ((sbp->sb_versionnum & XFS_SB_VERSION_MOREBITSBIT) &&
+             (sbp->sb_features2 & ~XFS_SB_VERSION2_OKBITS)))
+                return false;
 
-        if (v == XFS_SB_VERSION_2)
-                return XFS_SB_VERSION_4 | XFS_SB_VERSION_ATTRBIT;
-
-        return XFS_SB_VERSION_4 | XFS_SB_VERSION_ATTRBIT |
-                XFS_SB_VERSION_NLINKBIT;
+        return true;
 }
 
-static inline unsigned xfs_sb_version_toold(unsigned v)
+static inline bool xfs_sb_good_version(struct xfs_sb *sbp)
 {
-        if (v & (XFS_SB_VERSION_QUOTABIT | XFS_SB_VERSION_ALIGNBIT))
-                return 0;
-        if (v & XFS_SB_VERSION_NLINKBIT)
-                return XFS_SB_VERSION_3;
-        if (v & XFS_SB_VERSION_ATTRBIT)
-                return XFS_SB_VERSION_2;
-        return XFS_SB_VERSION_1;
-}
-
-static inline int xfs_sb_version_hasattr(xfs_sb_t *sbp)
-{
-        return sbp->sb_versionnum == XFS_SB_VERSION_2 ||
-                sbp->sb_versionnum == XFS_SB_VERSION_3 ||
-                (XFS_SB_VERSION_NUM(sbp) >= XFS_SB_VERSION_4 &&
-                 (sbp->sb_versionnum & XFS_SB_VERSION_ATTRBIT));
+        if (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_5)
+                return true;
+        if (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4)
+                return xfs_sb_good_v4_features(sbp);
+        return false;
 }
 
-static inline void xfs_sb_version_addattr(xfs_sb_t *sbp)
+/*
+ * Detect a mismatched features2 field.  Older kernels read/wrote
+ * this into the wrong slot, so to be safe we keep them in sync.
+ */
+static inline bool xfs_sb_has_mismatched_features2(struct xfs_sb *sbp)
 {
-        if (sbp->sb_versionnum == XFS_SB_VERSION_1)
-                sbp->sb_versionnum = XFS_SB_VERSION_2;
-        else if (XFS_SB_VERSION_NUM(sbp) >= XFS_SB_VERSION_4)
-                sbp->sb_versionnum |= XFS_SB_VERSION_ATTRBIT;
-        else
-                sbp->sb_versionnum = XFS_SB_VERSION_4 | XFS_SB_VERSION_ATTRBIT;
+        return sbp->sb_bad_features2 != sbp->sb_features2;
 }
 
-static inline int xfs_sb_version_hasnlink(xfs_sb_t *sbp)
+static inline bool xfs_sb_version_hasattr(struct xfs_sb *sbp)
 {
-        return sbp->sb_versionnum == XFS_SB_VERSION_3 ||
-                 (XFS_SB_VERSION_NUM(sbp) >= XFS_SB_VERSION_4 &&
-                  (sbp->sb_versionnum & XFS_SB_VERSION_NLINKBIT));
+        return (sbp->sb_versionnum & XFS_SB_VERSION_ATTRBIT);
 }
 
-static inline void xfs_sb_version_addnlink(xfs_sb_t *sbp)
+static inline void xfs_sb_version_addattr(struct xfs_sb *sbp)
 {
-        if (sbp->sb_versionnum <= XFS_SB_VERSION_2)
-                sbp->sb_versionnum = XFS_SB_VERSION_3;
-        else
-                sbp->sb_versionnum |= XFS_SB_VERSION_NLINKBIT;
+        sbp->sb_versionnum |= XFS_SB_VERSION_ATTRBIT;
 }
 
-static inline int xfs_sb_version_hasquota(xfs_sb_t *sbp)
+static inline bool xfs_sb_version_hasquota(struct xfs_sb *sbp)
 {
-        return XFS_SB_VERSION_NUM(sbp) >= XFS_SB_VERSION_4 &&
-                (sbp->sb_versionnum & XFS_SB_VERSION_QUOTABIT);
+        return (sbp->sb_versionnum & XFS_SB_VERSION_QUOTABIT);
 }
 
-static inline void xfs_sb_version_addquota(xfs_sb_t *sbp)
+static inline void xfs_sb_version_addquota(struct xfs_sb *sbp)
 {
-        if (XFS_SB_VERSION_NUM(sbp) >= XFS_SB_VERSION_4)
-                sbp->sb_versionnum |= XFS_SB_VERSION_QUOTABIT;
-        else
-                sbp->sb_versionnum = xfs_sb_version_tonew(sbp->sb_versionnum) |
-                                        XFS_SB_VERSION_QUOTABIT;
+        sbp->sb_versionnum |= XFS_SB_VERSION_QUOTABIT;
 }
 
-static inline int xfs_sb_version_hasalign(xfs_sb_t *sbp)
+static inline bool xfs_sb_version_hasalign(struct xfs_sb *sbp)
 {
-        return (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_5) ||
-               (XFS_SB_VERSION_NUM(sbp) >= XFS_SB_VERSION_4 &&
+        return (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_5 ||
                 (sbp->sb_versionnum & XFS_SB_VERSION_ALIGNBIT));
 }
 
-static inline int xfs_sb_version_hasdalign(xfs_sb_t *sbp)
+static inline bool xfs_sb_version_hasdalign(struct xfs_sb *sbp)
 {
-        return XFS_SB_VERSION_NUM(sbp) >= XFS_SB_VERSION_4 &&
-                (sbp->sb_versionnum & XFS_SB_VERSION_DALIGNBIT);
+        return (sbp->sb_versionnum & XFS_SB_VERSION_DALIGNBIT);
 }
 
-static inline int xfs_sb_version_hasshared(xfs_sb_t *sbp)
+static inline bool xfs_sb_version_haslogv2(struct xfs_sb *sbp)
 {
-        return XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4 &&
-                (sbp->sb_versionnum & XFS_SB_VERSION_SHAREDBIT);
+        return XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_5 ||
+               (sbp->sb_versionnum & XFS_SB_VERSION_LOGV2BIT);
 }
 
-static inline int xfs_sb_version_hasdirv2(xfs_sb_t *sbp)
+static inline bool xfs_sb_version_hasextflgbit(struct xfs_sb *sbp)
 {
-        return (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_5) ||
-               (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4 &&
-                (sbp->sb_versionnum & XFS_SB_VERSION_DIRV2BIT));
+        return XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_5 ||
+               (sbp->sb_versionnum & XFS_SB_VERSION_EXTFLGBIT);
 }
 
-static inline int xfs_sb_version_haslogv2(xfs_sb_t *sbp)
+static inline bool xfs_sb_version_hassector(struct xfs_sb *sbp)
 {
-        return (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_5) ||
-               (XFS_SB_VERSION_NUM(sbp) >= XFS_SB_VERSION_4 &&
-                (sbp->sb_versionnum & XFS_SB_VERSION_LOGV2BIT));
+        return (sbp->sb_versionnum & XFS_SB_VERSION_SECTORBIT);
 }
 
-static inline int xfs_sb_version_hasextflgbit(xfs_sb_t *sbp)
+static inline bool xfs_sb_version_hasasciici(struct xfs_sb *sbp)
 {
-        return (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_5) ||
-               (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4 &&
-                (sbp->sb_versionnum & XFS_SB_VERSION_EXTFLGBIT));
+        return (sbp->sb_versionnum & XFS_SB_VERSION_BORGBIT);
 }
 
-static inline int xfs_sb_version_hassector(xfs_sb_t *sbp)
+static inline bool xfs_sb_version_hasmorebits(struct xfs_sb *sbp)
 {
-        return XFS_SB_VERSION_NUM(sbp) >= XFS_SB_VERSION_4 &&
-                (sbp->sb_versionnum & XFS_SB_VERSION_SECTORBIT);
-}
-
-static inline int xfs_sb_version_hasasciici(xfs_sb_t *sbp)
-{
-        return XFS_SB_VERSION_NUM(sbp) >= XFS_SB_VERSION_4 &&
-                (sbp->sb_versionnum & XFS_SB_VERSION_BORGBIT);
-}
-
-static inline int xfs_sb_version_hasmorebits(xfs_sb_t *sbp)
-{
-        return (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_5) ||
-               (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4 &&
-                (sbp->sb_versionnum & XFS_SB_VERSION_MOREBITSBIT));
+        return XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_5 ||
+               (sbp->sb_versionnum & XFS_SB_VERSION_MOREBITSBIT);
 }
 
 /*
  * sb_features2 bit version macros.
- *
- * For example, for a bit defined as XFS_SB_VERSION2_FUNBIT, has a macro:
- *
- * SB_VERSION_HASFUNBIT(xfs_sb_t *sbp)
- *      ((xfs_sb_version_hasmorebits(sbp) &&
- *       ((sbp)->sb_features2 & XFS_SB_VERSION2_FUNBIT)
  */
-
-static inline int xfs_sb_version_haslazysbcount(xfs_sb_t *sbp)
+static inline bool xfs_sb_version_haslazysbcount(struct xfs_sb *sbp)
 {
         return (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_5) ||
                (xfs_sb_version_hasmorebits(sbp) &&
                 (sbp->sb_features2 & XFS_SB_VERSION2_LAZYSBCOUNTBIT));
 }
 
-static inline int xfs_sb_version_hasattr2(xfs_sb_t *sbp)
+static inline bool xfs_sb_version_hasattr2(struct xfs_sb *sbp)
 {
         return (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_5) ||
                (xfs_sb_version_hasmorebits(sbp) &&
                 (sbp->sb_features2 & XFS_SB_VERSION2_ATTR2BIT));
 }
 
-static inline void xfs_sb_version_addattr2(xfs_sb_t *sbp)
+static inline void xfs_sb_version_addattr2(struct xfs_sb *sbp)
 {
         sbp->sb_versionnum |= XFS_SB_VERSION_MOREBITSBIT;
         sbp->sb_features2 |= XFS_SB_VERSION2_ATTR2BIT;
+        sbp->sb_bad_features2 |= XFS_SB_VERSION2_ATTR2BIT;
 }
 
-static inline void xfs_sb_version_removeattr2(xfs_sb_t *sbp)
+static inline void xfs_sb_version_removeattr2(struct xfs_sb *sbp)
 {
         sbp->sb_features2 &= ~XFS_SB_VERSION2_ATTR2BIT;
+        sbp->sb_bad_features2 &= ~XFS_SB_VERSION2_ATTR2BIT;
         if (!sbp->sb_features2)
                 sbp->sb_versionnum &= ~XFS_SB_VERSION_MOREBITSBIT;
 }
 
-static inline int xfs_sb_version_hasprojid32bit(xfs_sb_t *sbp)
+static inline bool xfs_sb_version_hasprojid32bit(struct xfs_sb *sbp)
 {
         return (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_5) ||
                (xfs_sb_version_hasmorebits(sbp) &&
                 (sbp->sb_features2 & XFS_SB_VERSION2_PROJID32BIT));
 }
 
-static inline void xfs_sb_version_addprojid32bit(xfs_sb_t *sbp)
+static inline void xfs_sb_version_addprojid32bit(struct xfs_sb *sbp)
 {
         sbp->sb_versionnum |= XFS_SB_VERSION_MOREBITSBIT;
         sbp->sb_features2 |= XFS_SB_VERSION2_PROJID32BIT;
@@ -625,12 +534,12 @@ xfs_sb_has_incompat_log_feature(
 /*
  * V5 superblock specific feature checks
  */
-static inline int xfs_sb_version_hascrc(xfs_sb_t *sbp)
+static inline int xfs_sb_version_hascrc(struct xfs_sb *sbp)
 {
         return XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_5;
 }
 
-static inline int xfs_sb_version_has_pquotino(xfs_sb_t *sbp)
+static inline int xfs_sb_version_has_pquotino(struct xfs_sb *sbp)
 {
         return XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_5;
 }