X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=fs%2Fxfs%2Flinux-2.6%2Fxfs_super.c;h=92d8ba6682a134359027943093d89d37cea4f330;hb=987b0145d94eecf292d8b301228356f44611ab7c;hp=4a79c7f2d010105b6567909496da1151d6342ab8;hpb=f7ed79d23a47594e7834d66a8f14449796d4f3e6;p=linux-2.6.git

diff --git a/fs/xfs/linux-2.6/xfs_super.c b/fs/xfs/linux-2.6/xfs_super.c
index 4a79c7f2d..92d8ba668 100644
--- a/fs/xfs/linux-2.6/xfs_super.c
+++ b/fs/xfs/linux-2.6/xfs_super.c
@@ -59,16 +59,15 @@
 #include <linux/writeback.h>
 #include <linux/kthread.h>
 
-STATIC struct quotactl_ops xfs_quotactl_operations;
-STATIC struct super_operations xfs_super_operations;
+STATIC struct quotactl_ops linvfs_qops;
+STATIC struct super_operations linvfs_sops;
 STATIC kmem_zone_t *xfs_vnode_zone;
 STATIC kmem_zone_t *xfs_ioend_zone;
 mempool_t *xfs_ioend_pool;
 
 STATIC struct xfs_mount_args *
 xfs_args_allocate(
-	struct super_block	*sb,
-	int			silent)
+	struct super_block	*sb)
 {
 	struct xfs_mount_args	*args;
 
@@ -77,12 +76,14 @@ xfs_args_allocate(
 	strncpy(args->fsname, sb->s_id, MAXNAMELEN);
 
 	/* Copy the already-parsed mount(2) flags we're interested in */
+	if (sb->s_flags & MS_NOATIME)
+		args->flags |= XFSMNT_NOATIME;
 	if (sb->s_flags & MS_DIRSYNC)
 		args->flags |= XFSMNT_DIRSYNC;
 	if (sb->s_flags & MS_SYNCHRONOUS)
 		args->flags |= XFSMNT_WSYNC;
-	if (silent)
-		args->flags |= XFSMNT_QUIET;
+
+	/* Default to 32 bit inodes on Linux all the time */
 	args->flags |= XFSMNT_32BITINODES;
 
 	return args;
@@ -128,21 +129,21 @@ xfs_set_inodeops(
 {
 	switch (inode->i_mode & S_IFMT) {
 	case S_IFREG:
-		inode->i_op = &xfs_inode_operations;
-		inode->i_fop = &xfs_file_operations;
-		inode->i_mapping->a_ops = &xfs_address_space_operations;
+		inode->i_op = &linvfs_file_inode_operations;
+		inode->i_fop = &linvfs_file_operations;
+		inode->i_mapping->a_ops = &linvfs_aops;
 		break;
 	case S_IFDIR:
-		inode->i_op = &xfs_dir_inode_operations;
-		inode->i_fop = &xfs_dir_file_operations;
+		inode->i_op = &linvfs_dir_inode_operations;
+		inode->i_fop = &linvfs_dir_operations;
 		break;
 	case S_IFLNK:
-		inode->i_op = &xfs_symlink_inode_operations;
+		inode->i_op = &linvfs_symlink_inode_operations;
 		if (inode->i_blocks)
-			inode->i_mapping->a_ops = &xfs_address_space_operations;
+			inode->i_mapping->a_ops = &linvfs_aops;
 		break;
 	default:
-		inode->i_op = &xfs_inode_operations;
+		inode->i_op = &linvfs_file_inode_operations;
 		init_special_inode(inode, inode->i_mode, inode->i_rdev);
 		break;
 	}
@@ -154,7 +155,7 @@ xfs_revalidate_inode(
 	vnode_t			*vp,
 	xfs_inode_t		*ip)
 {
-	struct inode		*inode = vn_to_inode(vp);
+	struct inode		*inode = LINVFS_GET_IP(vp);
 
 	inode->i_mode	= ip->i_d.di_mode;
 	inode->i_nlink	= ip->i_d.di_nlink;
@@ -220,7 +221,7 @@ xfs_initialize_vnode(
 	int			unlock)
 {
 	xfs_inode_t		*ip = XFS_BHVTOI(inode_bhv);
-	struct inode		*inode = vn_to_inode(vp);
+	struct inode		*inode = LINVFS_GET_IP(vp);
 
 	if (!inode_bhv->bd_vobj) {
 		vp->v_vfsp = bhvtovfs(bdp);
@@ -238,7 +239,7 @@ xfs_initialize_vnode(
 	if (ip->i_d.di_mode != 0 && unlock && (inode->i_state & I_NEW)) {
 		xfs_revalidate_inode(XFS_BHVTOM(bdp), vp, ip);
 		xfs_set_inodeops(inode);
-
+	
 		ip->i_flags &= ~XFS_INEW;
 		barrier();
 
@@ -342,42 +343,43 @@ xfs_blkdev_issue_flush(
 }
 
 STATIC struct inode *
-xfs_fs_alloc_inode(
+linvfs_alloc_inode(
 	struct super_block	*sb)
 {
 	vnode_t			*vp;
 
-	vp = kmem_zone_alloc(xfs_vnode_zone, KM_SLEEP);
-	if (unlikely(!vp))
+	vp = kmem_cache_alloc(xfs_vnode_zone, kmem_flags_convert(KM_SLEEP));
+	if (!vp)
 		return NULL;
-	return vn_to_inode(vp);
+	return LINVFS_GET_IP(vp);
 }
 
 STATIC void
-xfs_fs_destroy_inode(
+linvfs_destroy_inode(
 	struct inode		*inode)
 {
-	kmem_zone_free(xfs_vnode_zone, vn_from_inode(inode));
+	kmem_zone_free(xfs_vnode_zone, LINVFS_GET_VP(inode));
 }
 
 STATIC void
-xfs_fs_inode_init_once(
-	void			*vnode,
-	kmem_zone_t		*zonep,
+linvfs_inode_init_once(
+	void			*data,
+	kmem_cache_t		*cachep,
 	unsigned long		flags)
 {
+	vnode_t			*vp = (vnode_t *)data;
+
 	if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
-		      SLAB_CTOR_CONSTRUCTOR)
-		inode_init_once(vn_to_inode((vnode_t *)vnode));
+	    SLAB_CTOR_CONSTRUCTOR)
+		inode_init_once(LINVFS_GET_IP(vp));
 }
 
 STATIC int
-xfs_init_zones(void)
+linvfs_init_zones(void)
 {
-	xfs_vnode_zone = kmem_zone_init_flags(sizeof(vnode_t), "xfs_vnode_t",
-					KM_ZONE_HWALIGN | KM_ZONE_RECLAIM |
-					KM_ZONE_SPREAD,
-					xfs_fs_inode_init_once);
+	xfs_vnode_zone = kmem_cache_create("xfs_vnode",
+				sizeof(vnode_t), 0, SLAB_RECLAIM_ACCOUNT,
+				linvfs_inode_init_once, NULL);
 	if (!xfs_vnode_zone)
 		goto out;
 
@@ -385,12 +387,15 @@ xfs_init_zones(void)
 	if (!xfs_ioend_zone)
 		goto out_destroy_vnode_zone;
 
-	xfs_ioend_pool = mempool_create_slab_pool(4 * MAX_BUF_PER_PAGE,
-						  xfs_ioend_zone);
+	xfs_ioend_pool = mempool_create(4 * MAX_BUF_PER_PAGE,
+			mempool_alloc_slab, mempool_free_slab,
+			xfs_ioend_zone);
 	if (!xfs_ioend_pool)
 		goto out_free_ioend_zone;
+
 	return 0;
 
+
  out_free_ioend_zone:
 	kmem_zone_destroy(xfs_ioend_zone);
  out_destroy_vnode_zone:
@@ -400,7 +405,7 @@ xfs_init_zones(void)
 }
 
 STATIC void
-xfs_destroy_zones(void)
+linvfs_destroy_zones(void)
 {
 	mempool_destroy(xfs_ioend_pool);
 	kmem_zone_destroy(xfs_vnode_zone);
@@ -411,14 +416,14 @@ xfs_destroy_zones(void)
  * Attempt to flush the inode, this will actually fail
  * if the inode is pinned, but we dirty the inode again
  * at the point when it is unpinned after a log write,
- * since this is when the inode itself becomes flushable.
+ * since this is when the inode itself becomes flushable. 
  */
 STATIC int
-xfs_fs_write_inode(
+linvfs_write_inode(
 	struct inode		*inode,
 	int			sync)
 {
-	vnode_t			*vp = vn_from_inode(inode);
+	vnode_t			*vp = LINVFS_GET_VP(inode);
 	int			error = 0, flags = FLUSH_INODE;
 
 	if (vp) {
@@ -438,13 +443,13 @@ xfs_fs_write_inode(
 }
 
 STATIC void
-xfs_fs_clear_inode(
+linvfs_clear_inode(
 	struct inode		*inode)
 {
-	vnode_t			*vp = vn_from_inode(inode);
+	vnode_t			*vp = LINVFS_GET_VP(inode);
 	int			error, cache;
 
-	vn_trace_entry(vp, __FUNCTION__, (inst_t *)__return_address);
+	vn_trace_entry(vp, "clear_inode", (inst_t *)__return_address);
 
 	XFS_STATS_INC(vn_rele);
 	XFS_STATS_INC(vn_remove);
@@ -520,7 +525,7 @@ void
 xfs_flush_inode(
 	xfs_inode_t	*ip)
 {
-	struct inode	*inode = vn_to_inode(XFS_ITOV(ip));
+	struct inode	*inode = LINVFS_GET_IP(XFS_ITOV(ip));
 	struct vfs	*vfs = XFS_MTOVFS(ip->i_mount);
 
 	igrab(inode);
@@ -545,7 +550,7 @@ void
 xfs_flush_device(
 	xfs_inode_t	*ip)
 {
-	struct inode	*inode = vn_to_inode(XFS_ITOV(ip));
+	struct inode	*inode = LINVFS_GET_IP(XFS_ITOV(ip));
 	struct vfs	*vfs = XFS_MTOVFS(ip->i_mount);
 
 	igrab(inode);
@@ -554,7 +559,7 @@ 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)
+#define SYNCD_FLAGS	(SYNC_FSDATA|SYNC_BDFLUSH|SYNC_ATTR)
 STATIC void
 vfs_sync_worker(
 	vfs_t		*vfsp,
@@ -617,7 +622,7 @@ xfssyncd(
 }
 
 STATIC int
-xfs_fs_start_syncd(
+linvfs_start_syncd(
 	vfs_t			*vfsp)
 {
 	vfsp->vfs_sync_work.w_syncer = vfs_sync_worker;
@@ -629,20 +634,20 @@ xfs_fs_start_syncd(
 }
 
 STATIC void
-xfs_fs_stop_syncd(
+linvfs_stop_syncd(
 	vfs_t			*vfsp)
 {
 	kthread_stop(vfsp->vfs_sync_task);
 }
 
 STATIC void
-xfs_fs_put_super(
+linvfs_put_super(
 	struct super_block	*sb)
 {
-	vfs_t			*vfsp = vfs_from_sb(sb);
+	vfs_t			*vfsp = LINVFS_GET_VFS(sb);
 	int			error;
 
-	xfs_fs_stop_syncd(vfsp);
+	linvfs_stop_syncd(vfsp);
 	VFS_SYNC(vfsp, SYNC_ATTR|SYNC_DELWRI, NULL, error);
 	if (!error)
 		VFS_UNMOUNT(vfsp, 0, NULL, error);
@@ -656,10 +661,10 @@ xfs_fs_put_super(
 }
 
 STATIC void
-xfs_fs_write_super(
+linvfs_write_super(
 	struct super_block	*sb)
 {
-	vfs_t			*vfsp = vfs_from_sb(sb);
+	vfs_t			*vfsp = LINVFS_GET_VFS(sb);
 	int			error;
 
 	if (sb->s_flags & MS_RDONLY) {
@@ -672,11 +677,11 @@ xfs_fs_write_super(
 }
 
 STATIC int
-xfs_fs_sync_super(
+linvfs_sync_super(
 	struct super_block	*sb,
 	int			wait)
 {
-	vfs_t		*vfsp = vfs_from_sb(sb);
+	vfs_t		*vfsp = LINVFS_GET_VFS(sb);
 	int		error;
 	int		flags = SYNC_FSDATA;
 
@@ -711,11 +716,11 @@ xfs_fs_sync_super(
 }
 
 STATIC int
-xfs_fs_statfs(
+linvfs_statfs(
 	struct super_block	*sb,
 	struct kstatfs		*statp)
 {
-	vfs_t			*vfsp = vfs_from_sb(sb);
+	vfs_t			*vfsp = LINVFS_GET_VFS(sb);
 	int			error;
 
 	VFS_STATVFS(vfsp, statp, NULL, error);
@@ -723,13 +728,13 @@ xfs_fs_statfs(
 }
 
 STATIC int
-xfs_fs_remount(
+linvfs_remount(
 	struct super_block	*sb,
 	int			*flags,
 	char			*options)
 {
-	vfs_t			*vfsp = vfs_from_sb(sb);
-	struct xfs_mount_args	*args = xfs_args_allocate(sb, 0);
+	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);
@@ -746,18 +751,18 @@ xfs_fs_remount(
 }
 
 STATIC void
-xfs_fs_lockfs(
+linvfs_freeze_fs(
 	struct super_block	*sb)
 {
-	VFS_FREEZE(vfs_from_sb(sb));
+	VFS_FREEZE(LINVFS_GET_VFS(sb));
 }
 
 STATIC int
-xfs_fs_show_options(
+linvfs_show_options(
 	struct seq_file		*m,
 	struct vfsmount		*mnt)
 {
-	struct vfs		*vfsp = vfs_from_sb(mnt->mnt_sb);
+	struct vfs		*vfsp = LINVFS_GET_VFS(mnt->mnt_sb);
 	int			error;
 
 	VFS_SHOWARGS(vfsp, m, error);
@@ -765,11 +770,11 @@ xfs_fs_show_options(
 }
 
 STATIC int
-xfs_fs_quotasync(
+linvfs_quotasync(
 	struct super_block	*sb,
 	int			type)
 {
-	struct vfs		*vfsp = vfs_from_sb(sb);
+	struct vfs		*vfsp = LINVFS_GET_VFS(sb);
 	int			error;
 
 	VFS_QUOTACTL(vfsp, Q_XQUOTASYNC, 0, (caddr_t)NULL, error);
@@ -777,11 +782,11 @@ xfs_fs_quotasync(
 }
 
 STATIC int
-xfs_fs_getxstate(
+linvfs_getxstate(
 	struct super_block	*sb,
 	struct fs_quota_stat	*fqs)
 {
-	struct vfs		*vfsp = vfs_from_sb(sb);
+	struct vfs		*vfsp = LINVFS_GET_VFS(sb);
 	int			error;
 
 	VFS_QUOTACTL(vfsp, Q_XGETQSTAT, 0, (caddr_t)fqs, error);
@@ -789,12 +794,12 @@ xfs_fs_getxstate(
 }
 
 STATIC int
-xfs_fs_setxstate(
+linvfs_setxstate(
 	struct super_block	*sb,
 	unsigned int		flags,
 	int			op)
 {
-	struct vfs		*vfsp = vfs_from_sb(sb);
+	struct vfs		*vfsp = LINVFS_GET_VFS(sb);
 	int			error;
 
 	VFS_QUOTACTL(vfsp, op, 0, (caddr_t)&flags, error);
@@ -802,13 +807,13 @@ xfs_fs_setxstate(
 }
 
 STATIC int
-xfs_fs_getxquota(
+linvfs_getxquota(
 	struct super_block	*sb,
 	int			type,
 	qid_t			id,
 	struct fs_disk_quota	*fdq)
 {
-	struct vfs		*vfsp = vfs_from_sb(sb);
+	struct vfs		*vfsp = LINVFS_GET_VFS(sb);
 	int			error, getmode;
 
 	getmode = (type == USRQUOTA) ? Q_XGETQUOTA :
@@ -818,13 +823,13 @@ xfs_fs_getxquota(
 }
 
 STATIC int
-xfs_fs_setxquota(
+linvfs_setxquota(
 	struct super_block	*sb,
 	int			type,
 	qid_t			id,
 	struct fs_disk_quota	*fdq)
 {
-	struct vfs		*vfsp = vfs_from_sb(sb);
+	struct vfs		*vfsp = LINVFS_GET_VFS(sb);
 	int			error, setmode;
 
 	setmode = (type == USRQUOTA) ? Q_XSETQLIM :
@@ -834,17 +839,21 @@ xfs_fs_setxquota(
 }
 
 STATIC int
-xfs_fs_fill_super(
+linvfs_fill_super(
 	struct super_block	*sb,
 	void			*data,
 	int			silent)
 {
 	vnode_t			*rootvp;
-	struct vfs		*vfsp = vfs_allocate(sb);
-	struct xfs_mount_args	*args = xfs_args_allocate(sb, silent);
+	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);
@@ -855,10 +864,10 @@ xfs_fs_fill_super(
 
 	sb_min_blocksize(sb, BBSIZE);
 #ifdef CONFIG_XFS_EXPORT
-	sb->s_export_op = &xfs_export_operations;
+	sb->s_export_op = &linvfs_export_ops;
 #endif
-	sb->s_qcop = &xfs_quotactl_operations;
-	sb->s_op = &xfs_super_operations;
+	sb->s_qcop = &linvfs_qops;
+	sb->s_op = &linvfs_sops;
 
 	VFS_MOUNT(vfsp, args, NULL, error);
 	if (error) {
@@ -882,7 +891,7 @@ xfs_fs_fill_super(
 	if (error)
 		goto fail_unmount;
 
-	sb->s_root = d_alloc_root(vn_to_inode(rootvp));
+	sb->s_root = d_alloc_root(LINVFS_GET_IP(rootvp));
 	if (!sb->s_root) {
 		error = ENOMEM;
 		goto fail_vnrele;
@@ -891,7 +900,7 @@ xfs_fs_fill_super(
 		error = EINVAL;
 		goto fail_vnrele;
 	}
-	if ((error = xfs_fs_start_syncd(vfsp)))
+	if ((error = linvfs_start_syncd(vfsp)))
 		goto fail_vnrele;
 	vn_trace_exit(rootvp, __FUNCTION__, (inst_t *)__return_address);
 
@@ -916,41 +925,41 @@ fail_vfsop:
 }
 
 STATIC struct super_block *
-xfs_fs_get_sb(
+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, xfs_fs_fill_super);
-}
-
-STATIC struct super_operations xfs_super_operations = {
-	.alloc_inode		= xfs_fs_alloc_inode,
-	.destroy_inode		= xfs_fs_destroy_inode,
-	.write_inode		= xfs_fs_write_inode,
-	.clear_inode		= xfs_fs_clear_inode,
-	.put_super		= xfs_fs_put_super,
-	.write_super		= xfs_fs_write_super,
-	.sync_fs		= xfs_fs_sync_super,
-	.write_super_lockfs	= xfs_fs_lockfs,
-	.statfs			= xfs_fs_statfs,
-	.remount_fs		= xfs_fs_remount,
-	.show_options		= xfs_fs_show_options,
+	return get_sb_bdev(fs_type, flags, dev_name, data, linvfs_fill_super);
+}
+
+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 xfs_quotactl_operations = {
-	.quota_sync		= xfs_fs_quotasync,
-	.get_xstate		= xfs_fs_getxstate,
-	.set_xstate		= xfs_fs_setxstate,
-	.get_xquota		= xfs_fs_getxquota,
-	.set_xquota		= xfs_fs_setxquota,
+STATIC struct quotactl_ops linvfs_qops = {
+	.quota_sync		= linvfs_quotasync,
+	.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			= xfs_fs_get_sb,
+	.get_sb			= linvfs_get_sb,
 	.kill_sb		= kill_block_super,
 	.fs_flags		= FS_REQUIRES_DEV,
 };
@@ -971,7 +980,7 @@ init_xfs_fs( void )
 
 	ktrace_init(64);
 
-	error = xfs_init_zones();
+	error = linvfs_init_zones();
 	if (error < 0)
 		goto undo_zones;
 
@@ -987,13 +996,14 @@ init_xfs_fs( void )
 	error = register_filesystem(&xfs_fs_type);
 	if (error)
 		goto undo_register;
+	XFS_DM_INIT(&xfs_fs_type);
 	return 0;
 
 undo_register:
 	xfs_buf_terminate();
 
 undo_buffers:
-	xfs_destroy_zones();
+	linvfs_destroy_zones();
 
 undo_zones:
 	return error;
@@ -1003,10 +1013,11 @@ STATIC void __exit
 exit_xfs_fs( void )
 {
 	vfs_exitquota();
+	XFS_DM_EXIT(&xfs_fs_type);
 	unregister_filesystem(&xfs_fs_type);
 	xfs_cleanup();
 	xfs_buf_terminate();
-	xfs_destroy_zones();
+	linvfs_destroy_zones();
 	ktrace_uninit();
 }