wmb();	wake_up_process(vfsp->vfs_sync_task);	wait_event(vfsp->vfs_wait_sync_task, !vfsp->vfs_sync_task);}STATIC voidlinvfs_put_super(	struct super_block	*sb){	vfs_t			*vfsp = LINVFS_GET_VFS(sb);	int			error;	linvfs_stop_syncd(vfsp);	VFS_SYNC(vfsp, SYNC_ATTR|SYNC_DELWRI, NULL, error);	if (!error)		VFS_UNMOUNT(vfsp, 0, NULL, error);	if (error) {		printk("XFS unmount got error %d\n", error);		printk("%s: vfsp/0x%p left dangling!\n", __FUNCTION__, vfsp);		return;	}	vfs_deallocate(vfsp);}STATIC voidlinvfs_write_super(	struct super_block	*sb){	vfs_t			*vfsp = LINVFS_GET_VFS(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);	sb->s_dirt = 0;}STATIC intlinvfs_sync_super(	struct super_block	*sb,	int			wait){	vfs_t		*vfsp = LINVFS_GET_VFS(sb);	int		error;	int		flags = SYNC_FSDATA;	if (wait)		flags |= SYNC_WAIT;	VFS_SYNC(vfsp, flags, NULL, error);	sb->s_dirt = 0;	if (unlikely(laptop_mode)) {		int	prev_sync_seq = vfsp->vfs_sync_seq;		/*		 * The disk must be active because we're syncing.		 * We schedule syncd now (now that the disk is		 * active) instead of later (when it might not be).		 */		wake_up_process(vfsp->vfs_sync_task);		/*		 * We have to wait for the sync iteration to complete.		 * If we don't, the disk activity caused by the sync		 * will come after the sync is completed, and that		 * triggers another sync from laptop mode.		 */		wait_event(vfsp->vfs_wait_single_sync_task,				vfsp->vfs_sync_seq != prev_sync_seq);	}	return -error;}STATIC intlinvfs_statfs(	struct super_block	*sb,	struct kstatfs		*statp){	vfs_t			*vfsp = LINVFS_GET_VFS(sb);	int			error;	VFS_STATVFS(vfsp, statp, NULL, error);	return -error;}STATIC intlinvfs_remount(	struct super_block	*sb,	int			*flags,	char			*options){	vfs_t			*vfsp = LINVFS_GET_VFS(sb);	struct xfs_mount_args	*args = xfs_args_allocate(sb);	int			error;	VFS_PARSEARGS(vfsp, options, args, 1, error);	if (!error)		VFS_MNTUPDATE(vfsp, flags, args, error);	kmem_free(args, sizeof(*args));	return -error;}STATIC voidlinvfs_freeze_fs(	struct super_block	*sb){	VFS_FREEZE(LINVFS_GET_VFS(sb));}STATIC struct dentry *linvfs_get_parent(	struct dentry		*child){	int			error;	vnode_t			*vp, *cvp;	struct dentry		*parent;	struct inode		*ip = NULL;	struct dentry		dotdot;	dotdot.d_name.name = "..";	dotdot.d_name.len = 2;	dotdot.d_inode = 0;	cvp = NULL;	vp = LINVFS_GET_VP(child->d_inode);	VOP_LOOKUP(vp, &dotdot, &cvp, 0, NULL, NULL, error);	if (!error) {		ASSERT(cvp);		ip = LINVFS_GET_IP(cvp);		if (!ip) {			VN_RELE(cvp);			return ERR_PTR(-EACCES);		}	}	if (error)		return ERR_PTR(-error);	parent = d_alloc_anon(ip);	if (!parent) {		VN_RELE(cvp);		parent = ERR_PTR(-ENOMEM);	}	return parent;}STATIC struct dentry *linvfs_get_dentry(	struct super_block	*sb,	void			*data){	vnode_t			*vp;	struct inode		*inode;	struct dentry		*result;	xfs_fid2_t		xfid;	vfs_t			*vfsp = LINVFS_GET_VFS(sb);	int			error;	xfid.fid_len = sizeof(xfs_fid2_t) - sizeof(xfid.fid_len);	xfid.fid_pad = 0;	xfid.fid_gen = ((__u32 *)data)[1];	xfid.fid_ino = ((__u32 *)data)[0];	VFS_VGET(vfsp, &vp, (fid_t *)&xfid, error);	if (error || vp == NULL)		return ERR_PTR(-ESTALE) ;	inode = LINVFS_GET_IP(vp);	result = d_alloc_anon(inode);        if (!result) {		iput(inode);		return ERR_PTR(-ENOMEM);	}	return result;}STATIC intlinvfs_show_options(	struct seq_file		*m,	struct vfsmount		*mnt){	struct vfs		*vfsp = LINVFS_GET_VFS(mnt->mnt_sb);	int			error;	VFS_SHOWARGS(vfsp, m, error);	return error;}STATIC intlinvfs_getxstate(	struct super_block	*sb,	struct fs_quota_stat	*fqs){	struct vfs		*vfsp = LINVFS_GET_VFS(sb);	int			error;	VFS_QUOTACTL(vfsp, Q_XGETQSTAT, 0, (caddr_t)fqs, error);	return -error;}STATIC intlinvfs_setxstate(	struct super_block	*sb,	unsigned int		flags,	int			op){	struct vfs		*vfsp = LINVFS_GET_VFS(sb);	int			error;	VFS_QUOTACTL(vfsp, op, 0, (caddr_t)&flags, error);	return -error;}STATIC intlinvfs_getxquota(	struct super_block	*sb,	int			type,	qid_t			id,	struct fs_disk_quota	*fdq){	struct vfs		*vfsp = LINVFS_GET_VFS(sb);	int			error, getmode;	getmode = (type == GRPQUOTA) ? Q_XGETGQUOTA : Q_XGETQUOTA;	VFS_QUOTACTL(vfsp, getmode, id, (caddr_t)fdq, error);	return -error;}STATIC intlinvfs_setxquota(	struct super_block	*sb,	int			type,	qid_t			id,	struct fs_disk_quota	*fdq){	struct vfs		*vfsp = LINVFS_GET_VFS(sb);	int			error, setmode;	setmode = (type == GRPQUOTA) ? Q_XSETGQLIM : Q_XSETQLIM;	VFS_QUOTACTL(vfsp, setmode, id, (caddr_t)fdq, error);	return -error;}STATIC intlinvfs_fill_super(	struct super_block	*sb,	void			*data,	int			silent){	vnode_t			*rootvp;	struct vfs		*vfsp = vfs_allocate();	struct xfs_mount_args	*args = xfs_args_allocate(sb);	struct kstatfs		statvfs;	int			error, error2;	vfsp->vfs_super = sb;	LINVFS_SET_VFS(sb, vfsp);	if (sb->s_flags & MS_RDONLY)		vfsp->vfs_flag |= VFS_RDONLY;	bhv_insert_all_vfsops(vfsp);	VFS_PARSEARGS(vfsp, (char *)data, args, 0, error);	if (error) {		bhv_remove_all_vfsops(vfsp, 1);		goto fail_vfsop;	}	sb_min_blocksize(sb, BBSIZE);	sb->s_export_op = &linvfs_export_ops;	sb->s_qcop = &linvfs_qops;	sb->s_op = &linvfs_sops;	VFS_MOUNT(vfsp, args, NULL, error);	if (error) {		bhv_remove_all_vfsops(vfsp, 1);		goto fail_vfsop;	}	VFS_STATVFS(vfsp, &statvfs, NULL, error);	if (error)		goto fail_unmount;	sb->s_dirt = 1;	sb->s_magic = statvfs.f_type;	sb->s_blocksize = statvfs.f_bsize;	sb->s_blocksize_bits = ffs(statvfs.f_bsize) - 1;	sb->s_maxbytes = xfs_max_file_offset(sb->s_blocksize_bits);	set_posix_acl_flag(sb);	VFS_ROOT(vfsp, &rootvp, error);	if (error)		goto fail_unmount;	sb->s_root = d_alloc_root(LINVFS_GET_IP(rootvp));	if (!sb->s_root) {		error = ENOMEM;		goto fail_vnrele;	}	if (is_bad_inode(sb->s_root->d_inode)) {		error = EINVAL;		goto fail_vnrele;	}	if ((error = linvfs_start_syncd(vfsp)))		goto fail_vnrele;	vn_trace_exit(rootvp, __FUNCTION__, (inst_t *)__return_address);	kmem_free(args, sizeof(*args));	return 0;fail_vnrele:	if (sb->s_root) {		dput(sb->s_root);		sb->s_root = NULL;	} else {		VN_RELE(rootvp);	}fail_unmount:	VFS_UNMOUNT(vfsp, 0, NULL, error2);fail_vfsop:	vfs_deallocate(vfsp);	kmem_free(args, sizeof(*args));	return -error;}STATIC struct super_block *linvfs_get_sb(	struct file_system_type	*fs_type,	int			flags,	const char		*dev_name,	void			*data){	return get_sb_bdev(fs_type, flags, dev_name, data, linvfs_fill_super);}STATIC struct export_operations linvfs_export_ops = {	.get_parent		= linvfs_get_parent,	.get_dentry		= linvfs_get_dentry,};STATIC struct super_operations linvfs_sops = {	.alloc_inode		= linvfs_alloc_inode,	.destroy_inode		= linvfs_destroy_inode,	.write_inode		= linvfs_write_inode,	.clear_inode		= linvfs_clear_inode,	.put_super		= linvfs_put_super,	.write_super		= linvfs_write_super,	.sync_fs		= linvfs_sync_super,	.write_super_lockfs	= linvfs_freeze_fs,	.statfs			= linvfs_statfs,	.remount_fs		= linvfs_remount,	.show_options		= linvfs_show_options,};STATIC struct quotactl_ops linvfs_qops = {	.get_xstate		= linvfs_getxstate,	.set_xstate		= linvfs_setxstate,	.get_xquota		= linvfs_getxquota,	.set_xquota		= linvfs_setxquota,};STATIC struct file_system_type xfs_fs_type = {	.owner			= THIS_MODULE,	.name			= "xfs",	.get_sb			= linvfs_get_sb,	.kill_sb		= kill_block_super,	.fs_flags		= FS_REQUIRES_DEV,};STATIC int __initinit_xfs_fs( void ){	int			error;	struct sysinfo		si;	static char		message[] __initdata = KERN_INFO \		XFS_VERSION_STRING " with " XFS_BUILD_OPTIONS " enabled\n";	printk(message);	si_meminfo(&si);	xfs_physmem = si.totalram;	ktrace_init(64);	error = init_inodecache();	if (error < 0)		goto undo_inodecache;	error = pagebuf_init();	if (error < 0)		goto undo_pagebuf;	vn_init();	xfs_init();	uuid_init();	vfs_initquota();	xfs_inode_shaker = kmem_shake_register(xfs_inode_shake);	if (!xfs_inode_shaker) {		error = -ENOMEM;		goto undo_shaker;	}	error = register_filesystem(&xfs_fs_type);	if (error)		goto undo_register;	XFS_DM_INIT(&xfs_fs_type);	return 0;undo_register:	kmem_shake_deregister(xfs_inode_shaker);undo_shaker:	pagebuf_terminate();undo_pagebuf:	destroy_inodecache();undo_inodecache:	return error;}STATIC void __exitexit_xfs_fs( void ){	vfs_exitquota();	XFS_DM_EXIT(&xfs_fs_type);	unregister_filesystem(&xfs_fs_type);	kmem_shake_deregister(xfs_inode_shaker);	xfs_cleanup();	pagebuf_terminate();	destroy_inodecache();	ktrace_uninit();}module_init(init_xfs_fs);module_exit(exit_xfs_fs);MODULE_AUTHOR("Silicon Graphics, Inc.");MODULE_DESCRIPTION(XFS_VERSION_STRING " with " XFS_BUILD_OPTIONS " enabled");MODULE_LICENSE("GPL");