[XFS] kill the v_flag member in struct bhv_vnode

[deliverable/linux.git] / fs / xfs / linux-2.6 / xfs_file.c

diff --git a/fs/xfs/linux-2.6/xfs_file.c b/fs/xfs/linux-2.6/xfs_file.c
index 3678f6912d046f4fbea8c3c4a7bfdfe49da71b70..123659e74b53aa11c9595f5c74811f733914d49a 100644 (file)
--- a/fs/xfs/linux-2.6/xfs_file.c
+++ b/fs/xfs/linux-2.6/xfs_file.c
@@ -37,6 +37,7 @@
 #include "xfs_error.h"
 #include "xfs_rw.h"
 #include "xfs_ioctl32.h"
+#include "xfs_vnodeops.h"
 
 #include <linux/dcache.h>
 #include <linux/smp_lock.h>
@@ -55,13 +56,12 @@ __xfs_file_read(
        loff_t                  pos)
 {
        struct file             *file = iocb->ki_filp;
-       bhv_vnode_t             *vp = vn_from_inode(file->f_path.dentry->d_inode);
 
        BUG_ON(iocb->ki_pos != pos);
        if (unlikely(file->f_flags & O_DIRECT))
                ioflags |= IO_ISDIRECT;
-       return bhv_vop_read(vp, iocb, iov, nr_segs, &iocb->ki_pos,
-                               ioflags, NULL);
+       return xfs_read(XFS_I(file->f_path.dentry->d_inode), iocb, iov,
+                               nr_segs, &iocb->ki_pos, ioflags);
 }
 
 STATIC ssize_t
@@ -93,14 +93,12 @@ __xfs_file_write(
        loff_t                  pos)
 {
        struct file     *file = iocb->ki_filp;
-       struct inode    *inode = file->f_mapping->host;
-       bhv_vnode_t     *vp = vn_from_inode(inode);
 
        BUG_ON(iocb->ki_pos != pos);
        if (unlikely(file->f_flags & O_DIRECT))
                ioflags |= IO_ISDIRECT;
-       return bhv_vop_write(vp, iocb, iov, nr_segs, &iocb->ki_pos,
-                               ioflags, NULL);
+       return xfs_write(XFS_I(file->f_mapping->host), iocb, iov, nr_segs,
+                               &iocb->ki_pos, ioflags);
 }
 
 STATIC ssize_t
@@ -131,8 +129,8 @@ xfs_file_splice_read(
        size_t                  len,
        unsigned int            flags)
 {
-       return bhv_vop_splice_read(vn_from_inode(infilp->f_path.dentry->d_inode),
-                                  infilp, ppos, pipe, len, flags, 0, NULL);
+       return xfs_splice_read(XFS_I(infilp->f_path.dentry->d_inode),
+                                  infilp, ppos, pipe, len, flags, 0);
 }
 
 STATIC ssize_t
@@ -143,9 +141,8 @@ xfs_file_splice_read_invis(
        size_t                  len,
        unsigned int            flags)
 {
-       return bhv_vop_splice_read(vn_from_inode(infilp->f_path.dentry->d_inode),
-                                  infilp, ppos, pipe, len, flags, IO_INVIS,
-                                  NULL);
+       return xfs_splice_read(XFS_I(infilp->f_path.dentry->d_inode),
+                                  infilp, ppos, pipe, len, flags, IO_INVIS);
 }
 
 STATIC ssize_t
@@ -156,8 +153,8 @@ xfs_file_splice_write(
        size_t                  len,
        unsigned int            flags)
 {
-       return bhv_vop_splice_write(vn_from_inode(outfilp->f_path.dentry->d_inode),
-                                   pipe, outfilp, ppos, len, flags, 0, NULL);
+       return xfs_splice_write(XFS_I(outfilp->f_path.dentry->d_inode),
+                                   pipe, outfilp, ppos, len, flags, 0);
 }
 
 STATIC ssize_t
@@ -168,9 +165,8 @@ xfs_file_splice_write_invis(
        size_t                  len,
        unsigned int            flags)
 {
-       return bhv_vop_splice_write(vn_from_inode(outfilp->f_path.dentry->d_inode),
-                                   pipe, outfilp, ppos, len, flags, IO_INVIS,
-                                   NULL);
+       return xfs_splice_write(XFS_I(outfilp->f_path.dentry->d_inode),
+                                   pipe, outfilp, ppos, len, flags, IO_INVIS);
 }
 
 STATIC int
