]> git.ipfire.org Git - thirdparty/xfsprogs-dev.git/commitdiff
xfs: Introduce macros to represent new maximum extent counts for data/attr forks
authorChandan Babu R <chandan.babu@oracle.com>
Wed, 22 Jun 2022 19:28:52 +0000 (14:28 -0500)
committerEric Sandeen <sandeen@sandeen.net>
Wed, 22 Jun 2022 19:28:52 +0000 (14:28 -0500)
Source kernel commit: df9ad5cc7a524048ea7ff983d6feeb6d8c47a761

This commit defines new macros to represent maximum extent counts allowed by
filesystems which have support for large per-inode extent counters.

Reviewed-by: Darrick J. Wong <djwong@kernel.org>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
Signed-off-by: Chandan Babu R <chandan.babu@oracle.com>
Signed-off-by: Eric Sandeen <sandeen@sandeen.net>
include/xfs_inode.h
libxfs/xfs_bmap.c
libxfs/xfs_bmap_btree.c
libxfs/xfs_format.h
libxfs/xfs_inode_buf.c
libxfs/xfs_inode_fork.c
libxfs/xfs_inode_fork.h
repair/dinode.c

index db9faa57d2510b575ebde61343472f00db456c90..6a29b0983e1c12809e9ca106fcc2b8adf2bc8801 100644 (file)
@@ -164,6 +164,11 @@ static inline bool xfs_inode_has_bigtime(struct xfs_inode *ip)
        return ip->i_diflags2 & XFS_DIFLAG2_BIGTIME;
 }
 
