6 files changed, 137 insertions, 170 deletions

diff --git a/fs/xfs/linux-2.6/xfs_export.c b/fs/xfs/linux-2.6/xfs_export.c
index b768ea910bbe..b5c579eeb8ef 100644
--- a/fs/xfs/linux-2.6/xfs_export.c
+++ b/fs/xfs/linux-2.6/xfs_export.c
@@ -97,7 +97,7 @@ xfs_fs_encode_fh(
         int                     len;
         int                     is64 = 0;
 #if XFS_BIG_INUMS
-        vfs_t                   *vfs = vfs_from_sb(inode->i_sb);
+        bhv_vfs_t               *vfs = vfs_from_sb(inode->i_sb);
 
         if (!(vfs->vfs_flag & VFS_32BITINODES)) {
                 /* filesystem may contain 64bit inode numbers */
@@ -139,10 +139,10 @@ xfs_fs_get_dentry(
         vnode_t                 *vp;
         struct inode            *inode;
         struct dentry           *result;
-        vfs_t                   *vfsp = vfs_from_sb(sb);
+        bhv_vfs_t               *vfsp = vfs_from_sb(sb);
         int                     error;
 
-        VFS_VGET(vfsp, &vp, (fid_t *)data, error);
+        error = bhv_vfs_vget(vfsp, &vp, (fid_t *)data);
         if (error || vp == NULL)
                 return ERR_PTR(-ESTALE) ;
 
diff --git a/fs/xfs/linux-2.6/xfs_super.c b/fs/xfs/linux-2.6/xfs_super.c
index 68f4793e8a11..97dbcb68b25f 100644
--- a/fs/xfs/linux-2.6/xfs_super.c
+++ b/fs/xfs/linux-2.6/xfs_super.c
@@ -475,13 +475,13 @@ xfs_fs_clear_inode(
  */
 STATIC void
 xfs_syncd_queue_work(
-        struct vfs      *vfs,
+        struct bhv_vfs  *vfs,
         void            *data,
-        void            (*syncer)(vfs_t *, void *))
+        void            (*syncer)(bhv_vfs_t *, void *))
 {
-        vfs_sync_work_t *work;
+        struct bhv_vfs_sync_work *work;
 
-        work = kmem_alloc(sizeof(struct vfs_sync_work), KM_SLEEP);
+        work = kmem_alloc(sizeof(struct bhv_vfs_sync_work), KM_SLEEP);
         INIT_LIST_HEAD(&work->w_list);
         work->w_syncer = syncer;
         work->w_data = data;
@@ -500,7 +500,7 @@ xfs_syncd_queue_work(
  */
 STATIC void
 xfs_flush_inode_work(
-        vfs_t           *vfs,
+        bhv_vfs_t       *vfs,
         void            *inode)
 {
         filemap_flush(((struct inode *)inode)->i_mapping);
@@ -512,7 +512,7 @@ xfs_flush_inode(
         xfs_inode_t     *ip)
 {
         struct inode    *inode = vn_to_inode(XFS_ITOV(ip));
-        struct vfs      *vfs = XFS_MTOVFS(ip->i_mount);
+        struct bhv_vfs  *vfs = XFS_MTOVFS(ip->i_mount);
 
         igrab(inode);
         xfs_syncd_queue_work(vfs, inode, xfs_flush_inode_work);
@@ -525,7 +525,7 @@ xfs_flush_inode(
  */
 STATIC void
 xfs_flush_device_work(
-        vfs_t           *vfs,
+        bhv_vfs_t       *vfs,
         void            *inode)
 {
         sync_blockdev(vfs->vfs_super->s_bdev);
@@ -537,7 +537,7 @@ xfs_flush_device(
         xfs_inode_t     *ip)
 {
         struct inode    *inode = vn_to_inode(XFS_ITOV(ip));
-        struct vfs      *vfs = XFS_MTOVFS(ip->i_mount);
+        struct bhv_vfs  *vfs = XFS_MTOVFS(ip->i_mount);
 
         igrab(inode);
         xfs_syncd_queue_work(vfs, inode, xfs_flush_device_work);
@@ -545,16 +545,16 @@ xfs_flush_device(
         xfs_log_force(ip->i_mount, (xfs_lsn_t)0, XFS_LOG_FORCE|XFS_LOG_SYNC);
 }
 
-#define SYNCD_FLAGS     (SYNC_FSDATA|SYNC_BDFLUSH|SYNC_ATTR|SYNC_REFCACHE)
 STATIC void
 vfs_sync_worker(
-        vfs_t           *vfsp,
+        bhv_vfs_t       *vfsp,
         void            *unused)
 {
         int             error;
 
         if (!(vfsp->vfs_flag & VFS_RDONLY))
-                VFS_SYNC(vfsp, SYNCD_FLAGS, NULL, error);
+                error = bhv_vfs_sync(vfsp, SYNC_FSDATA | SYNC_BDFLUSH | \
+                                        SYNC_ATTR | SYNC_REFCACHE, NULL);
         vfsp->vfs_sync_seq++;
         wmb();
         wake_up(&vfsp->vfs_wait_single_sync_task);
@@ -565,8 +565,8 @@ xfssyncd(
         void                    *arg)
 {
         long                    timeleft;
-        vfs_t                   *vfsp = (vfs_t *) arg;
-        struct vfs_sync_work    *work, *n;
+        bhv_vfs_t               *vfsp = (bhv_vfs_t *) arg;
+        bhv_vfs_sync_work_t     *work, *n;
         LIST_HEAD               (tmp);
 
         timeleft = xfs_syncd_centisecs * msecs_to_jiffies(10);
@@ -600,7 +600,7 @@ xfssyncd(
                         list_del(&work->w_list);
                         if (work == &vfsp->vfs_sync_work)
                                 continue;
-                        kmem_free(work, sizeof(struct vfs_sync_work));
+                        kmem_free(work, sizeof(struct bhv_vfs_sync_work));
                 }
         }
 
@@ -609,7 +609,7 @@ xfssyncd(
 
 STATIC int
 xfs_fs_start_syncd(
-        vfs_t                   *vfsp)
+        bhv_vfs_t               *vfsp)
 {
         vfsp->vfs_sync_work.w_syncer = vfs_sync_worker;
         vfsp->vfs_sync_work.w_vfs = vfsp;
@@ -621,7 +621,7 @@ xfs_fs_start_syncd(
 
 STATIC void
 xfs_fs_stop_syncd(
-        vfs_t                   *vfsp)
+        bhv_vfs_t               *vfsp)
 {
         kthread_stop(vfsp->vfs_sync_task);
 }
@@ -630,35 +630,26 @@ STATIC void
 xfs_fs_put_super(
         struct super_block      *sb)
 {
-        vfs_t                   *vfsp = vfs_from_sb(sb);
+        bhv_vfs_t               *vfsp = vfs_from_sb(sb);
         int                     error;
 
         xfs_fs_stop_syncd(vfsp);
-        VFS_SYNC(vfsp, SYNC_ATTR|SYNC_DELWRI, NULL, error);
-        if (!error)
-                VFS_UNMOUNT(vfsp, 0, NULL, error);
+        bhv_vfs_sync(vfsp, SYNC_ATTR | SYNC_DELWRI, NULL);
+        error = bhv_vfs_unmount(vfsp, 0, NULL);
         if (error) {
-                printk("XFS unmount got error %d\n", error);
-                printk("%s: vfsp/0x%p left dangling!\n", __FUNCTION__, vfsp);
-                return;
+                printk("XFS: unmount got error=%d\n", error);
+                printk("%s: vfs=0x%p left dangling!\n", __FUNCTION__, vfsp);
+        } else {
+                vfs_deallocate(vfsp);
         }
-
-        vfs_deallocate(vfsp);
 }
 
 STATIC void
 xfs_fs_write_super(
         struct super_block      *sb)
 {
-        vfs_t                   *vfsp = vfs_from_sb(sb);
-        int                     error;
-
-        if (sb->s_flags & MS_RDONLY) {
-                sb->s_dirt = 0; /* paranoia */
-                return;
-        }
-        /* Push the log and superblock a little */
-        VFS_SYNC(vfsp, SYNC_FSDATA, NULL, error);
+        if (!(sb->s_flags & MS_RDONLY))
+                bhv_vfs_sync(vfs_from_sb(sb), SYNC_FSDATA, NULL);
         sb->s_dirt = 0;
 }
 
@@ -667,16 +658,16 @@ xfs_fs_sync_super(
         struct super_block      *sb,
         int                     wait)
 {
-        vfs_t           *vfsp = vfs_from_sb(sb);
-        int             error;
-        int             flags = SYNC_FSDATA;
+        bhv_vfs_t               *vfsp = vfs_from_sb(sb);
+        int                     error;
+        int                     flags;
 
         if (unlikely(sb->s_frozen == SB_FREEZE_WRITE))
                 flags = SYNC_QUIESCE;
         else
                 flags = SYNC_FSDATA | (wait ? SYNC_WAIT : 0);
 
-        VFS_SYNC(vfsp, flags, NULL, error);
+        error = bhv_vfs_sync(vfsp, flags, NULL);
         sb->s_dirt = 0;
 
         if (unlikely(laptop_mode)) {
@@ -706,11 +697,7 @@ xfs_fs_statfs(
         struct super_block      *sb,
         struct kstatfs          *statp)
 {
-        vfs_t                   *vfsp = vfs_from_sb(sb);
-        int                     error;
-
-        VFS_STATVFS(vfsp, statp, NULL, error);
-        return -error;
+        return -bhv_vfs_statvfs(vfs_from_sb(sb), statp, NULL);
 }
 
 STATIC int
@@ -719,13 +706,13 @@ xfs_fs_remount(
         int                     *flags,
         char                    *options)
 {
-        vfs_t                   *vfsp = vfs_from_sb(sb);
+        bhv_vfs_t               *vfsp = vfs_from_sb(sb);
         struct xfs_mount_args   *args = xfs_args_allocate(sb, 0);
         int                     error;
 
-        VFS_PARSEARGS(vfsp, options, args, 1, error);
+        error = bhv_vfs_parseargs(vfsp, options, args, 1);
         if (!error)
-                VFS_MNTUPDATE(vfsp, flags, args, error);
+                error = bhv_vfs_mntupdate(vfsp, flags, args);
         kmem_free(args, sizeof(*args));
         return -error;
 }
@@ -734,7 +721,7 @@ STATIC void
 xfs_fs_lockfs(
         struct super_block      *sb)
 {
-        VFS_FREEZE(vfs_from_sb(sb));
+        bhv_vfs_freeze(vfs_from_sb(sb));
 }
 
 STATIC int
@@ -742,11 +729,7 @@ xfs_fs_show_options(
         struct seq_file         *m,
         struct vfsmount         *mnt)
 {
-        struct vfs              *vfsp = vfs_from_sb(mnt->mnt_sb);
-        int                     error;
-
-        VFS_SHOWARGS(vfsp, m, error);
-        return error;
+        return -bhv_vfs_showargs(vfs_from_sb(mnt->mnt_sb), m);
 }
 
 STATIC int
@@ -754,11 +737,7 @@ xfs_fs_quotasync(
         struct super_block      *sb,
         int                     type)
 {
-        struct vfs              *vfsp = vfs_from_sb(sb);
-        int                     error;
-
-        VFS_QUOTACTL(vfsp, Q_XQUOTASYNC, 0, (caddr_t)NULL, error);
-        return -error;
+        return -bhv_vfs_quotactl(vfs_from_sb(sb), Q_XQUOTASYNC, 0, NULL);
 }
 
 STATIC int
@@ -766,11 +745,7 @@ xfs_fs_getxstate(
         struct super_block      *sb,
         struct fs_quota_stat    *fqs)
 {
-        struct vfs              *vfsp = vfs_from_sb(sb);
-        int                     error;
-
-        VFS_QUOTACTL(vfsp, Q_XGETQSTAT, 0, (caddr_t)fqs, error);
-        return -error;
+        return -bhv_vfs_quotactl(vfs_from_sb(sb), Q_XGETQSTAT, 0, (caddr_t)fqs);
 }
 
 STATIC int
@@ -779,11 +754,7 @@ xfs_fs_setxstate(
         unsigned int            flags,
         int                     op)
 {
-        struct vfs              *vfsp = vfs_from_sb(sb);
-        int                     error;
-
-        VFS_QUOTACTL(vfsp, op, 0, (caddr_t)&flags, error);
-        return -error;
+        return -bhv_vfs_quotactl(vfs_from_sb(sb), op, 0, (caddr_t)&flags);
 }
 
 STATIC int
@@ -793,13 +764,10 @@ xfs_fs_getxquota(
         qid_t                   id,
         struct fs_disk_quota    *fdq)
 {
-        struct vfs              *vfsp = vfs_from_sb(sb);
-        int                     error, getmode;
-
-        getmode = (type == USRQUOTA) ? Q_XGETQUOTA :
-                 ((type == GRPQUOTA) ? Q_XGETGQUOTA : Q_XGETPQUOTA);
-        VFS_QUOTACTL(vfsp, getmode, id, (caddr_t)fdq, error);
-        return -error;
+        return -bhv_vfs_quotactl(vfs_from_sb(sb),
+                                 (type == USRQUOTA) ? Q_XGETQUOTA :
+                                  ((type == GRPQUOTA) ? Q_XGETGQUOTA :
+                                   Q_XGETPQUOTA), id, (caddr_t)fdq);
 }
 
 STATIC int
@@ -809,13 +777,10 @@ xfs_fs_setxquota(
         qid_t                   id,
         struct fs_disk_quota    *fdq)
 {
-        struct vfs              *vfsp = vfs_from_sb(sb);
-        int                     error, setmode;
-
-        setmode = (type == USRQUOTA) ? Q_XSETQLIM :
-                 ((type == GRPQUOTA) ? Q_XSETGQLIM : Q_XSETPQLIM);
-        VFS_QUOTACTL(vfsp, setmode, id, (caddr_t)fdq, error);
-        return -error;
+        return -bhv_vfs_quotactl(vfs_from_sb(sb),
+                                 (type == USRQUOTA) ? Q_XSETQLIM :
+                                  ((type == GRPQUOTA) ? Q_XSETGQLIM :
+                                   Q_XSETPQLIM), id, (caddr_t)fdq);
 }
 
 STATIC int
@@ -825,14 +790,14 @@ xfs_fs_fill_super(
         int                     silent)
 {
         vnode_t                 *rootvp;
-        struct vfs              *vfsp = vfs_allocate(sb);
+        struct bhv_vfs          *vfsp = vfs_allocate(sb);
         struct xfs_mount_args   *args = xfs_args_allocate(sb, silent);
         struct kstatfs          statvfs;
-        int                     error, error2;
+        int                     error;
 
         bhv_insert_all_vfsops(vfsp);
 
-        VFS_PARSEARGS(vfsp, (char *)data, args, 0, error);
+        error = bhv_vfs_parseargs(vfsp, (char *)data, args, 0);
         if (error) {
                 bhv_remove_all_vfsops(vfsp, 1);
                 goto fail_vfsop;
@@ -845,13 +810,13 @@ xfs_fs_fill_super(
         sb->s_qcop = &xfs_quotactl_operations;
         sb->s_op = &xfs_super_operations;
 
-        VFS_MOUNT(vfsp, args, NULL, error);
+        error = bhv_vfs_mount(vfsp, args, NULL);
         if (error) {
                 bhv_remove_all_vfsops(vfsp, 1);
                 goto fail_vfsop;
         }
 
-        VFS_STATVFS(vfsp, &statvfs, NULL, error);
+        error = bhv_vfs_statvfs(vfsp, &statvfs, NULL);
         if (error)
                 goto fail_unmount;
 
@@ -863,7 +828,7 @@ xfs_fs_fill_super(
         sb->s_time_gran = 1;
         set_posix_acl_flag(sb);
 
-        VFS_ROOT(vfsp, &rootvp, error);
+        error = bhv_vfs_root(vfsp, &rootvp);
         if (error)
                 goto fail_unmount;
 
@@ -892,7 +857,7 @@ fail_vnrele:
         }
 
 fail_unmount:
-        VFS_UNMOUNT(vfsp, 0, NULL, error2);
+        bhv_vfs_unmount(vfsp, 0, NULL);
 
 fail_vfsop:
         vfs_deallocate(vfsp);
diff --git a/fs/xfs/linux-2.6/xfs_vfs.c b/fs/xfs/linux-2.6/xfs_vfs.c
index 6f7c9f7a8624..9f9bc894deb9 100644
--- a/fs/xfs/linux-2.6/xfs_vfs.c
+++ b/fs/xfs/linux-2.6/xfs_vfs.c
@@ -226,13 +226,13 @@ vfs_freeze(
         ((*bhvtovfsops(next)->vfs_freeze)(next));
 }
 
-vfs_t *
+bhv_vfs_t *
 vfs_allocate(
         struct super_block      *sb)
 {
-        struct vfs              *vfsp;
+        struct bhv_vfs          *vfsp;
 
-        vfsp = kmem_zalloc(sizeof(vfs_t), KM_SLEEP);
+        vfsp = kmem_zalloc(sizeof(bhv_vfs_t), KM_SLEEP);
         bhv_head_init(VFS_BHVHEAD(vfsp), "vfs");
         INIT_LIST_HEAD(&vfsp->vfs_sync_list);
         spin_lock_init(&vfsp->vfs_sync_lock);
@@ -247,25 +247,25 @@ vfs_allocate(
         return vfsp;
 }
 
-vfs_t *
+bhv_vfs_t *
 vfs_from_sb(
         struct super_block      *sb)
 {
-        return (vfs_t *)sb->s_fs_info;
+        return (bhv_vfs_t *)sb->s_fs_info;
 }
 
 void
 vfs_deallocate(
-        struct vfs              *vfsp)
+        struct bhv_vfs          *vfsp)
 {
         bhv_head_destroy(VFS_BHVHEAD(vfsp));
-        kmem_free(vfsp, sizeof(vfs_t));
+        kmem_free(vfsp, sizeof(bhv_vfs_t));
 }
 
 void
 vfs_insertops(
-        struct vfs              *vfsp,
-        struct bhv_vfsops       *vfsops)
+        struct bhv_vfs          *vfsp,
+        struct bhv_module_vfsops *vfsops)
 {
         struct bhv_desc         *bdp;
 
@@ -276,9 +276,9 @@ vfs_insertops(
 
 void
 vfs_insertbhv(
-        struct vfs              *vfsp,
+        struct bhv_vfs          *vfsp,
         struct bhv_desc         *bdp,
-        struct vfsops           *vfsops,
+        struct bhv_vfsops       *vfsops,
         void                    *mount)
 {
         bhv_desc_init(bdp, mount, vfsp, vfsops);
@@ -287,7 +287,7 @@ vfs_insertbhv(
 
 void
 bhv_remove_vfsops(
-        struct vfs              *vfsp,
+        struct bhv_vfs          *vfsp,
         int                     pos)
 {
         struct bhv_desc         *bhv;
@@ -301,7 +301,7 @@ bhv_remove_vfsops(
 
 void
 bhv_remove_all_vfsops(
-        struct vfs              *vfsp,
+        struct bhv_vfs          *vfsp,
         int                     freebase)
 {
         struct xfs_mount        *mp;
@@ -317,7 +317,7 @@ bhv_remove_all_vfsops(
 
 void
 bhv_insert_all_vfsops(
-        struct vfs              *vfsp)
+        struct bhv_vfs          *vfsp)
 {
         struct xfs_mount        *mp;
 
diff --git a/fs/xfs/linux-2.6/xfs_vfs.h b/fs/xfs/linux-2.6/xfs_vfs.h
index 2ca05043a0fd..55f0afd3e794 100644
--- a/fs/xfs/linux-2.6/xfs_vfs.h
+++ b/fs/xfs/linux-2.6/xfs_vfs.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2000-2005 Silicon Graphics, Inc.
+ * Copyright (c) 2000-2006 Silicon Graphics, Inc.
  * All Rights Reserved.
  *
  * This program is free software; you can redistribute it and/or
@@ -21,42 +21,42 @@
 #include <linux/vfs.h>
 #include "xfs_fs.h"
 
+struct bhv_vfs;
 struct fid;
-struct vfs;
 struct cred;
 struct vnode;
-struct kstatfs;
+struct statfs;
 struct seq_file;
 struct super_block;
 struct xfs_mount_args;
 
 typedef struct kstatfs xfs_statfs_t;
 
-typedef struct vfs_sync_work {
+typedef struct bhv_vfs_sync_work {
         struct list_head        w_list;
-        struct vfs              *w_vfs;
+        struct bhv_vfs          *w_vfs;
         void                    *w_data;        /* syncer routine argument */
-        void                    (*w_syncer)(struct vfs *, void *);
-} vfs_sync_work_t;
+        void                    (*w_syncer)(struct bhv_vfs *, void *);
+} bhv_vfs_sync_work_t;
 
-typedef struct vfs {
+typedef struct bhv_vfs {
         u_int                   vfs_flag;       /* flags */
         xfs_fsid_t              vfs_fsid;       /* file system ID */
         xfs_fsid_t              *vfs_altfsid;   /* An ID fixed for life of FS */
         bhv_head_t              vfs_bh;         /* head of vfs behavior chain */
         struct super_block      *vfs_super;     /* generic superblock pointer */
         struct task_struct      *vfs_sync_task; /* generalised sync thread */
-        vfs_sync_work_t         vfs_sync_work;  /* work item for VFS_SYNC */
+        bhv_vfs_sync_work_t     vfs_sync_work;  /* work item for VFS_SYNC */
         struct list_head        vfs_sync_list;  /* sync thread work item list */
         spinlock_t              vfs_sync_lock;  /* work item list lock */
-        int                     vfs_sync_seq;   /* sync thread generation no. */
+        int                     vfs_sync_seq;   /* sync thread generation no. */
         wait_queue_head_t       vfs_wait_single_sync_task;
-} vfs_t;
+} bhv_vfs_t;
 
 #define vfs_fbhv                vfs_bh.bh_first /* 1st on vfs behavior chain */
 
-#define bhvtovfs(bdp)           ( (struct vfs *)BHV_VOBJ(bdp) )
-#define bhvtovfsops(bdp)        ( (struct vfsops *)BHV_OPS(bdp) )
+#define bhvtovfs(bdp)           ( (struct bhv_vfs *)BHV_VOBJ(bdp) )
+#define bhvtovfsops(bdp)        ( (struct bhv_vfsops *)BHV_OPS(bdp) )
 #define VFS_BHVHEAD(vfs)        ( &(vfs)->vfs_bh )
 #define VFS_REMOVEBHV(vfs, bdp) ( bhv_remove(VFS_BHVHEAD(vfs), bdp) )
 
@@ -71,7 +71,7 @@ typedef enum {
         VFS_BHV_QM,             /* quota manager */
         VFS_BHV_IO,             /* IO path */
         VFS_BHV_END             /* housekeeping end-of-range */
-} vfs_bhv_t;
+} bhv_vfs_type_t;
 
 #define VFS_POSITION_XFS        (BHV_POSITION_BASE)
 #define VFS_POSITION_DM         (VFS_POSITION_BASE+10)
@@ -81,8 +81,9 @@ typedef enum {
 #define VFS_RDONLY              0x0001  /* read-only vfs */
 #define VFS_GRPID               0x0002  /* group-ID assigned from directory */
 #define VFS_DMI                 0x0004  /* filesystem has the DMI enabled */
-#define VFS_32BITINODES         0x0008  /* do not use inums above 32 bits */
-#define VFS_END                 0x0008  /* max flag */
+#define VFS_UMOUNT              0x0008  /* unmount in progress */
+#define VFS_32BITINODES         0x0010  /* do not use inums above 32 bits */
+#define VFS_END                 0x0010  /* max flag */
 
 #define SYNC_ATTR               0x0001  /* sync attributes */
 #define SYNC_CLOSE              0x0002  /* close file system down */
@@ -92,7 +93,7 @@ typedef enum {
 #define SYNC_FSDATA             0x0020  /* flush fs data (e.g. superblocks) */
 #define SYNC_REFCACHE           0x0040  /* prune some of the nfs ref cache */
 #define SYNC_REMOUNT            0x0080  /* remount readonly, no dummy LRs */
-#define SYNC_QUIESCE            0x0100  /* quiesce filesystem for a snapshot */
+#define SYNC_QUIESCE            0x0100  /* quiesce fileystem for a snapshot */
 
 #define SHUTDOWN_META_IO_ERROR  0x0001  /* write attempt to metadata failed */
 #define SHUTDOWN_LOG_IO_ERROR   0x0002  /* write attempt to the log failed */
@@ -120,7 +121,7 @@ typedef void	(*vfs_init_vnode_t)(bhv_desc_t *,
 typedef void    (*vfs_force_shutdown_t)(bhv_desc_t *, int, char *, int);
 typedef void    (*vfs_freeze_t)(bhv_desc_t *);
 
-typedef struct vfsops {
+typedef struct bhv_vfsops {
         bhv_position_t          vf_position;    /* behavior chain position */
         vfs_mount_t             vfs_mount;      /* mount file system */
         vfs_parseargs_t         vfs_parseargs;  /* parse mount options */
@@ -136,44 +137,44 @@ typedef struct vfsops {
         vfs_init_vnode_t        vfs_init_vnode; /* initialize a new vnode */
         vfs_force_shutdown_t    vfs_force_shutdown;     /* crash and burn */
         vfs_freeze_t            vfs_freeze;     /* freeze fs for snapshot */
-} vfsops_t;
+} bhv_vfsops_t;
 
 /*
  * VFS's.  Operates on vfs structure pointers (starts at bhv head).
  */
 #define VHEAD(v)                        ((v)->vfs_fbhv)
-#define VFS_MOUNT(v, ma,cr, rv)         ((rv) = vfs_mount(VHEAD(v), ma,cr))
-#define VFS_PARSEARGS(v, o,ma,f, rv)    ((rv) = vfs_parseargs(VHEAD(v), o,ma,f))
-#define VFS_SHOWARGS(v, m, rv)          ((rv) = vfs_showargs(VHEAD(v), m))
-#define VFS_UNMOUNT(v, f, cr, rv)       ((rv) = vfs_unmount(VHEAD(v), f,cr))
-#define VFS_MNTUPDATE(v, fl, args, rv)  ((rv) = vfs_mntupdate(VHEAD(v), fl, args))
-#define VFS_ROOT(v, vpp, rv)            ((rv) = vfs_root(VHEAD(v), vpp))
-#define VFS_STATVFS(v, sp,vp, rv)       ((rv) = vfs_statvfs(VHEAD(v), sp,vp))
-#define VFS_SYNC(v, flag,cr, rv)        ((rv) = vfs_sync(VHEAD(v), flag,cr))
-#define VFS_VGET(v, vpp,fidp, rv)       ((rv) = vfs_vget(VHEAD(v), vpp,fidp))
-#define VFS_DMAPIOPS(v, p, rv)          ((rv) = vfs_dmapiops(VHEAD(v), p))
-#define VFS_QUOTACTL(v, c,id,p, rv)     ((rv) = vfs_quotactl(VHEAD(v), c,id,p))
-#define VFS_INIT_VNODE(v, vp,b,ul)      ( vfs_init_vnode(VHEAD(v), vp,b,ul) )
-#define VFS_FORCE_SHUTDOWN(v, fl,f,l)   ( vfs_force_shutdown(VHEAD(v), fl,f,l) )
-#define VFS_FREEZE(v)                   ( vfs_freeze(VHEAD(v)) )
+#define bhv_vfs_mount(v, ma,cr)         vfs_mount(VHEAD(v), ma,cr)
+#define bhv_vfs_parseargs(v, o,ma,f)    vfs_parseargs(VHEAD(v), o,ma,f)
+#define bhv_vfs_showargs(v, m)          vfs_showargs(VHEAD(v), m)
+#define bhv_vfs_unmount(v, f,cr)        vfs_unmount(VHEAD(v), f,cr)
+#define bhv_vfs_mntupdate(v, fl,args)   vfs_mntupdate(VHEAD(v), fl,args)
+#define bhv_vfs_root(v, vpp)            vfs_root(VHEAD(v), vpp)
+#define bhv_vfs_statvfs(v, sp,vp)       vfs_statvfs(VHEAD(v), sp,vp)
+#define bhv_vfs_sync(v, flag,cr)        vfs_sync(VHEAD(v), flag,cr)
+#define bhv_vfs_vget(v, vpp,fidp)       vfs_vget(VHEAD(v), vpp,fidp)
+#define bhv_vfs_dmapiops(v, p)          vfs_dmapiops(VHEAD(v), p)
+#define bhv_vfs_quotactl(v, c,id,p)     vfs_quotactl(VHEAD(v), c,id,p)
+#define bhv_vfs_init_vnode(v, vp,b,ul)  vfs_init_vnode(VHEAD(v), vp,b,ul)
+#define bhv_vfs_force_shutdown(v,u,f,l) vfs_force_shutdown(VHEAD(v), u,f,l)
+#define bhv_vfs_freeze(v)               vfs_freeze(VHEAD(v))
 
 /*
  * PVFS's.  Operates on behavior descriptor pointers.
  */
-#define PVFS_MOUNT(b, ma,cr, rv)        ((rv) = vfs_mount(b, ma,cr))
-#define PVFS_PARSEARGS(b, o,ma,f, rv)   ((rv) = vfs_parseargs(b, o,ma,f))
-#define PVFS_SHOWARGS(b, m, rv)         ((rv) = vfs_showargs(b, m))
-#define PVFS_UNMOUNT(b, f,cr, rv)       ((rv) = vfs_unmount(b, f,cr))
-#define PVFS_MNTUPDATE(b, fl, args, rv) ((rv) = vfs_mntupdate(b, fl, args))
-#define PVFS_ROOT(b, vpp, rv)           ((rv) = vfs_root(b, vpp))
-#define PVFS_STATVFS(b, sp,vp, rv)      ((rv) = vfs_statvfs(b, sp,vp))
-#define PVFS_SYNC(b, flag,cr, rv)       ((rv) = vfs_sync(b, flag,cr))
-#define PVFS_VGET(b, vpp,fidp, rv)      ((rv) = vfs_vget(b, vpp,fidp))
-#define PVFS_DMAPIOPS(b, p, rv)         ((rv) = vfs_dmapiops(b, p))
-#define PVFS_QUOTACTL(b, c,id,p, rv)    ((rv) = vfs_quotactl(b, c,id,p))
-#define PVFS_INIT_VNODE(b, vp,b2,ul)    ( vfs_init_vnode(b, vp,b2,ul) )
-#define PVFS_FORCE_SHUTDOWN(b, fl,f,l)  ( vfs_force_shutdown(b, fl,f,l) )
-#define PVFS_FREEZE(b)                  ( vfs_freeze(b) )
+#define bhv_next_vfs_mount(b, ma,cr)            vfs_mount(b, ma,cr)
+#define bhv_next_vfs_parseargs(b, o,ma,f)       vfs_parseargs(b, o,ma,f)
+#define bhv_next_vfs_showargs(b, m)             vfs_showargs(b, m)
+#define bhv_next_vfs_unmount(b, f,cr)           vfs_unmount(b, f,cr)
+#define bhv_next_vfs_mntupdate(b, fl,args)      vfs_mntupdate(b, fl, args)
+#define bhv_next_vfs_root(b, vpp)               vfs_root(b, vpp)
+#define bhv_next_vfs_statvfs(b, sp,vp)          vfs_statvfs(b, sp,vp)
+#define bhv_next_vfs_sync(b, flag,cr)           vfs_sync(b, flag,cr)
+#define bhv_next_vfs_vget(b, vpp,fidp)          vfs_vget(b, vpp,fidp)
+#define bhv_next_vfs_dmapiops(b, p)             vfs_dmapiops(b, p)
+#define bhv_next_vfs_quotactl(b, c,id,p)        vfs_quotactl(b, c,id,p)
+#define bhv_next_vfs_init_vnode(b, vp,b2,ul)    vfs_init_vnode(b, vp,b2,ul)
+#define bhv_next_force_shutdown(b, fl,f,l)      vfs_force_shutdown(b, fl,f,l)
+#define bhv_next_vfs_freeze(b)                  vfs_freeze(b)
 
 extern int vfs_mount(bhv_desc_t *, struct xfs_mount_args *, struct cred *);
 extern int vfs_parseargs(bhv_desc_t *, char *, struct xfs_mount_args *, int);
@@ -190,25 +191,26 @@ extern void vfs_init_vnode(bhv_desc_t *, struct vnode *, bhv_desc_t *, int);
 extern void vfs_force_shutdown(bhv_desc_t *, int, char *, int);
 extern void vfs_freeze(bhv_desc_t *);
 
-typedef struct bhv_vfsops {
-        struct vfsops           bhv_common;
+typedef struct bhv_module_vfsops {
+        struct bhv_vfsops       bhv_common;
         void *                  bhv_custom;
-} bhv_vfsops_t;
+} bhv_module_vfsops_t;
+
+#define vfs_bhv_lookup(v, id)   (bhv_lookup_range(&(v)->vfs_bh, (id), (id)))
+#define vfs_bhv_custom(b)       (((bhv_module_vfsops_t*)BHV_OPS(b))->bhv_custom)
+#define vfs_bhv_set_custom(b,o) ((b)->bhv_custom = (void *)(o))
+#define vfs_bhv_clr_custom(b)   ((b)->bhv_custom = NULL)
 
-#define vfs_bhv_lookup(v, id)   ( bhv_lookup_range(&(v)->vfs_bh, (id), (id)) )
-#define vfs_bhv_custom(b)       ( ((bhv_vfsops_t *)BHV_OPS(b))->bhv_custom )
-#define vfs_bhv_set_custom(b,o) ( (b)->bhv_custom = (void *)(o))
-#define vfs_bhv_clr_custom(b)   ( (b)->bhv_custom = NULL )
+extern bhv_vfs_t *vfs_allocate(struct super_block *);
+extern bhv_vfs_t *vfs_from_sb(struct super_block *);
+extern void vfs_deallocate(bhv_vfs_t *);
+extern void vfs_insertbhv(bhv_vfs_t *, bhv_desc_t *, bhv_vfsops_t *, void *);
 
-extern vfs_t *vfs_allocate(struct super_block *);
-extern vfs_t *vfs_from_sb(struct super_block *);
-extern void vfs_deallocate(vfs_t *);
-extern void vfs_insertops(vfs_t *, bhv_vfsops_t *);
-extern void vfs_insertbhv(vfs_t *, bhv_desc_t *, vfsops_t *, void *);
+extern void vfs_insertops(bhv_vfs_t *, bhv_module_vfsops_t *);
 
-extern void bhv_insert_all_vfsops(struct vfs *);
-extern void bhv_remove_all_vfsops(struct vfs *, int);
-extern void bhv_remove_vfsops(struct vfs *, int);
+extern void bhv_insert_all_vfsops(struct bhv_vfs *);
+extern void bhv_remove_all_vfsops(struct bhv_vfs *, int);
+extern void bhv_remove_vfsops(struct bhv_vfs *, int);
 
 #define fs_frozen(vfsp)         ((vfsp)->vfs_super->s_frozen)
 #define fs_check_frozen(vfsp, level) \
diff --git a/fs/xfs/linux-2.6/xfs_vnode.c b/fs/xfs/linux-2.6/xfs_vnode.c
index f17e39cff230..82777f1a70a7 100644
--- a/fs/xfs/linux-2.6/xfs_vnode.c
+++ b/fs/xfs/linux-2.6/xfs_vnode.c
@@ -67,7 +67,7 @@ vn_ioerror(
         int             l)
 {
         if (unlikely(error == -ENODEV))
-                VFS_FORCE_SHUTDOWN(vp->v_vfsp, SHUTDOWN_DEVICE_REQ, f, l);
+                bhv_vfs_force_shutdown(vp->v_vfsp, SHUTDOWN_DEVICE_REQ, f, l);
 }
 
 struct vnode *
diff --git a/fs/xfs/linux-2.6/xfs_vnode.h b/fs/xfs/linux-2.6/xfs_vnode.h
index 569a4e7b5cc1..95343637ab66 100644
--- a/fs/xfs/linux-2.6/xfs_vnode.h
+++ b/fs/xfs/linux-2.6/xfs_vnode.h
@@ -68,7 +68,7 @@ typedef enum vflags {
  */
 typedef struct vnode {
         vflags_t        v_flag;                 /* vnode flags (see above) */
-        struct vfs      *v_vfsp;                /* ptr to containing VFS */
+        struct bhv_vfs  *v_vfsp;                /* ptr to containing VFS */
         vnumber_t       v_number;               /* in-core vnode number */
         vn_bhv_head_t   v_bh;                   /* behavior head */
         spinlock_t      v_lock;                 /* VN_LOCK/VN_UNLOCK */
@@ -503,7 +503,7 @@ extern vnode_t	*vn_initialize(struct inode *);
  * vnode_map structures _must_ match vn_epoch and vnode structure sizes.
  */
 typedef struct vnode_map {
-        vfs_t           *v_vfsp;
+        bhv_vfs_t       *v_vfsp;
         vnumber_t       v_number;               /* in-core vnode number */
         xfs_ino_t       v_ino;                  /* inode #      */
 } vmap_t;