/*ARGSUSED*/
static int
zfs_vfsinit(int fstype, char *name)
{
int error;
zfsfstype = fstype;
/*
* Setup vfsops and vnodeops tables.
*/
error = vfs_setfsops(fstype, zfs_vfsops_template, &zfs_vfsops);
if (error != 0) {
cmn_err(CE_WARN, "zfs: bad vfs ops template");
}
error = zfs_create_op_tables();
if (error) {
zfs_remove_op_tables();
cmn_err(CE_WARN, "zfs: bad vnode ops template");
(void) vfs_freevfsops_by_type(zfsfstype);
return (error);
}
mutex_init(&zfs_dev_mtx, NULL, MUTEX_DEFAULT, NULL);
/*
* Unique major number for all zfs mounts.
* If we run out of 32-bit minors, we'll getudev() another major.
*/
zfs_major = ddi_name_to_major(ZFS_DRIVER);
zfs_minor = ZFS_MIN_MINOR;
return (0);
}
/* ARGSUSED */
static int
objfs_init(int fstype, char *name)
{
vfsops_t *vfsops;
int error;
objfs_fstype = fstype;
if (error = vfs_setfsops(fstype, objfs_vfstops, &vfsops)) {
cmn_err(CE_WARN, "objfs_init: bad vfs ops template");
return (error);
}
if (error = gfs_make_opsvec(objfs_opsvec)) {
(void) vfs_freevfsops(vfsops);
return (error);
}
if ((objfs_major = getudev()) == (major_t)-1) {
cmn_err(CE_WARN, "objfs_init: can't get unique device number");
objfs_major = 0;
}
objfs_data_init();
return (0);
}
int
VMBlockInit(int fstype, // IN: file system type
char *name) // IN: Name of the file system
{
int ret;
static const fs_operation_def_t vfsOpsArr[] = {
VMBLOCK_VOP(VFSNAME_MOUNT, vfs_mount, VMBlockMount),
VMBLOCK_VOP(VFSNAME_UNMOUNT, vfs_unmount, VMBlockUnmount),
VMBLOCK_VOP(VFSNAME_ROOT, vfs_root, VMBlockRoot),
VMBLOCK_VOP(VFSNAME_STATVFS, vfs_statvfs, VMBlockStatvfs),
{ NULL }
};
if (!name) {
Warning("VMBlockInit: received NULL input from kernel.\n");
return EINVAL;
}
Debug(VMBLOCK_ENTRY_LOGLEVEL, "VMBlockInit: fstype=%d, name=\"%s\"\n", fstype, name);
/*
* Set our file system type and the vfs operations in the kernel's VFS
* switch table.
*/
vmblockType = fstype;
ret = vfs_setfsops(vmblockType, vfsOpsArr, &vmblockVfsOps);
if (ret) {
Warning("VMBlockInit: could not set vfs operations.\n");
return ret;
}
ret = vn_make_ops(name, vnodeOpsArr, &vmblockVnodeOps);
if (ret) {
Warning("VMBlockInit: could not create vnode operations.\n");
/*
* It's important not to call vfs_freevfsops() here; that's only for
* freeing ops created with vfs_makefsops().
*/
vfs_freevfsops_by_type(vmblockType);
return ret;
}
/*
* We need to find a unique device number for this instance of the module;
* it will be used at each mount to secure a unique device number and file
* system identifier. If one cannot be located, we'll just use zero like
* other Solaris file systems.
*/
if ((vmblockMajor = getudev()) == (major_t)-1) {
Warning("VMBlockInit: could not obtain unique device.\n");
vmblockMajor = 0;
}
vmblockMinor = 0;
mutex_init(&vmblockMutex, NULL, MUTEX_DEFAULT, NULL);
return 0;
}
iumfs_init(struct vfssw *iumfs_vfssw, int fstype)
#endif
{
int err;
DEBUG_PRINT((CE_CONT, "iumfs_init called\n"));
DEBUG_PRINT((CE_CONT, "iumfs_init: fstype = %d(0x%x)\n", fstype, fstype));
iumfs_fstype = fstype;
#ifdef SOL10
do {
err = vfs_setfsops(fstype, iumfs_vfs_ops_def_array, &iumfs_vfsops);
if (err)
break;
err = vn_make_ops(fsname, iumfs_vnode_ops_def_array, &iumfs_vnodeops);
if (err)
break;
} while (FALSE);
if (err) {
if (iumfs_vfsops != NULL) {
vfs_freevfsops_by_type(fstype);
}
if (iumfs_vnodeops != NULL) {
vn_freevnodeops(iumfs_vnodeops);
}
}
#endif
/*
* filesystem id に使うデバイス番号を決める。
*/
iumfs_major = getudev();
DEBUG_PRINT((CE_CONT, "iumfs_init: major = %d(0x%x)\n", iumfs_major, iumfs_major));
DEBUG_PRINT((CE_CONT, "iumfs_init: return(%d)\n", err));
return (err);
}
int
smbfsinit(int fstyp, char *name)
{
int error;
error = vfs_setfsops(fstyp, smbfs_vfsops_template, &smbfs_vfsops);
if (error != 0) {
zcmn_err(GLOBAL_ZONEID, CE_WARN,
"smbfsinit: bad vfs ops template");
return (error);
}
error = vn_make_ops(name, smbfs_vnodeops_template, &smbfs_vnodeops);
if (error != 0) {
(void) vfs_freevfsops_by_type(fstyp);
zcmn_err(GLOBAL_ZONEID, CE_WARN,
"smbfsinit: bad vnode ops template");
return (error);
}
smbfsfstyp = fstyp;
return (0);
}
static int
hsfsinit(int fstype, char *name)
{
static const fs_operation_def_t hsfs_vfsops_template[] = {
VFSNAME_MOUNT, { .vfs_mount = hsfs_mount },
VFSNAME_UNMOUNT, { .vfs_unmount = hsfs_unmount },
VFSNAME_ROOT, { .vfs_root = hsfs_root },
VFSNAME_STATVFS, { .vfs_statvfs = hsfs_statvfs },
VFSNAME_VGET, { .vfs_vget = hsfs_vget },
VFSNAME_MOUNTROOT, { .vfs_mountroot = hsfs_mountroot },
NULL, NULL
};
int error;
error = vfs_setfsops(fstype, hsfs_vfsops_template, NULL);
if (error != 0) {
cmn_err(CE_WARN, "hsfsinit: bad vfs ops template");
return (error);
}
error = vn_make_ops(name, hsfs_vnodeops_template, &hsfs_vnodeops);
if (error != 0) {
(void) vfs_freevfsops_by_type(fstype);
cmn_err(CE_WARN, "hsfsinit: bad vnode ops template");
return (error);
}
hsfsfstype = fstype;
mutex_init(&hs_mounttab_lock, NULL, MUTEX_DEFAULT, NULL);
hs_init_hsnode_cache();
static int
lofsinit(int fstyp, char *name)
{
static const fs_operation_def_t lo_vfsops_template[] = {
VFSNAME_MOUNT, { .vfs_mount = lo_mount },
VFSNAME_UNMOUNT, { .vfs_unmount = lo_unmount },
VFSNAME_ROOT, { .vfs_root = lo_root },
VFSNAME_STATVFS, { .vfs_statvfs = lo_statvfs },
VFSNAME_SYNC, { .vfs_sync = lo_sync },
VFSNAME_VGET, { .vfs_vget = lo_vget },
VFSNAME_FREEVFS, { .vfs_freevfs = lo_freevfs },
NULL, NULL
};
int error;
error = vfs_setfsops(fstyp, lo_vfsops_template, &lo_vfsops);
if (error != 0) {
cmn_err(CE_WARN, "lofsinit: bad vfs ops template");
return (error);
}
error = vn_make_ops(name, lo_vnodeops_template, &lo_vnodeops);
if (error != 0) {
(void) vfs_freevfsops_by_type(fstyp);
cmn_err(CE_WARN, "lofsinit: bad vnode ops template");
return (error);
}
lofsfstype = fstyp;
return (0);
nfsinit(int fstyp, char *name)
{
static const fs_operation_def_t nfs_vfsops_template[] = {
VFSNAME_MOUNT, { .vfs_mount = nfs_mount },
VFSNAME_UNMOUNT, { .vfs_unmount = nfs_unmount },
VFSNAME_ROOT, { .vfs_root = nfs_root },
VFSNAME_STATVFS, { .vfs_statvfs = nfs_statvfs },
VFSNAME_SYNC, { .vfs_sync = nfs_sync },
VFSNAME_VGET, { .vfs_vget = nfs_vget },
VFSNAME_MOUNTROOT, { .vfs_mountroot = nfs_mountroot },
VFSNAME_FREEVFS, { .vfs_freevfs = nfs_freevfs },
NULL, NULL
};
int error;
error = vfs_setfsops(fstyp, nfs_vfsops_template, &nfs_vfsops);
if (error != 0) {
zcmn_err(GLOBAL_ZONEID, CE_WARN,
"nfsinit: bad vfs ops template");
return (error);
}
error = vn_make_ops(name, nfs_vnodeops_template, &nfs_vnodeops);
if (error != 0) {
(void) vfs_freevfsops_by_type(fstyp);
zcmn_err(GLOBAL_ZONEID, CE_WARN,
"nfsinit: bad vnode ops template");
return (error);
}
{
static const fs_operation_def_t auto_vfsops_template[] = {
VFSNAME_MOUNT, { .vfs_mount = auto_mount },
VFSNAME_UNMOUNT, { .vfs_unmount = auto_unmount },
VFSNAME_ROOT, { .vfs_root = auto_root },
VFSNAME_STATVFS, { .vfs_statvfs = auto_statvfs },
NULL, NULL
};
int error;
autofs_fstype = fstype;
ASSERT(autofs_fstype != 0);
/*
* Associate VFS ops vector with this fstype
*/
error = vfs_setfsops(fstype, auto_vfsops_template, NULL);
if (error != 0) {
cmn_err(CE_WARN, "autofs_init: bad vfs ops template");
return (error);
}
error = vn_make_ops(name, auto_vnodeops_template, &auto_vnodeops);
if (error != 0) {
(void) vfs_freevfsops_by_type(fstype);
cmn_err(CE_WARN, "autofs_init: bad vnode ops template");
return (error);
}
mutex_init(&autofs_minor_lock, NULL, MUTEX_DEFAULT, NULL);
/*
* Assign unique major number for all autofs mounts
devinit(int fstype, char *name)
{
static const fs_operation_def_t dev_vfsops_tbl[] = {
VFSNAME_MOUNT, { .vfs_mount = sdev_mount },
VFSNAME_UNMOUNT, { .vfs_unmount = sdev_unmount },
VFSNAME_ROOT, { .vfs_root = sdev_root },
VFSNAME_STATVFS, { .vfs_statvfs = sdev_statvfs },
NULL, NULL
};
int error;
extern major_t getudev(void);
devtype = fstype;
error = vfs_setfsops(fstype, dev_vfsops_tbl, NULL);
if (error != 0) {
cmn_err(CE_WARN, "devinit: bad vfs ops tbl");
return (error);
}
error = vn_make_ops("dev", sdev_vnodeops_tbl, &sdev_vnodeops);
if (error != 0) {
(void) vfs_freevfsops_by_type(fstype);
cmn_err(CE_WARN, "devinit: bad vnode ops tbl");
return (error);
}
if ((devmajor = getudev()) == (major_t)-1) {
cmn_err(CE_WARN, "%s: can't get unique dev", sdev_vfssw.name);
return (1);
/*
* Save file system type/index, initialize vfs operations vector, get
* unique device number for FIFOFS and initialize the FIFOFS hash.
* Create and initialize a "generic" vfs pointer that will be placed
* in the v_vfsp field of each pipe's vnode.
*/
int
fifoinit(int fstype, char *name)
{
static const fs_operation_def_t fifo_vfsops_template[] = {
NULL, NULL
};
int error;
major_t dev;
fifofstype = fstype;
error = vfs_setfsops(fstype, fifo_vfsops_template, &fifo_vfsops);
if (error != 0) {
cmn_err(CE_WARN, "fifoinit: bad vfs ops template");
return (error);
}
error = vn_make_ops(name, fifo_vnodeops_template, &fifo_vnodeops);
if (error != 0) {
(void) vfs_freevfsops_by_type(fstype);
cmn_err(CE_WARN, "fifoinit: bad vnode ops template");
return (error);
}
if ((dev = getudev()) == (major_t)-1) {
cmn_err(CE_WARN, "fifoinit: can't get unique device number");
dev = 0;
}
fifodev = makedevice(dev, 0);
fifovfsp = kmem_zalloc(sizeof (struct vfs), KM_SLEEP);
fifovfsp->vfs_next = NULL;
vfs_setops(fifovfsp, fifo_vfsops);
fifovfsp->vfs_vnodecovered = NULL;
fifovfsp->vfs_flag = 0;
fifovfsp->vfs_bsize = 1024;
fifovfsp->vfs_fstype = fifofstype;
vfs_make_fsid(&fifovfsp->vfs_fsid, fifodev, fifofstype);
fifovfsp->vfs_data = NULL;
fifovfsp->vfs_dev = fifodev;
fifovfsp->vfs_bcount = 0;
/*
* It is necessary to initialize vfs_count here to 1.
* This prevents the fifovfsp from getting freed when
* a thread does a VFS_HOLD followed by a VFS_RELE
* on the fifovfsp
*
* The fifovfsp should never be freed.
*/
fifovfsp->vfs_count = 1;
mutex_init(&ftable_lock, NULL, MUTEX_DEFAULT, NULL);
mutex_init(&fino_lock, NULL, MUTEX_DEFAULT, NULL);
/*
* vnodes are cached aligned
*/
fnode_cache = kmem_cache_create("fnode_cache",
sizeof (fifodata_t) - sizeof (fifonode_t), 32,
fnode_constructor, fnode_destructor, NULL,
(void *)(sizeof (fifodata_t) - sizeof (fifonode_t)), NULL, 0);
pipe_cache = kmem_cache_create("pipe_cache", sizeof (fifodata_t), 32,
pipe_constructor, pipe_destructor, NULL,
(void *)(sizeof (fifodata_t)), NULL, 0);
#if FIFODEBUG
if (Fifohiwat < FIFOHIWAT)
Fifohiwat = FIFOHIWAT;
#endif /* FIFODEBUG */
fifo_strdata.qi_minfo->mi_hiwat = Fifohiwat;
return (0);
}
VFSNAME_UNMOUNT, { .vfs_unmount = nm_unmount },
VFSNAME_ROOT, { .vfs_root = nm_root },
VFSNAME_STATVFS, { .vfs_statvfs = nm_statvfs },
VFSNAME_SYNC, { .vfs_sync = nm_sync },
NULL, NULL
};
static const fs_operation_def_t nm_dummy_vfsops_template[] = {
VFSNAME_STATVFS, { .vfs_statvfs = nm_statvfs },
VFSNAME_SYNC, { .vfs_sync = nm_sync },
NULL, NULL
};
int error;
int dev;
vfsops_t *dummy_vfsops;
error = vfs_setfsops(fstype, nm_vfsops_template, &namefs_vfsops);
if (error != 0) {
cmn_err(CE_WARN, "nameinit: bad vfs ops template");
return (error);
}
error = vfs_makefsops(nm_dummy_vfsops_template, &dummy_vfsops);
if (error != 0) {
(void) vfs_freevfsops_by_type(fstype);
cmn_err(CE_WARN, "nameinit: bad dummy vfs ops template");
return (error);
}
error = vn_make_ops(name, nm_vnodeops_template, &nm_vnodeops);
if (error != 0) {
(void) vfs_freevfsops_by_type(fstype);