+static inline bool xfs_inode_has_large_extent_counts(struct xfs_inode *ip)
+{
+       return ip->i_diflags2 & XFS_DIFLAG2_NREXT64;
+}
+
 /* Always set the child's GID to this value, even if the parent is setgid. */
 #define CRED_FORCE_GID (1U << 0)
 struct cred {
index 40764571b75ab10388efa7f4bf90c40798c62fea..105717f4ceeeb58e99e58cd23944d1e2b630f905 100644 (file)
@@ -54,10 +54,8 @@ xfs_bmap_compute_maxlevels(
        int             sz;             /* root block size */
 
        /*
-        * The maximum number of extents in a file, hence the maximum number of
-        * leaf entries, is controlled by the size of the on-disk extent count,
-        * either a signed 32-bit number for the data fork, or a signed 16-bit
-        * number for the attr fork.
+        * The maximum number of extents in a fork, hence the maximum number of
+        * leaf entries, is controlled by the size of the on-disk extent count.
         *
         * Note that we can no longer assume that if we are in ATTR1 that the
         * fork offset of all the inodes will be
@@ -67,7 +65,8 @@ xfs_bmap_compute_maxlevels(
         * ATTR2 we have to assume the worst case scenario of a minimum size
         * available.
         */
-       maxleafents = xfs_iext_max_nextents(whichfork);
+       maxleafents = xfs_iext_max_nextents(xfs_has_large_extent_counts(mp),
+                               whichfork);
        if (whichfork == XFS_DATA_FORK)
                sz = XFS_BMDR_SPACE_CALC(MINDBTPTRS);
        else
index ba239d6ec22ce084a8bd3d58f13aa56b72f603e8..c691252257727673815c8655ffb3589a6bc2c0fa 100644 (file)
@@ -595,7 +595,11 @@ xfs_bmbt_maxrecs(
        return xfs_bmbt_block_maxrecs(blocklen, leaf);
 }
 
-/* Compute the max possible height for block mapping btrees. */
+/*
+ * Calculate the maximum possible height of the btree that the on-disk format
+ * supports. This is used for sizing structures large enough to support every
+ * possible configuration of a filesystem that might get mounted.
+ */
 unsigned int
 xfs_bmbt_maxlevels_ondisk(void)
 {
@@ -609,7 +613,8 @@ xfs_bmbt_maxlevels_ondisk(void)
        minrecs[1] = xfs_bmbt_block_maxrecs(blocklen, false) / 2;
 
        /* One extra level for the inode root. */
-       return xfs_btree_compute_maxlevels(minrecs, MAXEXTNUM) + 1;
+       return xfs_btree_compute_maxlevels(minrecs,
+                       XFS_MAX_EXTCNT_DATA_FORK_LARGE) + 1;
 }
 
 /*
index 57b24744a7c2306fe923256df965d8970a2c9f49..eb85bc9b229b67157099c50a37eaeb6571c74514 100644 (file)
@@ -872,9 +872,29 @@ enum xfs_dinode_fmt {
 
 /*
  * Max values for extnum and aextnum.
+ *
+ * The original on-disk extent counts were held in signed fields, resulting in
+ * maximum extent counts of 2^31 and 2^15 for the data and attr forks
+ * respectively. Similarly the maximum extent length is limited to 2^21 blocks
+ * by the 21-bit wide blockcount field of a BMBT extent record.
+ *
+ * The newly introduced data fork extent counter can hold a 64-bit value,
+ * however the maximum number of extents in a file is also limited to 2^54
+ * extents by the 54-bit wide startoff field of a BMBT extent record.
+ *
+ * It is further limited by the maximum supported file size of 2^63
+ * *bytes*. This leads to a maximum extent count for maximally sized filesystem
+ * blocks (64kB) of:
+ *
+ * 2^63 bytes / 2^16 bytes per block = 2^47 blocks
+ *
+ * Rounding up 47 to the nearest multiple of bits-per-byte results in 48. Hence
+ * 2^48 was chosen as the maximum data fork extent count.
  */
-#define        MAXEXTNUM       ((xfs_extnum_t)0x7fffffff)      /* signed int */
-#define        MAXAEXTNUM      ((xfs_aextnum_t)0x7fff)         /* signed short */
+#define XFS_MAX_EXTCNT_DATA_FORK_LARGE ((xfs_extnum_t)((1ULL << 48) - 1))
+#define XFS_MAX_EXTCNT_ATTR_FORK_LARGE ((xfs_extnum_t)((1ULL << 32) - 1))
+#define XFS_MAX_EXTCNT_DATA_FORK_SMALL ((xfs_extnum_t)((1ULL << 31) - 1))
+#define XFS_MAX_EXTCNT_ATTR_FORK_SMALL ((xfs_extnum_t)((1ULL << 15) - 1))
 
 /*
  * Inode minimum and maximum sizes.
index eebcb2b6c15baa2e646dfdfc4d4995cc0569f3a3..deb143171ff3607ac6df999912dbd102ceb94ed3 100644 (file)
@@ -358,7 +358,9 @@ xfs_dinode_verify_fork(
                        return __this_address;
                break;
        case XFS_DINODE_FMT_BTREE:
-               max_extents = xfs_iext_max_nextents(whichfork);
+               max_extents = xfs_iext_max_nextents(
+                                       xfs_dinode_has_large_extent_counts(dip),
+                                       whichfork);
                if (di_nextents > max_extents)
                        return __this_address;
                break;
index 26527602fbb92fe148b4abf4641d865b61a7e0db..568c0ff4e5cdd535a1f28845247202b32a7c7f60 100644 (file)
@@ -742,7 +742,8 @@ xfs_iext_count_may_overflow(
        if (whichfork == XFS_COW_FORK)
                return 0;
 
-       max_exts = xfs_iext_max_nextents(whichfork);
+       max_exts = xfs_iext_max_nextents(xfs_inode_has_large_extent_counts(ip),
+                               whichfork);
 
        if (XFS_TEST_ERROR(false, ip->i_mount, XFS_ERRTAG_REDUCE_MAX_IEXTENTS))
                max_exts = 10;
index 4a8b77d425df2cbfc877b70ad2301f4d0c876cdb..967837a88860c63f1915d68693d3f40568c3beef 100644 (file)
@@ -133,12 +133,25 @@ static inline int8_t xfs_ifork_format(struct xfs_ifork *ifp)
        return ifp->if_format;
 }
 
-static inline xfs_extnum_t xfs_iext_max_nextents(int whichfork)
+static inline xfs_extnum_t xfs_iext_max_nextents(bool has_large_extent_counts,
+                               int whichfork)
 {
-       if (whichfork == XFS_DATA_FORK || whichfork == XFS_COW_FORK)
-               return MAXEXTNUM;
+       switch (whichfork) {
+       case XFS_DATA_FORK:
+       case XFS_COW_FORK:
+               if (has_large_extent_counts)
+                       return XFS_MAX_EXTCNT_DATA_FORK_LARGE;
+               return XFS_MAX_EXTCNT_DATA_FORK_SMALL;
+
+       case XFS_ATTR_FORK:
+               if (has_large_extent_counts)
+                       return XFS_MAX_EXTCNT_ATTR_FORK_LARGE;
+               return XFS_MAX_EXTCNT_ATTR_FORK_SMALL;
 
-       return MAXAEXTNUM;
+       default:
+               ASSERT(0);
+               return 0;
+       }
 }
 
 static inline xfs_extnum_t
index 28343083c539c0ebe5ad6a1a394aaac7bc16dbb8..21d428a019829631fcdce76bec14e6bb7d19a82e 100644 (file)
@@ -1812,7 +1812,9 @@ _("bad nblocks %llu for inode %" PRIu64 ", would reset to %" PRIu64 "\n"),
                }
        }
 
-       if (nextents > xfs_iext_max_nextents(XFS_DATA_FORK))  {
+       if (nextents > xfs_iext_max_nextents(
+                               xfs_dinode_has_large_extent_counts(dino),
+                               XFS_DATA_FORK)) {
                do_warn(
 _("too many data fork extents (%" PRIu64 ") in inode %" PRIu64 "\n"),
                        nextents, lino);
@@ -1833,7 +1835,9 @@ _("bad nextents %" PRIu64 " for inode %" PRIu64 ", would reset to %" PRIu64 "\n"
                }
        }
 
-       if (anextents > xfs_iext_max_nextents(XFS_ATTR_FORK))  {
+       if (anextents > xfs_iext_max_nextents(
+                               xfs_dinode_has_large_extent_counts(dino),
+                               XFS_ATTR_FORK)) {
                do_warn(
 _("too many attr fork extents (%" PRIu64 ") in inode %" PRIu64 "\n"),
                        anextents, lino);