[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>
This commit is contained in:
Nathan Scott
parent
932f2c3231
commit
b83bd13881
19 changed files with 183 additions and 224 deletions
|
|
@ -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) ;
|
||||
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
* 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. */
|
||||
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_set_custom(b,o) ( (b)->bhv_custom = (void *)(o))
|
||||
#define vfs_bhv_clr_custom(b) ( (b)->bhv_custom = NULL )
|
||||
#define vfs_bhv_lookup(v, id) (bhv_lookup_range(&(v)->vfs_bh, (id), (id)))
|
||||
#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 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 vfs_insertops(bhv_vfs_t *, bhv_module_vfsops_t *);
|
||||
|
||||
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) \
|
||||
|
|
|
|||
|
|
@ -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 *
|
||||
|
|
|
|||
|
|
@ -68,7 +68,7 @@ typedef enum vflags {
|
|||
*/
|
||||
typedef struct vnode {
|
||||
vflags_t v_flag; /* vnode flags (see above) */
|
||||
struct vfs *v_vfsp; /* ptr to containing VFS */
|
||||
struct bhv_vfs *v_vfsp; /* ptr to containing VFS */
|
||||
vnumber_t v_number; /* in-core vnode number */
|
||||
vn_bhv_head_t v_bh; /* behavior head */
|
||||
spinlock_t v_lock; /* VN_LOCK/VN_UNLOCK */
|
||||
|
|
@ -503,7 +503,7 @@ extern vnode_t *vn_initialize(struct inode *);
|
|||
* vnode_map structures _must_ match vn_epoch and vnode structure sizes.
|
||||
*/
|
||||
typedef struct vnode_map {
|
||||
vfs_t *v_vfsp;
|
||||
bhv_vfs_t *v_vfsp;
|
||||
vnumber_t v_number; /* in-core vnode number */
|
||||
xfs_ino_t v_ino; /* inode # */
|
||||
} vmap_t;
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue