xfs: only check the superblock version for dinode size calculation

Source kernel commit: e9e2eae89ddb658ea332295153fdca78c12c1e0d

The size of the dinode structure is only dependent on the file system
version, so instead of checking the individual inode version just use
the newly added xfs_sb_version_has_large_dinode helper, and simplify
various calling conventions.

Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Reviewed-by: Chandan Rajendra <chandanrlinux@gmail.com>
Reviewed-by: Darrick J. Wong <darrick.wong@oracle.com>
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Signed-off-by: Eric Sandeen <sandeen@sandeen.net>

diff --git a/db/check.c b/db/check.c
index bb66135a29de00ea40b17f0a8e9748d4a45b8de5..9485da43ef45ba81a09cd2aa5105ac326943c540 100644 (file)
--- a/db/check.c
+++ b/db/check.c
@@ -2771,8 +2771,7 @@ process_inode(
                error++;
                return;
        }
-       if ((unsigned int)XFS_DFORK_ASIZE(dip, mp) >=
-                                       XFS_LITINO(mp, xino.i_d.di_version))  {
+       if ((unsigned int)XFS_DFORK_ASIZE(dip, mp) >= XFS_LITINO(mp)) {
                if (v)
                        dbprintf(_("bad fork offset %d for inode %lld\n"),
                                xino.i_d.di_forkoff, id->ino);

diff --git a/db/metadump.c b/db/metadump.c
index ac0e28b2521d987a6f33cd02a680f79190a7e742..14e7eaa736ab0233ec5b44a0cfcbd4bd8cdaa86d 100644 (file)
--- a/db/metadump.c
+++ b/db/metadump.c
@@ -2382,8 +2382,7 @@ process_inode(
        if (free_inode) {
                if (zero_stale_data) {
                        /* Zero all of the inode literal area */
-                       memset(XFS_DFORK_DPTR(dip), 0,
-                              XFS_LITINO(mp, dip->di_version));
+                       memset(XFS_DFORK_DPTR(dip), 0, XFS_LITINO(mp));
                }
                goto done;
        }
@@ -2417,7 +2416,7 @@ process_inode(
 
        /* copy extended attributes if they exist and forkoff is valid */
        if (success &&
-           XFS_DFORK_DSIZE(dip, mp) < XFS_LITINO(mp, dip->di_version)) {
+           XFS_DFORK_DSIZE(dip, mp) < XFS_LITINO(mp)) {
                attr_data.remote_val_count = 0;
                switch (dip->di_aformat) {
                        case XFS_DINODE_FMT_LOCAL:

diff --git a/libxfs/xfs_attr_leaf.c b/libxfs/xfs_attr_leaf.c
index 832979c996a5cc61b0d3a7b7a587c0056d5b9b84..92a2abe10e51791e1d7a6f639473a431f95113db 100644 (file)
--- a/libxfs/xfs_attr_leaf.c
+++ b/libxfs/xfs_attr_leaf.c
@@ -534,7 +534,7 @@ xfs_attr_shortform_bytesfit(
        int                     offset;
 
        /* rounded down */
-       offset = (XFS_LITINO(mp, dp->i_d.di_version) - bytes) >> 3;
+       offset = (XFS_LITINO(mp) - bytes) >> 3;
 
        if (dp->i_d.di_format == XFS_DINODE_FMT_DEV) {
                minforkoff = roundup(sizeof(xfs_dev_t), 8) >> 3;
@@ -601,8 +601,7 @@ xfs_attr_shortform_bytesfit(
        minforkoff = roundup(minforkoff, 8) >> 3;
 
        /* attr fork btree root can have at least this many key/ptr pairs */
-       maxforkoff = XFS_LITINO(mp, dp->i_d.di_version) -
-                       XFS_BMDR_SPACE_CALC(MINABTPTRS);
+       maxforkoff = XFS_LITINO(mp) - XFS_BMDR_SPACE_CALC(MINABTPTRS);
        maxforkoff = maxforkoff >> 3;   /* rounded down */
 
        if (offset >= maxforkoff)

diff --git a/libxfs/xfs_bmap.c b/libxfs/xfs_bmap.c
index c00133acfdf36faaecfa6ae171df38d014781d20..11f3f5f9d2071a3f5176a413573dd39cb9fbeeb5 100644 (file)
--- a/libxfs/xfs_bmap.c
+++ b/libxfs/xfs_bmap.c
@@ -186,14 +186,12 @@ xfs_default_attroffset(
        struct xfs_mount        *mp = ip->i_mount;
        uint                    offset;
 
-       if (mp->m_sb.sb_inodesize == 256) {
-               offset = XFS_LITINO(mp, ip->i_d.di_version) -
-                               XFS_BMDR_SPACE_CALC(MINABTPTRS);
-       } else {
+       if (mp->m_sb.sb_inodesize == 256)
+               offset = XFS_LITINO(mp) - XFS_BMDR_SPACE_CALC(MINABTPTRS);
+       else
                offset = XFS_BMDR_SPACE_CALC(6 * MINABTPTRS);
-       }
 
-       ASSERT(offset < XFS_LITINO(mp, ip->i_d.di_version));
+       ASSERT(offset < XFS_LITINO(mp));
        return offset;
 }
 

diff --git a/libxfs/xfs_format.h b/libxfs/xfs_format.h
index f00012c05e1ffdaee0db4b9872cd4eada81970e4..a738cd8b20dcf762823a6fa73466b886873d98cb 100644 (file)
--- a/libxfs/xfs_format.h
+++ b/libxfs/xfs_format.h
@@ -954,8 +954,12 @@ enum xfs_dinode_fmt {
 /*
  * Inode size for given fs.
  */
-#define XFS_LITINO(mp, version) \
-       ((int)(((mp)->m_sb.sb_inodesize) - xfs_dinode_size(version)))
+#define XFS_DINODE_SIZE(sbp) \
+       (xfs_sb_version_has_v3inode(sbp) ? \
+               sizeof(struct xfs_dinode) : \
+               offsetof(struct xfs_dinode, di_crc))
+#define XFS_LITINO(mp) \
+       ((mp)->m_sb.sb_inodesize - XFS_DINODE_SIZE(&(mp)->m_sb))
 
 /*
  * Inode data & attribute fork sizes, per inode.
@@ -964,13 +968,9 @@ enum xfs_dinode_fmt {
 #define XFS_DFORK_BOFF(dip)            ((int)((dip)->di_forkoff << 3))
 
 #define XFS_DFORK_DSIZE(dip,mp) \
-       (XFS_DFORK_Q(dip) ? \
-               XFS_DFORK_BOFF(dip) : \
-               XFS_LITINO(mp, (dip)->di_version))
+       (XFS_DFORK_Q(dip) ? XFS_DFORK_BOFF(dip) : XFS_LITINO(mp))
 #define XFS_DFORK_ASIZE(dip,mp) \
-       (XFS_DFORK_Q(dip) ? \
-               XFS_LITINO(mp, (dip)->di_version) - XFS_DFORK_BOFF(dip) : \
-               0)
+       (XFS_DFORK_Q(dip) ? XFS_LITINO(mp) - XFS_DFORK_BOFF(dip) : 0)
 #define XFS_DFORK_SIZE(dip,mp,w) \
        ((w) == XFS_DATA_FORK ? \
                XFS_DFORK_DSIZE(dip, mp) : \

diff --git a/libxfs/xfs_ialloc.c b/libxfs/xfs_ialloc.c
index fd102ab37fc791353075ffbe0705345f8ddf7e53..d2e80d0a09724e8b1d9a9452f90eecb8e1332155 100644 (file)
--- a/libxfs/xfs_ialloc.c
+++ b/libxfs/xfs_ialloc.c
@@ -334,7 +334,7 @@ xfs_ialloc_inode_init(
                xfs_buf_zero(fbuf, 0, BBTOB(fbuf->b_length));
                for (i = 0; i < M_IGEO(mp)->inodes_per_cluster; i++) {
                        int     ioffset = i << mp->m_sb.sb_inodelog;
-                       uint    isize = xfs_dinode_size(version);
+                       uint    isize = XFS_DINODE_SIZE(&mp->m_sb);
 
                        free = xfs_make_iptr(mp, fbuf, i);
                        free->di_magic = cpu_to_be16(XFS_DINODE_MAGIC);

diff --git a/libxfs/xfs_inode_buf.c b/libxfs/xfs_inode_buf.c
index 496aadc0ba15c30306f6a8221a05eee7e0793c41..857e5ea63978c5ec1a9db387dcbf26416fe275af 100644 (file)
--- a/libxfs/xfs_inode_buf.c
+++ b/libxfs/xfs_inode_buf.c
@@ -414,7 +414,7 @@ xfs_dinode_verify_forkoff(
        case XFS_DINODE_FMT_LOCAL:      /* fall through ... */
        case XFS_DINODE_FMT_EXTENTS:    /* fall through ... */
        case XFS_DINODE_FMT_BTREE:
-               if (dip->di_forkoff >= (XFS_LITINO(mp, dip->di_version) >> 3))
+               if (dip->di_forkoff >= (XFS_LITINO(mp) >> 3))
                        return __this_address;
                break;
        default:

diff --git a/libxfs/xfs_inode_fork.c b/libxfs/xfs_inode_fork.c
index 819faa6336a8440d428cf560af948765f3da0a27..80ba6c1289d0ab4a9eccdf5d722a5e4ed54ae1d2 100644 (file)
--- a/libxfs/xfs_inode_fork.c
+++ b/libxfs/xfs_inode_fork.c
@@ -181,7 +181,7 @@ xfs_iformat_local(
         */
        if (unlikely(size > XFS_DFORK_SIZE(dip, ip->i_mount, whichfork))) {
                xfs_warn(ip->i_mount,
-       "corrupt inode %Lu (bad size %d for local fork, size = %d).",
+       "corrupt inode %Lu (bad size %d for local fork, size = %zd).",
                        (unsigned long long) ip->i_ino, size,
                        XFS_DFORK_SIZE(dip, ip->i_mount, whichfork));
                xfs_inode_verifier_error(ip, -EFSCORRUPTED,

diff --git a/libxfs/xfs_inode_fork.h b/libxfs/xfs_inode_fork.h
index 500333d0101e3b2f8f77b26794ffa91374d71915..668ee942be224f87c0d76093fbb3dd5d0435b190 100644 (file)
--- a/libxfs/xfs_inode_fork.h
+++ b/libxfs/xfs_inode_fork.h
@@ -46,14 +46,9 @@ struct xfs_ifork {
                        (ip)->i_afp : \
                        (ip)->i_cowfp))
 #define XFS_IFORK_DSIZE(ip) \
-       (XFS_IFORK_Q(ip) ? \
-               XFS_IFORK_BOFF(ip) : \
-               XFS_LITINO((ip)->i_mount, (ip)->i_d.di_version))
+       (XFS_IFORK_Q(ip) ? XFS_IFORK_BOFF(ip) : XFS_LITINO((ip)->i_mount))
 #define XFS_IFORK_ASIZE(ip) \
-       (XFS_IFORK_Q(ip) ? \
-               XFS_LITINO((ip)->i_mount, (ip)->i_d.di_version) - \
-                       XFS_IFORK_BOFF(ip) : \
-               0)
+       (XFS_IFORK_Q(ip) ? XFS_LITINO((ip)->i_mount) - XFS_IFORK_BOFF(ip) : 0)
 #define XFS_IFORK_SIZE(ip,w) \
        ((w) == XFS_DATA_FORK ? \
                XFS_IFORK_DSIZE(ip) : \

diff --git a/libxfs/xfs_log_format.h b/libxfs/xfs_log_format.h
index 9bac0d2e56dcc67fcbd82a87753fcc1e5bea95e3..e3400c9c71cdb2371d40d5e11ed4c1cf51ff7f21 100644 (file)
--- a/libxfs/xfs_log_format.h
+++ b/libxfs/xfs_log_format.h
@@ -424,12 +424,10 @@ struct xfs_log_dinode {
        /* structure must be padded to 64 bit alignment */
 };
 
-static inline uint xfs_log_dinode_size(int version)
-{
-       if (version == 3)
-               return sizeof(struct xfs_log_dinode);
-       return offsetof(struct xfs_log_dinode, di_next_unlinked);
-}
+#define xfs_log_dinode_size(mp)                                                \
+       (xfs_sb_version_has_v3inode(&(mp)->m_sb) ?                      \
+               sizeof(struct xfs_log_dinode) :                         \
+               offsetof(struct xfs_log_dinode, di_next_unlinked))
 
 /*
  * Buffer Log Format definitions

diff --git a/logprint/log_misc.c b/logprint/log_misc.c
index 45f697fc3ec2fab1c726aee54df04f89408903ed..be88988778e5d63b613ece4e9363b03c6cc061d1 100644 (file)
--- a/logprint/log_misc.c
+++ b/logprint/log_misc.c
@@ -563,7 +563,7 @@ xlog_print_trans_inode(
     mode = dino.di_mode & S_IFMT;
     size = (int)dino.di_size;
     xlog_print_trans_inode_core(&dino);
-    *ptr += xfs_log_dinode_size(dino.di_version);
+    *ptr += xfs_log_dinode_size(log->l_mp);
     skip_count--;
 
     switch (f->ilf_fields & (XFS_ILOG_DEV | XFS_ILOG_UUID)) {

diff --git a/logprint/log_print_all.c b/logprint/log_print_all.c
index 32d13719a088aac5484fe73d30b6aa42a4a0ac06..e2e28b9c3299d555fc45b31a5e2f9af81de3c8fc 100644 (file)
--- a/logprint/log_print_all.c
+++ b/logprint/log_print_all.c
@@ -285,8 +285,10 @@ xlog_recover_print_inode(
               f->ilf_dsize);
 
        /* core inode comes 2nd */
-       ASSERT(item->ri_buf[1].i_len == xfs_log_dinode_size(2) ||
-               item->ri_buf[1].i_len == xfs_log_dinode_size(3));
+       /* ASSERT len vs xfs_log_dinode_size() for V3 or V2 inodes */
+       ASSERT(item->ri_buf[1].i_len ==
+                       offsetof(struct xfs_log_dinode, di_next_unlinked) ||
+              item->ri_buf[1].i_len == sizeof(struct xfs_log_dinode));
        xlog_recover_print_inode_core((struct xfs_log_dinode *)
                                      item->ri_buf[1].i_addr);
 

diff --git a/repair/dinode.c b/repair/dinode.c
index 3367c40ee5f02b3f7fc340c012fd65d7f4a81f65..1f1cc26b948b52ed381e6ba450c757d6a91b6908 100644 (file)
--- a/repair/dinode.c
+++ b/repair/dinode.c
@@ -143,7 +143,7 @@ clear_dinode(xfs_mount_t *mp, xfs_dinode_t *dino, xfs_ino_t ino_num)
        clear_dinode_unlinked(mp, dino);
 
        /* and clear the forks */
-       memset(XFS_DFORK_DPTR(dino), 0, XFS_LITINO(mp, dino->di_version));
+       memset(XFS_DFORK_DPTR(dino), 0, XFS_LITINO(mp));
        return;
 }
 
@@ -1017,7 +1017,7 @@ process_lclinode(
        if (whichfork == XFS_DATA_FORK && be64_to_cpu(dip->di_size) >
                                                XFS_DFORK_DSIZE(dip, mp)) {
                do_warn(
-       _("local inode %" PRIu64 " data fork is too large (size = %lld, max = %d)\n"),
+       _("local inode %" PRIu64 " data fork is too large (size = %lld, max = %zu)\n"),
                       lino, (unsigned long long) be64_to_cpu(dip->di_size),
                        XFS_DFORK_DSIZE(dip, mp));
                return(1);
@@ -1025,7 +1025,7 @@ process_lclinode(
                asf = (xfs_attr_shortform_t *)XFS_DFORK_APTR(dip);
                if (be16_to_cpu(asf->hdr.totsize) > XFS_DFORK_ASIZE(dip, mp)) {
                        do_warn(
-       _("local inode %" PRIu64 " attr fork too large (size %d, max = %d)\n"),
+       _("local inode %" PRIu64 " attr fork too large (size %d, max = %zu)\n"),
                                lino, be16_to_cpu(asf->hdr.totsize),
                                XFS_DFORK_ASIZE(dip, mp));
                        return(1);
@@ -1797,12 +1797,10 @@ _("bad attr fork offset %d in dev inode %" PRIu64 ", should be %d\n"),
        case XFS_DINODE_FMT_LOCAL:      /* fall through ... */
        case XFS_DINODE_FMT_EXTENTS:    /* fall through ... */
        case XFS_DINODE_FMT_BTREE:
-               if (dino->di_forkoff >=
-                               (XFS_LITINO(mp, dino->di_version) >> 3)) {
+               if (dino->di_forkoff >= (XFS_LITINO(mp) >> 3)) {
                        do_warn(
-_("bad attr fork offset %d in inode %" PRIu64 ", max=%d\n"),
-                               dino->di_forkoff, lino,
-                               XFS_LITINO(mp, dino->di_version) >> 3);
+_("bad attr fork offset %d in inode %" PRIu64 ", max=%zu\n"),
+                               dino->di_forkoff, lino, XFS_LITINO(mp) >> 3);
                        return 1;
                }
                break;

diff --git a/repair/prefetch.c b/repair/prefetch.c
index 2eff6e07cf9a0dda50c5ea8087cf49934e6abe3d..3ac49db1eca934eaa76858d5702a9abfb02620bd 100644 (file)
--- a/repair/prefetch.c
+++ b/repair/prefetch.c
@@ -445,7 +445,7 @@ pf_read_inode_dirs(
                        continue;
 
                if ((dino->di_forkoff != 0) &&
-                   (dino->di_forkoff >= XFS_LITINO(mp, dino->di_version) >> 3))
+                   (dino->di_forkoff >= XFS_LITINO(mp) >> 3))
                        continue;
 
                switch (dino->di_format) {