[deliverable/linux.git] / fs / xfs / linux-2.6 / xfs_vfs.c

/*
 * Copyright (c) 2000-2005 Silicon Graphics, Inc.
 * All Rights Reserved.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it would be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write the Free Software Foundation,
 * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */
#include "xfs.h"
#include "xfs_fs.h"
#include "xfs_inum.h"
#include "xfs_log.h"
#include "xfs_clnt.h"
#include "xfs_trans.h"
#include "xfs_sb.h"
#include "xfs_ag.h"
#include "xfs_dir2.h"
#include "xfs_imap.h"
#include "xfs_alloc.h"
#include "xfs_dmapi.h"
#include "xfs_mount.h"
#include "xfs_quota.h"

int
vfs_mount(
	struct bhv_desc		*bdp,
	struct xfs_mount_args	*args,
	struct cred		*cr)
{
	struct bhv_desc		*next = bdp;

	ASSERT(next);
	while (! (bhvtovfsops(next))->vfs_mount)
		next = BHV_NEXT(next);
	return ((*bhvtovfsops(next)->vfs_mount)(next, args, cr));
}

int
vfs_parseargs(
	struct bhv_desc		*bdp,
	char			*s,
	struct xfs_mount_args	*args,
	int			f)
{
	struct bhv_desc		*next = bdp;

	ASSERT(next);
	while (! (bhvtovfsops(next))->vfs_parseargs)
		next = BHV_NEXT(next);
	return ((*bhvtovfsops(next)->vfs_parseargs)(next, s, args, f));
}

int
vfs_showargs(
	struct bhv_desc		*bdp,
	struct seq_file		*m)
{
	struct bhv_desc		*next = bdp;

	ASSERT(next);
	while (! (bhvtovfsops(next))->vfs_showargs)
		next = BHV_NEXT(next);
	return ((*bhvtovfsops(next)->vfs_showargs)(next, m));
}

int
vfs_unmount(
	struct bhv_desc		*bdp,
	int			fl,
	struct cred		*cr)
{
	struct bhv_desc		*next = bdp;

	ASSERT(next);
	while (! (bhvtovfsops(next))->vfs_unmount)
		next = BHV_NEXT(next);
	return ((*bhvtovfsops(next)->vfs_unmount)(next, fl, cr));
}

int
vfs_mntupdate(
	struct bhv_desc		*bdp,
	int			*fl,
	struct xfs_mount_args	*args)
{
	struct bhv_desc		*next = bdp;

	ASSERT(next);
	while (! (bhvtovfsops(next))->vfs_mntupdate)
		next = BHV_NEXT(next);
	return ((*bhvtovfsops(next)->vfs_mntupdate)(next, fl, args));
}

int
vfs_root(
	struct bhv_desc		*bdp,
	struct bhv_vnode	**vpp)
{
	struct bhv_desc		*next = bdp;

	ASSERT(next);
	while (! (bhvtovfsops(next))->vfs_root)
		next = BHV_NEXT(next);
	return ((*bhvtovfsops(next)->vfs_root)(next, vpp));
}

int
vfs_statvfs(
	struct bhv_desc		*bdp,
	bhv_statvfs_t		*statp,
	struct bhv_vnode	*vp)
{
	struct bhv_desc		*next = bdp;

	ASSERT(next);
	while (! (bhvtovfsops(next))->vfs_statvfs)
		next = BHV_NEXT(next);
	return ((*bhvtovfsops(next)->vfs_statvfs)(next, statp, vp));
}

int
vfs_sync(
	struct bhv_desc		*bdp,
	int			fl,
	struct cred		*cr)
{
	struct bhv_desc		*next = bdp;

	ASSERT(next);
	while (! (bhvtovfsops(next))->vfs_sync)
		next = BHV_NEXT(next);
	return ((*bhvtovfsops(next)->vfs_sync)(next, fl, cr));
}

int
vfs_vget(
	struct bhv_desc		*bdp,
	struct bhv_vnode	**vpp,
	struct fid		*fidp)
{
	struct bhv_desc		*next = bdp;

	ASSERT(next);
	while (! (bhvtovfsops(next))->vfs_vget)
		next = BHV_NEXT(next);
	return ((*bhvtovfsops(next)->vfs_vget)(next, vpp, fidp));
}

