[XFS] Resolve a namespace collision on vfs/vfsops for FreeBSD porters.

SGI-PV: 9533338
SGI-Modid: xfs-linux-melb:xfs-kern:26106a

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

1 files changed, 53 insertions, 88 deletions

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);