Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit b83bd138 authored by Nathan Scott's avatar Nathan Scott
Browse files

[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: default avatarNathan Scott <nathans@sgi.com>
parent 932f2c32

fs/xfs/linux-2.6/xfs_export.c

+3 −3
Original line number Diff line number Diff line
@@ -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) ;

fs/xfs/linux-2.6/xfs_super.c

+53 −88
Original line number Diff line number Diff line
@@ -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);

	}

}



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

	bhv_vfs_t		*vfsp = vfs_from_sb(sb);

	int			error;

	int		flags = SYNC_FSDATA;

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

fs/xfs/linux-2.6/xfs_vfs.c

+14 −14
Original line number Diff line number Diff line
@@ -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;

fs/xfs/linux-2.6/xfs_vfs.h

+64 −62
Original line number Diff line number Diff line 
/*

 * 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. */

	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_vfsops_t *)BHV_OPS(b))->bhv_custom )

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



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

fs/xfs/linux-2.6/xfs_vnode.c

+1 −1
Original line number Diff line number Diff line
@@ -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 *