int
vfs_dmapiops(
	struct bhv_desc		*bdp,
	caddr_t			addr)
{
	struct bhv_desc		*next = bdp;

	ASSERT(next);
	while (! (bhvtovfsops(next))->vfs_dmapiops)
		next = BHV_NEXT(next);
	return ((*bhvtovfsops(next)->vfs_dmapiops)(next, addr));
}

int
vfs_quotactl(
	struct bhv_desc		*bdp,
	int			cmd,
	int			id,
	caddr_t			addr)
{
	struct bhv_desc		*next = bdp;

	ASSERT(next);
	while (! (bhvtovfsops(next))->vfs_quotactl)
		next = BHV_NEXT(next);
	return ((*bhvtovfsops(next)->vfs_quotactl)(next, cmd, id, addr));
}

void
vfs_init_vnode(
	struct bhv_desc		*bdp,
	struct bhv_vnode	*vp,
	struct xfs_inode	*ip,
	int			unlock)
{
	struct bhv_desc		*next = bdp;

	ASSERT(next);
	while (! (bhvtovfsops(next))->vfs_init_vnode)
		next = BHV_NEXT(next);
	((*bhvtovfsops(next)->vfs_init_vnode)(next, vp, ip, unlock));
}

void
vfs_force_shutdown(
	struct bhv_desc		*bdp,
	int			fl,
	char			*file,
	int			line)
{
	struct bhv_desc		*next = bdp;

	ASSERT(next);
	while (! (bhvtovfsops(next))->vfs_force_shutdown)
		next = BHV_NEXT(next);
	((*bhvtovfsops(next)->vfs_force_shutdown)(next, fl, file, line));
}

void
vfs_freeze(
	struct bhv_desc		*bdp)
{
	struct bhv_desc		*next = bdp;

	ASSERT(next);
	while (! (bhvtovfsops(next))->vfs_freeze)
		next = BHV_NEXT(next);
	((*bhvtovfsops(next)->vfs_freeze)(next));
}

bhv_vfs_t *
vfs_allocate(
	struct super_block	*sb)
{
	struct bhv_vfs		*vfsp;

	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);
	init_waitqueue_head(&vfsp->vfs_wait_single_sync_task);

	vfsp->vfs_super = sb;
	sb->s_fs_info = vfsp;

	if (sb->s_flags & MS_RDONLY)
		vfsp->vfs_flag |= VFS_RDONLY;

	return vfsp;
}

bhv_vfs_t *
vfs_from_sb(
	struct super_block	*sb)
{
	return (bhv_vfs_t *)sb->s_fs_info;
}

void
vfs_deallocate(
	struct bhv_vfs		*vfsp)
{
	bhv_head_destroy(VFS_BHVHEAD(vfsp));
	kmem_free(vfsp, sizeof(bhv_vfs_t));
}

void
vfs_insertops(
	struct bhv_vfs		*vfsp,
	struct bhv_module_vfsops *vfsops)
{
	struct bhv_desc		*bdp;

	bdp = kmem_alloc(sizeof(struct bhv_desc), KM_SLEEP);
	bhv_desc_init(bdp, NULL, vfsp, vfsops);
	bhv_insert(&vfsp->vfs_bh, bdp);
}

void
vfs_insertbhv(
	struct bhv_vfs		*vfsp,
	struct bhv_desc		*bdp,
	struct bhv_vfsops	*vfsops,
	void			*mount)
{
	bhv_desc_init(bdp, mount, vfsp, vfsops);
	bhv_insert_initial(&vfsp->vfs_bh, bdp);
}

void
bhv_remove_vfsops(
	struct bhv_vfs		*vfsp,
	int			pos)
{
	struct bhv_desc		*bhv;

	bhv = bhv_lookup_range(&vfsp->vfs_bh, pos, pos);
	if (!bhv)
		return;
	bhv_remove(&vfsp->vfs_bh, bhv);
	kmem_free(bhv, sizeof(*bhv));
}

void
bhv_remove_all_vfsops(
	struct bhv_vfs		*vfsp,
	int			freebase)
{
	struct xfs_mount	*mp;

	bhv_remove_vfsops(vfsp, VFS_POSITION_QM);
	bhv_remove_vfsops(vfsp, VFS_POSITION_DM);
	if (!freebase)
		return;
	mp = XFS_VFSTOM(vfsp);
	VFS_REMOVEBHV(vfsp, &mp->m_bhv);
	xfs_mount_free(mp, 0);
}

