Gitweb:     
http://git.kernel.org/git/?p=linux/kernel/git/torvalds/linux-2.6.git;a=commit;h=45ba598e56fa9f77801e06432b50580d97994fa4
Commit:     45ba598e56fa9f77801e06432b50580d97994fa4
Parent:     a9759f2de38a3443d5107bddde03b4f3f550060e
Author:     Christoph Hellwig <[EMAIL PROTECTED]>
AuthorDate: Fri Dec 7 14:07:20 2007 +1100
Committer:  Lachlan McIlroy <[EMAIL PROTECTED]>
CommitDate: Thu Feb 7 18:19:24 2008 +1100

    [XFS] Remove CFORK macros and use code directly in IFORK and DFORK macros.
    
    Currently XFS_IFORK_* and XFS_DFORK* are implemented by means of
    XFS_CFORK* macros. But given that XFS_IFORK_* operates on an xfs_inode
    that embedds and xfs_icdinode_core and XFS_DFORK_* operates on an
    xfs_dinode that embedds a xfs_dinode_core one will have to do endian
    swapping while the other doesn't. Instead of having the current mess with
    the CFORK macros that have byteswapping and non-byteswapping version
    (which are inconsistantly named while we're at it) just define each family
    of the macros to stand by itself and simplify the whole matter.
    
    A few direct references to the CFORK variants were cleaned up to use IFORK
    or DFORK to make this possible.
    
    SGI-PV: 971186
    SGI-Modid: xfs-linux-melb:xfs-kern:30163a
    
    Signed-off-by: Christoph Hellwig <[EMAIL PROTECTED]>
    Signed-off-by: Tim Shimmin <[EMAIL PROTECTED]>
    Signed-off-by: Lachlan McIlroy <[EMAIL PROTECTED]>
---
 fs/xfs/xfs_dinode.h |   78 ++++++++++++++------------------------------------
 fs/xfs/xfs_inode.c  |    8 +++--
 fs/xfs/xfs_inode.h  |   47 +++++++++++++++++++++++-------
 fs/xfs/xfs_itable.c |    4 +-
 4 files changed, 65 insertions(+), 72 deletions(-)

diff --git a/fs/xfs/xfs_dinode.h b/fs/xfs/xfs_dinode.h
index 85030cb..c9065ea 100644
--- a/fs/xfs/xfs_dinode.h
+++ b/fs/xfs/xfs_dinode.h
@@ -171,69 +171,35 @@ typedef enum xfs_dinode_fmt
 /*
  * Inode data & attribute fork sizes, per inode.
  */
-#define XFS_CFORK_Q(dcp)                    ((dcp)->di_forkoff != 0)
-#define        XFS_CFORK_Q_DISK(dcp)               ((dcp)->di_forkoff != 0)
-
-#define XFS_CFORK_BOFF(dcp)                 ((int)((dcp)->di_forkoff << 3))
-#define        XFS_CFORK_BOFF_DISK(dcp)            ((int)((dcp)->di_forkoff << 
3))
-
-#define        XFS_CFORK_DSIZE_DISK(dcp,mp) \
-       (XFS_CFORK_Q_DISK(dcp) ? XFS_CFORK_BOFF_DISK(dcp) : XFS_LITINO(mp))
-#define XFS_CFORK_DSIZE(dcp,mp) \
-       (XFS_CFORK_Q(dcp) ? XFS_CFORK_BOFF(dcp) : XFS_LITINO(mp))
-
-#define        XFS_CFORK_ASIZE_DISK(dcp,mp) \
-       (XFS_CFORK_Q_DISK(dcp) ? XFS_LITINO(mp) - XFS_CFORK_BOFF_DISK(dcp) : 0)
-#define XFS_CFORK_ASIZE(dcp,mp) \
-       (XFS_CFORK_Q(dcp) ? XFS_LITINO(mp) - XFS_CFORK_BOFF(dcp) : 0)
-
-#define        XFS_CFORK_SIZE_DISK(dcp,mp,w) \
-       ((w) == XFS_DATA_FORK ? \
-               XFS_CFORK_DSIZE_DISK(dcp, mp) : \
-               XFS_CFORK_ASIZE_DISK(dcp, mp))
-#define XFS_CFORK_SIZE(dcp,mp,w) \
-       ((w) == XFS_DATA_FORK ? \
-               XFS_CFORK_DSIZE(dcp, mp) : XFS_CFORK_ASIZE(dcp, mp))
+#define XFS_DFORK_Q(dip)               ((dip)->di_core.di_forkoff != 0)
+#define XFS_DFORK_BOFF(dip)            ((int)((dip)->di_core.di_forkoff << 3))
 
 #define XFS_DFORK_DSIZE(dip,mp) \
