[XFS] Complete transition away from linvfs naming convention, finally.

SGI-PV: 947038
SGI-Modid: xfs-linux-melb:xfs-kern:25474a

Signed-off-by: Nathan Scott <nathans@sgi.com>

diff --git a/fs/xfs/linux-2.6/xfs_aops.c b/fs/xfs/linux-2.6/xfs_aops.c
index 2b610c7ba322137342dbfddcd6530a72d4c68162..448912f0e75341599dacc022c33c06a5087a7427 100644 (file)
--- a/fs/xfs/linux-2.6/xfs_aops.c
+++ b/fs/xfs/linux-2.6/xfs_aops.c
@@ -76,7 +76,7 @@ xfs_page_trace(
        int             mask)
 {
        xfs_inode_t     *ip;
-       vnode_t         *vp = LINVFS_GET_VP(inode);
+       vnode_t         *vp = vn_from_inode(inode);
        loff_t          isize = i_size_read(inode);
        loff_t          offset = page_offset(page);
        int             delalloc = -1, unmapped = -1, unwritten = -1;
@@ -214,7 +214,7 @@ xfs_alloc_ioend(
        ioend->io_uptodate = 1; /* cleared if any I/O fails */
        ioend->io_list = NULL;
        ioend->io_type = type;
-       ioend->io_vnode = LINVFS_GET_VP(inode);
+       ioend->io_vnode = vn_from_inode(inode);
        ioend->io_buffer_head = NULL;
        ioend->io_buffer_tail = NULL;
        atomic_inc(&ioend->io_vnode->v_iocount);
@@ -239,7 +239,7 @@ xfs_map_blocks(
        xfs_iomap_t             *mapp,
        int                     flags)
 {
-       vnode_t                 *vp = LINVFS_GET_VP(inode);
+       vnode_t                 *vp = vn_from_inode(inode);
        int                     error, nmaps = 1;
 
        VOP_BMAP(vp, offset, count, flags, mapp, &nmaps, error);
@@ -1229,7 +1229,7 @@ __xfs_get_block(
        int                     direct,
        bmapi_flags_t           flags)
 {
-       vnode_t                 *vp = LINVFS_GET_VP(inode);
+       vnode_t                 *vp = vn_from_inode(inode);
        xfs_iomap_t             iomap;
        xfs_off_t               offset;
        ssize_t                 size;
@@ -1371,7 +1371,7 @@ xfs_vm_direct_IO(
 {
        struct file     *file = iocb->ki_filp;
        struct inode    *inode = file->f_mapping->host;
-       vnode_t         *vp = LINVFS_GET_VP(inode);
+       vnode_t         *vp = vn_from_inode(inode);
        xfs_iomap_t     iomap;
        int             maps = 1;
        int             error;
@@ -1410,7 +1410,7 @@ xfs_vm_bmap(
        sector_t                block)
 {
        struct inode            *inode = (struct inode *)mapping->host;
-       vnode_t                 *vp = LINVFS_GET_VP(inode);
+       vnode_t                 *vp = vn_from_inode(inode);
        int                     error;
 
        vn_trace_entry(vp, __FUNCTION__, (inst_t *)__return_address);

diff --git a/fs/xfs/linux-2.6/xfs_export.c b/fs/xfs/linux-2.6/xfs_export.c
index 391c1353cd42b435980a786340ca99129a2461d4..b768ea910bbe00e3741ca9cec61b21cb06a3d9e5 100644 (file)
--- a/fs/xfs/linux-2.6/xfs_export.c
+++ b/fs/xfs/linux-2.6/xfs_export.c
@@ -97,7 +97,7 @@ xfs_fs_encode_fh(
        int                     len;
        int                     is64 = 0;
 #if XFS_BIG_INUMS
-       vfs_t                   *vfs = LINVFS_GET_VFS(inode->i_sb);
+       vfs_t                   *vfs = vfs_from_sb(inode->i_sb);
 
        if (!(vfs->vfs_flag & VFS_32BITINODES)) {
                /* filesystem may contain 64bit inode numbers */
@@ -139,14 +139,14 @@ xfs_fs_get_dentry(
        vnode_t                 *vp;
        struct inode            *inode;
        struct dentry           *result;
-       vfs_t                   *vfsp = LINVFS_GET_VFS(sb);
+       vfs_t                   *vfsp = vfs_from_sb(sb);
        int                     error;
 
        VFS_VGET(vfsp, &vp, (fid_t *)data, error);
        if (error || vp == NULL)
                return ERR_PTR(-ESTALE) ;
 
-       inode = LINVFS_GET_IP(vp);
+       inode = vn_to_inode(vp);
        result = d_alloc_anon(inode);
         if (!result) {
                iput(inode);
@@ -164,12 +164,12 @@ xfs_fs_get_parent(
        struct dentry           *parent;
 
        cvp = NULL;
-       vp = LINVFS_GET_VP(child->d_inode);
+       vp = vn_from_inode(child->d_inode);
        VOP_LOOKUP(vp, &dotdot, &cvp, 0, NULL, NULL, error);
        if (unlikely(error))
                return ERR_PTR(-error);
 
-       parent = d_alloc_anon(LINVFS_GET_IP(cvp));
+       parent = d_alloc_anon(vn_to_inode(cvp));
        if (unlikely(!parent)) {
                VN_RELE(cvp);
                return ERR_PTR(-ENOMEM);

diff --git a/fs/xfs/linux-2.6/xfs_file.c b/fs/xfs/linux-2.6/xfs_file.c
index c271c99364980b2fd53384071a11d331558fbb4a..185567a6a56118cb47dcf6da77b7df8de98f5af5 100644 (file)
--- a/fs/xfs/linux-2.6/xfs_file.c
+++ b/fs/xfs/linux-2.6/xfs_file.c
@@ -58,7 +58,7 @@ __xfs_file_read(
 {
        struct iovec            iov = {buf, count};
        struct file             *file = iocb->ki_filp;
-       vnode_t                 *vp = LINVFS_GET_VP(file->f_dentry->d_inode);
+       vnode_t                 *vp = vn_from_inode(file->f_dentry->d_inode);
        ssize_t                 rval;
 
        BUG_ON(iocb->ki_pos != pos);
@@ -102,7 +102,7 @@ __xfs_file_write(
        struct iovec    iov = {(void __user *)buf, count};
        struct file     *file = iocb->ki_filp;
        struct inode    *inode = file->f_mapping->host;
-       vnode_t         *vp = LINVFS_GET_VP(inode);
+       vnode_t         *vp = vn_from_inode(inode);
        ssize_t         rval;
 
        BUG_ON(iocb->ki_pos != pos);
@@ -144,7 +144,7 @@ __xfs_file_readv(
        loff_t                  *ppos)
 {
        struct inode    *inode = file->f_mapping->host;
-       vnode_t         *vp = LINVFS_GET_VP(inode);
+       vnode_t         *vp = vn_from_inode(inode);
        struct kiocb    kiocb;
        ssize_t         rval;
 
@@ -189,7 +189,7 @@ __xfs_file_writev(
        loff_t                  *ppos)
 {
        struct inode    *inode = file->f_mapping->host;
-       vnode_t         *vp = LINVFS_GET_VP(inode);
+       vnode_t         *vp = vn_from_inode(inode);
        struct kiocb    kiocb;
        ssize_t         rval;
 
@@ -233,7 +233,7 @@ xfs_file_sendfile(
        read_actor_t            actor,
        void                    *target)
 {
-       vnode_t                 *vp = LINVFS_GET_VP(filp->f_dentry->d_inode);
+       vnode_t                 *vp = vn_from_inode(filp->f_dentry->d_inode);
        ssize_t                 rval;
 
        VOP_SENDFILE(vp, filp, ppos, 0, count, actor, target, NULL, rval);
@@ -246,7 +246,7 @@ xfs_file_open(
        struct inode    *inode,
        struct file     *filp)
 {
-       vnode_t         *vp = LINVFS_GET_VP(inode);
+       vnode_t         *vp = vn_from_inode(inode);
        int             error;
 
        if (!(filp->f_flags & O_LARGEFILE) && i_size_read(inode) > MAX_NON_LFS)
@@ -263,7 +263,7 @@ xfs_file_release(
        struct inode    *inode,
        struct file     *filp)
 {
-       vnode_t         *vp = LINVFS_GET_VP(inode);
+       vnode_t         *vp = vn_from_inode(inode);
        int             error = 0;
 
        if (vp)
@@ -279,7 +279,7 @@ xfs_file_fsync(
        int             datasync)
 {
        struct inode    *inode = dentry->d_inode;
-       vnode_t         *vp = LINVFS_GET_VP(inode);
+       vnode_t         *vp = vn_from_inode(inode);
        int             error;
        int             flags = FSYNC_WAIT;
 
@@ -307,7 +307,7 @@ xfs_vm_nopage(
        int                     *type)
 {
        struct inode    *inode = area->vm_file->f_dentry->d_inode;
-       vnode_t         *vp = LINVFS_GET_VP(inode);
+       vnode_t         *vp = vn_from_inode(inode);
        xfs_mount_t     *mp = XFS_VFSTOM(vp->v_vfsp);
        int             error;
 
@@ -340,7 +340,7 @@ xfs_file_readdir(
        xfs_off_t       start_offset, curr_offset;
        xfs_dirent_t    *dbp = NULL;
 
-       vp = LINVFS_GET_VP(filp->f_dentry->d_inode);
+       vp = vn_from_inode(filp->f_dentry->d_inode);
        ASSERT(vp);
 
        /* Try fairly hard to get memory */
@@ -409,7 +409,7 @@ xfs_file_mmap(
        struct vm_area_struct *vma)
 {
        struct inode    *ip = filp->f_dentry->d_inode;
-       vnode_t         *vp = LINVFS_GET_VP(ip);
+       vnode_t         *vp = vn_from_inode(ip);
        vattr_t         vattr;
        int             error;
 
@@ -437,7 +437,7 @@ xfs_file_ioctl(
 {
        int             error;
        struct inode    *inode = filp->f_dentry->d_inode;
-       vnode_t         *vp = LINVFS_GET_VP(inode);
+       vnode_t         *vp = vn_from_inode(inode);
 
        VOP_IOCTL(vp, inode, filp, 0, cmd, (void __user *)arg, error);
        VMODIFY(vp);
@@ -459,7 +459,7 @@ xfs_file_ioctl_invis(
 {
        int             error;
        struct inode    *inode = filp->f_dentry->d_inode;
-       vnode_t         *vp = LINVFS_GET_VP(inode);
+       vnode_t         *vp = vn_from_inode(inode);
 
        ASSERT(vp);
        VOP_IOCTL(vp, inode, filp, IO_INVIS, cmd, (void __user *)arg, error);
@@ -481,7 +481,7 @@ xfs_vm_mprotect(
        struct vm_area_struct *vma,
        unsigned int    newflags)
 {
-       vnode_t         *vp = LINVFS_GET_VP(vma->vm_file->f_dentry->d_inode);
+       vnode_t         *vp = vn_from_inode(vma->vm_file->f_dentry->d_inode);
        int             error = 0;
 
        if (vp->v_vfsp->vfs_flag & VFS_DMI) {
@@ -507,7 +507,7 @@ STATIC int
 xfs_file_open_exec(
        struct inode    *inode)
 {
-       vnode_t         *vp = LINVFS_GET_VP(inode);
+       vnode_t         *vp = vn_from_inode(inode);
        xfs_mount_t     *mp = XFS_VFSTOM(vp->v_vfsp);
        int             error = 0;
        xfs_inode_t     *ip;

diff --git a/fs/xfs/linux-2.6/xfs_fs_subr.c b/fs/xfs/linux-2.6/xfs_fs_subr.c
index 4fa4b1a5187e095fbe9a3dfb9d324d9aad9c4d5b..575f2a790f315e9ff84530ea39d4659c1135756e 100644 (file)
--- a/fs/xfs/linux-2.6/xfs_fs_subr.c
+++ b/fs/xfs/linux-2.6/xfs_fs_subr.c
@@ -57,7 +57,7 @@ fs_tosspages(
        int             fiopt)
 {
        vnode_t         *vp = BHV_TO_VNODE(bdp);
-       struct inode    *ip = LINVFS_GET_IP(vp);
+       struct inode    *ip = vn_to_inode(vp);
 
        if (VN_CACHED(vp))
                truncate_inode_pages(ip->i_mapping, first);
@@ -76,7 +76,7 @@ fs_flushinval_pages(
        int             fiopt)
 {
        vnode_t         *vp = BHV_TO_VNODE(bdp);
-       struct inode    *ip = LINVFS_GET_IP(vp);
+       struct inode    *ip = vn_to_inode(vp);
 
        if (VN_CACHED(vp)) {
                filemap_write_and_wait(ip->i_mapping);
@@ -98,7 +98,7 @@ fs_flush_pages(
        int             fiopt)
 {
        vnode_t         *vp = BHV_TO_VNODE(bdp);
-       struct inode    *ip = LINVFS_GET_IP(vp);
+       struct inode    *ip = vn_to_inode(vp);
 
        if (VN_CACHED(vp)) {
                filemap_fdatawrite(ip->i_mapping);

diff --git a/fs/xfs/linux-2.6/xfs_ioctl.c b/fs/xfs/linux-2.6/xfs_ioctl.c
index e435ad17419de53bab86179c746b4108e686d31d..84478491609b8e8566cbab3779cd38c1306f7130 100644 (file)
--- a/fs/xfs/linux-2.6/xfs_ioctl.c
+++ b/fs/xfs/linux-2.6/xfs_ioctl.c
@@ -138,7 +138,7 @@ xfs_find_handle(
        }
 
        /* we need the vnode */
-       vp = LINVFS_GET_VP(inode);
+       vp = vn_from_inode(inode);
 
        /* now we can grab the fsid */
        memcpy(&handle.ha_fsid, vp->v_vfsp->vfs_altfsid, sizeof(xfs_fsid_t));
@@ -256,7 +256,7 @@ xfs_vget_fsop_handlereq(
        }
 
        vpp = XFS_ITOV(ip);
-       inodep = LINVFS_GET_IP(vpp);
+       inodep = vn_to_inode(vpp);
        xfs_iunlock(ip, XFS_ILOCK_SHARED);
 
        *vp = vpp;
@@ -715,7 +715,7 @@ xfs_ioctl(
        xfs_inode_t             *ip;
        xfs_mount_t             *mp;
 
-       vp = LINVFS_GET_VP(inode);
+       vp = vn_from_inode(inode);
 
        vn_trace_entry(vp, "xfs_ioctl", (inst_t *)__return_address);
 
@@ -1270,7 +1270,7 @@ xfs_ioc_xattr(
        }
 
        case XFS_IOC_GETVERSION: {
-               flags = LINVFS_GET_IP(vp)->i_generation;
+               flags = vn_to_inode(vp)->i_generation;
                if (copy_to_user(arg, &flags, sizeof(flags)))
                        error = -EFAULT;
                break;

diff --git a/fs/xfs/linux-2.6/xfs_ioctl32.c b/fs/xfs/linux-2.6/xfs_ioctl32.c
index e9da0bde36a6e957d331880483a2c62aec4faf76..b6321abd9a81364d609cab9e43f53831cac07377 100644 (file)
--- a/fs/xfs/linux-2.6/xfs_ioctl32.c
+++ b/fs/xfs/linux-2.6/xfs_ioctl32.c
@@ -111,7 +111,7 @@ xfs_compat_ioctl(int mode, struct file *f, unsigned cmd, unsigned long arg)
 {
        int             error;
        struct          inode *inode = f->f_dentry->d_inode;
-       vnode_t         *vp = LINVFS_GET_VP(inode);
+       vnode_t         *vp = vn_to_inode(inode);
 
        switch (cmd) {
        case XFS_IOC_DIOINFO:

diff --git a/fs/xfs/linux-2.6/xfs_iops.c b/fs/xfs/linux-2.6/xfs_iops.c
index 0a508580e5723f5c627bcd46bebd3949a3fefb03..64c3395074dea86bfcd16c4c045cb8c0dc529714 100644 (file)
--- a/fs/xfs/linux-2.6/xfs_iops.c
+++ b/fs/xfs/linux-2.6/xfs_iops.c
@@ -106,7 +106,7 @@ xfs_ichgtime(
        xfs_inode_t     *ip,
        int             flags)
 {
-       struct inode    *inode = LINVFS_GET_IP(XFS_ITOV(ip));
+       struct inode    *inode = vn_to_inode(XFS_ITOV(ip));
        timespec_t      tv;
 
        nanotime(&tv);
@@ -202,7 +202,7 @@ xfs_validate_fields(
        struct inode    *ip,
        struct vattr    *vattr)
 {
-       vnode_t         *vp = LINVFS_GET_VP(ip);
+       vnode_t         *vp = vn_from_inode(ip);
        int             error;
 
        vattr->va_mask = XFS_AT_NLINK|XFS_AT_SIZE|XFS_AT_NBLOCKS;
@@ -228,7 +228,7 @@ xfs_init_security(
        struct vnode    *vp,
        struct inode    *dir)
 {
-       struct inode    *ip = LINVFS_GET_IP(vp);
+       struct inode    *ip = vn_to_inode(vp);
        size_t          length;
        void            *value;
        char            *name;
@@ -277,7 +277,7 @@ xfs_cleanup_inode(
         * xfs_init_security we must back out.
         * ENOSPC can hit here, among other things.
         */
-       teardown.d_inode = LINVFS_GET_IP(vp);
+       teardown.d_inode = vn_to_inode(vp);
        teardown.d_name = dentry->d_name;
 
        if (S_ISDIR(mode))
@@ -296,7 +296,7 @@ xfs_vn_mknod(
 {
        struct inode    *ip;
        vattr_t         vattr = { 0 };
-       vnode_t         *vp = NULL, *dvp = LINVFS_GET_VP(dir);
+       vnode_t         *vp = NULL, *dvp = vn_from_inode(dir);
        xfs_acl_t       *default_acl = NULL;
        attrexists_t    test_default_acl = _ACL_DEFAULT_EXISTS;
        int             error;
@@ -359,7 +359,7 @@ xfs_vn_mknod(
 
        if (likely(!error)) {
                ASSERT(vp);
-               ip = LINVFS_GET_IP(vp);
+               ip = vn_to_inode(vp);
 
                if (S_ISCHR(mode) || S_ISBLK(mode))
                        ip->i_rdev = rdev;
@@ -396,7 +396,7 @@ xfs_vn_lookup(
        struct dentry   *dentry,
        struct nameidata *nd)
 {
-       struct vnode    *vp = LINVFS_GET_VP(dir), *cvp;
+       struct vnode    *vp = vn_from_inode(dir), *cvp;
        int             error;
 
        if (dentry->d_name.len >= MAXNAMELEN)
@@ -410,7 +410,7 @@ xfs_vn_lookup(
                return NULL;
        }
 
-       return d_splice_alias(LINVFS_GET_IP(cvp), dentry);
+       return d_splice_alias(vn_to_inode(cvp), dentry);
 }
 
 STATIC int
@@ -429,8 +429,8 @@ xfs_vn_link(
        if (S_ISDIR(ip->i_mode))
                return -EPERM;
 
-       tdvp = LINVFS_GET_VP(dir);
-       vp = LINVFS_GET_VP(ip);
+       tdvp = vn_from_inode(dir);
+       vp = vn_from_inode(ip);
 
        VOP_LINK(tdvp, vp, dentry, NULL, error);
        if (likely(!error)) {
@@ -453,7 +453,7 @@ xfs_vn_unlink(
        int             error;
 
        inode = dentry->d_inode;
-       dvp = LINVFS_GET_VP(dir);
+       dvp = vn_from_inode(dir);
 
        VOP_REMOVE(dvp, dentry, NULL, error);
        if (likely(!error)) {
@@ -475,7 +475,7 @@ xfs_vn_symlink(
        vnode_t         *cvp;   /* used to lookup symlink to put in dentry */
        int             error;
 
-       dvp = LINVFS_GET_VP(dir);
+       dvp = vn_from_inode(dir);
        cvp = NULL;
 
        vattr.va_mode = S_IFLNK |
@@ -487,7 +487,7 @@ xfs_vn_symlink(
        if (likely(!error && cvp)) {
                error = xfs_init_security(cvp, dir);
                if (likely(!error)) {
-                       ip = LINVFS_GET_IP(cvp);
+                       ip = vn_to_inode(cvp);
                        d_instantiate(dentry, ip);
                        xfs_validate_fields(dir, &vattr);
                        xfs_validate_fields(ip, &vattr);
@@ -502,7 +502,7 @@ xfs_vn_rmdir(
        struct dentry   *dentry)
 {
        struct inode    *inode = dentry->d_inode;
-       vnode_t         *dvp = LINVFS_GET_VP(dir);
+       vnode_t         *dvp = vn_from_inode(dir);
        vattr_t         vattr;
        int             error;
 
@@ -527,8 +527,8 @@ xfs_vn_rename(
        vattr_t         vattr;
        int             error;
 
-       fvp = LINVFS_GET_VP(odir);
-       tvp = LINVFS_GET_VP(ndir);
+       fvp = vn_from_inode(odir);
+       tvp = vn_from_inode(ndir);
 
        VOP_RENAME(fvp, odentry, tvp, ndentry, NULL, error);
        if (likely(!error)) {
@@ -573,7 +573,7 @@ xfs_vn_follow_link(
                return NULL;
        }
 
-       vp = LINVFS_GET_VP(dentry->d_inode);
+       vp = vn_from_inode(dentry->d_inode);
 
        iov.iov_base = link;
        iov.iov_len = MAXPATHLEN;
@@ -616,7 +616,7 @@ xfs_vn_permission(
        int             mode,
        struct nameidata *nd)
 {
-       vnode_t         *vp = LINVFS_GET_VP(inode);
+       vnode_t         *vp = vn_from_inode(inode);
        int             error;
 
        mode <<= 6;             /* convert from linux to vnode access bits */
@@ -634,7 +634,7 @@ xfs_vn_getattr(
        struct kstat    *stat)
 {
        struct inode    *inode = dentry->d_inode;
-       vnode_t         *vp = LINVFS_GET_VP(inode);
+       vnode_t         *vp = vn_from_inode(inode);
        int             error = 0;
 
        if (unlikely(vp->v_flag & VMODIFIED))
@@ -651,7 +651,7 @@ xfs_vn_setattr(
 {
        struct inode    *inode = dentry->d_inode;
        unsigned int    ia_valid = attr->ia_valid;
-       vnode_t         *vp = LINVFS_GET_VP(inode);
+       vnode_t         *vp = vn_from_inode(inode);
        vattr_t         vattr = { 0 };
        int             flags = 0;
        int             error;
@@ -717,7 +717,7 @@ xfs_vn_setxattr(
        size_t          size,
        int             flags)
 {
-       vnode_t         *vp = LINVFS_GET_VP(dentry->d_inode);
+       vnode_t         *vp = vn_from_inode(dentry->d_inode);
        char            *attr = (char *)name;
        attrnames_t     *namesp;
        int             xflags = 0;
@@ -747,7 +747,7 @@ xfs_vn_getxattr(
        void            *data,
        size_t          size)
 {
-       vnode_t         *vp = LINVFS_GET_VP(dentry->d_inode);
+       vnode_t         *vp = vn_from_inode(dentry->d_inode);
        char            *attr = (char *)name;
        attrnames_t     *namesp;
        int             xflags = 0;
@@ -776,7 +776,7 @@ xfs_vn_listxattr(
        char                    *data,
        size_t                  size)
 {
-       vnode_t                 *vp = LINVFS_GET_VP(dentry->d_inode);
+       vnode_t                 *vp = vn_from_inode(dentry->d_inode);
        int                     error, xflags = ATTR_KERNAMELS;
        ssize_t                 result;
 
@@ -795,7 +795,7 @@ xfs_vn_removexattr(
        struct dentry   *dentry,
        const char      *name)
 {
-       vnode_t         *vp = LINVFS_GET_VP(dentry->d_inode);
+       vnode_t         *vp = vn_from_inode(dentry->d_inode);
        char            *attr = (char *)name;
        attrnames_t     *namesp;
        int             xflags = 0;

diff --git a/fs/xfs/linux-2.6/xfs_linux.h b/fs/xfs/linux-2.6/xfs_linux.h
index bd88ccb0cad04b825762ec35053d2a654b2e3b6b..1fe09f2d65194db07c33e204b4a53dce89365323 100644 (file)
--- a/fs/xfs/linux-2.6/xfs_linux.h
+++ b/fs/xfs/linux-2.6/xfs_linux.h
@@ -234,7 +234,7 @@ BUFFER_FNS(PrivateStart, unwritten);
 #define xfs_sort(a,n,s,fn)     sort(a,n,s,fn,NULL)
 #define xfs_stack_trace()      dump_stack()
 #define xfs_itruncate_data(ip, off)    \
-       (-vmtruncate(LINVFS_GET_IP(XFS_ITOV(ip)), (off)))
+       (-vmtruncate(vn_to_inode(XFS_ITOV(ip)), (off)))
 #define xfs_statvfs_fsid(statp, mp)    \
        ({ u64 id = huge_encode_dev((mp)->m_ddev_targp->bt_dev); \
           __kernel_fsid_t *fsid = &(statp)->f_fsid;    \

diff --git a/fs/xfs/linux-2.6/xfs_lrw.c b/fs/xfs/linux-2.6/xfs_lrw.c
index e0ab45fbfebd4e0cbe6fbc2b5c992ae9deeb952b..2ede4bb7ecd0770da1a28329fff21ab5b7b0975e 100644 (file)
--- a/fs/xfs/linux-2.6/xfs_lrw.c
+++ b/fs/xfs/linux-2.6/xfs_lrw.c
@@ -432,7 +432,7 @@ xfs_zero_eof(
        xfs_fsize_t     isize,          /* current inode size */
        xfs_fsize_t     end_size)       /* terminal inode size */
 {
-       struct inode    *ip = LINVFS_GET_IP(vp);
+       struct inode    *ip = vn_to_inode(vp);
        xfs_fileoff_t   start_zero_fsb;
        xfs_fileoff_t   end_zero_fsb;
        xfs_fileoff_t   zero_count_fsb;

diff --git a/fs/xfs/linux-2.6/xfs_super.c b/fs/xfs/linux-2.6/xfs_super.c
index 352aa3d40c1fbfc9ef75e588f95b5516b141c6b0..d9d28a965bac2098a7f547f727cd029f8e680c8b 100644 (file)
--- a/fs/xfs/linux-2.6/xfs_super.c
+++ b/fs/xfs/linux-2.6/xfs_super.c
@@ -153,7 +153,7 @@ xfs_revalidate_inode(
        vnode_t                 *vp,
        xfs_inode_t             *ip)
 {
-       struct inode            *inode = LINVFS_GET_IP(vp);
+       struct inode            *inode = vn_to_inode(vp);
 
        inode->i_mode   = ip->i_d.di_mode;
        inode->i_nlink  = ip->i_d.di_nlink;
@@ -210,7 +210,7 @@ xfs_initialize_vnode(
        int                     unlock)
 {
        xfs_inode_t             *ip = XFS_BHVTOI(inode_bhv);
-       struct inode            *inode = LINVFS_GET_IP(vp);
+       struct inode            *inode = vn_to_inode(vp);
 
        if (!inode_bhv->bd_vobj) {
                vp->v_vfsp = bhvtovfs(bdp);
@@ -228,7 +228,7 @@ xfs_initialize_vnode(
        if (ip->i_d.di_mode != 0 && unlock && (inode->i_state & I_NEW)) {
                xfs_revalidate_inode(XFS_BHVTOM(bdp), vp, ip);
                xfs_set_inodeops(inode);
-       
+
                ip->i_flags &= ~XFS_INEW;
                barrier();
 
@@ -340,14 +340,14 @@ xfs_fs_alloc_inode(
        vp = kmem_zone_alloc(xfs_vnode_zone, KM_SLEEP);
        if (unlikely(!vp))
                return NULL;
-       return LINVFS_GET_IP(vp);
+       return vn_to_inode(vp);
 }
 
 STATIC void
 xfs_fs_destroy_inode(
        struct inode            *inode)
 {
-       kmem_zone_free(xfs_vnode_zone, LINVFS_GET_VP(inode));
+       kmem_zone_free(xfs_vnode_zone, vn_from_inode(inode));
 }
 
 STATIC void
@@ -358,7 +358,7 @@ xfs_fs_inode_init_once(
 {
        if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
                      SLAB_CTOR_CONSTRUCTOR)
-               inode_init_once(LINVFS_GET_IP((vnode_t *)vnode));
+               inode_init_once(vn_to_inode((vnode_t *)vnode));
 }
 
 STATIC int
@@ -409,7 +409,7 @@ xfs_fs_write_inode(
        struct inode            *inode,
        int                     sync)
 {
-       vnode_t                 *vp = LINVFS_GET_VP(inode);
+       vnode_t                 *vp = vn_from_inode(inode);
        int                     error = 0, flags = FLUSH_INODE;
 
        if (vp) {
@@ -432,7 +432,7 @@ STATIC void
 xfs_fs_clear_inode(
        struct inode            *inode)
 {
-       vnode_t                 *vp = LINVFS_GET_VP(inode);
+       vnode_t                 *vp = vn_from_inode(inode);
        int                     error, cache;
 
        vn_trace_entry(vp, __FUNCTION__, (inst_t *)__return_address);
@@ -511,7 +511,7 @@ void
 xfs_flush_inode(
        xfs_inode_t     *ip)
 {
-       struct inode    *inode = LINVFS_GET_IP(XFS_ITOV(ip));
+       struct inode    *inode = vn_to_inode(XFS_ITOV(ip));
        struct vfs      *vfs = XFS_MTOVFS(ip->i_mount);
 
        igrab(inode);
@@ -536,7 +536,7 @@ void
 xfs_flush_device(
        xfs_inode_t     *ip)
 {
-       struct inode    *inode = LINVFS_GET_IP(XFS_ITOV(ip));
+       struct inode    *inode = vn_to_inode(XFS_ITOV(ip));
        struct vfs      *vfs = XFS_MTOVFS(ip->i_mount);
 
        igrab(inode);
@@ -630,7 +630,7 @@ STATIC void
 xfs_fs_put_super(
        struct super_block      *sb)
 {
-       vfs_t                   *vfsp = LINVFS_GET_VFS(sb);
+       vfs_t                   *vfsp = vfs_from_sb(sb);
        int                     error;
 
        xfs_fs_stop_syncd(vfsp);
@@ -650,7 +650,7 @@ STATIC void
 xfs_fs_write_super(
        struct super_block      *sb)
 {
-       vfs_t                   *vfsp = LINVFS_GET_VFS(sb);
+       vfs_t                   *vfsp = vfs_from_sb(sb);
        int                     error;
 
        if (sb->s_flags & MS_RDONLY) {
@@ -667,7 +667,7 @@ xfs_fs_sync_super(
        struct super_block      *sb,
        int                     wait)
 {
-       vfs_t           *vfsp = LINVFS_GET_VFS(sb);
+       vfs_t           *vfsp = vfs_from_sb(sb);
        int             error;
        int             flags = SYNC_FSDATA;
 
@@ -706,7 +706,7 @@ xfs_fs_statfs(
        struct super_block      *sb,
        struct kstatfs          *statp)
 {
-       vfs_t                   *vfsp = LINVFS_GET_VFS(sb);
+       vfs_t                   *vfsp = vfs_from_sb(sb);
        int                     error;
 
        VFS_STATVFS(vfsp, statp, NULL, error);
@@ -719,7 +719,7 @@ xfs_fs_remount(
        int                     *flags,
        char                    *options)
 {
-       vfs_t                   *vfsp = LINVFS_GET_VFS(sb);
+       vfs_t                   *vfsp = vfs_from_sb(sb);
        struct xfs_mount_args   *args = xfs_args_allocate(sb);
        int                     error;
 
@@ -734,7 +734,7 @@ STATIC void
 xfs_fs_lockfs(
        struct super_block      *sb)
 {
-       VFS_FREEZE(LINVFS_GET_VFS(sb));
+       VFS_FREEZE(vfs_from_sb(sb));
 }
 
 STATIC int
@@ -742,7 +742,7 @@ xfs_fs_show_options(
        struct seq_file         *m,
        struct vfsmount         *mnt)
 {
-       struct vfs              *vfsp = LINVFS_GET_VFS(mnt->mnt_sb);
+       struct vfs              *vfsp = vfs_from_sb(mnt->mnt_sb);
        int                     error;
 
        VFS_SHOWARGS(vfsp, m, error);
@@ -754,7 +754,7 @@ xfs_fs_quotasync(
        struct super_block      *sb,
        int                     type)
 {
-       struct vfs              *vfsp = LINVFS_GET_VFS(sb);
+       struct vfs              *vfsp = vfs_from_sb(sb);
        int                     error;
 
        VFS_QUOTACTL(vfsp, Q_XQUOTASYNC, 0, (caddr_t)NULL, error);
@@ -766,7 +766,7 @@ xfs_fs_getxstate(
        struct super_block      *sb,
        struct fs_quota_stat    *fqs)
 {
-       struct vfs              *vfsp = LINVFS_GET_VFS(sb);
+       struct vfs              *vfsp = vfs_from_sb(sb);
        int                     error;
 
        VFS_QUOTACTL(vfsp, Q_XGETQSTAT, 0, (caddr_t)fqs, error);
@@ -779,7 +779,7 @@ xfs_fs_setxstate(
        unsigned int            flags,
        int                     op)
 {
-       struct vfs              *vfsp = LINVFS_GET_VFS(sb);
+       struct vfs              *vfsp = vfs_from_sb(sb);
        int                     error;
 
        VFS_QUOTACTL(vfsp, op, 0, (caddr_t)&flags, error);
@@ -793,7 +793,7 @@ xfs_fs_getxquota(
        qid_t                   id,
        struct fs_disk_quota    *fdq)
 {
-       struct vfs              *vfsp = LINVFS_GET_VFS(sb);
+       struct vfs              *vfsp = vfs_from_sb(sb);
        int                     error, getmode;
 
        getmode = (type == USRQUOTA) ? Q_XGETQUOTA :
@@ -809,7 +809,7 @@ xfs_fs_setxquota(
        qid_t                   id,
        struct fs_disk_quota    *fdq)
 {
-       struct vfs              *vfsp = LINVFS_GET_VFS(sb);
+       struct vfs              *vfsp = vfs_from_sb(sb);
        int                     error, setmode;
 
        setmode = (type == USRQUOTA) ? Q_XSETQLIM :
@@ -825,15 +825,11 @@ xfs_fs_fill_super(
        int                     silent)
 {
        vnode_t                 *rootvp;
-       struct vfs              *vfsp = vfs_allocate();
+       struct vfs              *vfsp = vfs_allocate(sb);
        struct xfs_mount_args   *args = xfs_args_allocate(sb);
        struct kstatfs          statvfs;
        int                     error, error2;
 
-       vfsp->vfs_super = sb;
-       LINVFS_SET_VFS(sb, vfsp);
-       if (sb->s_flags & MS_RDONLY)
-               vfsp->vfs_flag |= VFS_RDONLY;
        bhv_insert_all_vfsops(vfsp);
 
        VFS_PARSEARGS(vfsp, (char *)data, args, 0, error);
@@ -871,7 +867,7 @@ xfs_fs_fill_super(
        if (error)
                goto fail_unmount;
 
-       sb->s_root = d_alloc_root(LINVFS_GET_IP(rootvp));
+       sb->s_root = d_alloc_root(vn_to_inode(rootvp));
        if (!sb->s_root) {
                error = ENOMEM;
                goto fail_vnrele;

diff --git a/fs/xfs/linux-2.6/xfs_super.h b/fs/xfs/linux-2.6/xfs_super.h
index 5e1b525cb1eb8a190efb2ee6e540adc1867b0a4c..376b96cb513a782d413b096b1e7e0b0962d285f1 100644 (file)
--- a/fs/xfs/linux-2.6/xfs_super.h
+++ b/fs/xfs/linux-2.6/xfs_super.h
@@ -98,11 +98,6 @@ extern void xfs_qm_exit(void);
                                XFS_DMAPI_STRING \
                                XFS_DBG_STRING /* DBG must be last */
 
-#define LINVFS_GET_VFS(s) \
-       (vfs_t *)((s)->s_fs_info)
-#define LINVFS_SET_VFS(s, vfsp) \
-       ((s)->s_fs_info = vfsp)
-
 struct xfs_inode;
 struct xfs_mount;
 struct xfs_buftarg;

diff --git a/fs/xfs/linux-2.6/xfs_vfs.c b/fs/xfs/linux-2.6/xfs_vfs.c
index a6b4084bda88d2ed425f4107664ece38cce7b0d3..6f7c9f7a86246ee1f3e822b5e706417718f77406 100644 (file)
--- a/fs/xfs/linux-2.6/xfs_vfs.c
+++ b/fs/xfs/linux-2.6/xfs_vfs.c
@@ -227,7 +227,8 @@ vfs_freeze(
 }
 
 vfs_t *
-vfs_allocate( void )
+vfs_allocate(
+       struct super_block      *sb)
 {
        struct vfs              *vfsp;
 
@@ -236,9 +237,23 @@ vfs_allocate( void )
        INIT_LIST_HEAD(&vfsp->vfs_sync_list);
        spin_lock_init(&vfsp->vfs_sync_lock);
        init_waitqueue_head(&vfsp->vfs_wait_single_sync_task);
+
+       vfsp->vfs_super = sb;
+       sb->s_fs_info = vfsp;
+
+       if (sb->s_flags & MS_RDONLY)
+               vfsp->vfs_flag |= VFS_RDONLY;
+
        return vfsp;
 }
 
+vfs_t *
+vfs_from_sb(
+       struct super_block      *sb)
+{
+       return (vfs_t *)sb->s_fs_info;
+}
+
 void
 vfs_deallocate(
        struct vfs              *vfsp)

diff --git a/fs/xfs/linux-2.6/xfs_vfs.h b/fs/xfs/linux-2.6/xfs_vfs.h
index 57caf9eddee002f02c29075749bcda75dce6777d..8fed356db055a5c10246f7e9a4cf2058dcd3fbae 100644 (file)
--- a/fs/xfs/linux-2.6/xfs_vfs.h
+++ b/fs/xfs/linux-2.6/xfs_vfs.h
@@ -193,7 +193,8 @@ typedef struct bhv_vfsops {
 #define vfs_bhv_set_custom(b,o)        ( (b)->bhv_custom = (void *)(o))
 #define vfs_bhv_clr_custom(b)  ( (b)->bhv_custom = NULL )
 
-extern vfs_t *vfs_allocate(void);
+extern vfs_t *vfs_allocate(struct super_block *);
+extern vfs_t *vfs_from_sb(struct super_block *);
 extern void vfs_deallocate(vfs_t *);
 extern void vfs_insertops(vfs_t *, bhv_vfsops_t *);
 extern void vfs_insertbhv(vfs_t *, bhv_desc_t *, vfsops_t *, void *);

diff --git a/fs/xfs/linux-2.6/xfs_vnode.c b/fs/xfs/linux-2.6/xfs_vnode.c
index 225e7dd8b21da8fa72cf7db9cd6c5cec491d26f3..d27c25b27ccd4aec1e4f8c8d235e7f41b07034dd 100644 (file)
--- a/fs/xfs/linux-2.6/xfs_vnode.c
+++ b/fs/xfs/linux-2.6/xfs_vnode.c
@@ -58,7 +58,7 @@ struct vnode *
 vn_initialize(
        struct inode    *inode)
 {
-       struct vnode    *vp = LINVFS_GET_VP(inode);
+       struct vnode    *vp = vn_from_inode(inode);
 
        XFS_STATS_INC(vn_active);
        XFS_STATS_INC(vn_alloc);
@@ -97,7 +97,7 @@ vn_revalidate_core(
        struct vnode    *vp,
        vattr_t         *vap)
 {
-       struct inode    *inode = LINVFS_GET_IP(vp);
+       struct inode    *inode = vn_to_inode(vp);
 
        inode->i_mode       = vap->va_mode;
        inode->i_nlink      = vap->va_nlink;
@@ -166,7 +166,7 @@ vn_hold(
        XFS_STATS_INC(vn_hold);
 
        VN_LOCK(vp);
-       inode = igrab(LINVFS_GET_IP(vp));
+       inode = igrab(vn_to_inode(vp));
        ASSERT(inode);
        VN_UNLOCK(vp, 0);
 

diff --git a/fs/xfs/linux-2.6/xfs_vnode.h b/fs/xfs/linux-2.6/xfs_vnode.h
index 0cf92ca80ce7361b1d91174724561bde0759b2fd..06f5845e9568eeeaf00be12a185c18f26a40db00 100644 (file)
--- a/fs/xfs/linux-2.6/xfs_vnode.h
+++ b/fs/xfs/linux-2.6/xfs_vnode.h
@@ -116,8 +116,14 @@ typedef enum {
 /*
  * Vnode to Linux inode mapping.
  */
-#define LINVFS_GET_VP(inode)   ((vnode_t *)list_entry(inode, vnode_t, v_inode))
-#define LINVFS_GET_IP(vp)      (&(vp)->v_inode)
+static inline struct vnode *vn_from_inode(struct inode *inode)
+{
+       return (vnode_t *)list_entry(inode, vnode_t, v_inode);
+}
+static inline struct inode *vn_to_inode(struct vnode *vnode)
+{
+       return &vnode->v_inode;
+}
 
 /*
  * Vnode flags.
@@ -498,7 +504,7 @@ extern void vn_iowake(struct vnode *vp);
 
 static inline int vn_count(struct vnode *vp)
 {
-       return atomic_read(&LINVFS_GET_IP(vp)->i_count);
+       return atomic_read(&vn_to_inode(vp)->i_count);
 }
 
 /*
@@ -512,16 +518,16 @@ extern vnode_t    *vn_hold(struct vnode *);
          vn_trace_hold(vp, __FILE__, __LINE__, (inst_t *)__return_address))
 #define VN_RELE(vp)            \
          (vn_trace_rele(vp, __FILE__, __LINE__, (inst_t *)__return_address), \
-          iput(LINVFS_GET_IP(vp)))
+          iput(vn_to_inode(vp)))
 #else
 #define VN_HOLD(vp)            ((void)vn_hold(vp))
-#define VN_RELE(vp)            (iput(LINVFS_GET_IP(vp)))
+#define VN_RELE(vp)            (iput(vn_to_inode(vp)))
 #endif
 
 static inline struct vnode *vn_grab(struct vnode *vp)
 {
-       struct inode *inode = igrab(LINVFS_GET_IP(vp));
-       return inode ? LINVFS_GET_VP(inode) : NULL;
+       struct inode *inode = igrab(vn_to_inode(vp));
+       return inode ? vn_from_inode(inode) : NULL;
 }
 
 /*
@@ -529,7 +535,7 @@ static inline struct vnode *vn_grab(struct vnode *vp)
  */
 #define VNAME(dentry)          ((char *) (dentry)->d_name.name)
 #define VNAMELEN(dentry)       ((dentry)->d_name.len)
-#define VNAME_TO_VNODE(dentry) (LINVFS_GET_VP((dentry)->d_inode))
+#define VNAME_TO_VNODE(dentry) (vn_from_inode((dentry)->d_inode))
 
 /*
  * Vnode spinlock manipulation.
@@ -558,12 +564,12 @@ static __inline__ void vn_flagclr(struct vnode *vp, uint flag)
  */
 static inline void vn_mark_bad(struct vnode *vp)
 {
-       make_bad_inode(LINVFS_GET_IP(vp));
+       make_bad_inode(vn_to_inode(vp));
 }
 
 static inline int VN_BAD(struct vnode *vp)
 {
-       return is_bad_inode(LINVFS_GET_IP(vp));
+       return is_bad_inode(vn_to_inode(vp));
 }
 
 /*
@@ -588,9 +594,9 @@ static inline void vn_atime_to_time_t(struct vnode *vp, time_t *tt)
 /*
  * Some useful predicates.
  */
-#define VN_MAPPED(vp)  mapping_mapped(LINVFS_GET_IP(vp)->i_mapping)
-#define VN_CACHED(vp)  (LINVFS_GET_IP(vp)->i_mapping->nrpages)
-#define VN_DIRTY(vp)   mapping_tagged(LINVFS_GET_IP(vp)->i_mapping, \
+#define VN_MAPPED(vp)  mapping_mapped(vn_to_inode(vp)->i_mapping)
+#define VN_CACHED(vp)  (vn_to_inode(vp)->i_mapping->nrpages)
+#define VN_DIRTY(vp)   mapping_tagged(vn_to_inode(vp)->i_mapping, \
                                        PAGECACHE_TAG_DIRTY)
 #define VMODIFY(vp)    VN_FLAGSET(vp, VMODIFIED)
 #define VUNMODIFY(vp)  VN_FLAGCLR(vp, VMODIFIED)

diff --git a/fs/xfs/xfs_attr.c b/fs/xfs/xfs_attr.c
index e5e91e9c7e898d9f65299813115b8373c22e4c26..acf1b7c9f1db0f16df5c9b8b6adee1abbcc5a4d7 100644 (file)
--- a/fs/xfs/xfs_attr.c
+++ b/fs/xfs/xfs_attr.c
@@ -2522,7 +2522,7 @@ attr_user_capable(
        struct vnode    *vp,
        cred_t          *cred)
 {
-       struct inode    *inode = LINVFS_GET_IP(vp);
+       struct inode    *inode = vn_to_inode(vp);
 
        if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
                return -EPERM;
@@ -2540,7 +2540,7 @@ attr_trusted_capable(
        struct vnode    *vp,
        cred_t          *cred)
 {
-       struct inode    *inode = LINVFS_GET_IP(vp);
+       struct inode    *inode = vn_to_inode(vp);
 
        if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
                return -EPERM;

diff --git a/fs/xfs/xfs_dfrag.c b/fs/xfs/xfs_dfrag.c
index c6191d00ad27fb721e11c2639e02a3c199653279..4968a6358e613acb627cc4e4e57aad45342a2367 100644 (file)
--- a/fs/xfs/xfs_dfrag.c
+++ b/fs/xfs/xfs_dfrag.c
@@ -83,7 +83,7 @@ xfs_swapext(
 
        /* Pull information for the target fd */
        if (((fp = fget((int)sxp->sx_fdtarget)) == NULL) ||
-           ((vp = LINVFS_GET_VP(fp->f_dentry->d_inode)) == NULL))  {
+           ((vp = vn_from_inode(fp->f_dentry->d_inode)) == NULL))  {
                error = XFS_ERROR(EINVAL);
                goto error0;
        }
@@ -95,7 +95,7 @@ xfs_swapext(
        }
 
        if (((tfp = fget((int)sxp->sx_fdtmp)) == NULL) ||
-           ((tvp = LINVFS_GET_VP(tfp->f_dentry->d_inode)) == NULL)) {
+           ((tvp = vn_from_inode(tfp->f_dentry->d_inode)) == NULL)) {
                error = XFS_ERROR(EINVAL);
                goto error0;
        }

diff --git a/fs/xfs/xfs_iget.c b/fs/xfs/xfs_iget.c
index 8e380a1fb79b691f03efa0e0aa126ce9c0e78727..3ce35a6f700b798ba09e6e2c348662dcbe6be534 100644 (file)
--- a/fs/xfs/xfs_iget.c
+++ b/fs/xfs/xfs_iget.c
@@ -258,7 +258,7 @@ again:
                                goto finish_inode;
 
                        } else if (vp != inode_vp) {
-                               struct inode *inode = LINVFS_GET_IP(inode_vp);
+                               struct inode *inode = vn_to_inode(inode_vp);
 
                                /* The inode is being torn down, pause and
                                 * try again.
@@ -495,7 +495,7 @@ retry:
        if ((inode = iget_locked(XFS_MTOVFS(mp)->vfs_super, ino))) {
                xfs_inode_t     *ip;
 
-               vp = LINVFS_GET_VP(inode);
+               vp = vn_from_inode(inode);
                if (inode->i_state & I_NEW) {
                        vn_initialize(inode);
                        error = xfs_iget_core(vp, mp, tp, ino, flags,
@@ -617,7 +617,7 @@ xfs_iput_new(xfs_inode_t    *ip,
             uint               lock_flags)
 {
        vnode_t         *vp = XFS_ITOV(ip);
-       struct inode    *inode = LINVFS_GET_IP(vp);
+       struct inode    *inode = vn_to_inode(vp);
 
        vn_trace_entry(vp, "xfs_iput_new", (inst_t *)__return_address);
 

diff --git a/fs/xfs/xfs_inode.c b/fs/xfs/xfs_inode.c
index a16df2d435fe328ec42c36128a4bdd1f0633f930..86a8451d10fc51d0ab2cb4caecfbdb30dbf1b897 100644 (file)
--- a/fs/xfs/xfs_inode.c
+++ b/fs/xfs/xfs_inode.c
@@ -2723,7 +2723,7 @@ xfs_iunpin(
 
                /* make sync come back and flush this inode */
                if (vp) {
-                       struct inode    *inode = LINVFS_GET_IP(vp);
+                       struct inode    *inode = vn_to_inode(vp);
 
                        if (!(inode->i_state & I_NEW))
                                mark_inode_dirty_sync(inode);
@@ -3519,7 +3519,7 @@ xfs_iaccess(
 {
        int             error;
        mode_t          orgmode = mode;
-       struct inode    *inode = LINVFS_GET_IP(XFS_ITOV(ip));
+       struct inode    *inode = vn_to_inode(XFS_ITOV(ip));
 
        if (mode & S_IWUSR) {
                umode_t         imode = inode->i_mode;

diff --git a/fs/xfs/xfs_vnodeops.c b/fs/xfs/xfs_vnodeops.c
index eaab355f5a892fcd95af7402dddf2845723d59ed..8b5a44fe28654a10ee02ae8e942e0adb443b97e6 100644 (file)
--- a/fs/xfs/xfs_vnodeops.c
+++ b/fs/xfs/xfs_vnodeops.c
@@ -1556,7 +1556,7 @@ xfs_release(
                        if ((error = xfs_inactive_free_eofblocks(mp, ip)))
                                return error;
                        /* Update linux inode block count after free above */
-                       LINVFS_GET_IP(vp)->i_blocks = XFS_FSB_TO_BB(mp,
+                       vn_to_inode(vp)->i_blocks = XFS_FSB_TO_BB(mp,
                                ip->i_d.di_nblocks + ip->i_delayed_blks);
                }
        }
@@ -1637,7 +1637,7 @@ xfs_inactive(
                        if ((error = xfs_inactive_free_eofblocks(mp, ip)))
                                return VN_INACTIVE_CACHE;
                        /* Update linux inode block count after free above */
-                       LINVFS_GET_IP(vp)->i_blocks = XFS_FSB_TO_BB(mp,
+                       vn_to_inode(vp)->i_blocks = XFS_FSB_TO_BB(mp,
                                ip->i_d.di_nblocks + ip->i_delayed_blks);
                }
                goto out;