void
bhv_insert_all_vfsops(
	struct bhv_vfs		*vfsp)
{
	struct xfs_mount	*mp;

	mp = xfs_mount_init();
	vfs_insertbhv(vfsp, &mp->m_bhv, &xfs_vfsops, mp);
	vfs_insertdmapi(vfsp);
	vfs_insertquota(vfsp);
}
Commit	Line	Data
1da177e4	1	/*
7b718769 NS	2	* Copyright (c) 2000-2005 Silicon Graphics, Inc.
7b718769 NS	3	* All Rights Reserved.
1da177e4	4	*
7b718769 NS	5	* This program is free software; you can redistribute it and/or
7b718769 NS	6	* modify it under the terms of the GNU General Public License as
1da177e4 LT	7	* published by the Free Software Foundation.
1da177e4 LT	8	*
7b718769 NS	9	* This program is distributed in the hope that it would be useful,
	10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	* GNU General Public License for more details.
1da177e4	13	*
7b718769 NS	14	* You should have received a copy of the GNU General Public License
	15	* along with this program; if not, write the Free Software Foundation,
	16	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
1da177e4	17	*/
1da177e4 LT	18	#include "xfs.h"
1da177e4 LT	19	#include "xfs_fs.h"
1da177e4 LT	20	#include "xfs_inum.h"
	21	#include "xfs_log.h"
	22	#include "xfs_clnt.h"
	23	#include "xfs_trans.h"
	24	#include "xfs_sb.h"
	25	#include "xfs_ag.h"
1da177e4 LT	26	#include "xfs_dir2.h"
	27	#include "xfs_imap.h"
	28	#include "xfs_alloc.h"
	29	#include "xfs_dmapi.h"
	30	#include "xfs_mount.h"
	31	#include "xfs_quota.h"
	32
	33	int
	34	vfs_mount(
	35	struct bhv_desc *bdp,
	36	struct xfs_mount_args *args,
	37	struct cred *cr)
	38	{
	39	struct bhv_desc *next = bdp;
	40
	41	ASSERT(next);
	42	while (! (bhvtovfsops(next))->vfs_mount)
	43	next = BHV_NEXT(next);
	44	return ((*bhvtovfsops(next)->vfs_mount)(next, args, cr));
	45	}
	46
	47	int
	48	vfs_parseargs(
	49	struct bhv_desc *bdp,
	50	char *s,
	51	struct xfs_mount_args *args,
	52	int f)
	53	{
	54	struct bhv_desc *next = bdp;
	55
	56	ASSERT(next);
	57	while (! (bhvtovfsops(next))->vfs_parseargs)
	58	next = BHV_NEXT(next);
	59	return ((*bhvtovfsops(next)->vfs_parseargs)(next, s, args, f));
	60	}
	61
	62	int
	63	vfs_showargs(
	64	struct bhv_desc *bdp,
	65	struct seq_file *m)
	66	{
	67	struct bhv_desc *next = bdp;
	68
	69	ASSERT(next);
	70	while (! (bhvtovfsops(next))->vfs_showargs)
	71	next = BHV_NEXT(next);
	72	return ((*bhvtovfsops(next)->vfs_showargs)(next, m));
	73	}
	74
	75	int
	76	vfs_unmount(
	77	struct bhv_desc *bdp,
	78	int fl,
	79	struct cred *cr)
	80	{
	81	struct bhv_desc *next = bdp;
	82
	83	ASSERT(next);
	84	while (! (bhvtovfsops(next))->vfs_unmount)
	85	next = BHV_NEXT(next);
	86	return ((*bhvtovfsops(next)->vfs_unmount)(next, fl, cr));
	87	}
	88
	89	int
