]> pilppa.com Git - linux-2.6-omap-h63xx.git/commitdiff
[XFS] call common xfs vnode-level helpers directly and remove vnode operations
authorChristoph Hellwig <hch@infradead.org>
Wed, 29 Aug 2007 00:58:01 +0000 (10:58 +1000)
committerTim Shimmin <tes@chook.melbourne.sgi.com>
Tue, 16 Oct 2007 00:40:00 +0000 (10:40 +1000)
SGI-PV: 969608
SGI-Modid: xfs-linux-melb:xfs-kern:29493a

Signed-off-by: Christoph Hellwig <hch@infradead.org>
Signed-off-by: David Chinner <dgc@sgi.com>
Signed-off-by: Tim Shimmin <tes@sgi.com>
27 files changed:
fs/xfs/Makefile-linux-2.6
fs/xfs/linux-2.6/xfs_aops.c
fs/xfs/linux-2.6/xfs_export.c
fs/xfs/linux-2.6/xfs_file.c
fs/xfs/linux-2.6/xfs_ioctl.c
fs/xfs/linux-2.6/xfs_ioctl32.c
fs/xfs/linux-2.6/xfs_iops.c
fs/xfs/linux-2.6/xfs_iops.h
fs/xfs/linux-2.6/xfs_lrw.c
fs/xfs/linux-2.6/xfs_super.c
fs/xfs/linux-2.6/xfs_super.h
fs/xfs/linux-2.6/xfs_vfs.c
fs/xfs/linux-2.6/xfs_vfs.h
fs/xfs/linux-2.6/xfs_vnode.c
fs/xfs/linux-2.6/xfs_vnode.h
fs/xfs/xfs_acl.c
fs/xfs/xfs_attr.c
fs/xfs/xfs_bmap.c
fs/xfs/xfs_dfrag.c
fs/xfs/xfs_iget.c
fs/xfs/xfs_inode.c
fs/xfs/xfs_inode.h
fs/xfs/xfs_mount.h
fs/xfs/xfs_rename.c
fs/xfs/xfs_vfsops.c
fs/xfs/xfs_vnodeops.c
fs/xfs/xfs_vnodeops_bhv.c [deleted file]

index 8ed1f0475778bafcdd8da82a5424a9bf667922a9..6d48a5ed38f33bc503c43658041772fc1056e9ea 100644 (file)
@@ -89,7 +89,6 @@ xfs-y                         += xfs_alloc.o \
                                   xfs_utils.o \
                                   xfs_vfsops.o \
                                   xfs_vnodeops.o \
-                                  xfs_vnodeops_bhv.o \
                                   xfs_rw.o \
                                   xfs_dmops.o \
                                   xfs_qmops.o
index 5f152f60d74d83ce8878fcba2ee16780ee767513..28ccca98839bd65f2208f7e086265ef7946bf06c 100644 (file)
@@ -37,6 +37,7 @@
 #include "xfs_error.h"
 #include "xfs_rw.h"
 #include "xfs_iomap.h"
+#include "xfs_vnodeops.h"
 #include <linux/mpage.h>
 #include <linux/pagevec.h>
 #include <linux/writeback.h>