-       XFS_CFORK_DSIZE_DISK(&(dip)->di_core, mp)
-#define XFS_DFORK_DSIZE_HOST(dip,mp) \
-       XFS_CFORK_DSIZE(&(dip)->di_core, mp)
+       (XFS_DFORK_Q(dip) ? \
+               XFS_DFORK_BOFF(dip) : \
+               XFS_LITINO(mp))
 #define XFS_DFORK_ASIZE(dip,mp) \
-       XFS_CFORK_ASIZE_DISK(&(dip)->di_core, mp)
-#define XFS_DFORK_ASIZE_HOST(dip,mp) \
-       XFS_CFORK_ASIZE(&(dip)->di_core, mp)
-#define        XFS_DFORK_SIZE(dip,mp,w) \
-       XFS_CFORK_SIZE_DISK(&(dip)->di_core, mp, w)
-#define        XFS_DFORK_SIZE_HOST(dip,mp,w) \
-       XFS_CFORK_SIZE(&(dip)->di_core, mp, w)
+       (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) : \
+               XFS_DFORK_ASIZE(dip, mp))
 
-#define        XFS_DFORK_Q(dip)                    
XFS_CFORK_Q_DISK(&(dip)->di_core)
-#define        XFS_DFORK_BOFF(dip)                 
XFS_CFORK_BOFF_DISK(&(dip)->di_core)
-#define        XFS_DFORK_DPTR(dip)                 ((dip)->di_u.di_c)
-#define        XFS_DFORK_APTR(dip)     \
+#define XFS_DFORK_DPTR(dip)                ((dip)->di_u.di_c)
+#define XFS_DFORK_APTR(dip)    \
        ((dip)->di_u.di_c + XFS_DFORK_BOFF(dip))
-#define        XFS_DFORK_PTR(dip,w)    \
+#define XFS_DFORK_PTR(dip,w)   \
        ((w) == XFS_DATA_FORK ? XFS_DFORK_DPTR(dip) : XFS_DFORK_APTR(dip))
-#define        XFS_CFORK_FORMAT(dcp,w) \
-       ((w) == XFS_DATA_FORK ? (dcp)->di_format : (dcp)->di_aformat)
-#define        XFS_CFORK_FMT_SET(dcp,w,n) \
+#define XFS_DFORK_FORMAT(dip,w) \
        ((w) == XFS_DATA_FORK ? \
-               ((dcp)->di_format = (n)) : ((dcp)->di_aformat = (n)))
-#define        XFS_DFORK_FORMAT(dip,w) XFS_CFORK_FORMAT(&(dip)->di_core, w)
-
-#define        XFS_CFORK_NEXTENTS_DISK(dcp,w) \
-       ((w) == XFS_DATA_FORK ? \
-               be32_to_cpu((dcp)->di_nextents) : \
-               be16_to_cpu((dcp)->di_anextents))
-#define XFS_CFORK_NEXTENTS(dcp,w) \
-       ((w) == XFS_DATA_FORK ? (dcp)->di_nextents : (dcp)->di_anextents)
-#define        XFS_DFORK_NEXTENTS(dip,w) 
XFS_CFORK_NEXTENTS_DISK(&(dip)->di_core, w)
-#define        XFS_DFORK_NEXTENTS_HOST(dip,w) 
XFS_CFORK_NEXTENTS(&(dip)->di_core, w)
-
-#define        XFS_CFORK_NEXT_SET(dcp,w,n) \
+               (dip)->di_core.di_format : \
+               (dip)->di_core.di_aformat)
+#define XFS_DFORK_NEXTENTS(dip,w) \
        ((w) == XFS_DATA_FORK ? \
-               ((dcp)->di_nextents = (n)) : ((dcp)->di_anextents = (n)))
+               be32_to_cpu((dip)->di_core.di_nextents) : \
+               be16_to_cpu((dip)->di_core.di_anextents))
 
 #define        XFS_BUF_TO_DINODE(bp)   ((xfs_dinode_t *)XFS_BUF_PTR(bp))
 