90	vfs_mntupdate(
91	struct bhv_desc *bdp,
92	int *fl,
93	struct xfs_mount_args *args)
94	{
95	struct bhv_desc *next = bdp;
96
97	ASSERT(next);
98	while (! (bhvtovfsops(next))->vfs_mntupdate)
99	next = BHV_NEXT(next);
100	return ((*bhvtovfsops(next)->vfs_mntupdate)(next, fl, args));
101	}
102
103	int
104	vfs_root(
105	struct bhv_desc *bdp,
67fcaa73	106	struct bhv_vnode **vpp)
1da177e4 LT	107	{
	108	struct bhv_desc *next = bdp;
	109
	110	ASSERT(next);
	111	while (! (bhvtovfsops(next))->vfs_root)
	112	next = BHV_NEXT(next);
	113	return ((*bhvtovfsops(next)->vfs_root)(next, vpp));
	114	}
	115
	116	int
	117	vfs_statvfs(
	118	struct bhv_desc *bdp,
8285fb58	119	bhv_statvfs_t *statp,
67fcaa73	120	struct bhv_vnode *vp)
1da177e4 LT	121	{
	122	struct bhv_desc *next = bdp;
	123
	124	ASSERT(next);
	125	while (! (bhvtovfsops(next))->vfs_statvfs)
	126	next = BHV_NEXT(next);
8285fb58	127	return ((*bhvtovfsops(next)->vfs_statvfs)(next, statp, vp));
1da177e4 LT	128	}
	129
	130	int
	131	vfs_sync(
	132	struct bhv_desc *bdp,
	133	int fl,
	134	struct cred *cr)
	135	{
	136	struct bhv_desc *next = bdp;
	137
	138	ASSERT(next);
	139	while (! (bhvtovfsops(next))->vfs_sync)
	140	next = BHV_NEXT(next);
	141	return ((*bhvtovfsops(next)->vfs_sync)(next, fl, cr));
	142	}
	143
	144	int
	145	vfs_vget(
	146	struct bhv_desc *bdp,
67fcaa73	147	struct bhv_vnode **vpp,
1da177e4 LT	148	struct fid *fidp)
	149	{
	150	struct bhv_desc *next = bdp;
	151
	152	ASSERT(next);
	153	while (! (bhvtovfsops(next))->vfs_vget)
	154	next = BHV_NEXT(next);
	155	return ((*bhvtovfsops(next)->vfs_vget)(next, vpp, fidp));
	156	}
	157
	158	int
	159	vfs_dmapiops(
	160	struct bhv_desc *bdp,
	161	caddr_t addr)
	162	{
	163	struct bhv_desc *next = bdp;
	164
	165	ASSERT(next);
	166	while (! (bhvtovfsops(next))->vfs_dmapiops)
	167	next = BHV_NEXT(next);
	168	return ((*bhvtovfsops(next)->vfs_dmapiops)(next, addr));
	169	}
	170
	171	int
	172	vfs_quotactl(
	173	struct bhv_desc *bdp,
	174	int cmd,
	175	int id,
	176	caddr_t addr)
	177	{
	178	struct bhv_desc *next = bdp;
	179
	180	ASSERT(next);
	181	while (! (bhvtovfsops(next))->vfs_quotactl)
	182	next = BHV_NEXT(next);
	183	return ((*bhvtovfsops(next)->vfs_quotactl)(next, cmd, id, addr));
	184	}
	185
	186	void
	187	vfs_init_vnode(
	188	struct bhv_desc *bdp,
67fcaa73	189	struct bhv_vnode *vp,
739bfb2a	190	struct xfs_inode *ip,
1da177e4 LT	191	int unlock)
	192	{
	193	struct bhv_desc *next = bdp;
	194
	195	ASSERT(next);
	196	while (! (bhvtovfsops(next))->vfs_init_vnode)
	197	next = BHV_NEXT(next);
739bfb2a	198	((*bhvtovfsops(next)->vfs_init_vnode)(next, vp, ip, unlock));
1da177e4 LT	199	}
	200
	201	void
	202	vfs_force_shutdown(
	203	struct bhv_desc *bdp,
	204	int fl,
	205	char *file,
	206	int line)
	207	{
	208	struct bhv_desc *next = bdp;
	209
	210	ASSERT(next);
	211	while (! (bhvtovfsops(next))->vfs_force_shutdown)
	212	next = BHV_NEXT(next);
	213	((*bhvtovfsops(next)->vfs_force_shutdown)(next, fl, file, line));
	214	}
	215
	216	void
	217	vfs_freeze(
	218	struct bhv_desc *bdp)
	219	{
	220	struct bhv_desc *next = bdp;
	221
	222	ASSERT(next);
	223	while (! (bhvtovfsops(next))->vfs_freeze)
	224	next = BHV_NEXT(next);
	225	((*bhvtovfsops(next)->vfs_freeze)(next));
	226	}
	227
