1 files changed, 137 insertions, 29 deletions

diff --git a/fs/xfs/xfs_sb.h b/fs/xfs/xfs_sb.h
index a05b45175fb0..2de58a85833c 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,20 @@ 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_features_log_incompat;
+
+        __uint32_t      sb_crc;         /* superblock crc */
+        __uint32_t      sb_pad;
+
+        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 +244,21 @@ 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;
+        __be32          sb_features_log_incompat;
+
+        __le32          sb_crc;         /* superblock crc */
+        __be32          sb_pad;
+
+        __be64          sb_pquotino;    /* project quota inode */
+        __be64          sb_lsn;         /* last write sequence */
 
         /* must be padded to 64 bit alignment */
 } xfs_dsb_t;
@@ -250,7 +279,10 @@ 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_FEATURES_LOG_INCOMPAT, XFS_SBS_CRC, XFS_SBS_PAD,
+        XFS_SBS_PQUOTINO, XFS_SBS_LSN,
         XFS_SBS_FIELDCOUNT
 } xfs_sb_field_t;
 
@@ -276,6 +308,12 @@ 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_FEATURES_LOG_INCOMPAT XFS_SB_MVAL(FEATURES_LOG_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 +321,9 @@ 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_FEATURES_LOG_INCOMPAT | XFS_SB_PQUOTINO)
 
 
 /*
@@ -325,6 +365,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 +407,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 +415,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 +424,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 +438,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 +453,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 +472,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 +522,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 +549,73 @@ 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;
+}
+
+
+/*
+ * Extended v5 superblock feature masks. These are to be used for new v5
+ * superblock features only.
+ *
+ * Compat features are new features that old kernels will not notice or affect
+ * and so can mount read-write without issues.
+ *
+ * RO-Compat (read only) are features that old kernels can read but will break
+ * if they write. Hence only read-only mounts of such filesystems are allowed on
+ * kernels that don't support the feature bit.
+ *
+ * InCompat features are features which old kernels will not understand and so
+ * must not mount.
+ *
+ * Log-InCompat features are for changes to log formats or new transactions that
+ * can't be replayed on older kernels. The fields are set when the filesystem is
+ * mounted, and a clean unmount clears the fields.
+ */
+#define XFS_SB_FEAT_COMPAT_ALL 0
+#define XFS_SB_FEAT_COMPAT_UNKNOWN      ~XFS_SB_FEAT_COMPAT_ALL
+static inline bool
+xfs_sb_has_compat_feature(
+        struct xfs_sb   *sbp,
+        __uint32_t      feature)
+{
+        return (sbp->sb_features_compat & feature) != 0;
+}
+
+#define XFS_SB_FEAT_RO_COMPAT_ALL 0
+#define XFS_SB_FEAT_RO_COMPAT_UNKNOWN   ~XFS_SB_FEAT_RO_COMPAT_ALL
+static inline bool
+xfs_sb_has_ro_compat_feature(
+        struct xfs_sb   *sbp,
+        __uint32_t      feature)
+{
+        return (sbp->sb_features_ro_compat & feature) != 0;
+}
+
+#define XFS_SB_FEAT_INCOMPAT_ALL 0
+#define XFS_SB_FEAT_INCOMPAT_UNKNOWN    ~XFS_SB_FEAT_INCOMPAT_ALL
+static inline bool
+xfs_sb_has_incompat_feature(
+        struct xfs_sb   *sbp,
+        __uint32_t      feature)
+{
+        return (sbp->sb_features_incompat & feature) != 0;
+}
+
+#define XFS_SB_FEAT_INCOMPAT_LOG_ALL 0
+#define XFS_SB_FEAT_INCOMPAT_LOG_UNKNOWN        ~XFS_SB_FEAT_INCOMPAT_LOG_ALL
+static inline bool
+xfs_sb_has_incompat_log_feature(
+        struct xfs_sb   *sbp,
+        __uint32_t      feature)
+{
+        return (sbp->sb_features_log_incompat & feature) != 0;
 }
 
 /*