diff --git a/fs/xfs/xfs_inode.c b/fs/xfs/xfs_inode.c
index dc4b8bd..75b636c 100644
--- a/fs/xfs/xfs_inode.c
+++ b/fs/xfs/xfs_inode.c
@@ -828,15 +828,17 @@ xfs_ip2xflags(
        xfs_icdinode_t          *dic = &ip->i_d;
 
        return _xfs_dic2xflags(dic->di_flags) |
-                               (XFS_CFORK_Q(dic) ? XFS_XFLAG_HASATTR : 0);
+                               (XFS_IFORK_Q(ip) ? XFS_XFLAG_HASATTR : 0);
 }
 
 uint
 xfs_dic2xflags(
-       xfs_dinode_core_t       *dic)
+       xfs_dinode_t            *dip)
 {
+       xfs_dinode_core_t       *dic = &dip->di_core;
+
        return _xfs_dic2xflags(be16_to_cpu(dic->di_flags)) |
-                               (XFS_CFORK_Q_DISK(dic) ? XFS_XFLAG_HASATTR : 0);
+                               (XFS_DFORK_Q(dip) ? XFS_XFLAG_HASATTR : 0);
 }
 
 /*
diff --git a/fs/xfs/xfs_inode.h b/fs/xfs/xfs_inode.h
index b2d7b2c..a8d6f5e 100644
--- a/fs/xfs/xfs_inode.h
+++ b/fs/xfs/xfs_inode.h
@@ -341,17 +341,42 @@ xfs_iflags_test_and_clear(xfs_inode_t *ip, unsigned short 
flags)
 /*
  * Fork handling.
  */
-#define        XFS_IFORK_PTR(ip,w)             \
-       ((w) == XFS_DATA_FORK ? &(ip)->i_df : (ip)->i_afp)
-#define        XFS_IFORK_Q(ip)                 XFS_CFORK_Q(&(ip)->i_d)
-#define        XFS_IFORK_DSIZE(ip)             XFS_CFORK_DSIZE(&ip->i_d, 
ip->i_mount)
-#define        XFS_IFORK_ASIZE(ip)             XFS_CFORK_ASIZE(&ip->i_d, 
ip->i_mount)
-#define        XFS_IFORK_SIZE(ip,w)            XFS_CFORK_SIZE(&ip->i_d, 
ip->i_mount, w)
-#define        XFS_IFORK_FORMAT(ip,w)          XFS_CFORK_FORMAT(&ip->i_d, w)
-#define        XFS_IFORK_FMT_SET(ip,w,n)       XFS_CFORK_FMT_SET(&ip->i_d, w, 
n)
-#define        XFS_IFORK_NEXTENTS(ip,w)        XFS_CFORK_NEXTENTS(&ip->i_d, w)
-#define        XFS_IFORK_NEXT_SET(ip,w,n)      XFS_CFORK_NEXT_SET(&ip->i_d, w, 
n)
 