@@ -180,7 +176,7 @@ xfs_file_open(
 {
        if (!(filp->f_flags & O_LARGEFILE) && i_size_read(inode) > MAX_NON_LFS)
                return -EFBIG;
-       return -bhv_vop_open(vn_from_inode(inode), NULL);
+       return -xfs_open(XFS_I(inode));
 }
 
 STATIC int
@@ -188,11 +184,7 @@ xfs_file_release(
        struct inode    *inode,
        struct file     *filp)
 {
-       bhv_vnode_t     *vp = vn_from_inode(inode);
-
-       if (vp)
-               return -bhv_vop_release(vp);
-       return 0;
+       return -xfs_release(XFS_I(inode));
 }
 
 STATIC int
@@ -201,14 +193,13 @@ xfs_file_fsync(
        struct dentry   *dentry,
        int             datasync)
 {
-       bhv_vnode_t     *vp = vn_from_inode(dentry->d_inode);
        int             flags = FSYNC_WAIT;
 
        if (datasync)
                flags |= FSYNC_DATA;
-       if (VN_TRUNC(vp))
-               VUNTRUNCATE(vp);
-       return -bhv_vop_fsync(vp, flags, NULL, (xfs_off_t)0, (xfs_off_t)-1);
+       xfs_iflags_clear(XFS_I(dentry->d_inode), XFS_ITRUNCATED);
+       return -xfs_fsync(XFS_I(dentry->d_inode), flags,
+                       (xfs_off_t)0, (xfs_off_t)-1);
 }
 
 #ifdef CONFIG_XFS_DMAPI
@@ -234,7 +225,7 @@ xfs_file_readdir(
        filldir_t       filldir)
 {
        struct inode    *inode = filp->f_path.dentry->d_inode;
-       bhv_vnode_t     *vp = vn_from_inode(inode);
+       xfs_inode_t     *ip = XFS_I(inode);
        int             error;
        size_t          bufsize;
 
@@ -252,7 +243,7 @@ xfs_file_readdir(
         */
        bufsize = (size_t)min_t(loff_t, PAGE_SIZE, inode->i_size);
 
-       error = bhv_vop_readdir(vp, dirent, bufsize,
+       error = xfs_readdir(ip, dirent, bufsize,
                                (xfs_off_t *)&filp->f_pos, filldir);
        if (error)
                return -error;
@@ -268,7 +259,7 @@ xfs_file_mmap(
        vma->vm_flags |= VM_CAN_NONLINEAR;
 
 #ifdef CONFIG_XFS_DMAPI
-       if (vn_from_inode(filp->f_path.dentry->d_inode)->v_vfsp->vfs_flag & VFS_DMI)
+       if (vfs_from_sb(filp->f_path.dentry->d_inode->i_sb)->vfs_flag & VFS_DMI)
                vma->vm_ops = &xfs_dmapi_file_vm_ops;
 #endif /* CONFIG_XFS_DMAPI */
 
@@ -284,10 +275,9 @@ xfs_file_ioctl(
 {
        int             error;
        struct inode    *inode = filp->f_path.dentry->d_inode;
-       bhv_vnode_t     *vp = vn_from_inode(inode);
 
-       error = bhv_vop_ioctl(vp, inode, filp, 0, cmd, (void __user *)p);
-       VMODIFY(vp);
+       error = xfs_ioctl(XFS_I(inode), filp, 0, cmd, (void __user *)p);
+       xfs_iflags_set(XFS_I(inode), XFS_IMODIFIED);
 
        /* NOTE:  some of the ioctl's return positive #'s as a
         *        byte count indicating success, such as
@@ -306,10 +296,9 @@ xfs_file_ioctl_invis(
 {
        int             error;
        struct inode    *inode = filp->f_path.dentry->d_inode;
-       bhv_vnode_t     *vp = vn_from_inode(inode);
 
-       error = bhv_vop_ioctl(vp, inode, filp, IO_INVIS, cmd, (void __user *)p);
-       VMODIFY(vp);
+       error = xfs_ioctl(XFS_I(inode), filp, IO_INVIS, cmd, (void __user *)p);
+       xfs_iflags_set(XFS_I(inode), XFS_IMODIFIED);
 
        /* NOTE:  some of the ioctl's return positive #'s as a
         *        byte count indicating success, such as
@@ -327,16 +316,14 @@ xfs_vm_mprotect(
        struct vm_area_struct *vma,
        unsigned int    newflags)
 {
-       bhv_vnode_t     *vp = vn_from_inode(vma->vm_file->f_path.dentry->d_inode);
+       struct inode    *inode = vma->vm_file->f_path.dentry->d_inode;
+       bhv_vfs_t       *vfsp = vfs_from_sb(inode->i_sb);
        int             error = 0;
 
-       if (vp->v_vfsp->vfs_flag & VFS_DMI) {
+       if (vfsp->vfs_flag & VFS_DMI) {
                if ((vma->vm_flags & VM_MAYSHARE) &&
-                   (newflags & VM_WRITE) && !(vma->vm_flags & VM_WRITE)) {
-                       xfs_mount_t     *mp = XFS_VFSTOM(vp->v_vfsp);
-
-                       error = XFS_SEND_MMAP(mp, vma, VM_WRITE);
-                   }
+                   (newflags & VM_WRITE) && !(vma->vm_flags & VM_WRITE))
+                       error = XFS_SEND_MMAP(XFS_VFSTOM(vfsp), vma, VM_WRITE);
        }
        return error;
 }
@@ -353,18 +340,17 @@ STATIC int
 xfs_file_open_exec(
        struct inode    *inode)
 {
-       bhv_vnode_t     *vp = vn_from_inode(inode);
+       bhv_vfs_t       *vfsp = vfs_from_sb(inode->i_sb);
 
-       if (unlikely(vp->v_vfsp->vfs_flag & VFS_DMI)) {
-               xfs_mount_t     *mp = XFS_VFSTOM(vp->v_vfsp);
-               xfs_inode_t     *ip = xfs_vtoi(vp);
+       if (unlikely(vfsp->vfs_flag & VFS_DMI)) {
+               if (DM_EVENT_ENABLED(XFS_I(inode), DM_EVENT_READ)) {
+                       bhv_vnode_t *vp = vn_from_inode(inode);
 
-               if (!ip)
-                       return -EINVAL;
-               if (DM_EVENT_ENABLED(ip, DM_EVENT_READ))
-                       return -XFS_SEND_DATA(mp, DM_EVENT_READ, vp,
-                                              0, 0, 0, NULL);
+                       return -XFS_SEND_DATA(XFS_VFSTOM(vfsp), DM_EVENT_READ,
+                                               vp, 0, 0, 0, NULL);
+               }
        }
+
        return 0;
 }
 #endif /* HAVE_FOP_OPEN_EXEC */