xfs: add CRC checks to the superblock

With the addition of CRCs, there is such a wide and varied change to
the on disk format that it makes sense to bump the superblock
version number rather than try to use feature bits for all the new
functionality.

This commit introduces all the new superblock fields needed for all
the new functionality: feature masks similar to ext4, separate
project quota inodes, a LSN field for recovery and the CRC field.

This commit does not bump the superblock version number, however.
That will be done as a separate commit at the end of the series
after all the new functionality is present so we switch it all on in
one commit. This means that we can slowly introduce the changes
without them being active and hence maintain bisectability of the
tree.

This patch is based on a patch originally written by myself back
from SGI days, which was subsequently modified by Christoph Hellwig.
There is relatively little of that patch remaining, but the history
of the patch still should be acknowledged here.

Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Ben Myers <bpm@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>

1 files changed, 71 insertions, 29 deletions

diff --git a/fs/xfs/xfs_sb.h b/fs/xfs/xfs_sb.h
index a05b45175fb0..457fefae5683 100644
--- a/fs/xfs/xfs_sb.h
+++ b/fs/xfs/xfs_sb.h
@@ -32,6 +32,7 @@ struct xfs_mount;
 #define XFS_SB_VERSION_2        2               /* 6.2 - attributes */
 #define XFS_SB_VERSION_3        3               /* 6.2 - new inode version */
 #define XFS_SB_VERSION_4        4               /* 6.2+ - bitmask version */
+#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
@@ -161,6 +162,18 @@ typedef struct xfs_sb {
          */
         __uint32_t      sb_bad_features2;
 
+        /* version 5 superblock fields start here */
+
+        /* feature masks */
+        __uint32_t      sb_features_compat;
+        __uint32_t      sb_features_ro_compat;
+        __uint32_t      sb_features_incompat;
+
+        __uint32_t      sb_crc;         /* superblock crc */
+
+        xfs_ino_t       sb_pquotino;    /* project quota inode */
+        xfs_lsn_t       sb_lsn;         /* last write sequence */
+
         /* must be padded to 64 bit alignment */
 } xfs_sb_t;
 
@@ -229,7 +242,19 @@ typedef struct xfs_dsb {
          * for features2 bits. Easiest just to mark it bad and not use
          * it for anything else.
          */
-        __be32  sb_bad_features2;
+        __be32          sb_bad_features2;
+
+        /* version 5 superblock fields start here */
+
+        /* feature masks */
+        __be32          sb_features_compat;
+        __be32          sb_features_ro_compat;
+        __be32          sb_features_incompat;
+
+        __le32          sb_crc;         /* superblock crc */
+
+        __be64          sb_pquotino;    /* project quota inode */
+        __be64          sb_lsn;         /* last write sequence */
 
         /* must be padded to 64 bit alignment */
 } xfs_dsb_t;
@@ -250,7 +275,9 @@ typedef enum {
         XFS_SBS_GQUOTINO, XFS_SBS_QFLAGS, XFS_SBS_FLAGS, XFS_SBS_SHARED_VN,
         XFS_SBS_INOALIGNMT, XFS_SBS_UNIT, XFS_SBS_WIDTH, XFS_SBS_DIRBLKLOG,
         XFS_SBS_LOGSECTLOG, XFS_SBS_LOGSECTSIZE, XFS_SBS_LOGSUNIT,
-        XFS_SBS_FEATURES2, XFS_SBS_BAD_FEATURES2,
+        XFS_SBS_FEATURES2, XFS_SBS_BAD_FEATURES2, XFS_SBS_FEATURES_COMPAT,
+        XFS_SBS_FEATURES_RO_COMPAT, XFS_SBS_FEATURES_INCOMPAT, XFS_SBS_CRC,
+        XFS_SBS_PQUOTINO, XFS_SBS_LSN,
         XFS_SBS_FIELDCOUNT
 } xfs_sb_field_t;
 