+#define XFS_IFORK_Q(ip)                        ((ip)->i_d.di_forkoff != 0)
+#define XFS_IFORK_BOFF(ip)             ((int)((ip)->i_d.di_forkoff << 3))
+
+#define XFS_IFORK_PTR(ip,w)            \
+       ((w) == XFS_DATA_FORK ? \
+               &(ip)->i_df : \
+               (ip)->i_afp)
+#define XFS_IFORK_DSIZE(ip) \
+       (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) - XFS_IFORK_BOFF(ip) : \
+               0)
+#define XFS_IFORK_SIZE(ip,w) \
+       ((w) == XFS_DATA_FORK ? \
+               XFS_IFORK_DSIZE(ip) : \
+               XFS_IFORK_ASIZE(ip))
+#define XFS_IFORK_FORMAT(ip,w) \
+       ((w) == XFS_DATA_FORK ? \
+               (ip)->i_d.di_format : \
+               (ip)->i_d.di_aformat)
+#define XFS_IFORK_FMT_SET(ip,w,n) \
+       ((w) == XFS_DATA_FORK ? \
+               ((ip)->i_d.di_format = (n)) : \
+               ((ip)->i_d.di_aformat = (n)))
+#define XFS_IFORK_NEXTENTS(ip,w) \
+       ((w) == XFS_DATA_FORK ? \
+               (ip)->i_d.di_nextents : \
+               (ip)->i_d.di_anextents)
+#define XFS_IFORK_NEXT_SET(ip,w,n) \
+       ((w) == XFS_DATA_FORK ? \
+               ((ip)->i_d.di_nextents = (n)) : \
+               ((ip)->i_d.di_anextents = (n)))
 
 #ifdef __KERNEL__
 
@@ -503,7 +528,7 @@ void                xfs_dinode_to_disk(struct 
xfs_dinode_core *,
                                   struct xfs_icdinode *);
 
 uint           xfs_ip2xflags(struct xfs_inode *);
-uint           xfs_dic2xflags(struct xfs_dinode_core *);
+uint           xfs_dic2xflags(struct xfs_dinode *);
 int            xfs_ifree(struct xfs_trans *, xfs_inode_t *,
                           struct xfs_bmap_free *);
 int            xfs_itruncate_start(xfs_inode_t *, uint, xfs_fsize_t);
diff --git a/fs/xfs/xfs_itable.c b/fs/xfs/xfs_itable.c
index a451baa..658aab6 100644
--- a/fs/xfs/xfs_itable.c
+++ b/fs/xfs/xfs_itable.c
@@ -170,7 +170,7 @@ xfs_bulkstat_one_dinode(
        buf->bs_mtime.tv_nsec = be32_to_cpu(dic->di_mtime.t_nsec);
        buf->bs_ctime.tv_sec = be32_to_cpu(dic->di_ctime.t_sec);
        buf->bs_ctime.tv_nsec = be32_to_cpu(dic->di_ctime.t_nsec);
-       buf->bs_xflags = xfs_dic2xflags(dic);
+       buf->bs_xflags = xfs_dic2xflags(dip);
        buf->bs_extsize = be32_to_cpu(dic->di_extsize) << mp->m_sb.sb_blocklog;
        buf->bs_extents = be32_to_cpu(dic->di_nextents);
        buf->bs_gen = be32_to_cpu(dic->di_gen);
@@ -307,7 +307,7 @@ xfs_bulkstat_use_dinode(
        }
        /* BULKSTAT_FG_INLINE: if attr fork is local, or not there, use it */
        aformat = dip->di_core.di_aformat;
-       if ((XFS_CFORK_Q(&dip->di_core) == 0) ||
+       if ((XFS_DFORK_Q(dip) == 0) ||
            (aformat == XFS_DINODE_FMT_LOCAL) ||
            (aformat == XFS_DINODE_FMT_EXTENTS && !dip->di_core.di_anextents)) {
                *dipp = dip;
-
To unsubscribe from this list: send the line "unsubscribe git-commits-head" in
the body of a message to [EMAIL PROTECTED]
More majordomo info at  http://vger.kernel.org/majordomo-info.html

Reply via email to