xfs: move the fork format fields into struct xfs_ifork

Source kernel commit: f7e67b20ecbbcb9180c888a5c4fde267935e075f

Both the data and attr fork have a format that is stored in the legacy
idinode.  Move it into the xfs_ifork structure instead, where it uses
up padding.

Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Reviewed-by: Chandan Babu R <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/libxfs/util.c b/libxfs/util.c
index d61178e86cf43545927aa00b362062bc154b18cd..7fb0a99596f4ee4a9a573daf090ec045b7226f39 100644 (file)
--- a/libxfs/util.c
+++ b/libxfs/util.c
@@ -293,7 +293,7 @@ libxfs_ialloc(
                /* FALLTHROUGH */
        case S_IFCHR:
        case S_IFBLK:
-               ip->i_d.di_format = XFS_DINODE_FMT_DEV;
+               ip->i_df.if_format = XFS_DINODE_FMT_DEV;
                flags |= XFS_ILOG_DEV;
                VFS_I(ip)->i_rdev = rdev;
                break;
@@ -324,7 +324,7 @@ libxfs_ialloc(
                }
                /* FALLTHROUGH */
        case S_IFLNK:
-               ip->i_d.di_format = XFS_DINODE_FMT_EXTENTS;
+               ip->i_df.if_format = XFS_DINODE_FMT_EXTENTS;
                ip->i_df.if_flags = XFS_IFEXTENTS;
                ip->i_df.if_bytes = 0;
                ip->i_df.if_u1.if_root = NULL;
@@ -332,8 +332,6 @@ libxfs_ialloc(
        default:
                ASSERT(0);
        }
-       /* Attribute fork settings for new inode. */
-       ip->i_d.di_aformat = XFS_DINODE_FMT_EXTENTS;
 
        /*
         * Log the new values stuffed into the inode.
@@ -357,7 +355,7 @@ libxfs_iflush_int(
        xfs_dinode_t                    *dip;
        xfs_mount_t                     *mp;
 
-       ASSERT(ip->i_d.di_format != XFS_DINODE_FMT_BTREE ||
+       ASSERT(ip->i_df.if_format != XFS_DINODE_FMT_BTREE ||
                ip->i_df.if_nextents > ip->i_df.if_ext_max);
 
        iip = ip->i_itemp;
@@ -368,12 +366,12 @@ libxfs_iflush_int(
 
        ASSERT(ip->i_d.di_magic == XFS_DINODE_MAGIC);
        if (XFS_ISREG(ip)) {
-               ASSERT( (ip->i_d.di_format == XFS_DINODE_FMT_EXTENTS) ||
-                       (ip->i_d.di_format == XFS_DINODE_FMT_BTREE) );
+               ASSERT( (ip->i_df.if_format == XFS_DINODE_FMT_EXTENTS) ||
+                       (ip->i_df.if_format == XFS_DINODE_FMT_BTREE) );
        } else if (XFS_ISDIR(ip)) {
-               ASSERT( (ip->i_d.di_format == XFS_DINODE_FMT_EXTENTS) ||
-                       (ip->i_d.di_format == XFS_DINODE_FMT_BTREE)   ||
-                       (ip->i_d.di_format == XFS_DINODE_FMT_LOCAL) );
+               ASSERT( (ip->i_df.if_format == XFS_DINODE_FMT_EXTENTS) ||
+                       (ip->i_df.if_format == XFS_DINODE_FMT_BTREE)   ||
+                       (ip->i_df.if_format == XFS_DINODE_FMT_LOCAL) );
        }
        ASSERT(ip->i_df.if_nextents+ip->i_afp->if_nextents <= ip->i_d.di_nblocks);
        ASSERT(ip->i_d.di_forkoff <= mp->m_sb.sb_inodesize);
@@ -386,10 +384,10 @@ libxfs_iflush_int(
         * If there are inline format data / attr forks attached to this inode,
         * make sure they are not corrupt.
         */
-       if (ip->i_d.di_format == XFS_DINODE_FMT_LOCAL &&
+       if (ip->i_df.if_format == XFS_DINODE_FMT_LOCAL &&
            xfs_ifork_verify_local_data(ip))
                return -EFSCORRUPTED;
-       if (ip->i_d.di_aformat == XFS_DINODE_FMT_LOCAL &&
+       if (ip->i_afp && ip->i_afp->if_format == XFS_DINODE_FMT_LOCAL &&
            xfs_ifork_verify_local_attr(ip))
                return -EFSCORRUPTED;
 

diff --git a/libxfs/xfs_attr.c b/libxfs/xfs_attr.c
index a33528198356ceda76dbaa5526eb42007c3d50a4..a276a57c94dd49f0ff7278ff3440e0d3ec3b6a7a 100644 (file)
--- a/libxfs/xfs_attr.c
+++ b/libxfs/xfs_attr.c
@@ -61,7 +61,7 @@ xfs_inode_hasattr(
        struct xfs_inode        *ip)
 {
        if (!XFS_IFORK_Q(ip) ||
-           (ip->i_d.di_aformat == XFS_DINODE_FMT_EXTENTS &&
+           (ip->i_afp->if_format == XFS_DINODE_FMT_EXTENTS &&
             ip->i_afp->if_nextents == 0))
                return 0;
        return 1;
@@ -84,7 +84,7 @@ xfs_attr_get_ilocked(
        if (!xfs_inode_hasattr(args->dp))
                return -ENOATTR;
 
-       if (args->dp->i_d.di_aformat == XFS_DINODE_FMT_LOCAL)
+       if (args->dp->i_afp->if_format == XFS_DINODE_FMT_LOCAL)
                return xfs_attr_shortform_getvalue(args);
        if (xfs_bmap_one_block(args->dp, XFS_ATTR_FORK))
                return xfs_attr_leaf_get(args);
@@ -212,14 +212,14 @@ xfs_attr_set_args(
         * If the attribute list is non-existent or a shortform list,
         * upgrade it to a single-leaf-block attribute list.
         */
-       if (dp->i_d.di_aformat == XFS_DINODE_FMT_LOCAL ||
-           (dp->i_d.di_aformat == XFS_DINODE_FMT_EXTENTS &&
+       if (dp->i_afp->if_format == XFS_DINODE_FMT_LOCAL ||
+           (dp->i_afp->if_format == XFS_DINODE_FMT_EXTENTS &&
             dp->i_afp->if_nextents == 0)) {
 
                /*
                 * Build initial attribute list (if required).
                 */
-               if (dp->i_d.di_aformat == XFS_DINODE_FMT_EXTENTS)
+               if (dp->i_afp->if_format == XFS_DINODE_FMT_EXTENTS)
                        xfs_attr_shortform_create(args);
 
                /*
@@ -272,7 +272,7 @@ xfs_attr_remove_args(
 
        if (!xfs_inode_hasattr(dp)) {
                error = -ENOATTR;
-       } else if (dp->i_d.di_aformat == XFS_DINODE_FMT_LOCAL) {
+       } else if (dp->i_afp->if_format == XFS_DINODE_FMT_LOCAL) {
                ASSERT(dp->i_afp->if_flags & XFS_IFINLINE);
                error = xfs_attr_shortform_remove(args);
        } else if (xfs_bmap_one_block(dp, XFS_ATTR_FORK)) {

diff --git a/libxfs/xfs_attr_leaf.c b/libxfs/xfs_attr_leaf.c
index 16ff1c7b8c029cfb27cff81258df66a66a74bf18..77331821373eafa8f802058e3e1636f73edb5bfb 100644 (file)
--- a/libxfs/xfs_attr_leaf.c
+++ b/libxfs/xfs_attr_leaf.c
@@ -535,7 +535,7 @@ xfs_attr_shortform_bytesfit(
        /* rounded down */
        offset = (XFS_LITINO(mp) - bytes) >> 3;
 
-       if (dp->i_d.di_format == XFS_DINODE_FMT_DEV) {
+       if (dp->i_df.if_format == XFS_DINODE_FMT_DEV) {
                minforkoff = roundup(sizeof(xfs_dev_t), 8) >> 3;
                return (offset >= minforkoff) ? minforkoff : 0;
        }
@@ -563,7 +563,7 @@ xfs_attr_shortform_bytesfit(
 
        dsize = dp->i_df.if_bytes;
 
-       switch (dp->i_d.di_format) {
+       switch (dp->i_df.if_format) {
        case XFS_DINODE_FMT_EXTENTS:
                /*
                 * If there is no attr fork and the data fork is extents,
@@ -632,22 +632,19 @@ xfs_sbversion_add_attr2(xfs_mount_t *mp, xfs_trans_t *tp)
  * Create the initial contents of a shortform attribute list.
  */
 void
-xfs_attr_shortform_create(xfs_da_args_t *args)
+xfs_attr_shortform_create(
+       struct xfs_da_args      *args)
 {
-       xfs_attr_sf_hdr_t *hdr;
-       xfs_inode_t *dp;
-       struct xfs_ifork *ifp;
+       struct xfs_inode        *dp = args->dp;
+       struct xfs_ifork        *ifp = dp->i_afp;
+       struct xfs_attr_sf_hdr  *hdr;
 
        trace_xfs_attr_sf_create(args);
 
-       dp = args->dp;
-       ASSERT(dp != NULL);
-       ifp = dp->i_afp;
-       ASSERT(ifp != NULL);
        ASSERT(ifp->if_bytes == 0);
-       if (dp->i_d.di_aformat == XFS_DINODE_FMT_EXTENTS) {
+       if (ifp->if_format == XFS_DINODE_FMT_EXTENTS) {
                ifp->if_flags &= ~XFS_IFEXTENTS;        /* just in case */
-               dp->i_d.di_aformat = XFS_DINODE_FMT_LOCAL;
+               ifp->if_format = XFS_DINODE_FMT_LOCAL;
                ifp->if_flags |= XFS_IFINLINE;
        } else {
                ASSERT(ifp->if_flags & XFS_IFINLINE);
@@ -719,7 +716,6 @@ xfs_attr_fork_remove(
 
        xfs_idestroy_fork(ip, XFS_ATTR_FORK);
        ip->i_d.di_forkoff = 0;
-       ip->i_d.di_aformat = XFS_DINODE_FMT_EXTENTS;
 
        ASSERT(ip->i_afp == NULL);
 
@@ -772,7 +768,7 @@ xfs_attr_shortform_remove(xfs_da_args_t *args)
        totsize -= size;
        if (totsize == sizeof(xfs_attr_sf_hdr_t) &&
            (mp->m_flags & XFS_MOUNT_ATTR2) &&
-           (dp->i_d.di_format != XFS_DINODE_FMT_BTREE) &&
+           (dp->i_df.if_format != XFS_DINODE_FMT_BTREE) &&
            !(args->op_flags & XFS_DA_OP_ADDNAME)) {
                xfs_attr_fork_remove(dp, args->trans);
        } else {
@@ -782,7 +778,7 @@ xfs_attr_shortform_remove(xfs_da_args_t *args)
                ASSERT(totsize > sizeof(xfs_attr_sf_hdr_t) ||
                                (args->op_flags & XFS_DA_OP_ADDNAME) ||
                                !(mp->m_flags & XFS_MOUNT_ATTR2) ||
-                               dp->i_d.di_format == XFS_DINODE_FMT_BTREE);
+                               dp->i_df.if_format == XFS_DINODE_FMT_BTREE);
                xfs_trans_log_inode(args->trans, dp,
                                        XFS_ILOG_CORE | XFS_ILOG_ADATA);
        }
@@ -959,7 +955,7 @@ xfs_attr_shortform_allfit(
                                + be16_to_cpu(name_loc->valuelen);
        }
        if ((dp->i_mount->m_flags & XFS_MOUNT_ATTR2) &&
-           (dp->i_d.di_format != XFS_DINODE_FMT_BTREE) &&
+           (dp->i_df.if_format != XFS_DINODE_FMT_BTREE) &&
            (bytes == sizeof(struct xfs_attr_sf_hdr)))
                return -1;
        return xfs_attr_shortform_bytesfit(dp, bytes);
@@ -978,7 +974,7 @@ xfs_attr_shortform_verify(
        int                             i;
        int64_t                         size;
 
-       ASSERT(ip->i_d.di_aformat == XFS_DINODE_FMT_LOCAL);
+       ASSERT(ip->i_afp->if_format == XFS_DINODE_FMT_LOCAL);
        ifp = XFS_IFORK_PTR(ip, XFS_ATTR_FORK);
        sfp = (struct xfs_attr_shortform *)ifp->if_u1.if_data;
        size = ifp->if_bytes;
@@ -1082,7 +1078,7 @@ xfs_attr3_leaf_to_shortform(
 
        if (forkoff == -1) {
                ASSERT(dp->i_mount->m_flags & XFS_MOUNT_ATTR2);
-               ASSERT(dp->i_d.di_format != XFS_DINODE_FMT_BTREE);
+               ASSERT(dp->i_df.if_format != XFS_DINODE_FMT_BTREE);
                xfs_attr_fork_remove(dp, args->trans);
                goto out;
        }

diff --git a/libxfs/xfs_bmap.c b/libxfs/xfs_bmap.c
index dbc4bafaaf2c9126ea65b437ab4a94f40e41dd0f..ba2f7d0a0bca572428b5ae281187010bbb28d2c4 100644 (file)
--- a/libxfs/xfs_bmap.c
+++ b/libxfs/xfs_bmap.c
@@ -116,7 +116,7 @@ static inline bool xfs_bmap_needs_btree(struct xfs_inode *ip, int whichfork)
        struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork);
 
        return whichfork != XFS_COW_FORK &&
-               XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_EXTENTS &&
+               ifp->if_format == XFS_DINODE_FMT_EXTENTS &&
                ifp->if_nextents > XFS_IFORK_MAXEXT(ip, whichfork);
 }
 
@@ -128,7 +128,7 @@ static inline bool xfs_bmap_wants_extents(struct xfs_inode *ip, int whichfork)
        struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork);
 
        return whichfork != XFS_COW_FORK &&
-               XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_BTREE &&
+               ifp->if_format == XFS_DINODE_FMT_BTREE &&
                ifp->if_nextents <= XFS_IFORK_MAXEXT(ip, whichfork);
 }
 
@@ -208,8 +208,8 @@ xfs_bmap_forkoff_reset(
        int             whichfork)
 {
        if (whichfork == XFS_ATTR_FORK &&
-           ip->i_d.di_format != XFS_DINODE_FMT_DEV &&
-           ip->i_d.di_format != XFS_DINODE_FMT_BTREE) {
+           ip->i_df.if_format != XFS_DINODE_FMT_DEV &&
+           ip->i_df.if_format != XFS_DINODE_FMT_BTREE) {
                uint    dfl_forkoff = xfs_default_attroffset(ip) >> 3;
 
                if (dfl_forkoff > ip->i_d.di_forkoff)
@@ -310,31 +310,28 @@ xfs_bmap_check_leaf_extents(
        xfs_inode_t             *ip,            /* incore inode pointer */
        int                     whichfork)      /* data or attr fork */
 {
+       struct xfs_mount        *mp = ip->i_mount;
+       struct xfs_ifork        *ifp = XFS_IFORK_PTR(ip, whichfork);
        struct xfs_btree_block  *block; /* current btree block */
        xfs_fsblock_t           bno;    /* block # of "block" */
        xfs_buf_t               *bp;    /* buffer for "block" */
        int                     error;  /* error return value */
        xfs_extnum_t            i=0, j; /* index into the extents list */
-       struct xfs_ifork        *ifp;   /* fork structure */
        int                     level;  /* btree level, for checking */
-       xfs_mount_t             *mp;    /* file system mount structure */
        __be64                  *pp;    /* pointer to block address */
        xfs_bmbt_rec_t          *ep;    /* pointer to current extent */
        xfs_bmbt_rec_t          last = {0, 0}; /* last extent in prev block */
        xfs_bmbt_rec_t          *nextp; /* pointer to next extent */
        int                     bp_release = 0;
 
-       if (XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE) {
+       if (ifp->if_format != XFS_DINODE_FMT_BTREE)
                return;
-       }
 
        /* skip large extent count inodes */
        if (ip->i_df.if_nextents > 10000)
                return;
 
        bno = NULLFSBLOCK;
-       mp = ip->i_mount;
-       ifp = XFS_IFORK_PTR(ip, whichfork);
        block = ifp->if_broot;
        /*
         * Root level must use BMAP_BROOT_PTR_ADDR macro to get ptr out.
@@ -599,7 +596,7 @@ xfs_bmap_btree_to_extents(
        ASSERT(cur);
        ASSERT(whichfork != XFS_COW_FORK);
        ASSERT(ifp->if_flags & XFS_IFEXTENTS);
-       ASSERT(XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_BTREE);
+       ASSERT(ifp->if_format == XFS_DINODE_FMT_BTREE);
        ASSERT(be16_to_cpu(rblock->bb_level) == 1);
        ASSERT(be16_to_cpu(rblock->bb_numrecs) == 1);
        ASSERT(xfs_bmbt_maxrecs(mp, ifp->if_broot_bytes, 0) == 1);
@@ -627,7 +624,7 @@ xfs_bmap_btree_to_extents(
        xfs_iroot_realloc(ip, -1, whichfork);
        ASSERT(ifp->if_broot == NULL);
        ASSERT((ifp->if_flags & XFS_IFBROOT) == 0);
-       XFS_IFORK_FMT_SET(ip, whichfork, XFS_DINODE_FMT_EXTENTS);
+       ifp->if_format = XFS_DINODE_FMT_EXTENTS;
        *logflagsp |= XFS_ILOG_CORE | xfs_ilog_fext(whichfork);
        return 0;
 }
@@ -663,7 +660,7 @@ xfs_bmap_extents_to_btree(
        mp = ip->i_mount;
        ASSERT(whichfork != XFS_COW_FORK);
        ifp = XFS_IFORK_PTR(ip, whichfork);
-       ASSERT(XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_EXTENTS);
+       ASSERT(ifp->if_format == XFS_DINODE_FMT_EXTENTS);
 
        /*
         * Make space in the inode incore. This needs to be undone if we fail
@@ -687,7 +684,7 @@ xfs_bmap_extents_to_btree(
        /*
         * Convert to a btree with two levels, one record in root.
         */
-       XFS_IFORK_FMT_SET(ip, whichfork, XFS_DINODE_FMT_BTREE);
+       ifp->if_format = XFS_DINODE_FMT_BTREE;
        memset(&args, 0, sizeof(args));
        args.tp = tp;
        args.mp = mp;
@@ -773,7 +770,7 @@ out_unreserve_dquot:
        xfs_trans_mod_dquot_byino(tp, ip, XFS_TRANS_DQ_BCOUNT, -1L);
 out_root_realloc:
        xfs_iroot_realloc(ip, -1, whichfork);
-       XFS_IFORK_FMT_SET(ip, whichfork, XFS_DINODE_FMT_EXTENTS);
+       ifp->if_format = XFS_DINODE_FMT_EXTENTS;
        ASSERT(ifp->if_broot == NULL);
        xfs_btree_del_cursor(cur, XFS_BTREE_ERROR);
 
@@ -795,7 +792,7 @@ xfs_bmap_local_to_extents_empty(
        struct xfs_ifork        *ifp = XFS_IFORK_PTR(ip, whichfork);
 
        ASSERT(whichfork != XFS_COW_FORK);
-       ASSERT(XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_LOCAL);
+       ASSERT(ifp->if_format == XFS_DINODE_FMT_LOCAL);
        ASSERT(ifp->if_bytes == 0);
        ASSERT(ifp->if_nextents == 0);
 
@@ -804,7 +801,7 @@ xfs_bmap_local_to_extents_empty(
        ifp->if_flags |= XFS_IFEXTENTS;
        ifp->if_u1.if_root = NULL;
        ifp->if_height = 0;
-       XFS_IFORK_FMT_SET(ip, whichfork, XFS_DINODE_FMT_EXTENTS);
+       ifp->if_format = XFS_DINODE_FMT_EXTENTS;
        xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
 }
 
@@ -835,7 +832,7 @@ xfs_bmap_local_to_extents(
         */
        ASSERT(!(S_ISREG(VFS_I(ip)->i_mode) && whichfork == XFS_DATA_FORK));
        ifp = XFS_IFORK_PTR(ip, whichfork);
-       ASSERT(XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_LOCAL);
+       ASSERT(ifp->if_format == XFS_DINODE_FMT_LOCAL);
 
        if (!ifp->if_bytes) {
                xfs_bmap_local_to_extents_empty(tp, ip, whichfork);
@@ -1029,7 +1026,7 @@ xfs_bmap_set_attrforkoff(
        int                     size,
        int                     *version)
 {
-       switch (ip->i_d.di_format) {
+       switch (ip->i_df.if_format) {
        case XFS_DINODE_FMT_DEV:
                ip->i_d.di_forkoff = roundup(sizeof(xfs_dev_t), 8) >> 3;
                break;
@@ -1087,13 +1084,6 @@ xfs_bmap_add_attrfork(
                goto trans_cancel;
        if (XFS_IFORK_Q(ip))
                goto trans_cancel;
-       if (ip->i_d.di_aformat != XFS_DINODE_FMT_EXTENTS) {
-               /*
-                * For inodes coming from pre-6.2 filesystems.
-                */
-               ASSERT(ip->i_d.di_aformat == 0);
-               ip->i_d.di_aformat = XFS_DINODE_FMT_EXTENTS;
-       }
 
        xfs_trans_ijoin(tp, ip, 0);
        xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
@@ -1102,9 +1092,10 @@ xfs_bmap_add_attrfork(
                goto trans_cancel;
        ASSERT(ip->i_afp == NULL);
        ip->i_afp = kmem_zone_zalloc(xfs_ifork_zone, 0);
+       ip->i_afp->if_format = XFS_DINODE_FMT_EXTENTS;
        ip->i_afp->if_flags = XFS_IFEXTENTS;
        logflags = 0;
-       switch (ip->i_d.di_format) {
+       switch (ip->i_df.if_format) {
        case XFS_DINODE_FMT_LOCAL:
                error = xfs_bmap_add_attrfork_local(tp, ip, &logflags);
                break;
@@ -1230,9 +1221,7 @@ xfs_iread_extents(
 
        ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
 
-       if (XFS_IS_CORRUPT(mp,
-                          XFS_IFORK_FORMAT(ip, whichfork) !=
-                          XFS_DINODE_FMT_BTREE)) {
+       if (XFS_IS_CORRUPT(mp, ifp->if_format != XFS_DINODE_FMT_BTREE)) {
                error = -EFSCORRUPTED;
                goto out;
        }
@@ -1280,14 +1269,13 @@ xfs_bmap_first_unused(
        xfs_fileoff_t           lowest, max;
        int                     error;
 
-       ASSERT(xfs_ifork_has_extents(ip, whichfork) ||
-              XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_LOCAL);
-
-       if (XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_LOCAL) {
+       if (ifp->if_format == XFS_DINODE_FMT_LOCAL) {
                *first_unused = 0;
                return 0;
        }
 
+       ASSERT(xfs_ifork_has_extents(ifp));
+
        if (!(ifp->if_flags & XFS_IFEXTENTS)) {
                error = xfs_iread_extents(tp, ip, whichfork);
                if (error)
@@ -1328,7 +1316,7 @@ xfs_bmap_last_before(
        struct xfs_iext_cursor  icur;
        int                     error;
 
-       switch (XFS_IFORK_FORMAT(ip, whichfork)) {
+       switch (ifp->if_format) {
        case XFS_DINODE_FMT_LOCAL:
                *last_block = 0;
                return 0;
@@ -1427,16 +1415,17 @@ xfs_bmap_last_offset(
        xfs_fileoff_t           *last_block,
        int                     whichfork)
 {
+       struct xfs_ifork        *ifp = XFS_IFORK_PTR(ip, whichfork);
        struct xfs_bmbt_irec    rec;
        int                     is_empty;
        int                     error;
 
        *last_block = 0;
 
-       if (XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_LOCAL)
+       if (ifp->if_format == XFS_DINODE_FMT_LOCAL)
                return 0;
 
-       if (XFS_IS_CORRUPT(ip->i_mount, !xfs_ifork_has_extents(ip, whichfork)))
+       if (XFS_IS_CORRUPT(ip->i_mount, !xfs_ifork_has_extents(ifp)))
                return -EFSCORRUPTED;
 
        error = xfs_bmap_last_extent(NULL, ip, whichfork, &rec, &is_empty);
@@ -1468,7 +1457,7 @@ xfs_bmap_one_block(
 #endif /* !DEBUG */
        if (ifp->if_nextents != 1)
                return 0;
-       if (XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS)
+       if (ifp->if_format != XFS_DINODE_FMT_EXTENTS)
                return 0;
        ASSERT(ifp->if_flags & XFS_IFEXTENTS);
        xfs_iext_first(ifp, &icur);
@@ -3888,10 +3877,9 @@ xfs_bmapi_read(
        if (WARN_ON_ONCE(!ifp))
                return -EFSCORRUPTED;
 
-       if (XFS_IS_CORRUPT(mp, !xfs_ifork_has_extents(ip, whichfork)) ||
-           XFS_TEST_ERROR(false, mp, XFS_ERRTAG_BMAPIFORMAT)) {
+       if (XFS_IS_CORRUPT(mp, !xfs_ifork_has_extents(ifp)) ||
+           XFS_TEST_ERROR(false, mp, XFS_ERRTAG_BMAPIFORMAT))
                return -EFSCORRUPTED;
-       }
 
        if (XFS_FORCED_SHUTDOWN(mp))
                return -EIO;
@@ -4274,11 +4262,13 @@ xfs_bmapi_minleft(
        struct xfs_inode        *ip,
        int                     fork)
 {
+       struct xfs_ifork        *ifp = XFS_IFORK_PTR(ip, fork);
+
        if (tp && tp->t_firstblock != NULLFSBLOCK)
                return 0;
-       if (XFS_IFORK_FORMAT(ip, fork) != XFS_DINODE_FMT_BTREE)
+       if (ifp->if_format != XFS_DINODE_FMT_BTREE)
                return 1;
-       return be16_to_cpu(XFS_IFORK_PTR(ip, fork)->if_broot->bb_level) + 1;
+       return be16_to_cpu(ifp->if_broot->bb_level) + 1;
 }
 
 /*
@@ -4293,11 +4283,13 @@ xfs_bmapi_finish(
        int                     whichfork,
        int                     error)
 {
+       struct xfs_ifork        *ifp = XFS_IFORK_PTR(bma->ip, whichfork);
+
        if ((bma->logflags & xfs_ilog_fext(whichfork)) &&
-           XFS_IFORK_FORMAT(bma->ip, whichfork) != XFS_DINODE_FMT_EXTENTS)
+           ifp->if_format != XFS_DINODE_FMT_EXTENTS)
                bma->logflags &= ~xfs_ilog_fext(whichfork);
        else if ((bma->logflags & xfs_ilog_fbroot(whichfork)) &&
-                XFS_IFORK_FORMAT(bma->ip, whichfork) != XFS_DINODE_FMT_BTREE)
+                ifp->if_format != XFS_DINODE_FMT_BTREE)
                bma->logflags &= ~xfs_ilog_fbroot(whichfork);
 
        if (bma->logflags)
@@ -4329,13 +4321,13 @@ xfs_bmapi_write(
                .total          = total,
        };
        struct xfs_mount        *mp = ip->i_mount;
-       struct xfs_ifork        *ifp;
+       int                     whichfork = xfs_bmapi_whichfork(flags);
+       struct xfs_ifork        *ifp = XFS_IFORK_PTR(ip, whichfork);
        xfs_fileoff_t           end;            /* end of mapped file region */
        bool                    eof = false;    /* after the end of extents */
        int                     error;          /* error return */
        int                     n;              /* current extent index */
        xfs_fileoff_t           obno;           /* old block number (offset) */
-       int                     whichfork;      /* data or attr fork */
 
 #ifdef DEBUG
        xfs_fileoff_t           orig_bno;       /* original block number value */
@@ -4350,13 +4342,12 @@ xfs_bmapi_write(
        orig_mval = mval;
        orig_nmap = *nmap;
 #endif
-       whichfork = xfs_bmapi_whichfork(flags);
 
        ASSERT(*nmap >= 1);
        ASSERT(*nmap <= XFS_BMAP_MAX_NMAP);
        ASSERT(tp != NULL);
        ASSERT(len > 0);
-       ASSERT(XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_LOCAL);
+       ASSERT(ifp->if_format != XFS_DINODE_FMT_LOCAL);
        ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
        ASSERT(!(flags & XFS_BMAPI_REMAP));
 
@@ -4372,7 +4363,7 @@ xfs_bmapi_write(
        ASSERT((flags & (XFS_BMAPI_PREALLOC | XFS_BMAPI_ZERO)) !=
                        (XFS_BMAPI_PREALLOC | XFS_BMAPI_ZERO));
 
-       if (XFS_IS_CORRUPT(mp, !xfs_ifork_has_extents(ip, whichfork)) ||
+       if (XFS_IS_CORRUPT(mp, !xfs_ifork_has_extents(ifp)) ||
            XFS_TEST_ERROR(false, mp, XFS_ERRTAG_BMAPIFORMAT)) {
                return -EFSCORRUPTED;
        }
@@ -4380,8 +4371,6 @@ xfs_bmapi_write(
        if (XFS_FORCED_SHUTDOWN(mp))
                return -EIO;
 
-       ifp = XFS_IFORK_PTR(ip, whichfork);
-
        XFS_STATS_INC(mp, xs_blk_mapw);
 
        if (!(ifp->if_flags & XFS_IFEXTENTS)) {
@@ -4491,7 +4480,7 @@ xfs_bmapi_write(
        if (error)
                goto error0;
 
-       ASSERT(XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE ||
+       ASSERT(ifp->if_format != XFS_DINODE_FMT_BTREE ||
               ifp->if_nextents > XFS_IFORK_MAXEXT(ip, whichfork));
        xfs_bmapi_finish(&bma, whichfork, 0);
        xfs_bmap_validate_ret(orig_bno, orig_len, orig_flags, orig_mval,
@@ -4638,7 +4627,7 @@ xfs_bmapi_remap(
        ASSERT((flags & (XFS_BMAPI_ATTRFORK | XFS_BMAPI_PREALLOC)) !=
                        (XFS_BMAPI_ATTRFORK | XFS_BMAPI_PREALLOC));
 
-       if (XFS_IS_CORRUPT(mp, !xfs_ifork_has_extents(ip, whichfork)) ||
+       if (XFS_IS_CORRUPT(mp, !xfs_ifork_has_extents(ifp)) ||
            XFS_TEST_ERROR(false, mp, XFS_ERRTAG_BMAPIFORMAT)) {
                return -EFSCORRUPTED;
        }
@@ -4682,9 +4671,9 @@ xfs_bmapi_remap(
        error = xfs_bmap_btree_to_extents(tp, ip, cur, &logflags, whichfork);
 
 error0:
-       if (ip->i_d.di_format != XFS_DINODE_FMT_EXTENTS)
+       if (ip->i_df.if_format != XFS_DINODE_FMT_EXTENTS)
                logflags &= ~XFS_ILOG_DEXT;
-       else if (ip->i_d.di_format != XFS_DINODE_FMT_BTREE)
+       else if (ip->i_df.if_format != XFS_DINODE_FMT_BTREE)
                logflags &= ~XFS_ILOG_DBROOT;
 
        if (logflags)
@@ -5034,7 +5023,7 @@ xfs_bmap_del_extent_real(
         * conversion to btree format, since the transaction will be dirty then.
         */
        if (tp->t_blk_res == 0 &&
-           XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_EXTENTS &&
+           ifp->if_format == XFS_DINODE_FMT_EXTENTS &&
            ifp->if_nextents >= XFS_IFORK_MAXEXT(ip, whichfork) &&
            del->br_startoff > got.br_startoff && del_endoff < got_endoff)
                return -ENOSPC;
@@ -5277,7 +5266,7 @@ __xfs_bunmapi(
        whichfork = xfs_bmapi_whichfork(flags);
        ASSERT(whichfork != XFS_COW_FORK);
        ifp = XFS_IFORK_PTR(ip, whichfork);
-       if (XFS_IS_CORRUPT(mp, !xfs_ifork_has_extents(ip, whichfork)))
+       if (XFS_IS_CORRUPT(mp, !xfs_ifork_has_extents(ifp)))
                return -EFSCORRUPTED;
        if (XFS_FORCED_SHUTDOWN(mp))
                return -EIO;
@@ -5315,7 +5304,7 @@ __xfs_bunmapi(
 
        logflags = 0;
        if (ifp->if_flags & XFS_IFBROOT) {
-               ASSERT(XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_BTREE);
+               ASSERT(ifp->if_format == XFS_DINODE_FMT_BTREE);
                cur = xfs_bmbt_init_cursor(mp, tp, ip, whichfork);
                cur->bc_ino.flags = 0;
        } else
@@ -5560,10 +5549,10 @@ error0:
         * logging the extent records if we've converted to btree format.
         */
        if ((logflags & xfs_ilog_fext(whichfork)) &&
-           XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS)
+           ifp->if_format != XFS_DINODE_FMT_EXTENTS)
                logflags &= ~xfs_ilog_fext(whichfork);
        else if ((logflags & xfs_ilog_fbroot(whichfork)) &&
-                XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE)
+                ifp->if_format != XFS_DINODE_FMT_BTREE)
                logflags &= ~xfs_ilog_fbroot(whichfork);
        /*
         * Log inode even in the error case, if the transaction
@@ -5774,7 +5763,7 @@ xfs_bmap_collapse_extents(
        int                     error = 0;
        int                     logflags = 0;
 
-       if (XFS_IS_CORRUPT(mp, !xfs_ifork_has_extents(ip, whichfork)) ||
+       if (XFS_IS_CORRUPT(mp, !xfs_ifork_has_extents(ifp)) ||
            XFS_TEST_ERROR(false, mp, XFS_ERRTAG_BMAPIFORMAT)) {
                return -EFSCORRUPTED;
        }
@@ -5891,7 +5880,7 @@ xfs_bmap_insert_extents(
        int                     error = 0;
        int                     logflags = 0;
 
-       if (XFS_IS_CORRUPT(mp, !xfs_ifork_has_extents(ip, whichfork)) ||
+       if (XFS_IS_CORRUPT(mp, !xfs_ifork_has_extents(ifp)) ||
            XFS_TEST_ERROR(false, mp, XFS_ERRTAG_BMAPIFORMAT)) {
                return -EFSCORRUPTED;
        }
@@ -5985,18 +5974,18 @@ xfs_bmap_split_extent(
        xfs_fileoff_t           split_fsb)
 {
        int                             whichfork = XFS_DATA_FORK;
+       struct xfs_ifork                *ifp = XFS_IFORK_PTR(ip, whichfork);
        struct xfs_btree_cur            *cur = NULL;
        struct xfs_bmbt_irec            got;
        struct xfs_bmbt_irec            new; /* split extent */
        struct xfs_mount                *mp = ip->i_mount;
-       struct xfs_ifork                *ifp;
        xfs_fsblock_t                   gotblkcnt; /* new block count for got */
        struct xfs_iext_cursor          icur;
        int                             error = 0;
        int                             logflags = 0;
        int                             i = 0;
 
-       if (XFS_IS_CORRUPT(mp, !xfs_ifork_has_extents(ip, whichfork)) ||
+       if (XFS_IS_CORRUPT(mp, !xfs_ifork_has_extents(ifp)) ||
            XFS_TEST_ERROR(false, mp, XFS_ERRTAG_BMAPIFORMAT)) {
                return -EFSCORRUPTED;
        }
@@ -6004,7 +5993,6 @@ xfs_bmap_split_extent(
        if (XFS_FORCED_SHUTDOWN(mp))
                return -EIO;
 
-       ifp = XFS_IFORK_PTR(ip, whichfork);
        if (!(ifp->if_flags & XFS_IFEXTENTS)) {
                /* Read in all the extents */
                error = xfs_iread_extents(tp, ip, whichfork);

diff --git a/libxfs/xfs_bmap_btree.c b/libxfs/xfs_bmap_btree.c
index 62f77aa1bbb5b7a650cfdcb2c58076bb43adf63d..579160b773729bbe36a4077b9c42429db8acd058 100644 (file)
--- a/libxfs/xfs_bmap_btree.c
+++ b/libxfs/xfs_bmap_btree.c
@@ -634,10 +634,7 @@ xfs_bmbt_change_owner(
 
        ASSERT(tp || buffer_list);
        ASSERT(!(tp && buffer_list));
-       if (whichfork == XFS_DATA_FORK)
-               ASSERT(ip->i_d.di_format == XFS_DINODE_FMT_BTREE);
-       else
-               ASSERT(ip->i_d.di_aformat == XFS_DINODE_FMT_BTREE);
+       ASSERT(XFS_IFORK_PTR(ip, whichfork)->if_format == XFS_DINODE_FMT_BTREE);
 
        cur = xfs_bmbt_init_cursor(ip->i_mount, tp, ip, whichfork);
        if (!cur)

diff --git a/libxfs/xfs_dir2.c b/libxfs/xfs_dir2.c
index 31ac89a3629af2da6448e869faa3186cd6022475..79196788379fc65262b0cd3032a40233cd00f92d 100644 (file)
--- a/libxfs/xfs_dir2.c
+++ b/libxfs/xfs_dir2.c
@@ -277,7 +277,7 @@ xfs_dir_createname(
        if (!inum)
                args->op_flags |= XFS_DA_OP_JUSTCHECK;
 
-       if (dp->i_d.di_format == XFS_DINODE_FMT_LOCAL) {
+       if (dp->i_df.if_format == XFS_DINODE_FMT_LOCAL) {
                rval = xfs_dir2_sf_addname(args);
                goto out_free;
        }
@@ -372,7 +372,7 @@ xfs_dir_lookup(
                args->op_flags |= XFS_DA_OP_CILOOKUP;
 
        lock_mode = xfs_ilock_data_map_shared(dp);
-       if (dp->i_d.di_format == XFS_DINODE_FMT_LOCAL) {
+       if (dp->i_df.if_format == XFS_DINODE_FMT_LOCAL) {
                rval = xfs_dir2_sf_lookup(args);
                goto out_check_rval;
        }
@@ -442,7 +442,7 @@ xfs_dir_removename(
        args->whichfork = XFS_DATA_FORK;
        args->trans = tp;
 
-       if (dp->i_d.di_format == XFS_DINODE_FMT_LOCAL) {
+       if (dp->i_df.if_format == XFS_DINODE_FMT_LOCAL) {
                rval = xfs_dir2_sf_removename(args);
                goto out_free;
        }
@@ -503,7 +503,7 @@ xfs_dir_replace(
        args->whichfork = XFS_DATA_FORK;
        args->trans = tp;
 
-       if (dp->i_d.di_format == XFS_DINODE_FMT_LOCAL) {
+       if (dp->i_df.if_format == XFS_DINODE_FMT_LOCAL) {
                rval = xfs_dir2_sf_replace(args);
                goto out_free;
        }

diff --git a/libxfs/xfs_dir2_sf.c b/libxfs/xfs_dir2_sf.c
index 0053b7c31f7c5bf041bee8260c2222925845b06d..fbbb638728bc4d16c0dbb821cc2e32fb1e6fc56b 100644 (file)
--- a/libxfs/xfs_dir2_sf.c
+++ b/libxfs/xfs_dir2_sf.c
@@ -343,7 +343,7 @@ xfs_dir2_block_to_sf(
         */
        ASSERT(dp->i_df.if_bytes == 0);
        xfs_init_local_fork(dp, XFS_DATA_FORK, sfp, size);
-       dp->i_d.di_format = XFS_DINODE_FMT_LOCAL;
+       dp->i_df.if_format = XFS_DINODE_FMT_LOCAL;
        dp->i_d.di_size = size;
 
        logflags |= XFS_ILOG_DDATA;
@@ -710,11 +710,11 @@ xfs_dir2_sf_verify(
        struct xfs_inode                *ip)
 {
        struct xfs_mount                *mp = ip->i_mount;
+       struct xfs_ifork                *ifp = XFS_IFORK_PTR(ip, XFS_DATA_FORK);
        struct xfs_dir2_sf_hdr          *sfp;
        struct xfs_dir2_sf_entry        *sfep;
        struct xfs_dir2_sf_entry        *next_sfep;
        char                            *endp;
-       struct xfs_ifork                *ifp;
        xfs_ino_t                       ino;
        int                             i;
        int                             i8count;
@@ -723,9 +723,8 @@ xfs_dir2_sf_verify(
        int                             error;
        uint8_t                         filetype;
 
-       ASSERT(ip->i_d.di_format == XFS_DINODE_FMT_LOCAL);
+       ASSERT(ifp->if_format == XFS_DINODE_FMT_LOCAL);
 
-       ifp = XFS_IFORK_PTR(ip, XFS_DATA_FORK);
        sfp = (struct xfs_dir2_sf_hdr *)ifp->if_u1.if_data;
        size = ifp->if_bytes;
 
@@ -827,9 +826,9 @@ xfs_dir2_sf_create(
         * If it's currently a zero-length extent file,
         * convert it to local format.
         */
-       if (dp->i_d.di_format == XFS_DINODE_FMT_EXTENTS) {
+       if (dp->i_df.if_format == XFS_DINODE_FMT_EXTENTS) {
                dp->i_df.if_flags &= ~XFS_IFEXTENTS;    /* just in case */
-               dp->i_d.di_format = XFS_DINODE_FMT_LOCAL;
+               dp->i_df.if_format = XFS_DINODE_FMT_LOCAL;
                xfs_trans_log_inode(args->trans, dp, XFS_ILOG_CORE);
                dp->i_df.if_flags |= XFS_IFINLINE;
        }
@@ -1027,7 +1026,7 @@ xfs_dir2_sf_replace_needblock(
        int                     newsize;
        struct xfs_dir2_sf_hdr  *sfp;
 
-       if (dp->i_d.di_format != XFS_DINODE_FMT_LOCAL)
+       if (dp->i_df.if_format != XFS_DINODE_FMT_LOCAL)
                return false;
 
        sfp = (struct xfs_dir2_sf_hdr *)dp->i_df.if_u1.if_data;

diff --git a/libxfs/xfs_inode_buf.c b/libxfs/xfs_inode_buf.c
index 79d5b82083894ab084febd8d17a8f0af22288498..586db284bb4c269f1fab90c17fa5e413c4d364a0 100644 (file)
--- a/libxfs/xfs_inode_buf.c
+++ b/libxfs/xfs_inode_buf.c
@@ -222,7 +222,6 @@ xfs_inode_from_disk(
                                        be16_to_cpu(from->di_projid_lo);
        }
 
-       to->di_format = from->di_format;
        i_uid_write(inode, be32_to_cpu(from->di_uid));
        i_gid_write(inode, be32_to_cpu(from->di_gid));
 
@@ -243,7 +242,6 @@ xfs_inode_from_disk(
        to->di_nblocks = be64_to_cpu(from->di_nblocks);
        to->di_extsize = be32_to_cpu(from->di_extsize);
        to->di_forkoff = from->di_forkoff;
-       to->di_aformat  = from->di_aformat;
        to->di_dmevmask = be32_to_cpu(from->di_dmevmask);
        to->di_dmstate  = be16_to_cpu(from->di_dmstate);
        to->di_flags    = be16_to_cpu(from->di_flags);
@@ -286,7 +284,7 @@ xfs_inode_to_disk(
        to->di_magic = cpu_to_be16(XFS_DINODE_MAGIC);
        to->di_onlink = 0;
 
-       to->di_format = from->di_format;
+       to->di_format = xfs_ifork_format(&ip->i_df);
        to->di_uid = cpu_to_be32(i_uid_read(inode));
        to->di_gid = cpu_to_be32(i_gid_read(inode));
        to->di_projid_lo = cpu_to_be16(from->di_projid & 0xffff);
@@ -309,7 +307,7 @@ xfs_inode_to_disk(
        to->di_nextents = cpu_to_be32(xfs_ifork_nextents(&ip->i_df));
        to->di_anextents = cpu_to_be16(xfs_ifork_nextents(ip->i_afp));
        to->di_forkoff = from->di_forkoff;
-       to->di_aformat = from->di_aformat;
+       to->di_aformat = xfs_ifork_format(ip->i_afp);
        to->di_dmevmask = cpu_to_be32(from->di_dmevmask);
        to->di_dmstate = cpu_to_be16(from->di_dmstate);
        to->di_flags = cpu_to_be16(from->di_flags);

diff --git a/libxfs/xfs_inode_buf.h b/libxfs/xfs_inode_buf.h
index fecccfb26463c9a2f50666c2bd19bcafc17095f1..865ac493c72a24f760369ebc31b2cd95cdc47bc5 100644 (file)
--- a/libxfs/xfs_inode_buf.h
+++ b/libxfs/xfs_inode_buf.h
@@ -16,14 +16,12 @@ struct xfs_dinode;
  * format specific structures at the appropriate time.
  */
 struct xfs_icdinode {
-       int8_t          di_format;      /* format of di_c data */
        uint16_t        di_flushiter;   /* incremented on flush */
        uint32_t        di_projid;      /* owner's project id */
        xfs_fsize_t     di_size;        /* number of bytes in file */
        xfs_rfsblock_t  di_nblocks;     /* # of direct & btree blocks used */
        xfs_extlen_t    di_extsize;     /* basic/minimum extent size for file */
        uint8_t         di_forkoff;     /* attr fork offs, <<3 for 64b align */
-       int8_t          di_aformat;     /* format of attr fork's data */
        uint32_t        di_dmevmask;    /* DMIG event mask */
        uint16_t        di_dmstate;     /* DMIG state info */
        uint16_t        di_flags;       /* random flags, XFS_DIFLAG_... */

diff --git a/libxfs/xfs_inode_fork.c b/libxfs/xfs_inode_fork.c
index d7bde9e8f3e21bd05b2e0b05756dea1ced428c56..9fba85d50db23ad5f3e61e4261d0644549b12f99 100644 (file)
--- a/libxfs/xfs_inode_fork.c
+++ b/libxfs/xfs_inode_fork.c
@@ -230,6 +230,7 @@ xfs_iformat_data_fork(
         * Initialize the extent count early, as the per-format routines may
         * depend on it.
         */
+       ip->i_df.if_format = dip->di_format;
        ip->i_df.if_nextents = be32_to_cpu(dip->di_nextents);
 
        switch (inode->i_mode & S_IFMT) {
@@ -243,7 +244,7 @@ xfs_iformat_data_fork(
        case S_IFREG:
        case S_IFLNK:
        case S_IFDIR:
-               switch (dip->di_format) {
+               switch (ip->i_df.if_format) {
                case XFS_DINODE_FMT_LOCAL:
                        error = xfs_iformat_local(ip, dip, XFS_DATA_FORK,
                                        be64_to_cpu(dip->di_size));
@@ -289,9 +290,12 @@ xfs_iformat_attr_fork(
         * depend on it.
         */
        ip->i_afp = kmem_zone_zalloc(xfs_ifork_zone, KM_NOFS);
+       ip->i_afp->if_format = dip->di_aformat;
+       if (unlikely(ip->i_afp->if_format == 0)) /* pre IRIX 6.2 file system */
+               ip->i_afp->if_format = XFS_DINODE_FMT_EXTENTS;
        ip->i_afp->if_nextents = be16_to_cpu(dip->di_anextents);
 
-       switch (dip->di_aformat) {
+       switch (ip->i_afp->if_format) {
        case XFS_DINODE_FMT_LOCAL:
                error = xfs_iformat_local(ip, dip, XFS_ATTR_FORK,
                                xfs_dfork_attr_shortform_size(dip));
@@ -514,7 +518,7 @@ xfs_idestroy_fork(
         * not local then we may or may not have an extents list,
         * so check and free it up if we do.
         */
-       if (XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_LOCAL) {
+       if (ifp->if_format == XFS_DINODE_FMT_LOCAL) {
                if (ifp->if_u1.if_data != NULL) {
                        kmem_free(ifp->if_u1.if_data);
                        ifp->if_u1.if_data = NULL;
@@ -611,7 +615,7 @@ xfs_iflush_fork(
        }
        cp = XFS_DFORK_PTR(dip, whichfork);
        mp = ip->i_mount;
-       switch (XFS_IFORK_FORMAT(ip, whichfork)) {
+       switch (ifp->if_format) {
        case XFS_DINODE_FMT_LOCAL:
                if ((iip->ili_fields & dataflag[whichfork]) &&
                    (ifp->if_bytes > 0)) {
@@ -684,7 +688,7 @@ xfs_ifork_init_cow(
        ip->i_cowfp = kmem_zone_zalloc(xfs_ifork_zone,
                                       KM_NOFS);
        ip->i_cowfp->if_flags = XFS_IFEXTENTS;
-       ip->i_cformat = XFS_DINODE_FMT_EXTENTS;
+       ip->i_cowfp->if_format = XFS_DINODE_FMT_EXTENTS;
 }
 
 /* Verify the inline contents of the data fork of an inode. */

diff --git a/libxfs/xfs_inode_fork.h b/libxfs/xfs_inode_fork.h
index a69d425fe68df8bd844c5fcbf08d37f4cd19484e..d849cca103edd7f45a41695bf8180d1eb9255a83 100644 (file)
--- a/libxfs/xfs_inode_fork.h
+++ b/libxfs/xfs_inode_fork.h
@@ -23,6 +23,7 @@ struct xfs_ifork {
        } if_u1;
        short                   if_broot_bytes; /* bytes allocated for root */
        unsigned char           if_flags;       /* per-fork flags */
+       int8_t                  if_format;      /* format of this fork */
        xfs_extnum_t            if_nextents;    /* # of extents in this fork */
 };
 
@@ -56,24 +57,14 @@ struct xfs_ifork {
                ((w) == XFS_ATTR_FORK ? \
                        XFS_IFORK_ASIZE(ip) : \
                        0))
-#define XFS_IFORK_FORMAT(ip,w) \
-       ((w) == XFS_DATA_FORK ? \
-               (ip)->i_d.di_format : \
-               ((w) == XFS_ATTR_FORK ? \
-                       (ip)->i_d.di_aformat : \
-                       (ip)->i_cformat))
-#define XFS_IFORK_FMT_SET(ip,w,n) \
-       ((w) == XFS_DATA_FORK ? \
-               ((ip)->i_d.di_format = (n)) : \
-               ((w) == XFS_ATTR_FORK ? \
-                       ((ip)->i_d.di_aformat = (n)) : \
-                       ((ip)->i_cformat = (n))))
 #define XFS_IFORK_MAXEXT(ip, w) \
        (XFS_IFORK_SIZE(ip, w) / sizeof(xfs_bmbt_rec_t))
 
-#define xfs_ifork_has_extents(ip, w) \
-       (XFS_IFORK_FORMAT((ip), (w)) == XFS_DINODE_FMT_EXTENTS || \
-        XFS_IFORK_FORMAT((ip), (w)) == XFS_DINODE_FMT_BTREE)
+static inline bool xfs_ifork_has_extents(struct xfs_ifork *ifp)
+{
+       return ifp->if_format == XFS_DINODE_FMT_EXTENTS ||
+               ifp->if_format == XFS_DINODE_FMT_BTREE;
+}
 
 static inline xfs_extnum_t xfs_ifork_nextents(struct xfs_ifork *ifp)
 {
@@ -82,6 +73,13 @@ static inline xfs_extnum_t xfs_ifork_nextents(struct xfs_ifork *ifp)
        return ifp->if_nextents;
 }
 
+static inline int8_t xfs_ifork_format(struct xfs_ifork *ifp)
+{
+       if (!ifp)
+               return XFS_DINODE_FMT_EXTENTS;
+       return ifp->if_format;
+}
+
 struct xfs_ifork *xfs_iext_state_to_fork(struct xfs_inode *ip, int state);
 
 int            xfs_iformat_data_fork(struct xfs_inode *, struct xfs_dinode *);

diff --git a/libxfs/xfs_symlink_remote.c b/libxfs/xfs_symlink_remote.c
index 004289e6fe7fa7757332da3f9ac6b83dc88d78af..8eb3d59fea9759ad8270ad86bcc447bf8d30b0ae 100644 (file)
--- a/libxfs/xfs_symlink_remote.c
+++ b/libxfs/xfs_symlink_remote.c
@@ -201,16 +201,12 @@ xfs_failaddr_t
 xfs_symlink_shortform_verify(
        struct xfs_inode        *ip)
 {
-       char                    *sfp;
-       char                    *endp;
-       struct xfs_ifork        *ifp;
-       int                     size;
-
-       ASSERT(ip->i_d.di_format == XFS_DINODE_FMT_LOCAL);
-       ifp = XFS_IFORK_PTR(ip, XFS_DATA_FORK);
-       sfp = (char *)ifp->if_u1.if_data;
-       size = ifp->if_bytes;
-       endp = sfp + size;
+       struct xfs_ifork        *ifp = XFS_IFORK_PTR(ip, XFS_DATA_FORK);
+       char                    *sfp = (char *)ifp->if_u1.if_data;
+       int                     size = ifp->if_bytes;
+       char                    *endp = sfp + size;
+
+       ASSERT(ifp->if_format == XFS_DINODE_FMT_LOCAL);
 
        /*
         * Zero length symlinks should never occur in memory as they are

diff --git a/mkfs/proto.c b/mkfs/proto.c
index 01b30c5f1b15ca9ada9b87410aed1c88f62856ca..9db8fe2d64477e74cffa42dc4e637dd21c8d6c2c 100644 (file)
--- a/mkfs/proto.c
+++ b/mkfs/proto.c
@@ -238,7 +238,7 @@ newfile(
        mp = ip->i_mount;
        if (symlink && len <= XFS_IFORK_DSIZE(ip)) {
                libxfs_init_local_fork(ip, XFS_DATA_FORK, buf, len);
-               ip->i_d.di_format = XFS_DINODE_FMT_LOCAL;
+               ip->i_df.if_format = XFS_DINODE_FMT_LOCAL;
                flags = XFS_ILOG_DDATA;
        } else if (len > 0) {
                nb = XFS_B_TO_FSB(mp, len);

diff --git a/repair/phase6.c b/repair/phase6.c
index f69582d47f733e6fd2e3dba82db70e6a18705f74..70d32089bb573ec1b3cc569839ca66d93aed597b 100644 (file)
--- a/repair/phase6.c
+++ b/repair/phase6.c
@@ -425,11 +425,13 @@ bmap_next_offset(
        struct xfs_ifork        *ifp;           /* inode fork pointer */
        struct xfs_iext_cursor  icur;
 
-       if (XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE &&
-           XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS &&
-           XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_LOCAL)
+       ifp = XFS_IFORK_PTR(ip, whichfork);
+
+       if (ifp->if_format != XFS_DINODE_FMT_BTREE &&
+           ifp->if_format != XFS_DINODE_FMT_EXTENTS &&
+           ifp->if_format != XFS_DINODE_FMT_LOCAL)
               return EIO;
-       if (XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_LOCAL) {
+       if (ifp->if_format == XFS_DINODE_FMT_LOCAL) {
                *bnop = NULLFILEOFF;
                return 0;
        }
@@ -487,8 +489,9 @@ mk_rbmino(xfs_mount_t *mp)
        memset(&ip->i_d, 0, sizeof(ip->i_d));
 
        VFS_I(ip)->i_mode = S_IFREG;
-       ip->i_d.di_format = XFS_DINODE_FMT_EXTENTS;
-       ip->i_d.di_aformat = XFS_DINODE_FMT_EXTENTS;
+       ip->i_df.if_format = XFS_DINODE_FMT_EXTENTS;
+       if (ip->i_afp)
+               ip->i_afp->if_format = XFS_DINODE_FMT_EXTENTS;
 
        set_nlink(VFS_I(ip), 1);        /* account for sb ptr */
 
@@ -727,8 +730,9 @@ mk_rsumino(xfs_mount_t *mp)
        memset(&ip->i_d, 0, sizeof(ip->i_d));
 
        VFS_I(ip)->i_mode = S_IFREG;
-       ip->i_d.di_format = XFS_DINODE_FMT_EXTENTS;
-       ip->i_d.di_aformat = XFS_DINODE_FMT_EXTENTS;
+       ip->i_df.if_format = XFS_DINODE_FMT_EXTENTS;
+       if (ip->i_afp)
+               ip->i_afp->if_format = XFS_DINODE_FMT_EXTENTS;
 
        set_nlink(VFS_I(ip), 1);        /* account for sb ptr */
 
@@ -826,8 +830,9 @@ mk_root_dir(xfs_mount_t *mp)
        memset(&ip->i_d, 0, sizeof(ip->i_d));
 
        VFS_I(ip)->i_mode = mode|S_IFDIR;
-       ip->i_d.di_format = XFS_DINODE_FMT_EXTENTS;
-       ip->i_d.di_aformat = XFS_DINODE_FMT_EXTENTS;
+       ip->i_df.if_format = XFS_DINODE_FMT_EXTENTS;
+       if (ip->i_afp)
+               ip->i_afp->if_format = XFS_DINODE_FMT_EXTENTS;
 
        set_nlink(VFS_I(ip), 2);        /* account for . and .. */
 
@@ -1204,8 +1209,8 @@ dir_binval(
        xfs_dablk_t             dabno;
        int                     error = 0;
 
-       if (ip->i_d.di_format != XFS_DINODE_FMT_EXTENTS &&
-           ip->i_d.di_format != XFS_DINODE_FMT_BTREE)
+       if (ip->i_df.if_format != XFS_DINODE_FMT_EXTENTS &&
+           ip->i_df.if_format != XFS_DINODE_FMT_BTREE)
                return 0;
 
        geo = tp->t_mountp->m_dir_geo;
@@ -2855,7 +2860,7 @@ process_dir_inode(
        /*
         * look for bogus entries
         */
-       switch (ip->i_d.di_format)  {
+       switch (ip->i_df.if_format)  {
                case XFS_DINODE_FMT_EXTENTS:
                case XFS_DINODE_FMT_BTREE:
                        /*
@@ -2920,7 +2925,7 @@ _("error %d fixing shortform directory %llu\n"),
         * if it has to move them around.
         */
        if (!no_modify && need_root_dotdot && ino == mp->m_sb.sb_rootino)  {
-               ASSERT(ip->i_d.di_format != XFS_DINODE_FMT_LOCAL);
+               ASSERT(ip->i_df.if_format != XFS_DINODE_FMT_LOCAL);
 
                do_warn(_("recreating root directory .. entry\n"));
 
@@ -2972,7 +2977,7 @@ _("error %d fixing shortform directory %llu\n"),
                        do_warn(
        _("would create missing \".\" entry in dir ino %" PRIu64 "\n"),
                                ino);
-               } else if (ip->i_d.di_format != XFS_DINODE_FMT_LOCAL)  {
+               } else if (ip->i_df.if_format != XFS_DINODE_FMT_LOCAL)  {
                        /*
                         * need to create . entry in longform dir.
                         */