xfs
[Top] [All Lists]

[RFC, PATCH] xfs: make superblock version checks reflect reality

To: xfs@xxxxxxxxxxx
Subject: [RFC, PATCH] xfs: make superblock version checks reflect reality
From: Dave Chinner <david@xxxxxxxxxxxxx>
Date: Thu, 6 Mar 2014 17:54:50 +1100
Delivered-to: xfs@xxxxxxxxxxx
From: Dave Chinner <dchinner@xxxxxxxxxx>

We only support filesystems that have v2 directory support, and than
means all the checking and handling of superblock versions prior to
this support being added is completely unnecessary overhead.

Strip out all the version 1-3 support, sanitise the good version
checking to reflect the supported versions, update all the feature
supported functions and clean up all the support bit definitions to
reflect the fact that we no longer care about Irix bootloader flag
regions for v4 feature bits.

Because the feature bit checking is all inline code, this relatively
small cleanup has a noticable impact on code size:

   text    data     bss     dec     hex filename
 802836   99339     632  902807   dc697 fs/xfs/xfs.o.orig
 801620   99339     632  901591   dc1d7 fs/xfs/xfs.o.patched

i.e. it reduces it by more than 1200 bytes.

Signed-off-by: Dave Chinner <dchinner@xxxxxxxxxx>
---
 fs/xfs/xfs_sb.h | 175 ++++++++++++++++++++++----------------------------------
 1 file changed, 67 insertions(+), 108 deletions(-)

diff --git a/fs/xfs/xfs_sb.h b/fs/xfs/xfs_sb.h
index f7b2fe7..1fe9818 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,26 @@ 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 | \
+
+/*
+ * We only support superblocks that have at least V2 Dir capability. Any 
feature
+ * bit added after v2 dir capability is also indicates a supported superblock
+ * format.
+ */
+#define XFS_SB_NEEDED_FEATURES         \
+       (XFS_SB_VERSION_DIRV2BIT        | \
+        XFS_SB_VERSION_LOGV2BIT        | \
+        XFS_SB_VERSION_SECTORBIT       | \
+        XFS_SB_VERSION_BORGBIT         | \
         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.
+ */
+#define        XFS_SB_VERSION_OKBITS           \
+       (XFS_SB_VERSION_NUMBITS         | \
+        XFS_SB_VERSION_ALLFBITS)
 
 /*
  * There are two words to hold XFS "feature" bits: the original
@@ -76,7 +76,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 +85,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,28 +339,40 @@ typedef enum {
 
 #define        XFS_SB_VERSION_NUM(sbp) ((sbp)->sb_versionnum & 
XFS_SB_VERSION_NUMBITS)
 
+/*
+ * The first XFS version we support is filesytsems with V2 directories.
+ */
 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)
+       /* We only support v4 and v5 */
+       if (XFS_SB_VERSION_NUM(sbp) < XFS_SB_VERSION_4 ||
+           XFS_SB_VERSION_NUM(sbp) > XFS_SB_VERSION_5)
+               return 0;
+
+       /*
+        * Version 5 feature checks are done separately.
+        */
+       if (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_5)
                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;
+       /*
+        * We only support version 4 for if at least one of the needed feature
+        * bits are set and all the feature bits are supported.
+        */
+       ASSERT(XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4);
+
+       if (!(sbp->sb_versionnum & XFS_SB_NEEDED_FEATURES))
+               return 0;
 
-               if (sbp->sb_shared_vn > XFS_SB_MAX_SHARED_VN)
+       if ((sbp->sb_versionnum & ~XFS_SB_VERSION_OKBITS) ||
+           ((sbp->sb_versionnum & XFS_SB_VERSION_MOREBITSBIT) &&
+            (sbp->sb_features2 & ~XFS_SB_VERSION2_OKBITS)))
                        return 0;
-               return 1;
-       }
-       if (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_5)
-               return 1;
 
-       return 0;
+       if (sbp->sb_shared_vn > XFS_SB_MAX_SHARED_VN)
+               return 0;
+
+       return 1;
 }
 
 /*
@@ -378,88 +384,45 @@ static inline int 
xfs_sb_has_mismatched_features2(xfs_sb_t *sbp)
        return (sbp->sb_bad_features2 != sbp->sb_features2);
 }
 
-static inline unsigned xfs_sb_version_tonew(unsigned v)
-{
-       if (v == XFS_SB_VERSION_1)
-               return XFS_SB_VERSION_4;
-
-       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;
-}
-
-static inline unsigned xfs_sb_version_toold(unsigned v)
-{
-       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));
+       return !!(sbp->sb_versionnum & XFS_SB_VERSION_ATTRBIT);
 }
 
 static inline void xfs_sb_version_addattr(xfs_sb_t *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;
+       sbp->sb_versionnum |= XFS_SB_VERSION_ATTRBIT;
 }
 
 static inline int xfs_sb_version_hasnlink(xfs_sb_t *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_NLINKBIT);
 }
 
 static inline void xfs_sb_version_addnlink(xfs_sb_t *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_NLINKBIT;
 }
 
 static inline int xfs_sb_version_hasquota(xfs_sb_t *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)
 {
-       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)
 {
-       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)
 {
-       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)
@@ -470,42 +433,36 @@ static inline int xfs_sb_version_hasshared(xfs_sb_t *sbp)
 
 static inline int xfs_sb_version_hasdirv2(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_DIRV2BIT));
+       return XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_5 ||
+              (sbp->sb_versionnum & XFS_SB_VERSION_DIRV2BIT);
 }
 
 static inline int xfs_sb_version_haslogv2(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_LOGV2BIT));
+       return XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_5 ||
+              (sbp->sb_versionnum & XFS_SB_VERSION_LOGV2BIT);
 }
 
 static inline int xfs_sb_version_hasextflgbit(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_EXTFLGBIT));
+       return XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_5 ||
+              (sbp->sb_versionnum & XFS_SB_VERSION_EXTFLGBIT);
 }
 
 static inline int xfs_sb_version_hassector(xfs_sb_t *sbp)
 {
-       return XFS_SB_VERSION_NUM(sbp) >= XFS_SB_VERSION_4 &&
-               (sbp->sb_versionnum & XFS_SB_VERSION_SECTORBIT);
+       return !!(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);
+       return !!(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);
 }
 
 /*
@@ -536,11 +493,13 @@ static inline void xfs_sb_version_addattr2(xfs_sb_t *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)
 {
        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;
 }
-- 
1.9.0

<Prev in Thread] Current Thread [Next in Thread>