@@ -276,6 +303,11 @@ typedef enum {
 #define XFS_SB_FDBLOCKS         XFS_SB_MVAL(FDBLOCKS)
 #define XFS_SB_FEATURES2        XFS_SB_MVAL(FEATURES2)
 #define XFS_SB_BAD_FEATURES2    XFS_SB_MVAL(BAD_FEATURES2)
+#define XFS_SB_FEATURES_COMPAT  XFS_SB_MVAL(FEATURES_COMPAT)
+#define XFS_SB_FEATURES_RO_COMPAT XFS_SB_MVAL(FEATURES_RO_COMPAT)
+#define XFS_SB_FEATURES_INCOMPAT XFS_SB_MVAL(FEATURES_INCOMPAT)
+#define XFS_SB_CRC              XFS_SB_MVAL(CRC)
+#define XFS_SB_PQUOTINO         XFS_SB_MVAL(PQUOTINO)
 #define XFS_SB_NUM_BITS         ((int)XFS_SBS_FIELDCOUNT)
 #define XFS_SB_ALL_BITS         ((1LL << XFS_SB_NUM_BITS) - 1)
 #define XFS_SB_MOD_BITS         \
@@ -283,7 +315,8 @@ typedef enum {
          XFS_SB_VERSIONNUM | XFS_SB_UQUOTINO | XFS_SB_GQUOTINO | \
          XFS_SB_QFLAGS | XFS_SB_SHARED_VN | XFS_SB_UNIT | XFS_SB_WIDTH | \
          XFS_SB_ICOUNT | XFS_SB_IFREE | XFS_SB_FDBLOCKS | XFS_SB_FEATURES2 | \
-         XFS_SB_BAD_FEATURES2)
+         XFS_SB_BAD_FEATURES2 | XFS_SB_FEATURES_COMPAT | \
+         XFS_SB_FEATURES_RO_COMPAT | XFS_SB_FEATURES_INCOMPAT | XFS_SB_PQUOTINO)
 
 
 /*
@@ -325,6 +358,8 @@ static inline int xfs_sb_good_version(xfs_sb_t *sbp)
 
                 return 1;
         }
+        if (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_5)
+                return 1;
 
         return 0;
 }
@@ -365,7 +400,7 @@ 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 &&
+                (XFS_SB_VERSION_NUM(sbp) >= XFS_SB_VERSION_4 &&
                  (sbp->sb_versionnum & XFS_SB_VERSION_ATTRBIT));
 }
 
@@ -373,7 +408,7 @@ 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)
+        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;
@@ -382,7 +417,7 @@ static inline void xfs_sb_version_addattr(xfs_sb_t *sbp)
 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 &&
+                 (XFS_SB_VERSION_NUM(sbp) >= XFS_SB_VERSION_4 &&
                   (sbp->sb_versionnum & XFS_SB_VERSION_NLINKBIT));
 }
 
@@ -396,13 +431,13 @@ static inline void xfs_sb_version_addnlink(xfs_sb_t *sbp)
 
 static inline int xfs_sb_version_hasquota(xfs_sb_t *sbp)
 {
-        return XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4 &&
+        return XFS_SB_VERSION_NUM(sbp) >= XFS_SB_VERSION_4 &&
                 (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)
+        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) |
@@ -411,13 +446,14 @@ static inline void xfs_sb_version_addquota(xfs_sb_t *sbp)
 
 static inline int xfs_sb_version_hasalign(xfs_sb_t *sbp)
 {
-        return XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4 &&
-                (sbp->sb_versionnum & XFS_SB_VERSION_ALIGNBIT);
+        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_ALIGNBIT));
 }
 
 static inline int xfs_sb_version_hasdalign(xfs_sb_t *sbp)
 {
-        return XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4 &&
+        return XFS_SB_VERSION_NUM(sbp) >= XFS_SB_VERSION_4 &&
                 (sbp->sb_versionnum & XFS_SB_VERSION_DALIGNBIT);
 }
 
@@ -429,38 +465,42 @@ 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_4 &&
-                (sbp->sb_versionnum & XFS_SB_VERSION_DIRV2BIT);
+        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));
 }
 
 static inline int xfs_sb_version_haslogv2(xfs_sb_t *sbp)
 {
-        return 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) ||
+               (XFS_SB_VERSION_NUM(sbp) >= XFS_SB_VERSION_4 &&
+                (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_4 &&
-                (sbp->sb_versionnum & XFS_SB_VERSION_EXTFLGBIT);
+        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));
 }
 
 static inline int xfs_sb_version_hassector(xfs_sb_t *sbp)
 {
-        return XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4 &&
+        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 &&
+        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_4 &&
-                (sbp->sb_versionnum & XFS_SB_VERSION_MOREBITSBIT);
+        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));
 }
 
 /*
@@ -475,14 +515,16 @@ static inline int xfs_sb_version_hasmorebits(xfs_sb_t *sbp)
 
 static inline int xfs_sb_version_haslazysbcount(xfs_sb_t *sbp)
 {
-        return xfs_sb_version_hasmorebits(sbp) &&
-                (sbp->sb_features2 & XFS_SB_VERSION2_LAZYSBCOUNTBIT);
+        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)
 {
-        return xfs_sb_version_hasmorebits(sbp) &&
-                (sbp->sb_features2 & XFS_SB_VERSION2_ATTR2BIT);
+        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)
@@ -500,14 +542,14 @@ static inline void xfs_sb_version_removeattr2(xfs_sb_t *sbp)
 
 static inline int xfs_sb_version_hasprojid32bit(xfs_sb_t *sbp)
 {
-        return xfs_sb_version_hasmorebits(sbp) &&
-                (sbp->sb_features2 & XFS_SB_VERSION2_PROJID32BIT);
+        return (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_5) ||
+               (xfs_sb_version_hasmorebits(sbp) &&
+                (sbp->sb_features2 & XFS_SB_VERSION2_PROJID32BIT));
 }
 
 static inline int xfs_sb_version_hascrc(xfs_sb_t *sbp)
 {
-        return (xfs_sb_version_hasmorebits(sbp) &&
-                (sbp->sb_features2 & XFS_SB_VERSION2_CRCBIT));
+        return XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_5;
 }
 
 /*