[XFS] decontaminate vnode operations from behavior details

All vnode ops now take struct xfs_inode pointers and the behaviour related
glue is split out into methods of it's own. This required fixing
xfs_create/mkdir/symlink to not mess with the inode pointer but rather use
a separate boolean for error handling. Thanks to Dave Chinner for that
fix.

SGI-PV: 969608
SGI-Modid: xfs-linux-melb:xfs-kern:29492a

Signed-off-by: Christoph Hellwig <hch@infradead.org>
Signed-off-by: David Chinner <dgc@sgi.com>
Signed-off-by: Tim Shimmin <tes@sgi.com>

6 files changed, 77 insertions, 103 deletions

diff --git a/fs/xfs/linux-2.6/xfs_fs_subr.c b/fs/xfs/linux-2.6/xfs_fs_subr.c
index 2eb87cd082af..e2897912fec7 100644
--- a/fs/xfs/linux-2.6/xfs_fs_subr.c
+++ b/fs/xfs/linux-2.6/xfs_fs_subr.c
@@ -16,66 +16,80 @@
  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  */
 #include "xfs.h"
+#include "xfs_vnodeops.h"
+
+/*
+ * The following six includes are needed so that we can include
+ * xfs_inode.h.  What a mess..
+ */
+#include "xfs_bmap_btree.h"
+#include "xfs_inum.h"
+#include "xfs_dir2.h"
+#include "xfs_dir2_sf.h"
+#include "xfs_attr_sf.h"
+#include "xfs_dinode.h"
+
+#include "xfs_inode.h"
 
 int  fs_noerr(void) { return 0; }
 int  fs_nosys(void) { return ENOSYS; }
 void fs_noval(void) { return; }
 
 void