b83bd138	228	bhv_vfs_t *
ec86dc02 NS	229	vfs_allocate(
ec86dc02 NS	230	struct super_block *sb)
1da177e4	231	{
b83bd138	232	struct bhv_vfs *vfsp;
1da177e4	233
b83bd138	234	vfsp = kmem_zalloc(sizeof(bhv_vfs_t), KM_SLEEP);
1da177e4 LT	235	bhv_head_init(VFS_BHVHEAD(vfsp), "vfs");
	236	INIT_LIST_HEAD(&vfsp->vfs_sync_list);
	237	spin_lock_init(&vfsp->vfs_sync_lock);
1da177e4	238	init_waitqueue_head(&vfsp->vfs_wait_single_sync_task);
ec86dc02 NS	239
	240	vfsp->vfs_super = sb;
	241	sb->s_fs_info = vfsp;
	242
	243	if (sb->s_flags & MS_RDONLY)
	244	vfsp->vfs_flag \|= VFS_RDONLY;
	245
1da177e4 LT	246	return vfsp;
	247	}
	248
b83bd138	249	bhv_vfs_t *
ec86dc02 NS	250	vfs_from_sb(
	251	struct super_block *sb)
	252	{
b83bd138	253	return (bhv_vfs_t *)sb->s_fs_info;
ec86dc02 NS	254	}
ec86dc02 NS	255
1da177e4 LT	256	void
1da177e4 LT	257	vfs_deallocate(
b83bd138	258	struct bhv_vfs *vfsp)
1da177e4 LT	259	{
1da177e4 LT	260	bhv_head_destroy(VFS_BHVHEAD(vfsp));
b83bd138	261	kmem_free(vfsp, sizeof(bhv_vfs_t));
1da177e4 LT	262	}
	263
	264	void
	265	vfs_insertops(
b83bd138 NS	266	struct bhv_vfs *vfsp,
b83bd138 NS	267	struct bhv_module_vfsops *vfsops)
1da177e4 LT	268	{
	269	struct bhv_desc *bdp;
	270
	271	bdp = kmem_alloc(sizeof(struct bhv_desc), KM_SLEEP);
	272	bhv_desc_init(bdp, NULL, vfsp, vfsops);
	273	bhv_insert(&vfsp->vfs_bh, bdp);
	274	}
	275
	276	void
	277	vfs_insertbhv(
b83bd138	278	struct bhv_vfs *vfsp,
1da177e4	279	struct bhv_desc *bdp,
b83bd138	280	struct bhv_vfsops *vfsops,
1da177e4 LT	281	void *mount)
	282	{
	283	bhv_desc_init(bdp, mount, vfsp, vfsops);
	284	bhv_insert_initial(&vfsp->vfs_bh, bdp);
	285	}
	286
	287	void
	288	bhv_remove_vfsops(
b83bd138	289	struct bhv_vfs *vfsp,
1da177e4 LT	290	int pos)
	291	{
	292	struct bhv_desc *bhv;
	293
	294	bhv = bhv_lookup_range(&vfsp->vfs_bh, pos, pos);
	295	if (!bhv)
	296	return;
	297	bhv_remove(&vfsp->vfs_bh, bhv);
	298	kmem_free(bhv, sizeof(*bhv));
	299	}
	300
	301	void
	302	bhv_remove_all_vfsops(
b83bd138	303	struct bhv_vfs *vfsp,
1da177e4 LT	304	int freebase)
	305	{
	306	struct xfs_mount *mp;
	307
	308	bhv_remove_vfsops(vfsp, VFS_POSITION_QM);
	309	bhv_remove_vfsops(vfsp, VFS_POSITION_DM);
	310	if (!freebase)
	311	return;
02d7c923	312	mp = XFS_VFSTOM(vfsp);
1da177e4 LT	313	VFS_REMOVEBHV(vfsp, &mp->m_bhv);
	314	xfs_mount_free(mp, 0);
	315	}
	316
	317	void
	318	bhv_insert_all_vfsops(
b83bd138	319	struct bhv_vfs *vfsp)
1da177e4 LT	320	{
	321	struct xfs_mount *mp;
	322
	323	mp = xfs_mount_init();
	324	vfs_insertbhv(vfsp, &mp->m_bhv, &xfs_vfsops, mp);
	325	vfs_insertdmapi(vfsp);
	326	vfs_insertquota(vfsp);
	327	}