@@ -232,7 +233,8 @@ xfs_end_bio_unwritten(
        size_t                  size = ioend->io_size;
 
        if (likely(!ioend->io_error)) {
-               bhv_vop_bmap(vp, offset, size, BMAPI_UNWRITTEN, NULL, NULL);
+               xfs_bmap(xfs_vtoi(vp), offset, size,
+                               BMAPI_UNWRITTEN, NULL, NULL);
                xfs_setfilesize(ioend);
        }
        xfs_destroy_ioend(ioend);
@@ -305,7 +307,8 @@ xfs_map_blocks(
        bhv_vnode_t             *vp = vn_from_inode(inode);
        int                     error, nmaps = 1;
 
-       error = bhv_vop_bmap(vp, offset, count, flags, mapp, &nmaps);
+       error = xfs_bmap(xfs_vtoi(vp), offset, count,
+                               flags, mapp, &nmaps);
        if (!error && (flags & (BMAPI_WRITE|BMAPI_ALLOCATE)))
                VMODIFY(vp);
        return -error;
@@ -1323,7 +1326,6 @@ __xfs_get_blocks(
        int                     direct,
        bmapi_flags_t           flags)
 {
-       bhv_vnode_t             *vp = vn_from_inode(inode);
        xfs_iomap_t             iomap;
        xfs_off_t               offset;
        ssize_t                 size;
@@ -1333,7 +1335,7 @@ __xfs_get_blocks(
        offset = (xfs_off_t)iblock << inode->i_blkbits;
        ASSERT(bh_result->b_size >= (1 << inode->i_blkbits));
        size = bh_result->b_size;
-       error = bhv_vop_bmap(vp, offset, size,
+       error = xfs_bmap(XFS_I(inode), offset, size,
                             create ? flags : BMAPI_READ, &iomap, &niomap);
        if (error)
                return -error;
@@ -1481,13 +1483,13 @@ xfs_vm_direct_IO(
 {
        struct file     *file = iocb->ki_filp;
        struct inode    *inode = file->f_mapping->host;
-       bhv_vnode_t     *vp = vn_from_inode(inode);
        xfs_iomap_t     iomap;
        int             maps = 1;
        int             error;
        ssize_t         ret;
 
-       error = bhv_vop_bmap(vp, offset, 0, BMAPI_DEVICE, &iomap, &maps);
+       error = xfs_bmap(XFS_I(inode), offset, 0,
+                               BMAPI_DEVICE, &iomap, &maps);
        if (error)
                return -error;
 
@@ -1528,12 +1530,13 @@ xfs_vm_bmap(
        sector_t                block)
 {
        struct inode            *inode = (struct inode *)mapping->host;
-       bhv_vnode_t             *vp = vn_from_inode(inode);
+       struct xfs_inode        *ip = XFS_I(inode);
 
-       vn_trace_entry(vp, __FUNCTION__, (inst_t *)__return_address);
-       bhv_vop_rwlock(vp, VRWLOCK_READ);
-       bhv_vop_flush_pages(vp, (xfs_off_t)0, -1, 0, FI_REMAPF);
-       bhv_vop_rwunlock(vp, VRWLOCK_READ);
+       vn_trace_entry(vn_from_inode(inode), __FUNCTION__,
+                       (inst_t *)__return_address);
+       xfs_rwlock(ip, VRWLOCK_READ);
+       xfs_flush_pages(ip, (xfs_off_t)0, -1, 0, FI_REMAPF);
+       xfs_rwunlock(ip, VRWLOCK_READ);
        return generic_block_bmap(mapping, block, xfs_get_blocks);
 }
 
index f6e99fa7a683c84509316dbae93f28386f010897..0919021d56c438b73f1318c8a968f745195e04e8 100644 (file)
@@ -25,6 +25,9 @@
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
 #include "xfs_export.h"
+#include "xfs_vnodeops.h"
+#include "xfs_bmap_btree.h"
+#include "xfs_inode.h"
 
 static struct dentry dotdot = { .d_name.name = "..", .d_name.len = 2, };
 
@@ -161,12 +164,11 @@ xfs_fs_get_parent(
        struct dentry           *child)
 {
        int                     error;
-       bhv_vnode_t             *vp, *cvp;
+       bhv_vnode_t             *cvp;
        struct dentry           *parent;
 
        cvp = NULL;
-       vp = vn_from_inode(child->d_inode);
-       error = bhv_vop_lookup(vp, &dotdot, &cvp, 0, NULL, NULL);
+       error = xfs_lookup(XFS_I(child->d_inode), &dotdot, &cvp);
        if (unlikely(error))
                return ERR_PTR(-error);
 
index 3678f6912d046f4fbea8c3c4a7bfdfe49da71b70..83707708ebb14d5dce292eb0546d71517e4b0018 100644 (file)
@@ -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
@@ -208,7 +200,8 @@ xfs_file_fsync(
                flags |= FSYNC_DATA;
        if (VN_TRUNC(vp))
                VUNTRUNCATE(vp);
-       return -bhv_vop_fsync(vp, flags, NULL, (xfs_off_t)0, (xfs_off_t)-1);
+       return -xfs_fsync(XFS_I(dentry->d_inode), flags,
+                       (xfs_off_t)0, (xfs_off_t)-1);
 }
 
 #ifdef CONFIG_XFS_DMAPI
@@ -234,7 +227,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 +245,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;
@@ -286,7 +279,7 @@ xfs_file_ioctl(
        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);
+       error = xfs_ioctl(XFS_I(inode), filp, 0, cmd, (void __user *)p);
        VMODIFY(vp);
 
        /* NOTE:  some of the ioctl's return positive #'s as a
@@ -308,7 +301,7 @@ xfs_file_ioctl_invis(
        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);
+       error = xfs_ioctl(XFS_I(inode), filp, IO_INVIS, cmd, (void __user *)p);
        VMODIFY(vp);
 
        /* NOTE:  some of the ioctl's return positive #'s as a
index f36902fa714d0a377578c2700c4e760de1651dc2..9bba9f8be1eb886e4d9f335a4927e8118724cf4b 100644 (file)
@@ -413,7 +413,7 @@ xfs_readlink_by_handle(
        if (!link)
                goto out_iput;
 
-       error = -bhv_vop_readlink(vp, link);
+       error = -xfs_readlink(XFS_I(inode), link);
        if (error)
                goto out_kfree;
        error = do_readlink(hreq.ohandle, olen, link);
@@ -497,8 +497,8 @@ xfs_attrlist_by_handle(
                goto out_vn_rele;
 
        cursor = (attrlist_cursor_kern_t *)&al_hreq.pos;
-       error = bhv_vop_attr_list(vp, kbuf, al_hreq.buflen, al_hreq.flags,
-                                       cursor, NULL);
+       error = xfs_attr_list(XFS_I(inode), kbuf, al_hreq.buflen,
+                                       al_hreq.flags, cursor);
        if (error)
                goto out_kfree;
 
@@ -515,7 +515,7 @@ xfs_attrlist_by_handle(
 
 STATIC int
 xfs_attrmulti_attr_get(
-       bhv_vnode_t             *vp,
+       struct inode            *inode,
        char                    *name,
        char                    __user *ubuf,
        __uint32_t              *len,
@@ -530,7 +530,7 @@ xfs_attrmulti_attr_get(
        if (!kbuf)
                return ENOMEM;
 
-       error = bhv_vop_attr_get(vp, name, kbuf, len, flags, NULL);
+       error = xfs_attr_get(XFS_I(inode), name, kbuf, len, flags, NULL);
        if (error)
                goto out_kfree;
 
@@ -544,7 +544,7 @@ xfs_attrmulti_attr_get(
 
 STATIC int
 xfs_attrmulti_attr_set(
-       bhv_vnode_t             *vp,
+       struct inode            *inode,
        char                    *name,
        const char              __user *ubuf,
        __uint32_t              len,
@@ -553,9 +553,9 @@ xfs_attrmulti_attr_set(
        char                    *kbuf;
        int                     error = EFAULT;
 
-       if (IS_RDONLY(&vp->v_inode))
+       if (IS_RDONLY(inode))
                return -EROFS;
-       if (IS_IMMUTABLE(&vp->v_inode) || IS_APPEND(&vp->v_inode))
+       if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
                return EPERM;
        if (len > XATTR_SIZE_MAX)
                return EINVAL;
@@ -567,7 +567,7 @@ xfs_attrmulti_attr_set(
        if (copy_from_user(kbuf, ubuf, len))
                goto out_kfree;
                        
-       error = bhv_vop_attr_set(vp, name, kbuf, len, flags, NULL);
+       error = xfs_attr_set(XFS_I(inode), name, kbuf, len, flags);
 
  out_kfree:
        kfree(kbuf);
@@ -576,15 +576,15 @@ xfs_attrmulti_attr_set(
 
 STATIC int
 xfs_attrmulti_attr_remove(
-       bhv_vnode_t             *vp,
+       struct inode            *inode,
        char                    *name,
        __uint32_t              flags)
 {
-       if (IS_RDONLY(&vp->v_inode))
+       if (IS_RDONLY(inode))
                return -EROFS;
-       if (IS_IMMUTABLE(&vp->v_inode) || IS_APPEND(&vp->v_inode))
+       if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
                return EPERM;
-       return bhv_vop_attr_remove(vp, name, flags, NULL);
+       return xfs_attr_remove(XFS_I(inode), name, flags);
 }
 
 STATIC int
@@ -640,17 +640,17 @@ xfs_attrmulti_by_handle(
 
                switch (ops[i].am_opcode) {
                case ATTR_OP_GET:
-                       ops[i].am_error = xfs_attrmulti_attr_get(vp,
+                       ops[i].am_error = xfs_attrmulti_attr_get(inode,
                                        attr_name, ops[i].am_attrvalue,
                                        &ops[i].am_length, ops[i].am_flags);
                        break;
                case ATTR_OP_SET:
-                       ops[i].am_error = xfs_attrmulti_attr_set(vp,
+                       ops[i].am_error = xfs_attrmulti_attr_set(inode,
                                        attr_name, ops[i].am_attrvalue,
                                        ops[i].am_length, ops[i].am_flags);
                        break;
                case ATTR_OP_REMOVE:
-                       ops[i].am_error = xfs_attrmulti_attr_remove(vp,
+                       ops[i].am_error = xfs_attrmulti_attr_remove(inode,
                                        attr_name, ops[i].am_flags);
                        break;
                default:
@@ -1182,7 +1182,7 @@ xfs_ioc_xattr(
        case XFS_IOC_FSGETXATTR: {
                vattr->va_mask = XFS_AT_XFLAGS | XFS_AT_EXTSIZE | \
                                 XFS_AT_NEXTENTS | XFS_AT_PROJID;
-               error = bhv_vop_getattr(vp, vattr, 0, NULL);
+               error = xfs_getattr(ip, vattr, 0);
                if (unlikely(error)) {
                        error = -error;
                        break;
@@ -1215,7 +1215,7 @@ xfs_ioc_xattr(
                vattr->va_extsize = fa.fsx_extsize;
                vattr->va_projid  = fa.fsx_projid;
 
-               error = bhv_vop_setattr(vp, vattr, attr_flags, NULL);
+               error = xfs_setattr(ip, vattr, attr_flags, NULL);
                if (likely(!error))
                        __vn_revalidate(vp, vattr);     /* update flags */
                error = -error;
@@ -1225,7 +1225,7 @@ xfs_ioc_xattr(
        case XFS_IOC_FSGETXATTRA: {
                vattr->va_mask = XFS_AT_XFLAGS | XFS_AT_EXTSIZE | \
                                 XFS_AT_ANEXTENTS | XFS_AT_PROJID;
-               error = bhv_vop_getattr(vp, vattr, 0, NULL);
+               error = xfs_getattr(ip, vattr, 0);
                if (unlikely(error)) {
                        error = -error;
                        break;
@@ -1271,7 +1271,7 @@ xfs_ioc_xattr(
                vattr->va_xflags = xfs_merge_ioc_xflags(flags,
                                                        xfs_ip2xflags(ip));
 
-               error = bhv_vop_setattr(vp, vattr, attr_flags, NULL);
+               error = xfs_setattr(ip, vattr, attr_flags, NULL);
                if (likely(!error))
                        __vn_revalidate(vp, vattr);     /* update flags */
                error = -error;
index 42319d75aaab1ff2123421c7d7b82bb5d6444240..83f5099603050f2bfdd0228a578fb8c46339fab8 100644 (file)
@@ -43,6 +43,7 @@
 #include "xfs_itable.h"
 #include "xfs_error.h"
 #include "xfs_dfrag.h"
+#include "xfs_vnodeops.h"
 
 #define  _NATIVE_IOC(cmd, type) \
          _IOC(_IOC_DIR(cmd), _IOC_TYPE(cmd), _IOC_NR(cmd), sizeof(type))
@@ -443,7 +444,7 @@ xfs_compat_ioctl(
        case XFS_IOC_FSBULKSTAT_SINGLE_32:
        case XFS_IOC_FSINUMBERS_32:
                cmd = _NATIVE_IOC(cmd, struct xfs_fsop_bulkreq);
-               return xfs_ioc_bulkstat_compat(XFS_BHVTOI(VNHEAD(vp))->i_mount,
+               return xfs_ioc_bulkstat_compat(XFS_I(inode)->i_mount,
                                cmd, (void __user*)arg);
        case XFS_IOC_FD_TO_HANDLE_32:
        case XFS_IOC_PATH_TO_HANDLE_32:
@@ -457,7 +458,7 @@ xfs_compat_ioctl(
                return -ENOIOCTLCMD;
        }
 
-       error = bhv_vop_ioctl(vp, inode, file, mode, cmd, (void __user *)arg);
+       error = xfs_ioctl(XFS_I(inode), file, mode, cmd, (void __user *)arg);
        VMODIFY(vp);
 
        return error;
index ef941f99b2bc7ee6cfb639b2c5645d1501e27922..4da034f4ae142aab6769c4c119b069c50f69fd51 100644 (file)
 #include "xfs_attr.h"
 #include "xfs_buf_item.h"
 #include "xfs_utils.h"
+#include "xfs_vnodeops.h"
 
 #include <linux/capability.h>
 #include <linux/xattr.h>
 #include <linux/namei.h>
 #include <linux/security.h>
 
-/*
- * Get a XFS inode from a given vnode.
- */
-xfs_inode_t *
-xfs_vtoi(
-       bhv_vnode_t     *vp)
-{
-       bhv_desc_t      *bdp;
-
-       bdp = bhv_lookup_range(VN_BHV_HEAD(vp),
-                       VNODE_POSITION_XFS, VNODE_POSITION_XFS);
-       if (unlikely(bdp == NULL))
-               return NULL;
-       return XFS_BHVTOI(bdp);
-}
-
 /*
  * Bring the atime in the XFS inode uptodate.
  * Used before logging the inode to disk or when the Linux inode goes away.
@@ -199,7 +184,7 @@ xfs_validate_fields(
        bhv_vattr_t     *vattr)
 {
        vattr->va_mask = XFS_AT_NLINK|XFS_AT_SIZE|XFS_AT_NBLOCKS;
-       if (!bhv_vop_getattr(vn_from_inode(ip), vattr, ATTR_LAZY, NULL)) {
+       if (!xfs_getattr(XFS_I(ip), vattr, ATTR_LAZY)) {
                ip->i_nlink = vattr->va_nlink;
                ip->i_blocks = vattr->va_nblocks;
 
@@ -233,7 +218,8 @@ xfs_init_security(
                return -error;
        }
 
-       error = bhv_vop_attr_set(vp, name, value, length, ATTR_SECURE, NULL);
+       error = xfs_attr_set(XFS_I(ip), name, value,
+                       length, ATTR_SECURE);
        if (!error)
                VMODIFY(vp);
 
@@ -256,7 +242,7 @@ xfs_has_fs_struct(struct task_struct *task)
 
 STATIC void
 xfs_cleanup_inode(
-       bhv_vnode_t     *dvp,
+       struct inode    *dir,
        bhv_vnode_t     *vp,
        struct dentry   *dentry,
        int             mode)
@@ -272,9 +258,9 @@ xfs_cleanup_inode(
        teardown.d_name = dentry->d_name;
 
        if (S_ISDIR(mode))
-               bhv_vop_rmdir(dvp, &teardown, NULL);
+               xfs_rmdir(XFS_I(dir), &teardown);
        else
-               bhv_vop_remove(dvp, &teardown, NULL);
+               xfs_remove(XFS_I(dir), &teardown);
        VN_RELE(vp);
 }
 
@@ -321,10 +307,10 @@ xfs_vn_mknod(
                vattr.va_mask |= XFS_AT_RDEV;
                /*FALLTHROUGH*/
        case S_IFREG:
-               error = bhv_vop_create(dvp, dentry, &vattr, &vp, NULL);
+               error = xfs_create(XFS_I(dir), dentry, &vattr, &vp, NULL);
                break;
        case S_IFDIR:
-               error = bhv_vop_mkdir(dvp, dentry, &vattr, &vp, NULL);
+               error = xfs_mkdir(XFS_I(dir), dentry, &vattr, &vp, NULL);
                break;
        default:
                error = EINVAL;
@@ -334,7 +320,7 @@ xfs_vn_mknod(
        if (unlikely(!error)) {
                error = xfs_init_security(vp, dir);
                if (error)
-                       xfs_cleanup_inode(dvp, vp, dentry, mode);
+                       xfs_cleanup_inode(dir, vp, dentry, mode);
        }
 
        if (unlikely(default_acl)) {
@@ -343,7 +329,7 @@ xfs_vn_mknod(
                        if (!error)
                                VMODIFY(vp);
                        else
-                               xfs_cleanup_inode(dvp, vp, dentry, mode);
+                               xfs_cleanup_inode(dir, vp, dentry, mode);
                }
                _ACL_FREE(default_acl);
        }
@@ -387,13 +373,13 @@ xfs_vn_lookup(
        struct dentry   *dentry,
        struct nameidata *nd)
 {
-       bhv_vnode_t     *vp = vn_from_inode(dir), *cvp;
+       bhv_vnode_t     *cvp;
        int             error;
 
        if (dentry->d_name.len >= MAXNAMELEN)
                return ERR_PTR(-ENAMETOOLONG);
 
-       error = bhv_vop_lookup(vp, dentry, &cvp, 0, NULL, NULL);
+       error = xfs_lookup(XFS_I(dir), dentry, &cvp);
        if (unlikely(error)) {
                if (unlikely(error != ENOENT))
                        return ERR_PTR(-error);
@@ -411,21 +397,19 @@ xfs_vn_link(
        struct dentry   *dentry)
 {
        struct inode    *ip;    /* inode of guy being linked to */
-       bhv_vnode_t     *tdvp;  /* target directory for new name/link */
        bhv_vnode_t     *vp;    /* vp of name being linked */
        bhv_vattr_t     vattr;
        int             error;
 
        ip = old_dentry->d_inode;       /* inode being linked to */
-       tdvp = vn_from_inode(dir);
        vp = vn_from_inode(ip);
 
        VN_HOLD(vp);
-       error = bhv_vop_link(tdvp, vp, dentry, NULL);
+       error = xfs_link(XFS_I(dir), vp, dentry);
        if (unlikely(error)) {
                VN_RELE(vp);
        } else {
-               VMODIFY(tdvp);
+               VMODIFY(vn_from_inode(dir));
                xfs_validate_fields(ip, &vattr);
                d_instantiate(dentry, ip);
        }
@@ -438,14 +422,12 @@ xfs_vn_unlink(
        struct dentry   *dentry)
 {
        struct inode    *inode;
-       bhv_vnode_t     *dvp;   /* directory containing name to remove */
        bhv_vattr_t     vattr;
        int             error;
 
        inode = dentry->d_inode;
-       dvp = vn_from_inode(dir);
 
-       error = bhv_vop_remove(dvp, dentry, NULL);
+       error = xfs_remove(XFS_I(dir), dentry);
        if (likely(!error)) {
                xfs_validate_fields(dir, &vattr);       /* size needs update */
                xfs_validate_fields(inode, &vattr);
@@ -461,18 +443,17 @@ xfs_vn_symlink(
 {
        struct inode    *ip;
        bhv_vattr_t     va = { 0 };
-       bhv_vnode_t     *dvp;   /* directory containing name of symlink */
        bhv_vnode_t     *cvp;   /* used to lookup symlink to put in dentry */
        int             error;
 
-       dvp = vn_from_inode(dir);
        cvp = NULL;
 
        va.va_mode = S_IFLNK |
                (irix_symlink_mode ? 0777 & ~current->fs->umask : S_IRWXUGO);
        va.va_mask = XFS_AT_TYPE|XFS_AT_MODE;
 
-       error = bhv_vop_symlink(dvp, dentry, &va, (char *)symname, &cvp, NULL);
+       error = xfs_symlink(XFS_I(dir), dentry, &va,
+                       (char *)symname, &cvp, NULL);
        if (likely(!error && cvp)) {
                error = xfs_init_security(cvp, dir);
                if (likely(!error)) {
@@ -481,7 +462,7 @@ xfs_vn_symlink(
                        xfs_validate_fields(dir, &va);
                        xfs_validate_fields(ip, &va);
                } else {
-                       xfs_cleanup_inode(dvp, cvp, dentry, 0);
+                       xfs_cleanup_inode(dir, cvp, dentry, 0);
                }
        }
        return -error;
@@ -493,11 +474,10 @@ xfs_vn_rmdir(
        struct dentry   *dentry)
 {
        struct inode    *inode = dentry->d_inode;
-       bhv_vnode_t     *dvp = vn_from_inode(dir);
        bhv_vattr_t     vattr;
        int             error;
 
-       error = bhv_vop_rmdir(dvp, dentry, NULL);
+       error = xfs_rmdir(XFS_I(dir), dentry);
        if (likely(!error)) {
                xfs_validate_fields(inode, &vattr);
                xfs_validate_fields(dir, &vattr);
@@ -513,15 +493,13 @@ xfs_vn_rename(
        struct dentry   *ndentry)
 {
        struct inode    *new_inode = ndentry->d_inode;
-       bhv_vnode_t     *fvp;   /* from directory */
        bhv_vnode_t     *tvp;   /* target directory */
        bhv_vattr_t     vattr;
        int             error;
 
-       fvp = vn_from_inode(odir);
        tvp = vn_from_inode(ndir);
 
-       error = bhv_vop_rename(fvp, odentry, tvp, ndentry, NULL);
+       error = xfs_rename(XFS_I(odir), odentry, tvp, ndentry);
        if (likely(!error)) {
                if (new_inode)
                        xfs_validate_fields(new_inode, &vattr);
@@ -542,7 +520,6 @@ xfs_vn_follow_link(
        struct dentry           *dentry,
        struct nameidata        *nd)
 {
-       bhv_vnode_t             *vp = vn_from_inode(dentry->d_inode);
        char                    *link;
        int                     error = -ENOMEM;
 
@@ -550,7 +527,7 @@ xfs_vn_follow_link(
        if (!link)
                goto out_err;
 
-       error = -bhv_vop_readlink(vp, link);
+       error = -xfs_readlink(XFS_I(dentry->d_inode), link);
        if (unlikely(error))
                goto out_kfree;
 
@@ -583,7 +560,7 @@ xfs_vn_permission(
        int             mode,
        struct nameidata *nd)
 {
-       return -bhv_vop_access(vn_from_inode(inode), mode << 6, NULL);
+       return -xfs_access(XFS_I(inode), mode << 6, NULL);
 }
 #else
 #define xfs_vn_permission NULL
@@ -596,11 +573,10 @@ xfs_vn_getattr(
        struct kstat    *stat)
 {
        struct inode    *inode = dentry->d_inode;
-       bhv_vnode_t     *vp = vn_from_inode(inode);
        bhv_vattr_t     vattr = { .va_mask = XFS_AT_STAT };
        int             error;
 
-       error = bhv_vop_getattr(vp, &vattr, ATTR_LAZY, NULL);
+       error = xfs_getattr(XFS_I(inode), &vattr, ATTR_LAZY);
        if (likely(!error)) {
                stat->size = i_size_read(inode);
                stat->dev = inode->i_sb->s_dev;
@@ -628,7 +604,6 @@ xfs_vn_setattr(
 {
        struct inode    *inode = dentry->d_inode;
        unsigned int    ia_valid = attr->ia_valid;
-       bhv_vnode_t     *vp = vn_from_inode(inode);
        bhv_vattr_t     vattr = { 0 };
        int             flags = 0;
        int             error;
@@ -672,9 +647,9 @@ xfs_vn_setattr(
                flags |= ATTR_NONBLOCK;
 #endif
 
-       error = bhv_vop_setattr(vp, &vattr, flags, NULL);
+       error = xfs_setattr(XFS_I(inode), &vattr, flags, NULL);
        if (likely(!error))
-               __vn_revalidate(vp, &vattr);
+               __vn_revalidate(vn_from_inode(inode), &vattr);
        return -error;
 }
 
index ce9852e9be00298be348f5e23e737e290814c261..14d0deb7afff2f57acfb65b7ec1d6de40f0aecc9 100644 (file)
@@ -31,4 +31,10 @@ struct xfs_inode;
 extern void xfs_ichgtime(struct xfs_inode *, int);
 extern void xfs_ichgtime_fast(struct xfs_inode *, struct inode *, int);
 
+#define xfs_vtoi(vp) \
+       ((struct xfs_inode *)vn_to_inode(vp)->i_private)
+
+#define XFS_I(inode) \
+       ((struct xfs_inode *)(inode)->i_private)
+
 #endif /* __XFS_IOPS_H__ */
index 2dc979e3e9693c8acead88e5c04c86fc36c93158..fb04b11bb81599c4ec1b8864fca782f1570c70b0 100644 (file)
@@ -257,8 +257,9 @@ xfs_read(
 
        if (unlikely(ioflags & IO_ISDIRECT)) {
                if (VN_CACHED(vp))
-                       ret = bhv_vop_flushinval_pages(vp, ctooff(offtoct(*offset)),
-                                                -1, FI_REMAPF_LOCKED);
+                       ret = xfs_flushinval_pages(ip,
+                                       ctooff(offtoct(*offset)),
+                                       -1, FI_REMAPF_LOCKED);
                mutex_unlock(&inode->i_mutex);
                if (ret) {
                        xfs_iunlock(ip, XFS_IOLOCK_SHARED);
@@ -752,7 +753,8 @@ retry:
                        WARN_ON(need_i_mutex == 0);
                        xfs_inval_cached_trace(io, pos, -1,
                                        ctooff(offtoct(pos)), -1);
-                       error = bhv_vop_flushinval_pages(vp, ctooff(offtoct(pos)),
+                       error = xfs_flushinval_pages(xip,
+                                       ctooff(offtoct(pos)),
                                        -1, FI_REMAPF_LOCKED);
                        if (error)
                                goto out_unlock_internal;
index 2fbf24a6cf58880ebbc35483d6f6dd48d4977b04..42d6ed1788ff477c79cdf8fc7166fac4382e5cef 100644 (file)
@@ -46,6 +46,7 @@
 #include "xfs_attr.h"
 #include "xfs_buf_item.h"
 #include "xfs_utils.h"
+#include "xfs_vnodeops.h"
 #include "xfs_version.h"
 
 #include <linux/namei.h>
@@ -203,16 +204,15 @@ void
 xfs_initialize_vnode(
        bhv_desc_t              *bdp,
        bhv_vnode_t             *vp,
-       bhv_desc_t              *inode_bhv,
+       struct xfs_inode        *ip,
        int                     unlock)
 {
-       xfs_inode_t             *ip = XFS_BHVTOI(inode_bhv);
        struct inode            *inode = vn_to_inode(vp);
 
-       if (!inode_bhv->bd_vobj) {
+       if (!ip->i_vnode) {
                vp->v_vfsp = bhvtovfs(bdp);
-               bhv_desc_init(inode_bhv, ip, vp, &xfs_vnodeops);
-               bhv_insert(VN_BHV_HEAD(vp), inode_bhv);
+               ip->i_vnode = vp;
+               inode->i_private = ip;
        }
 
        /*
@@ -402,19 +402,23 @@ xfs_fs_write_inode(
        struct inode            *inode,
        int                     sync)
 {
-       bhv_vnode_t             *vp = vn_from_inode(inode);
        int                     error = 0, flags = FLUSH_INODE;
 
-       if (vp) {
-               vn_trace_entry(vp, __FUNCTION__, (inst_t *)__return_address);
-               if (sync) {
-                       filemap_fdatawait(inode->i_mapping);
-                       flags |= FLUSH_SYNC;
-               }
-               error = bhv_vop_iflush(vp, flags);
-               if (error == EAGAIN)
-                       error = sync? bhv_vop_iflush(vp, flags | FLUSH_LOG) : 0;
+       vn_trace_entry(vn_from_inode(inode), __FUNCTION__,
+                       (inst_t *)__return_address);
+       if (sync) {
+               filemap_fdatawait(inode->i_mapping);
+               flags |= FLUSH_SYNC;
        }
+       error = xfs_inode_flush(XFS_I(inode), flags);
+       if (error == EAGAIN) {
+               if (sync)
+                       error = xfs_inode_flush(XFS_I(inode),
+                                                      flags | FLUSH_LOG);
+               else
+                       error = 0;
+       }
+
        return -error;
 }
 
@@ -435,18 +439,18 @@ xfs_fs_clear_inode(
         * This can happen because xfs_iget_core calls xfs_idestroy if we
         * find an inode with di_mode == 0 but without IGET_CREATE set.
         */
-       if (VNHEAD(vp))
-               bhv_vop_inactive(vp, NULL);
+       if (XFS_I(inode))
+               xfs_inactive(XFS_I(inode));
 
        VN_LOCK(vp);
        vp->v_flag &= ~VMODIFIED;
        VN_UNLOCK(vp, 0);
 
-       if (VNHEAD(vp))
-               if (bhv_vop_reclaim(vp))
+       if (XFS_I(inode))
+               if (xfs_reclaim(XFS_I(inode)))
                        panic("%s: cannot reclaim 0x%p\n", __FUNCTION__, vp);
 
-       ASSERT(VNHEAD(vp) == NULL);
+       ASSERT(XFS_I(inode) == NULL);
 
 #ifdef XFS_VNODE_TRACE
        ktrace_free(vp->v_trace);
index 201cc3273c84da38ec921e35b115a1505d8678f4..ea2ee5a92637cf28d539b1c96df249b909fd4fbe 100644 (file)
@@ -107,7 +107,7 @@ struct block_device;
 
 extern __uint64_t xfs_max_file_offset(unsigned int);
 
-extern void xfs_initialize_vnode(bhv_desc_t *, bhv_vnode_t *, bhv_desc_t *, int);
+extern void xfs_initialize_vnode(bhv_desc_t *, bhv_vnode_t *, struct xfs_inode *, int);
 
 extern void xfs_flush_inode(struct xfs_inode *);
 extern void xfs_flush_device(struct xfs_inode *);
index 6145e8bd0be2f7a34bc95da993acae2ac2bfaa59..0dc87cd20229514bb15b658f3f071531a25d335c 100644 (file)
@@ -187,7 +187,7 @@ void
 vfs_init_vnode(
        struct bhv_desc         *bdp,
        struct bhv_vnode        *vp,
-       struct bhv_desc         *bp,
+       struct xfs_inode        *ip,
        int                     unlock)
 {
        struct bhv_desc         *next = bdp;
@@ -195,7 +195,7 @@ vfs_init_vnode(
        ASSERT(next);
        while (! (bhvtovfsops(next))->vfs_init_vnode)
                next = BHV_NEXT(next);
-       ((*bhvtovfsops(next)->vfs_init_vnode)(next, vp, bp, unlock));
+       ((*bhvtovfsops(next)->vfs_init_vnode)(next, vp, ip, unlock));
 }
 
 void
index dca3481aaafa4c0b71b2a550347d2c3c68dced8e..75994e1318bc0d30d767188640d6fac50f5b9e77 100644 (file)
@@ -28,6 +28,7 @@ struct fid;
 struct cred;
 struct seq_file;
 struct super_block;
+struct xfs_inode;
 struct xfs_mount_args;
 
 typedef struct kstatfs bhv_statvfs_t;
@@ -131,7 +132,7 @@ typedef int (*vfs_vget_t)(bhv_desc_t *, struct bhv_vnode **, struct fid *);
 typedef int    (*vfs_dmapiops_t)(bhv_desc_t *, caddr_t);
 typedef int    (*vfs_quotactl_t)(bhv_desc_t *, int, int, caddr_t);
 typedef void   (*vfs_init_vnode_t)(bhv_desc_t *,
-                               struct bhv_vnode *, bhv_desc_t *, int);
+                               struct bhv_vnode *, struct xfs_inode *, int);
 typedef void   (*vfs_force_shutdown_t)(bhv_desc_t *, int, char *, int);
 typedef void   (*vfs_freeze_t)(bhv_desc_t *);
 
@@ -201,7 +202,7 @@ extern int vfs_sync(bhv_desc_t *, int, struct cred *);
 extern int vfs_vget(bhv_desc_t *, struct bhv_vnode **, struct fid *);
 extern int vfs_dmapiops(bhv_desc_t *, caddr_t);
 extern int vfs_quotactl(bhv_desc_t *, int, int, caddr_t);
-extern void vfs_init_vnode(bhv_desc_t *, struct bhv_vnode *, bhv_desc_t *, int);
+extern void vfs_init_vnode(bhv_desc_t *, struct bhv_vnode *, struct xfs_inode *, int);
 extern void vfs_force_shutdown(bhv_desc_t *, int, char *, int);
 extern void vfs_freeze(bhv_desc_t *);
 
index ada24baf88de47dd6b8c150191ab6f2408589810..ad0494c5c0d16de1cb1f6ce4eea36c6d415aa435 100644 (file)
@@ -16,6 +16,9 @@
  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  */
 #include "xfs.h"
+#include "xfs_vnodeops.h"
+#include "xfs_bmap_btree.h"
+#include "xfs_inode.h"
 
 uint64_t vn_generation;                /* vnode generation number */
 DEFINE_SPINLOCK(vnumber_lock);
@@ -90,9 +93,6 @@ vn_initialize(
 
        ASSERT(VN_CACHED(vp) == 0);
 
-       /* Initialize the first behavior and the behavior chain head. */
-       vn_bhv_head_init(VN_BHV_HEAD(vp), "vnode");
-
        atomic_set(&vp->v_iocount, 0);
 
 #ifdef XFS_VNODE_TRACE
@@ -152,7 +152,7 @@ __vn_revalidate(
 
        vn_trace_entry(vp, __FUNCTION__, (inst_t *)__return_address);
        vattr->va_mask = XFS_AT_STAT | XFS_AT_XFLAGS;
-       error = bhv_vop_getattr(vp, vattr, 0, NULL);
+       error = xfs_getattr(xfs_vtoi(vp), vattr, 0);
        if (likely(!error)) {
                vn_revalidate_core(vp, vattr);
                VUNMODIFY(vp);
index bddbdb90423419966c9ef675828a797d3ed40226..5abcbd198d73f90d07078381a4f2c5f578920b40 100644 (file)
@@ -41,7 +41,6 @@ typedef struct bhv_vnode {
        bhv_vflags_t    v_flag;                 /* vnode flags (see above) */
        bhv_vfs_t       *v_vfsp;                /* ptr to containing VFS */
        bhv_vnumber_t   v_number;               /* in-core vnode number */
-       bhv_head_t      v_bh;                   /* behavior head */
        spinlock_t      v_lock;                 /* VN_LOCK/VN_UNLOCK */
        atomic_t        v_iocount;              /* outstanding I/O count */
 #ifdef XFS_VNODE_TRACE
@@ -57,34 +56,6 @@ typedef struct bhv_vnode {
 #define VN_ISCHR(vp)   S_ISCHR((vp)->v_inode.i_mode)
 #define VN_ISBLK(vp)   S_ISBLK((vp)->v_inode.i_mode)
 
-#define VNODE_POSITION_BASE    BHV_POSITION_BASE       /* chain bottom */
-#define VNODE_POSITION_TOP     BHV_POSITION_TOP        /* chain top */
-#define VNODE_POSITION_INVALID BHV_POSITION_INVALID    /* invalid pos. num */
-
-typedef enum {
-       VN_BHV_UNKNOWN,         /* not specified */
-       VN_BHV_XFS,             /* xfs */
-       VN_BHV_DM,              /* data migration */
-       VN_BHV_QM,              /* quota manager */
-       VN_BHV_IO,              /* IO path */
-       VN_BHV_END              /* housekeeping end-of-range */
-} vn_bhv_t;
-
-#define VNODE_POSITION_XFS     (VNODE_POSITION_BASE)
-#define VNODE_POSITION_DM      (VNODE_POSITION_BASE+10)
-#define VNODE_POSITION_QM      (VNODE_POSITION_BASE+20)
-#define VNODE_POSITION_IO      (VNODE_POSITION_BASE+30)
-
-/*
- * Macros for dealing with the behavior descriptor inside of the vnode.
- */
-#define BHV_TO_VNODE(bdp)      ((bhv_vnode_t *)BHV_VOBJ(bdp))
-#define BHV_TO_VNODE_NULL(bdp) ((bhv_vnode_t *)BHV_VOBJNULL(bdp))
-
-#define VN_BHV_HEAD(vp)                        ((bhv_head_t *)(&((vp)->v_bh)))
-#define vn_bhv_head_init(bhp,name)     bhv_head_init(bhp,name)
-#define vn_bhv_remove(bhp,bdp)         bhv_remove(bhp,bdp)
-
 /*
  * Vnode to Linux inode mapping.
  */
@@ -110,199 +81,13 @@ typedef enum bhv_vrwlock {
 } bhv_vrwlock_t;
 
 /*
- * Return values for bhv_vop_inactive.  A return value of
+ * Return values for xfs_inactive.  A return value of
  * VN_INACTIVE_NOCACHE implies that the file system behavior
  * has disassociated its state and bhv_desc_t from the vnode.
  */
 #define        VN_INACTIVE_CACHE       0
 #define        VN_INACTIVE_NOCACHE     1
 
-/*
- * Values for the cmd code given to vop_vnode_change.
- */
-typedef enum bhv_vchange {
-       VCHANGE_FLAGS_FRLOCKS           = 0,
-       VCHANGE_FLAGS_ENF_LOCKING       = 1,
-       VCHANGE_FLAGS_TRUNCATED         = 2,
-       VCHANGE_FLAGS_PAGE_DIRTY        = 3,
-       VCHANGE_FLAGS_IOEXCL_COUNT      = 4
-} bhv_vchange_t;
-
-typedef int    (*vop_open_t)(bhv_desc_t *, struct cred *);
-typedef ssize_t (*vop_read_t)(bhv_desc_t *, struct kiocb *,
-                               const struct iovec *, unsigned int,
-                               loff_t *, int, struct cred *);
-typedef ssize_t (*vop_write_t)(bhv_desc_t *, struct kiocb *,
-                               const struct iovec *, unsigned int,
-                               loff_t *, int, struct cred *);
-typedef ssize_t (*vop_splice_read_t)(bhv_desc_t *, struct file *, loff_t *,
-                               struct pipe_inode_info *, size_t, int, int,
-                               struct cred *);
-typedef ssize_t (*vop_splice_write_t)(bhv_desc_t *, struct pipe_inode_info *,
-                               struct file *, loff_t *, size_t, int, int,
-                               struct cred *);
-typedef int    (*vop_ioctl_t)(bhv_desc_t *, struct inode *, struct file *,
-                               int, unsigned int, void __user *);
-typedef int    (*vop_getattr_t)(bhv_desc_t *, struct bhv_vattr *, int,
-                               struct cred *);
-typedef int    (*vop_setattr_t)(bhv_desc_t *, struct bhv_vattr *, int,
-                               struct cred *);
-typedef int    (*vop_access_t)(bhv_desc_t *, int, struct cred *);
-typedef int    (*vop_lookup_t)(bhv_desc_t *, bhv_vname_t *, bhv_vnode_t **,
-                               int, bhv_vnode_t *, struct cred *);
-typedef int    (*vop_create_t)(bhv_desc_t *, bhv_vname_t *, struct bhv_vattr *,
-                               bhv_vnode_t **, struct cred *);
-typedef int    (*vop_remove_t)(bhv_desc_t *, bhv_vname_t *, struct cred *);
-typedef int    (*vop_link_t)(bhv_desc_t *, bhv_vnode_t *, bhv_vname_t *,
-                               struct cred *);
-typedef int    (*vop_rename_t)(bhv_desc_t *, bhv_vname_t *, bhv_vnode_t *,
-                               bhv_vname_t *, struct cred *);
-typedef int    (*vop_mkdir_t)(bhv_desc_t *, bhv_vname_t *, struct bhv_vattr *,
-                               bhv_vnode_t **, struct cred *);
-typedef int    (*vop_rmdir_t)(bhv_desc_t *, bhv_vname_t *, struct cred *);
-typedef int    (*vop_readdir_t)(bhv_desc_t *, void *dirent, size_t bufsize,
-                                xfs_off_t *offset, filldir_t filldir);
-typedef int    (*vop_symlink_t)(bhv_desc_t *, bhv_vname_t *, struct bhv_vattr*,
-                               char *, bhv_vnode_t **, struct cred *);
-typedef int    (*vop_readlink_t)(bhv_desc_t *, char *);
-typedef int    (*vop_fsync_t)(bhv_desc_t *, int, struct cred *,
-                               xfs_off_t, xfs_off_t);
-typedef int    (*vop_inactive_t)(bhv_desc_t *, struct cred *);
-typedef int    (*vop_fid2_t)(bhv_desc_t *, struct fid *);
-typedef int    (*vop_release_t)(bhv_desc_t *);
-typedef int    (*vop_rwlock_t)(bhv_desc_t *, bhv_vrwlock_t);
-typedef void   (*vop_rwunlock_t)(bhv_desc_t *, bhv_vrwlock_t);
-typedef int    (*vop_bmap_t)(bhv_desc_t *, xfs_off_t, ssize_t, int,
-                               struct xfs_iomap *, int *);
-typedef int    (*vop_reclaim_t)(bhv_desc_t *);
-typedef int    (*vop_attr_get_t)(bhv_desc_t *, const char *, char *, int *,
-                               int, struct cred *);
-typedef        int     (*vop_attr_set_t)(bhv_desc_t *, const char *, char *, int,
-                               int, struct cred *);
-typedef        int     (*vop_attr_remove_t)(bhv_desc_t *, const char *,
-                               int, struct cred *);
-typedef        int     (*vop_attr_list_t)(bhv_desc_t *, char *, int, int,
-                               struct attrlist_cursor_kern *, struct cred *);
-typedef void   (*vop_link_removed_t)(bhv_desc_t *, bhv_vnode_t *, int);
-typedef void   (*vop_vnode_change_t)(bhv_desc_t *, bhv_vchange_t, __psint_t);
-typedef void   (*vop_ptossvp_t)(bhv_desc_t *, xfs_off_t, xfs_off_t, int);
-typedef int    (*vop_pflushinvalvp_t)(bhv_desc_t *, xfs_off_t, xfs_off_t, int);
-typedef int    (*vop_pflushvp_t)(bhv_desc_t *, xfs_off_t, xfs_off_t,
-                               uint64_t, int);
-typedef int    (*vop_iflush_t)(bhv_desc_t *, int);
-
-
-typedef struct bhv_vnodeops {
-       bhv_position_t  vn_position;    /* position within behavior chain */
-       vop_open_t              vop_open;
-       vop_read_t              vop_read;
-       vop_write_t             vop_write;
-       vop_splice_read_t       vop_splice_read;
-       vop_splice_write_t      vop_splice_write;
-       vop_ioctl_t             vop_ioctl;
-       vop_getattr_t           vop_getattr;
-       vop_setattr_t           vop_setattr;
-       vop_access_t            vop_access;
-       vop_lookup_t            vop_lookup;
-       vop_create_t            vop_create;
-       vop_remove_t            vop_remove;
-       vop_link_t              vop_link;
-       vop_rename_t            vop_rename;
-       vop_mkdir_t             vop_mkdir;
-       vop_rmdir_t             vop_rmdir;
-       vop_readdir_t           vop_readdir;
-       vop_symlink_t           vop_symlink;
-       vop_readlink_t          vop_readlink;
-       vop_fsync_t             vop_fsync;
-       vop_inactive_t          vop_inactive;
-       vop_fid2_t              vop_fid2;
-       vop_rwlock_t            vop_rwlock;
-       vop_rwunlock_t          vop_rwunlock;
-       vop_bmap_t              vop_bmap;
-       vop_reclaim_t           vop_reclaim;
-       vop_attr_get_t          vop_attr_get;
-       vop_attr_set_t          vop_attr_set;
-       vop_attr_remove_t       vop_attr_remove;
-       vop_attr_list_t         vop_attr_list;
-       vop_link_removed_t      vop_link_removed;
-       vop_vnode_change_t      vop_vnode_change;
-       vop_ptossvp_t           vop_tosspages;
-       vop_pflushinvalvp_t     vop_flushinval_pages;
-       vop_pflushvp_t          vop_flush_pages;
-       vop_release_t           vop_release;
-       vop_iflush_t            vop_iflush;
-} bhv_vnodeops_t;
-
-/*
- * Virtual node operations, operating from head bhv.
- */
-#define VNHEAD(vp)     ((vp)->v_bh.bh_first)
-#define VOP(op, vp)    (*((bhv_vnodeops_t *)VNHEAD(vp)->bd_ops)->op)
-#define bhv_vop_open(vp, cr)           VOP(vop_open, vp)(VNHEAD(vp),cr)
-#define bhv_vop_read(vp,file,iov,segs,offset,ioflags,cr)               \
-               VOP(vop_read, vp)(VNHEAD(vp),file,iov,segs,offset,ioflags,cr)
-#define bhv_vop_write(vp,file,iov,segs,offset,ioflags,cr)              \
-               VOP(vop_write, vp)(VNHEAD(vp),file,iov,segs,offset,ioflags,cr)
-#define bhv_vop_splice_read(vp,f,o,pipe,cnt,fl,iofl,cr)                        \
-               VOP(vop_splice_read, vp)(VNHEAD(vp),f,o,pipe,cnt,fl,iofl,cr)
-#define bhv_vop_splice_write(vp,f,o,pipe,cnt,fl,iofl,cr)               \
-               VOP(vop_splice_write, vp)(VNHEAD(vp),f,o,pipe,cnt,fl,iofl,cr)
-#define bhv_vop_bmap(vp,of,sz,rw,b,n)                                  \
-               VOP(vop_bmap, vp)(VNHEAD(vp),of,sz,rw,b,n)
-#define bhv_vop_getattr(vp, vap,f,cr)                                  \
-               VOP(vop_getattr, vp)(VNHEAD(vp), vap,f,cr)
-#define        bhv_vop_setattr(vp, vap,f,cr)                                   \
-               VOP(vop_setattr, vp)(VNHEAD(vp), vap,f,cr)
-#define        bhv_vop_access(vp, mode,cr)     VOP(vop_access, vp)(VNHEAD(vp), mode,cr)
-#define        bhv_vop_lookup(vp,d,vpp,f,rdir,cr)                              \
-               VOP(vop_lookup, vp)(VNHEAD(vp),d,vpp,f,rdir,cr)
-#define bhv_vop_create(dvp,d,vap,vpp,cr)                               \
-               VOP(vop_create, dvp)(VNHEAD(dvp),d,vap,vpp,cr)
-#define bhv_vop_remove(dvp,d,cr)       VOP(vop_remove, dvp)(VNHEAD(dvp),d,cr)
-#define        bhv_vop_link(dvp,fvp,d,cr)      VOP(vop_link, dvp)(VNHEAD(dvp),fvp,d,cr)
-#define        bhv_vop_rename(fvp,fnm,tdvp,tnm,cr)                             \
-               VOP(vop_rename, fvp)(VNHEAD(fvp),fnm,tdvp,tnm,cr)
-#define        bhv_vop_mkdir(dp,d,vap,vpp,cr)                                  \
-               VOP(vop_mkdir, dp)(VNHEAD(dp),d,vap,vpp,cr)
-#define        bhv_vop_rmdir(dp,d,cr)          VOP(vop_rmdir, dp)(VNHEAD(dp),d,cr)
-#define        bhv_vop_readdir(vp,dirent,bufsize,offset,filldir)               \
-               VOP(vop_readdir, vp)(VNHEAD(vp),dirent,bufsize,offset,filldir)
-#define        bhv_vop_symlink(dvp,d,vap,tnm,vpp,cr)                           \
-               VOP(vop_symlink, dvp)(VNHEAD(dvp),d,vap,tnm,vpp,cr)
-#define        bhv_vop_readlink(vp,link)                                       \
-               VOP(vop_readlink, vp)(VNHEAD(vp), link)
-#define        bhv_vop_fsync(vp,f,cr,b,e)      VOP(vop_fsync, vp)(VNHEAD(vp),f,cr,b,e)
-#define bhv_vop_inactive(vp,cr)                VOP(vop_inactive, vp)(VNHEAD(vp),cr)
-#define bhv_vop_release(vp)            VOP(vop_release, vp)(VNHEAD(vp))
-#define bhv_vop_fid2(vp,fidp)          VOP(vop_fid2, vp)(VNHEAD(vp),fidp)
-#define bhv_vop_rwlock(vp,i)           VOP(vop_rwlock, vp)(VNHEAD(vp),i)
-#define bhv_vop_rwlock_try(vp,i)       VOP(vop_rwlock, vp)(VNHEAD(vp),i)
-#define bhv_vop_rwunlock(vp,i)         VOP(vop_rwunlock, vp)(VNHEAD(vp),i)
-#define bhv_vop_frlock(vp,c,fl,flags,offset,fr)                                \
-               VOP(vop_frlock, vp)(VNHEAD(vp),c,fl,flags,offset,fr)
-#define bhv_vop_reclaim(vp)            VOP(vop_reclaim, vp)(VNHEAD(vp))
-#define bhv_vop_attr_get(vp, name, val, vallenp, fl, cred)             \
-               VOP(vop_attr_get, vp)(VNHEAD(vp),name,val,vallenp,fl,cred)
-#define        bhv_vop_attr_set(vp, name, val, vallen, fl, cred)               \
-               VOP(vop_attr_set, vp)(VNHEAD(vp),name,val,vallen,fl,cred)
-#define        bhv_vop_attr_remove(vp, name, flags, cred)                      \
-               VOP(vop_attr_remove, vp)(VNHEAD(vp),name,flags,cred)
-#define        bhv_vop_attr_list(vp, buf, buflen, fl, cursor, cred)            \
-               VOP(vop_attr_list, vp)(VNHEAD(vp),buf,buflen,fl,cursor,cred)
-#define bhv_vop_link_removed(vp, dvp, linkzero)                                \
-               VOP(vop_link_removed, vp)(VNHEAD(vp), dvp, linkzero)
-#define bhv_vop_vnode_change(vp, cmd, val)                             \
-               VOP(vop_vnode_change, vp)(VNHEAD(vp), cmd, val)
-#define bhv_vop_toss_pages(vp, first, last, fiopt)                     \
-               VOP(vop_tosspages, vp)(VNHEAD(vp), first, last, fiopt)
-#define bhv_vop_flushinval_pages(vp, first, last, fiopt)               \
-               VOP(vop_flushinval_pages, vp)(VNHEAD(vp),first,last,fiopt)
-#define bhv_vop_flush_pages(vp, first, last, flags, fiopt)             \
-               VOP(vop_flush_pages, vp)(VNHEAD(vp),first,last,flags,fiopt)
-#define bhv_vop_ioctl(vp, inode, filp, fl, cmd, arg)                   \
-               VOP(vop_ioctl, vp)(VNHEAD(vp),inode,filp,fl,cmd,arg)
-#define bhv_vop_iflush(vp, flags)      VOP(vop_iflush, vp)(VNHEAD(vp), flags)
-
 /*
  * Flags for read/write calls - same values as IRIX
  */
index 4ca4beb7bb546b6fce761d4d8cc29fefdbb7732b..034c5ea80dd14f694c4f65ed9034a9adc93396e0 100644 (file)
@@ -32,6 +32,7 @@
 #include "xfs_btree.h"
 #include "xfs_acl.h"
 #include "xfs_attr.h"
+#include "xfs_vnodeops.h"
 
 #include <linux/capability.h>
 #include <linux/posix_acl_xattr.h>
@@ -241,7 +242,7 @@ xfs_acl_vget(
                        bhv_vattr_t     va;
 
                        va.va_mask = XFS_AT_MODE;
-                       error = bhv_vop_getattr(vp, &va, 0, sys_cred);
+                       error = xfs_getattr(xfs_vtoi(vp), &va, 0);
                        if (error)
                                goto out;
                        xfs_acl_sync_mode(va.va_mode, xfs_acl);
@@ -265,9 +266,10 @@ xfs_acl_vremove(
        VN_HOLD(vp);
        error = xfs_acl_allow_set(vp, kind);
        if (!error) {
-               error = bhv_vop_attr_remove(vp, kind == _ACL_TYPE_DEFAULT?
+               error = xfs_attr_remove(xfs_vtoi(vp),
+                                               kind == _ACL_TYPE_DEFAULT?
                                                SGI_ACL_DEFAULT: SGI_ACL_FILE,
-                                               ATTR_ROOT, sys_cred);
+                                               ATTR_ROOT);
                if (error == ENOATTR)
                        error = 0;      /* 'scool */
        }
@@ -380,7 +382,7 @@ xfs_acl_allow_set(
        if (vp->v_vfsp->vfs_flag & VFS_RDONLY)
                return EROFS;
        va.va_mask = XFS_AT_UID;
-       error = bhv_vop_getattr(vp, &va, 0, NULL);
+       error = xfs_getattr(xfs_vtoi(vp), &va, 0);
        if (error)
                return error;
        if (va.va_uid != current->fsuid && !capable(CAP_FOWNER))
@@ -613,7 +615,8 @@ xfs_acl_get_attr(
 
        ASSERT((flags & ATTR_KERNOVAL) ? (aclp == NULL) : 1);
        flags |= ATTR_ROOT;
-       *error = bhv_vop_attr_get(vp, kind == _ACL_TYPE_ACCESS ?
+       *error = xfs_attr_get(xfs_vtoi(vp),
+                                       kind == _ACL_TYPE_ACCESS ?
                                        SGI_ACL_FILE : SGI_ACL_DEFAULT,
                                        (char *)aclp, &len, flags, sys_cred);
        if (*error || (flags & ATTR_KERNOVAL))
@@ -651,9 +654,10 @@ xfs_acl_set_attr(
                INT_SET(newace->ae_perm, ARCH_CONVERT, ace->ae_perm);
        }
        INT_SET(newacl->acl_cnt, ARCH_CONVERT, aclp->acl_cnt);
-       *error = bhv_vop_attr_set(vp, kind == _ACL_TYPE_ACCESS ?
+       *error = xfs_attr_set(xfs_vtoi(vp),
+                               kind == _ACL_TYPE_ACCESS ?
                                SGI_ACL_FILE: SGI_ACL_DEFAULT,
-                               (char *)newacl, len, ATTR_ROOT, sys_cred);
+                               (char *)newacl, len, ATTR_ROOT);
        _ACL_FREE(newacl);
 }
 
@@ -675,7 +679,7 @@ xfs_acl_vtoacl(
                if (!error) {
                        /* Got the ACL, need the mode... */
                        va.va_mask = XFS_AT_MODE;
-                       error = bhv_vop_getattr(vp, &va, 0, sys_cred);
+                       error = xfs_getattr(xfs_vtoi(vp), &va, 0);
                }
 
                if (error)
@@ -773,7 +777,7 @@ xfs_acl_setmode(
         * mode.  The m:: bits take precedence over the g:: bits.
         */
        va.va_mask = XFS_AT_MODE;
-       error = bhv_vop_getattr(vp, &va, 0, sys_cred);
+       error = xfs_getattr(xfs_vtoi(vp), &va, 0);
        if (error)
                return error;
 
@@ -807,7 +811,7 @@ xfs_acl_setmode(
        if (gap && nomask)
                va.va_mode |= gap->ae_perm << 3;
 
-       return bhv_vop_setattr(vp, &va, 0, sys_cred);
+       return xfs_setattr(xfs_vtoi(vp), &va, 0, sys_cred);
 }
 
 /*
index 1a10bffc77555db17864b67af48956e5c3db4623..93fa64dd1be6ab49287bc5a1e8a4659767fa20f0 100644 (file)
@@ -49,6 +49,7 @@
 #include "xfs_trans_space.h"
 #include "xfs_acl.h"
 #include "xfs_rw.h"
+#include "xfs_vnodeops.h"
 
 /*
  * xfs_attr.c
@@ -2512,7 +2513,7 @@ STATIC int
 attr_generic_set(
        bhv_vnode_t *vp, char *name, void *data, size_t size, int xflags)
 {
-       return -bhv_vop_attr_set(vp, name, data, size, xflags, NULL);
+       return -xfs_attr_set(xfs_vtoi(vp), name, data, size, xflags);
 }
 
 STATIC int
@@ -2521,7 +2522,8 @@ attr_generic_get(
 {
        int     error, asize = size;
 
-       error = bhv_vop_attr_get(vp, name, data, &asize, xflags, NULL);
+       error = xfs_attr_get(xfs_vtoi(vp), name, data,
+                                   &asize, xflags, NULL);
        if (!error)
                return asize;
        return -error;
@@ -2531,7 +2533,7 @@ STATIC int
 attr_generic_remove(
        bhv_vnode_t *vp, char *name, int xflags)
 {
-       return -bhv_vop_attr_remove(vp, name, xflags, NULL);
+       return -xfs_attr_remove(xfs_vtoi(vp), name, xflags);
 }
 
 STATIC int
@@ -2586,7 +2588,7 @@ attr_generic_list(
        attrlist_cursor_kern_t  cursor = { 0 };
        int                     error;
 
-       error = bhv_vop_attr_list(vp, data, size, xflags, &cursor, NULL);
+       error = xfs_attr_list(xfs_vtoi(vp), data, size, xflags, &cursor);
        if (error > 0)
                return -error;
        *result = -error;
index 16b97db4f8aa7edab1628082ca8a6cbbe9b7c0b7..2e9b34b7344b4e81f268db68428e45e9363ef787 100644 (file)
@@ -53,6 +53,7 @@
 #include "xfs_trans_space.h"
 #include "xfs_buf_item.h"
 #include "xfs_filestream.h"
+#include "xfs_vnodeops.h"
 
 
 #ifdef DEBUG
@@ -5868,7 +5869,8 @@ xfs_getbmap(
        if (whichfork == XFS_DATA_FORK &&
                (ip->i_delayed_blks || ip->i_size > ip->i_d.di_size)) {
                /* xfs_fsize_t last_byte = xfs_file_last_byte(ip); */
-               error = bhv_vop_flush_pages(vp, (xfs_off_t)0, -1, 0, FI_REMAPF);
+               error = xfs_flush_pages(ip, (xfs_off_t)0,
+                                              -1, 0, FI_REMAPF);
        }
 
        ASSERT(whichfork == XFS_ATTR_FORK || ip->i_delayed_blks == 0);
index de35d18cc002c5eefcf7c631143bdfacef753bf9..584f1ae85cd9b9537dcf6d052aaf796f81ac0a5b 100644 (file)
@@ -42,6 +42,7 @@
 #include "xfs_dfrag.h"
 #include "xfs_error.h"
 #include "xfs_rw.h"
+#include "xfs_vnodeops.h"
 
 /*
  * Syssgi interface for swapext
@@ -199,7 +200,8 @@ xfs_swap_extents(
 
        if (VN_CACHED(tvp) != 0) {
                xfs_inval_cached_trace(&tip->i_iocore, 0, -1, 0, -1);
-               error = bhv_vop_flushinval_pages(tvp, 0, -1, FI_REMAPF_LOCKED);
+               error = xfs_flushinval_pages(tip, 0, -1,
+                               FI_REMAPF_LOCKED);
                if (error)
                        goto error0;
        }
@@ -265,7 +267,7 @@ xfs_swap_extents(
         * fields change.
         */
 
-       bhv_vop_toss_pages(vp, 0, -1, FI_REMAPF);
+       xfs_tosspages(ip, 0, -1, FI_REMAPF);
 
        tp = xfs_trans_alloc(mp, XFS_TRANS_SWAPEXT);
        if ((error = xfs_trans_reserve(tp, 0,
index e07dcc1b70a6b6f9bc88bbef7e988b8c969da234..5806597b9ec4f9c57488326454a3f2f257775d1a 100644 (file)
@@ -342,7 +342,7 @@ finish_inode:
         * If we have a real type for an on-disk inode, we can set ops(&unlock)
         * now.  If it's a new inode being created, xfs_ialloc will handle it.
         */
-       bhv_vfs_init_vnode(XFS_MTOVFS(mp), vp, XFS_ITOBHV(ip), 1);
+       bhv_vfs_init_vnode(XFS_MTOVFS(mp), vp, ip, 1);
 
        return 0;
 }
@@ -536,7 +536,8 @@ xfs_ireclaim(xfs_inode_t *ip)
         */
        vp = XFS_ITOV_NULL(ip);
        if (vp) {
-               vn_bhv_remove(VN_BHV_HEAD(vp), XFS_ITOBHV(ip));
+               vn_to_inode(vp)->i_private = NULL;
+               ip->i_vnode = NULL;
        }
 
        /*
index c1b917bd5951e421aa517beee3a2046afa17266b..c2fc4838a5fa188b33d5df69e92b3b88c524028c 100644 (file)
@@ -49,6 +49,7 @@
 #include "xfs_quota.h"
 #include "xfs_acl.h"
 #include "xfs_filestream.h"
+#include "xfs_vnodeops.h"
 
 kmem_zone_t *xfs_ifork_zone;
 kmem_zone_t *xfs_inode_zone;
@@ -1267,7 +1268,7 @@ xfs_ialloc(
        xfs_trans_log_inode(tp, ip, flags);
 
        /* now that we have an i_mode we can setup inode ops and unlock */
-       bhv_vfs_init_vnode(XFS_MTOVFS(tp->t_mountp), vp, XFS_ITOBHV(ip), 1);
+       bhv_vfs_init_vnode(XFS_MTOVFS(tp->t_mountp), vp, ip, 1);
 
        *ipp = ip;
        return 0;
@@ -1489,9 +1490,11 @@ xfs_itruncate_start(
                         last_byte);
        if (last_byte > toss_start) {
                if (flags & XFS_ITRUNC_DEFINITE) {
-                       bhv_vop_toss_pages(vp, toss_start, -1, FI_REMAPF_LOCKED);
+                       xfs_tosspages(ip, toss_start,
+                                       -1, FI_REMAPF_LOCKED);
                } else {
-                       error = bhv_vop_flushinval_pages(vp, toss_start, -1, FI_REMAPF_LOCKED);
+                       error = xfs_flushinval_pages(ip, toss_start,
+                                       -1, FI_REMAPF_LOCKED);
                }
        }
 
index b6dd23d9b3d63e69b7a50013a4354a16aa8084ea..6f88ac3b10ae3e3f44faccc8943de04746f2b2e6 100644 (file)
@@ -257,7 +257,7 @@ typedef struct xfs_inode {
        struct xfs_inode        *i_mprev;       /* ptr to prev inode */
        struct xfs_mount        *i_mount;       /* fs mount struct ptr */
        struct list_head        i_reclaim;      /* reclaim list */
-       struct bhv_desc         i_bhv_desc;     /* inode behavior descriptor*/
+       struct bhv_vnode        *i_vnode;       /* vnode backpointer */
        struct xfs_dquot        *i_udquot;      /* user dquot */
        struct xfs_dquot        *i_gdquot;      /* group dquot */
 
@@ -465,12 +465,8 @@ xfs_iflags_test(xfs_inode_t *ip, unsigned short flags)
 #define        XFS_ITRUNC_DEFINITE     0x1
 #define        XFS_ITRUNC_MAYBE        0x2
 
-#define        XFS_ITOV(ip)            BHV_TO_VNODE(XFS_ITOBHV(ip))
-#define        XFS_ITOV_NULL(ip)       BHV_TO_VNODE_NULL(XFS_ITOBHV(ip))
-#define        XFS_ITOBHV(ip)          ((struct bhv_desc *)(&((ip)->i_bhv_desc)))
-#define        XFS_BHVTOI(bhvp)        ((xfs_inode_t *)((char *)(bhvp) - \
-                               (char *)&(((xfs_inode_t *)0)->i_bhv_desc)))
-#define BHV_IS_XFS(bdp)                (BHV_OPS(bdp) == &xfs_vnodeops)
+#define        XFS_ITOV(ip)            ((ip)->i_vnode)
+#define        XFS_ITOV_NULL(ip)       ((ip)->i_vnode)
 
 /*
  * For multiple groups support: if S_ISGID bit is set in the parent
@@ -557,8 +553,6 @@ void                xfs_ichgtime(xfs_inode_t *, int);
 xfs_fsize_t    xfs_file_last_byte(xfs_inode_t *);
 void           xfs_lock_inodes(xfs_inode_t **, int, int, uint);
 
-xfs_inode_t    *xfs_vtoi(struct bhv_vnode *vp);
-
 void           xfs_synchronize_atime(xfs_inode_t *);
 
 xfs_bmbt_rec_host_t *xfs_iext_get_ext(xfs_ifork_t *, xfs_extnum_t);
index bc23cb407701328c2bf33666faba1eb52d8be3f3..f5e32f43cd6298cf02da2ad5a628e50adf533add 100644 (file)
@@ -66,7 +66,6 @@ struct xfs_swapext;
 struct xfs_mru_cache;
 
 extern struct bhv_vfsops xfs_vfsops;
-extern struct bhv_vnodeops xfs_vnodeops;
 
 #define        AIL_LOCK_T              lock_t
 #define        AIL_LOCKINIT(x,y)       spinlock_init(x,y)
index b62b8771afcf1e1440ec435dcb8c2baf46cb0b2e..2f5c8740b25c2cf1b332fd88708dc8a23f98006c 100644 (file)
@@ -586,11 +586,8 @@ xfs_rename(
        /*
         * Let interposed file systems know about removed links.
         */
-       if (target_ip_dropped) {
-               bhv_vop_link_removed(XFS_ITOV(target_ip), target_dir_vp,
-                                       target_link_zero);
+       if (target_ip_dropped)
                IRELE(target_ip);
-       }
 
        IRELE(src_ip);
 
index b4db8a208076a242734a443730f50c78261180c9..a9cebcb0b33b96472fc0e36d8dc3cc2de6cc583d 100644 (file)
@@ -54,6 +54,8 @@
 #include "xfs_mru_cache.h"
 #include "xfs_filestream.h"
 #include "xfs_fsops.h"
+#include "xfs_vnodeops.h"
+
 
 STATIC int     xfs_sync(bhv_desc_t *, int, cred_t *);
 
@@ -1191,12 +1193,13 @@ xfs_sync_inodes(
                        if (flags & SYNC_CLOSE) {
                                /* Shutdown case. Flush and invalidate. */
                                if (XFS_FORCED_SHUTDOWN(mp))
-                                       bhv_vop_toss_pages(vp, 0, -1, FI_REMAPF);
+                                       xfs_tosspages(ip, 0, -1,
+                                                            FI_REMAPF);
                                else
-                                       error = bhv_vop_flushinval_pages(vp, 0,
-                                                               -1, FI_REMAPF);
+                                       error = xfs_flushinval_pages(ip,
+                                                       0, -1, FI_REMAPF);
                        } else if ((flags & SYNC_DELWRI) && VN_DIRTY(vp)) {
-                               error = bhv_vop_flush_pages(vp, (xfs_off_t)0,
+                               error = xfs_flush_pages(ip, 0,
                                                        -1, fflag, FI_NONE);
                        }
 
index 2b30fa690b4aaaa6346553caf968afce76ef1c3b..5eb392d062983555ddb819aa7df8290cbd467e30 100644 (file)
@@ -592,7 +592,7 @@ xfs_setattr(
                if (!code &&
                    (ip->i_size != ip->i_d.di_size) &&
                    (vap->va_size > ip->i_d.di_size)) {
-                       code = bhv_vop_flush_pages(XFS_ITOV(ip),
+                       code = xfs_flush_pages(ip,
                                        ip->i_d.di_size, vap->va_size,
                                        XFS_B_ASYNC, FI_NONE);
                }
@@ -864,10 +864,6 @@ xfs_setattr(
         * racing calls to vop_vnode_change.
         */
        mandlock_after = MANDLOCK(vp, ip->i_d.di_mode);
-       if (mandlock_before != mandlock_after) {
-               bhv_vop_vnode_change(vp, VCHANGE_FLAGS_ENF_LOCKING,
-                                mandlock_after);
-       }
 
        xfs_iunlock(ip, lock_flags);
 
@@ -1544,7 +1540,7 @@ xfs_release(
                 * be exposed to that problem.
                 */
                if (VUNTRUNCATE(vp) && VN_DIRTY(vp) && ip->i_delayed_blks > 0)
-                       bhv_vop_flush_pages(vp, 0, -1, XFS_B_ASYNC, FI_NONE);
+                       xfs_flush_pages(ip, 0, -1, XFS_B_ASYNC, FI_NONE);
        }
 
 #ifdef HAVE_REFCACHE
@@ -2008,12 +2004,6 @@ xfs_create(
        XFS_QM_DQRELE(mp, udqp);
        XFS_QM_DQRELE(mp, gdqp);
 
-       /*
-        * Propagate the fact that the vnode changed after the
-        * xfs_inode locks have been released.
-        */
-       bhv_vop_vnode_change(vp, VCHANGE_FLAGS_TRUNCATED, 3);
-
        *vpp = vp;
 
        /* Fallthrough to std_return with error = 0  */
@@ -2512,11 +2502,6 @@ xfs_remove(
 
        vn_trace_exit(XFS_ITOV(ip), __FUNCTION__, (inst_t *)__return_address);
 
-       /*
-        * Let interposed file systems know about removed links.
-        */
-       bhv_vop_link_removed(XFS_ITOV(ip), dir_vp, link_zero);
-
        IRELE(ip);
 
 /*     Fall through to std_return with error = 0 */
@@ -3146,11 +3131,6 @@ xfs_rmdir(
        }
 
 
-       /*
-        * Let interposed file systems know about removed links.
-        */
-       bhv_vop_link_removed(XFS_ITOV(cdp), dir_vp, last_cdp_link);
-
        IRELE(cdp);
 
        /* Fall through to std_return with error = 0 or the errno
@@ -3732,7 +3712,8 @@ xfs_reclaim(
                XFS_MOUNT_ILOCK(mp);
                spin_lock(&ip->i_flags_lock);
                __xfs_iflags_set(ip, XFS_IRECLAIMABLE);
-               vn_bhv_remove(VN_BHV_HEAD(vp), XFS_ITOBHV(ip));
+               vn_to_inode(vp)->i_private = NULL;
+               ip->i_vnode = NULL;
                spin_unlock(&ip->i_flags_lock);
                list_add_tail(&ip->i_reclaim, &mp->m_del_inodes);
                XFS_MOUNT_IUNLOCK(mp);
@@ -4214,7 +4195,8 @@ xfs_free_file_space(
        if (VN_CACHED(vp) != 0) {
                xfs_inval_cached_trace(&ip->i_iocore, ioffset, -1,
                                ctooff(offtoct(ioffset)), -1);
-               error = bhv_vop_flushinval_pages(vp, ctooff(offtoct(ioffset)),
+               error = xfs_flushinval_pages(ip,
+                               ctooff(offtoct(ioffset)),
                                -1, FI_REMAPF_LOCKED);
                if (error)
                        goto out_unlock_iolock;
diff --git a/fs/xfs/xfs_vnodeops_bhv.c b/fs/xfs/xfs_vnodeops_bhv.c
deleted file mode 100644 (file)
index c61653a..0000000
+++ /dev/null
@@ -1,438 +0,0 @@
-
-#include "xfs_linux.h"
-#include "xfs_vnodeops.h"
-
-#include "xfs_bmap_btree.h"
-#include "xfs_inode.h"
-
-STATIC int
-xfs_bhv_open(
-       bhv_desc_t      *bdp,
-       cred_t          *credp)
-{
-       return xfs_open(XFS_BHVTOI(bdp));
-}
-
-STATIC int
-xfs_bhv_getattr(
-       bhv_desc_t      *bdp,
-       bhv_vattr_t     *vap,
-       int             flags,
-       cred_t          *credp)
-{
-       return xfs_getattr(XFS_BHVTOI(bdp), vap, flags);
-}
-
-int
-xfs_bhv_setattr(
-       bhv_desc_t              *bdp,
-       bhv_vattr_t             *vap,
-       int                     flags,
-       cred_t                  *credp)
-{
-       return xfs_setattr(XFS_BHVTOI(bdp), vap, flags, credp);
-}
-
-STATIC int
-xfs_bhv_access(
-       bhv_desc_t      *bdp,
-       int             mode,
-       cred_t          *credp)
-{
-       return xfs_access(XFS_BHVTOI(bdp), mode, credp);
-}
-
-STATIC int
-xfs_bhv_readlink(
-       bhv_desc_t      *bdp,
-       char            *link)
-{
-       return xfs_readlink(XFS_BHVTOI(bdp), link);
-}
-
-STATIC int
-xfs_bhv_fsync(
-       bhv_desc_t      *bdp,
-       int             flag,
-       cred_t          *credp,
-       xfs_off_t       start,
-       xfs_off_t       stop)
-{
-       return xfs_fsync(XFS_BHVTOI(bdp), flag, start, stop);
-}
-
-STATIC int
-xfs_bhv_release(
-       bhv_desc_t      *bdp)
-{
-       return xfs_release(XFS_BHVTOI(bdp));
-}
-
-STATIC int
-xfs_bhv_inactive(
-       bhv_desc_t      *bdp,
-       cred_t          *credp)
-{
-       return xfs_inactive(XFS_BHVTOI(bdp));
-}
-
-STATIC int
-xfs_bhv_lookup(
-       bhv_desc_t              *dir_bdp,
-       bhv_vname_t             *dentry,
-       bhv_vnode_t             **vpp,
-       int                     flags,
-       bhv_vnode_t             *rdir,
-       cred_t                  *credp)
-{
-       return xfs_lookup(XFS_BHVTOI(dir_bdp), dentry, vpp);
-}
-
-STATIC int
-xfs_bhv_create(
-       bhv_desc_t              *dir_bdp,
-       bhv_vname_t             *dentry,
-       bhv_vattr_t             *vap,
-       bhv_vnode_t             **vpp,
-       cred_t                  *credp)
-{
-       return xfs_create(XFS_BHVTOI(dir_bdp), dentry, vap, vpp, credp);
-}
-
-STATIC int
-xfs_bhv_remove(
-       bhv_desc_t              *dir_bdp,
-       bhv_vname_t             *dentry,
-       cred_t                  *credp)
-{
-       return xfs_remove(XFS_BHVTOI(dir_bdp), dentry);
-}
-
-STATIC int
-xfs_bhv_link(
-       bhv_desc_t              *target_dir_bdp,
-       bhv_vnode_t             *src_vp,
-       bhv_vname_t             *dentry,
-       cred_t                  *credp)
-{
-       return xfs_link(XFS_BHVTOI(target_dir_bdp), src_vp, dentry);
-}
-
-STATIC int
-xfs_bhv_mkdir(
-       bhv_desc_t              *dir_bdp,
-       bhv_vname_t             *dentry,
-       bhv_vattr_t             *vap,
-       bhv_vnode_t             **vpp,
-       cred_t                  *credp)
-{
-       return xfs_mkdir(XFS_BHVTOI(dir_bdp), dentry, vap, vpp, credp);
-}
-
-STATIC int
-xfs_bhv_rmdir(
-       bhv_desc_t              *dir_bdp,
-       bhv_vname_t             *dentry,
-       cred_t                  *credp)
-{
-       return xfs_rmdir(XFS_BHVTOI(dir_bdp), dentry);
-}
-
-STATIC int
-xfs_bhv_readdir(
-       bhv_desc_t      *dir_bdp,
-       void            *dirent,
-       size_t          bufsize,
-       xfs_off_t       *offset,
-       filldir_t       filldir)
-{
-       return xfs_readdir(XFS_BHVTOI(dir_bdp), dirent, bufsize, offset, filldir);
-}
-
-STATIC int
-xfs_bhv_symlink(
-       bhv_desc_t              *dir_bdp,
-       bhv_vname_t             *dentry,
-       bhv_vattr_t             *vap,
-       char                    *target_path,
-       bhv_vnode_t             **vpp,
-       cred_t                  *credp)
-{
-       return xfs_symlink(XFS_BHVTOI(dir_bdp), dentry, vap, target_path, vpp, credp);
-}
-
-STATIC int
-xfs_bhv_fid2(
-       bhv_desc_t      *bdp,
-       fid_t           *fidp)
-{
-       return xfs_fid2(XFS_BHVTOI(bdp), fidp);
-}
-
-STATIC int
-xfs_bhv_rwlock(
-       bhv_desc_t      *bdp,
-       bhv_vrwlock_t   locktype)
-{
-       return xfs_rwlock(XFS_BHVTOI(bdp), locktype);
-}
-
-STATIC void
-xfs_bhv_rwunlock(
-       bhv_desc_t      *bdp,
-       bhv_vrwlock_t   locktype)
-{
-       xfs_rwunlock(XFS_BHVTOI(bdp), locktype);
-}
-
-STATIC int
-xfs_bhv_inode_flush(
-       bhv_desc_t      *bdp,
-       int             flags)
-{
-       return xfs_inode_flush(XFS_BHVTOI(bdp), flags);
-}
-
-STATIC int
-xfs_bhv_reclaim(
-       bhv_desc_t      *bdp)
-{
-       return xfs_reclaim(XFS_BHVTOI(bdp));
-}
-
-STATIC int
-xfs_bhv_rename(
-       bhv_desc_t      *src_dir_bdp,
-       bhv_vname_t     *src_vname,
-       bhv_vnode_t     *target_dir_vp,
-       bhv_vname_t     *target_vname,
-       cred_t          *credp)
-{
-       return xfs_rename(XFS_BHVTOI(src_dir_bdp), src_vname,
-                       target_dir_vp, target_vname);
-}
-
-STATIC int
-xfs_bhv_attr_get(
-       bhv_desc_t      *bdp,
-       const char      *name,
-       char            *value,
-       int             *valuelenp,
-       int             flags,
-       cred_t          *cred)
-{
-       return xfs_attr_get(XFS_BHVTOI(bdp), name, value, valuelenp,
-                       flags, cred);
-}
-
-STATIC int
-xfs_bhv_attr_set(
-       bhv_desc_t      *bdp,
-       const char      *name,
-       char            *value,
-       int             valuelen,
-       int             flags,
-       cred_t          *cred)
-{
-       return xfs_attr_set(XFS_BHVTOI(bdp), name, value, valuelen,
-                       flags);
-}
-
-STATIC int
-xfs_bhv_attr_remove(
-       bhv_desc_t      *bdp,
-       const char      *name,
-       int             flags,
-       cred_t          *cred)
-{
-       return xfs_attr_remove(XFS_BHVTOI(bdp), name, flags);
-}
-
-STATIC int
-xfs_bhv_attr_list(
-       bhv_desc_t      *bdp,
-       char            *buffer,
-       int             bufsize,
-       int             flags,
-       struct attrlist_cursor_kern *cursor,
-       cred_t          *cred)
-{
-       return xfs_attr_list(XFS_BHVTOI(bdp), buffer, bufsize, flags,
-                       cursor);
-}
-
-STATIC int
-xfs_bhv_ioctl(
-       bhv_desc_t              *bdp,
-       struct inode            *inode,
-       struct file             *filp,
-       int                     ioflags,
-       unsigned int            cmd,
-       void                    __user *arg)
-{
-       return xfs_ioctl(XFS_BHVTOI(bdp), filp, ioflags, cmd, arg);
-}
-
-STATIC ssize_t
-xfs_bhv_read(
-       bhv_desc_t              *bdp,
-       struct kiocb            *iocb,
-       const struct iovec      *iovp,
-       unsigned int            segs,
-       loff_t                  *offset,
-       int                     ioflags,
-       cred_t                  *credp)
-{
-       return xfs_read(XFS_BHVTOI(bdp), iocb, iovp, segs,
-                       offset, ioflags);
-}
-
-STATIC ssize_t
-xfs_bhv_sendfile(
-       bhv_desc_t              *bdp,
-       struct file             *filp,
-       loff_t                  *offset,
-       int                     ioflags,
-       size_t                  count,
-       read_actor_t            actor,
-       void                    *target,
-       cred_t                  *credp)
-{
-       return xfs_sendfile(XFS_BHVTOI(bdp), filp, offset, ioflags,
-                       count, actor, target);
-}
-
-STATIC ssize_t
-xfs_bhv_splice_read(
-       bhv_desc_t              *bdp,
-       struct file             *infilp,
-       loff_t                  *ppos,
-       struct pipe_inode_info  *pipe,
-       size_t                  count,
-       int                     flags,
-       int                     ioflags,
-       cred_t                  *credp)
-{
-       return xfs_splice_read(XFS_BHVTOI(bdp), infilp, ppos, pipe,
-                       count, flags, ioflags);
-}
-
-STATIC ssize_t
-xfs_bhv_splice_write(
-       bhv_desc_t              *bdp,
-       struct pipe_inode_info  *pipe,
-       struct file             *outfilp,
-       loff_t                  *ppos,
-       size_t                  count,
-       int                     flags,
-       int                     ioflags,
-       cred_t                  *credp)
-{
-       return xfs_splice_write(XFS_BHVTOI(bdp), pipe, outfilp, ppos,
-                       count, flags, ioflags);
-}
-
-STATIC ssize_t
-xfs_bhv_write(
-       bhv_desc_t              *bdp,
-       struct kiocb            *iocb,
-       const struct iovec      *iovp,
-       unsigned int            nsegs,
-       loff_t                  *offset,
-       int                     ioflags,
-       cred_t                  *credp)
-{
-       return xfs_write(XFS_BHVTOI(bdp), iocb, iovp, nsegs, offset,
-                       ioflags);
-}
-
-STATIC int
-xfs_bhv_bmap(bhv_desc_t        *bdp,
-       xfs_off_t       offset,
-       ssize_t         count,
-       int             flags,
-       struct xfs_iomap *iomapp,
-       int             *niomaps)
-{
-       return xfs_bmap(XFS_BHVTOI(bdp), offset, count, flags,
-                       iomapp, niomaps);
-}
-
-STATIC void
-fs_tosspages(
-       bhv_desc_t      *bdp,
-       xfs_off_t       first,
-       xfs_off_t       last,
-       int             fiopt)
-{
-       xfs_tosspages(XFS_BHVTOI(bdp), first, last, fiopt);
-}
-
-STATIC int
-fs_flushinval_pages(
-       bhv_desc_t      *bdp,
-       xfs_off_t       first,
-       xfs_off_t       last,
-       int             fiopt)
-{
-       return xfs_flushinval_pages(XFS_BHVTOI(bdp), first, last,
-                       fiopt);
-}
-
-STATIC int
-fs_flush_pages(
-       bhv_desc_t      *bdp,
-       xfs_off_t       first,
-       xfs_off_t       last,
-       uint64_t        flags,
-       int             fiopt)
-{
-       return xfs_flush_pages(XFS_BHVTOI(bdp), first, last, flags,
-                       fiopt);
-}
-
-bhv_vnodeops_t xfs_vnodeops = {
-       BHV_IDENTITY_INIT(VN_BHV_XFS,VNODE_POSITION_XFS),
-       .vop_open               = xfs_bhv_open,
-       .vop_read               = xfs_bhv_read,
-#ifdef HAVE_SENDFILE
-       .vop_sendfile           = xfs_bhv_sendfile,
-#endif
-#ifdef HAVE_SPLICE
-       .vop_splice_read        = xfs_bhv_splice_read,
-       .vop_splice_write       = xfs_bhv_splice_write,
-#endif
-       .vop_write              = xfs_bhv_write,
-       .vop_ioctl              = xfs_bhv_ioctl,
-       .vop_getattr            = xfs_bhv_getattr,
-       .vop_setattr            = xfs_bhv_setattr,
-       .vop_access             = xfs_bhv_access,
-       .vop_lookup             = xfs_bhv_lookup,
-       .vop_create             = xfs_bhv_create,
-       .vop_remove             = xfs_bhv_remove,
-       .vop_link               = xfs_bhv_link,
-       .vop_rename             = xfs_bhv_rename,
-       .vop_mkdir              = xfs_bhv_mkdir,
-       .vop_rmdir              = xfs_bhv_rmdir,
-       .vop_readdir            = xfs_bhv_readdir,
-       .vop_symlink            = xfs_bhv_symlink,
-       .vop_readlink           = xfs_bhv_readlink,
-       .vop_fsync              = xfs_bhv_fsync,
-       .vop_inactive           = xfs_bhv_inactive,
-       .vop_fid2               = xfs_bhv_fid2,
-       .vop_rwlock             = xfs_bhv_rwlock,
-       .vop_rwunlock           = xfs_bhv_rwunlock,
-       .vop_bmap               = xfs_bhv_bmap,
-       .vop_reclaim            = xfs_bhv_reclaim,
-       .vop_attr_get           = xfs_bhv_attr_get,
-       .vop_attr_set           = xfs_bhv_attr_set,
-       .vop_attr_remove        = xfs_bhv_attr_remove,
-       .vop_attr_list          = xfs_bhv_attr_list,
-       .vop_link_removed       = (vop_link_removed_t)fs_noval,
-       .vop_vnode_change       = (vop_vnode_change_t)fs_noval,
-       .vop_tosspages          = fs_tosspages,
-       .vop_flushinval_pages   = fs_flushinval_pages,
-       .vop_flush_pages        = fs_flush_pages,
-       .vop_release            = xfs_bhv_release,
-       .vop_iflush             = xfs_bhv_inode_flush,
-};