-fs_tosspages(
-        bhv_desc_t      *bdp,
+xfs_tosspages(
+        xfs_inode_t     *ip,
         xfs_off_t       first,
         xfs_off_t       last,
         int             fiopt)
 {
-        bhv_vnode_t     *vp = BHV_TO_VNODE(bdp);
-        struct inode    *ip = vn_to_inode(vp);
+        bhv_vnode_t     *vp = XFS_ITOV(ip);
+        struct inode    *inode = vn_to_inode(vp);
 
         if (VN_CACHED(vp))
-                truncate_inode_pages(ip->i_mapping, first);
+                truncate_inode_pages(inode->i_mapping, first);
 }
 
 int
-fs_flushinval_pages(
-        bhv_desc_t      *bdp,
+xfs_flushinval_pages(
+        xfs_inode_t     *ip,
         xfs_off_t       first,
         xfs_off_t       last,
         int             fiopt)
 {
-        bhv_vnode_t     *vp = BHV_TO_VNODE(bdp);
-        struct inode    *ip = vn_to_inode(vp);
+        bhv_vnode_t     *vp = XFS_ITOV(ip);
+        struct inode    *inode = vn_to_inode(vp);
         int             ret = 0;
 
         if (VN_CACHED(vp)) {
                 if (VN_TRUNC(vp))
                         VUNTRUNCATE(vp);
-                ret = filemap_write_and_wait(ip->i_mapping);
+                ret = filemap_write_and_wait(inode->i_mapping);
                 if (!ret)
-                        truncate_inode_pages(ip->i_mapping, first);
+                        truncate_inode_pages(inode->i_mapping, first);
         }
         return ret;
 }
 
 int
-fs_flush_pages(
-        bhv_desc_t      *bdp,
+xfs_flush_pages(
+        xfs_inode_t     *ip,
         xfs_off_t       first,
         xfs_off_t       last,
         uint64_t        flags,
         int             fiopt)
 {
-        bhv_vnode_t     *vp = BHV_TO_VNODE(bdp);
-        struct inode    *ip = vn_to_inode(vp);
+        bhv_vnode_t     *vp = XFS_ITOV(ip);
+        struct inode    *inode = vn_to_inode(vp);
         int             ret = 0;
         int             ret2;
 
         if (VN_DIRTY(vp)) {
                 if (VN_TRUNC(vp))
                         VUNTRUNCATE(vp);
-                ret = filemap_fdatawrite(ip->i_mapping);
+                ret = filemap_fdatawrite(inode->i_mapping);
                 if (flags & XFS_B_ASYNC)
                         return ret;
-                ret2 = filemap_fdatawait(ip->i_mapping);
+                ret2 = filemap_fdatawait(inode->i_mapping);
                 if (!ret)
                         ret = ret2;
         }
diff --git a/fs/xfs/linux-2.6/xfs_fs_subr.h b/fs/xfs/linux-2.6/xfs_fs_subr.h
index c1b53118a303..82bb19b2599e 100644
--- a/fs/xfs/linux-2.6/xfs_fs_subr.h
+++ b/fs/xfs/linux-2.6/xfs_fs_subr.h
@@ -18,12 +18,8 @@
 #ifndef __XFS_FS_SUBR_H__
 #define __XFS_FS_SUBR_H__
 
-struct cred;
 extern int  fs_noerr(void);
 extern int  fs_nosys(void);
 extern void fs_noval(void);
-extern void fs_tosspages(bhv_desc_t *, xfs_off_t, xfs_off_t, int);
-extern int  fs_flushinval_pages(bhv_desc_t *, xfs_off_t, xfs_off_t, int);
-extern int  fs_flush_pages(bhv_desc_t *, xfs_off_t, xfs_off_t, uint64_t, int);
 
 #endif  /* __XFS_FS_SUBR_H__ */
diff --git a/fs/xfs/linux-2.6/xfs_ioctl.c b/fs/xfs/linux-2.6/xfs_ioctl.c
index 47cfde6cfae2..f36902fa714d 100644
--- a/fs/xfs/linux-2.6/xfs_ioctl.c
+++ b/fs/xfs/linux-2.6/xfs_ioctl.c
@@ -47,6 +47,7 @@
 #include "xfs_utils.h"
 #include "xfs_dfrag.h"
 #include "xfs_fsops.h"
+#include "xfs_vnodeops.h"
 
 #include <linux/capability.h>
 #include <linux/dcache.h>
@@ -436,7 +437,6 @@ xfs_fssetdm_by_handle(
         struct fsdmidata        fsd;
         xfs_fsop_setdm_handlereq_t dmhreq;
         struct inode            *inode;
-        bhv_desc_t              *bdp;
         bhv_vnode_t             *vp;
 
         if (!capable(CAP_MKNOD))
@@ -458,8 +458,8 @@ xfs_fssetdm_by_handle(
                 return -XFS_ERROR(EFAULT);
         }
 
-        bdp = bhv_base_unlocked(VN_BHV_HEAD(vp));
-        error = xfs_set_dmattrs(bdp, fsd.fsd_dmevmask, fsd.fsd_dmstate, NULL);
+        error = xfs_set_dmattrs(xfs_vtoi(vp),
+                        fsd.fsd_dmevmask, fsd.fsd_dmstate);
 
         VN_RELE(vp);
         if (error)
@@ -676,7 +676,7 @@ xfs_attrmulti_by_handle(
 
 STATIC int
 xfs_ioc_space(
-        bhv_desc_t              *bdp,
+        struct xfs_inode        *ip,
         struct inode            *inode,
         struct file             *filp,
         int                     flags,
@@ -709,37 +709,31 @@ xfs_ioc_xattr(
 
 STATIC int
 xfs_ioc_getbmap(
-        bhv_desc_t              *bdp,
+        struct xfs_inode        *ip,
         int                     flags,
         unsigned int            cmd,
         void                    __user *arg);
 
 STATIC int
 xfs_ioc_getbmapx(
-        bhv_desc_t              *bdp,
+        struct xfs_inode        *ip,
         void                    __user *arg);
 
 int
 xfs_ioctl(
-        bhv_desc_t              *bdp,
-        struct inode            *inode,
+        xfs_inode_t             *ip,
         struct file             *filp,
         int                     ioflags,
         unsigned int            cmd,
         void                    __user *arg)
 {
+        struct inode            *inode = filp->f_path.dentry->d_inode;
+        bhv_vnode_t             *vp = vn_from_inode(inode);
+        xfs_mount_t             *mp = ip->i_mount;
         int                     error;
-        bhv_vnode_t             *vp;
-        xfs_inode_t             *ip;
-        xfs_mount_t             *mp;
-
-        vp = vn_from_inode(inode);
 
         vn_trace_entry(vp, "xfs_ioctl", (inst_t *)__return_address);
 
-        ip = XFS_BHVTOI(bdp);
-        mp = ip->i_mount;
-
         switch (cmd) {
 
         case XFS_IOC_ALLOCSP:
@@ -758,7 +752,7 @@ xfs_ioctl(
                     !capable(CAP_SYS_ADMIN))
                         return -EPERM;
 
-                return xfs_ioc_space(bdp, inode, filp, ioflags, cmd, arg);
+                return xfs_ioc_space(ip, inode, filp, ioflags, cmd, arg);
 
         case XFS_IOC_DIOINFO: {
                 struct dioattr  da;
@@ -801,17 +795,17 @@ xfs_ioctl(
                 if (copy_from_user(&dmi, arg, sizeof(dmi)))
                         return -XFS_ERROR(EFAULT);
 
-                error = xfs_set_dmattrs(bdp, dmi.fsd_dmevmask, dmi.fsd_dmstate,
-                                                        NULL);
+                error = xfs_set_dmattrs(ip, dmi.fsd_dmevmask,
+                                dmi.fsd_dmstate);
                 return -error;
         }
 
         case XFS_IOC_GETBMAP:
         case XFS_IOC_GETBMAPA:
-                return xfs_ioc_getbmap(bdp, ioflags, cmd, arg);
+                return xfs_ioc_getbmap(ip, ioflags, cmd, arg);
 
         case XFS_IOC_GETBMAPX:
-                return xfs_ioc_getbmapx(bdp, arg);
+                return xfs_ioc_getbmapx(ip, arg);
 
         case XFS_IOC_FD_TO_HANDLE:
         case XFS_IOC_PATH_TO_HANDLE:
@@ -981,7 +975,7 @@ xfs_ioctl(
 
 STATIC int
 xfs_ioc_space(
-        bhv_desc_t              *bdp,
+        struct xfs_inode        *ip,
         struct inode            *inode,
         struct file             *filp,
         int                     ioflags,
@@ -1009,7 +1003,7 @@ xfs_ioc_space(
         if (ioflags & IO_INVIS)
                 attr_flags |= ATTR_DMI;
 
-        error = xfs_change_file_space(bdp, cmd, &bf, filp->f_pos,
+        error = xfs_change_file_space(ip, cmd, &bf, filp->f_pos,
                                               NULL, attr_flags);
         return -error;
 }
@@ -1295,7 +1289,7 @@ xfs_ioc_xattr(
 
 STATIC int
 xfs_ioc_getbmap(
-        bhv_desc_t              *bdp,
+        struct xfs_inode        *ip,
         int                     ioflags,
         unsigned int            cmd,
         void                    __user *arg)
@@ -1314,7 +1308,7 @@ xfs_ioc_getbmap(
         if (ioflags & IO_INVIS)
                 iflags |= BMV_IF_NO_DMAPI_READ;
 
-        error = xfs_getbmap(bdp, &bm, (struct getbmap __user *)arg+1, iflags);
+        error = xfs_getbmap(ip, &bm, (struct getbmap __user *)arg+1, iflags);
         if (error)
                 return -error;
 
@@ -1325,7 +1319,7 @@ xfs_ioc_getbmap(
 
 STATIC int
 xfs_ioc_getbmapx(
-        bhv_desc_t              *bdp,
+        struct xfs_inode        *ip,
         void                    __user *arg)
 {
         struct getbmapx         bmx;
@@ -1352,7 +1346,7 @@ xfs_ioc_getbmapx(
 
         iflags |= BMV_IF_EXTENDED;
 
-        error = xfs_getbmap(bdp, &bm, (struct getbmapx __user *)arg+1, iflags);
+        error = xfs_getbmap(ip, &bm, (struct getbmapx __user *)arg+1, iflags);
         if (error)
                 return -error;
 
diff --git a/fs/xfs/linux-2.6/xfs_iops.h b/fs/xfs/linux-2.6/xfs_iops.h
index 95a69398fce0..ce9852e9be00 100644
--- a/fs/xfs/linux-2.6/xfs_iops.h
+++ b/fs/xfs/linux-2.6/xfs_iops.h
@@ -26,8 +26,6 @@ extern const struct file_operations xfs_file_operations;
 extern const struct file_operations xfs_dir_file_operations;
 extern const struct file_operations xfs_invis_file_operations;
 
-extern int xfs_ioctl(struct bhv_desc *, struct inode *, struct file *,
-                        int, unsigned int, void __user *);
 
 struct xfs_inode;
 extern void xfs_ichgtime(struct xfs_inode *, int);
diff --git a/fs/xfs/linux-2.6/xfs_lrw.c b/fs/xfs/linux-2.6/xfs_lrw.c
index 94941da6c4da..2dc979e3e969 100644
--- a/fs/xfs/linux-2.6/xfs_lrw.c
+++ b/fs/xfs/linux-2.6/xfs_lrw.c
@@ -48,6 +48,7 @@
 #include "xfs_buf_item.h"
 #include "xfs_utils.h"
 #include "xfs_iomap.h"
+#include "xfs_vnodeops.h"
 
 #include <linux/capability.h>
 #include <linux/writeback.h>
@@ -180,27 +181,22 @@ unlock:
 
 ssize_t                 /* bytes read, or (-)  error */
 xfs_read(
-        bhv_desc_t              *bdp,
+        xfs_inode_t             *ip,
         struct kiocb            *iocb,
         const struct iovec      *iovp,
         unsigned int            segs,
         loff_t                  *offset,
-        int                     ioflags,
-        cred_t                  *credp)
+        int                     ioflags)
 {
         struct file             *file = iocb->ki_filp;
         struct inode            *inode = file->f_mapping->host;
+        bhv_vnode_t             *vp = XFS_ITOV(ip);
+        xfs_mount_t             *mp = ip->i_mount;
         size_t                  size = 0;
         ssize_t                 ret = 0;
         xfs_fsize_t             n;
-        xfs_inode_t             *ip;
-        xfs_mount_t             *mp;
-        bhv_vnode_t             *vp;
         unsigned long           seg;
 
-        ip = XFS_BHVTOI(bdp);
-        vp = BHV_TO_VNODE(bdp);
-        mp = ip->i_mount;
 
         XFS_STATS_INC(xs_read_calls);
 
@@ -249,8 +245,7 @@ xfs_read(
                 bhv_vrwlock_t locktype = VRWLOCK_READ;
                 int dmflags = FILP_DELAY_FLAG(file) | DM_SEM_FLAG_RD(ioflags);
 
-                ret = -XFS_SEND_DATA(mp, DM_EVENT_READ,
-                                        BHV_TO_VNODE(bdp), *offset, size,
+                ret = -XFS_SEND_DATA(mp, DM_EVENT_READ, vp, *offset, size,
                                         dmflags, &locktype);
                 if (ret) {
                         xfs_iunlock(ip, XFS_IOLOCK_SHARED);
@@ -287,16 +282,15 @@ xfs_read(
 
 ssize_t
 xfs_splice_read(
-        bhv_desc_t              *bdp,
+        xfs_inode_t             *ip,
         struct file             *infilp,
         loff_t                  *ppos,
         struct pipe_inode_info  *pipe,
         size_t                  count,
         int                     flags,
-        int                     ioflags,
-        cred_t                  *credp)
+        int                     ioflags)
 {
-        xfs_inode_t             *ip = XFS_BHVTOI(bdp);
+        bhv_vnode_t             *vp = XFS_ITOV(ip);
         xfs_mount_t             *mp = ip->i_mount;
         ssize_t                 ret;
 
@@ -310,8 +304,7 @@ xfs_splice_read(
                 bhv_vrwlock_t locktype = VRWLOCK_READ;
                 int error;
 
-                error = XFS_SEND_DATA(mp, DM_EVENT_READ, BHV_TO_VNODE(bdp),
-                                        *ppos, count,
+                error = XFS_SEND_DATA(mp, DM_EVENT_READ, vp, *ppos, count,
                                         FILP_DELAY_FLAG(infilp), &locktype);
                 if (error) {
                         xfs_iunlock(ip, XFS_IOLOCK_SHARED);
@@ -330,16 +323,15 @@ xfs_splice_read(
 
 ssize_t
 xfs_splice_write(
-        bhv_desc_t              *bdp,
+        xfs_inode_t             *ip,
         struct pipe_inode_info  *pipe,
         struct file             *outfilp,
         loff_t                  *ppos,
         size_t                  count,
         int                     flags,
-        int                     ioflags,
-        cred_t                  *credp)
+        int                     ioflags)
 {
-        xfs_inode_t             *ip = XFS_BHVTOI(bdp);
+        bhv_vnode_t             *vp = XFS_ITOV(ip);
         xfs_mount_t             *mp = ip->i_mount;
         xfs_iocore_t            *io = &ip->i_iocore;
         ssize_t                 ret;
@@ -356,8 +348,7 @@ xfs_splice_write(
                 bhv_vrwlock_t locktype = VRWLOCK_WRITE;
                 int error;
 
-                error = XFS_SEND_DATA(mp, DM_EVENT_WRITE, BHV_TO_VNODE(bdp),
-                                        *ppos, count,
+                error = XFS_SEND_DATA(mp, DM_EVENT_WRITE, vp, *ppos, count,
                                         FILP_DELAY_FLAG(outfilp), &locktype);
                 if (error) {
                         xfs_iunlock(ip, XFS_IOLOCK_EXCL);
@@ -591,24 +582,22 @@ out_lock:
 
 ssize_t                         /* bytes written, or (-) error */
 xfs_write(
-        bhv_desc_t              *bdp,
+        struct xfs_inode        *xip,
         struct kiocb            *iocb,
         const struct iovec      *iovp,
         unsigned int            nsegs,
         loff_t                  *offset,
-        int                     ioflags,
-        cred_t                  *credp)
+        int                     ioflags)
 {
         struct file             *file = iocb->ki_filp;
         struct address_space    *mapping = file->f_mapping;
         struct inode            *inode = mapping->host;
+        bhv_vnode_t             *vp = XFS_ITOV(xip);
         unsigned long           segs = nsegs;
-        xfs_inode_t             *xip;
         xfs_mount_t             *mp;
         ssize_t                 ret = 0, error = 0;
         xfs_fsize_t             isize, new_size;
         xfs_iocore_t            *io;
-        bhv_vnode_t             *vp;
         int                     iolock;
         int                     eventsent = 0;
         bhv_vrwlock_t           locktype;
@@ -618,9 +607,6 @@ xfs_write(
 
         XFS_STATS_INC(xs_write_calls);
 
-        vp = BHV_TO_VNODE(bdp);
-        xip = XFS_BHVTOI(bdp);
-
         error = generic_segment_checks(iovp, &segs, &ocount, VERIFY_READ);
         if (error)
                 return error;
@@ -730,7 +716,7 @@ start:
          */
 
         if (pos > xip->i_size) {
-                error = xfs_zero_eof(BHV_TO_VNODE(bdp), io, pos, xip->i_size);
+                error = xfs_zero_eof(vp, io, pos, xip->i_size);
                 if (error) {
                         xfs_iunlock(xip, XFS_ILOCK_EXCL);
                         goto out_unlock_internal;
@@ -815,7 +801,7 @@ retry:
 
         if (ret == -ENOSPC &&
             DM_EVENT_ENABLED(xip, DM_EVENT_NOSPACE) && !(ioflags & IO_INVIS)) {
-                xfs_rwunlock(bdp, locktype);
+                xfs_rwunlock(xip, locktype);
                 if (need_i_mutex)
                         mutex_unlock(&inode->i_mutex);
                 error = XFS_SEND_NAMESP(xip->i_mount, DM_EVENT_NOSPACE, vp,
@@ -823,7 +809,7 @@ retry:
                                 0, 0, 0); /* Delay flag intentionally  unused */
                 if (need_i_mutex)
                         mutex_lock(&inode->i_mutex);
-                xfs_rwlock(bdp, locktype);
+                xfs_rwlock(xip, locktype);
                 if (error)
                         goto out_unlock_internal;
                 pos = xip->i_size;
@@ -854,7 +840,7 @@ retry:
                 if (error)
                         goto out_unlock_internal;
 
-                xfs_rwunlock(bdp, locktype);
+                xfs_rwunlock(xip, locktype);
                 if (need_i_mutex)
                         mutex_unlock(&inode->i_mutex);
 
@@ -863,7 +849,7 @@ retry:
                         error = -ret;
                 if (need_i_mutex)
                         mutex_lock(&inode->i_mutex);
-                xfs_rwlock(bdp, locktype);
+                xfs_rwlock(xip, locktype);
         }
 
  out_unlock_internal:
@@ -881,7 +867,7 @@ retry:
                         xip->i_d.di_size = xip->i_size;
                 xfs_iunlock(xip, XFS_ILOCK_EXCL);
         }
-        xfs_rwunlock(bdp, locktype);
+        xfs_rwunlock(xip, locktype);
  out_unlock_mutex:
         if (need_i_mutex)
                 mutex_unlock(&inode->i_mutex);
@@ -920,14 +906,14 @@ xfs_bdstrat_cb(struct xfs_buf *bp)
 
 
 int
-xfs_bmap(bhv_desc_t     *bdp,
+xfs_bmap(
+        xfs_inode_t     *ip,
         xfs_off_t       offset,
         ssize_t         count,
         int             flags,
         xfs_iomap_t     *iomapp,
         int             *niomaps)
 {
-        xfs_inode_t     *ip = XFS_BHVTOI(bdp);
         xfs_iocore_t    *io = &ip->i_iocore;
 
         ASSERT((ip->i_d.di_mode & S_IFMT) == S_IFREG);
diff --git a/fs/xfs/linux-2.6/xfs_lrw.h b/fs/xfs/linux-2.6/xfs_lrw.h
index 1ad29bae5415..fa7cefa86a82 100644
--- a/fs/xfs/linux-2.6/xfs_lrw.h
+++ b/fs/xfs/linux-2.6/xfs_lrw.h
@@ -71,25 +71,11 @@ extern void xfs_inval_cached_trace(struct xfs_iocore *,
 #define xfs_inval_cached_trace(io, offset, len, first, last)
 #endif
 
-extern int xfs_bmap(struct bhv_desc *, xfs_off_t, ssize_t, int,
-                        struct xfs_iomap *, int *);
 extern int xfsbdstrat(struct xfs_mount *, struct xfs_buf *);
 extern int xfs_bdstrat_cb(struct xfs_buf *);
 extern int xfs_dev_is_read_only(struct xfs_mount *, char *);
 
 extern int xfs_zero_eof(struct bhv_vnode *, struct xfs_iocore *, xfs_off_t,
                                 xfs_fsize_t);
-extern ssize_t xfs_read(struct bhv_desc *, struct kiocb *,
-                                const struct iovec *, unsigned int,
-                                loff_t *, int, struct cred *);
-extern ssize_t xfs_write(struct bhv_desc *, struct kiocb *,
-                                const struct iovec *, unsigned int,
-                                loff_t *, int, struct cred *);
-extern ssize_t xfs_splice_read(struct bhv_desc *, struct file *, loff_t *,
-                                struct pipe_inode_info *, size_t, int, int,
-                                struct cred *);
-extern ssize_t xfs_splice_write(struct bhv_desc *, struct pipe_inode_info *,
-                                struct file *, loff_t *, size_t, int, int,
-                                struct cred *);
 
 #endif  /* __XFS_LRW_H__ */