/*
* gfs_root_create_file(): create a root vnode for a GFS file as a filesystem
*
* Similar to gfs_root_create(), this creates a root vnode for a file to
* be the pseudo-filesystem.
*/
struct vnode *
gfs_root_create_file(size_t size, vfs_t *vfsp, vnodeops_t *ops, ino64_t ino)
{
struct vnode *vp = gfs_file_create(size, NULL, ops, VREG);
((gfs_file_t *)vnode_fsnode(vp))->gfs_ino = ino;
VFS_HOLD(vfsp);
VN_SET_VFS_TYPE_DEV(vp, vfsp, VREG, 0);
vp->v_flag |= VROOT | VNOCACHE | VNOMAP | VNOSWAP | VNOMOUNT;
return (vp);
}
void
osi_PostPopulateVCache(struct vcache *avc) {
AFSTOV(avc)->v_op = afs_ops;
AFSTOV(avc)->v_vfsp = afs_globalVFS;
vSetType(avc, VREG);
#ifdef AFS_SUN58_ENV
/* Normally we do this in osi_vnhold when we notice the ref count went from
* 0 -> 1. But if we just setup or reused a vcache, we set the refcount to
* 1 directly. So, we must explicitly VFS_HOLD here. */
VFS_HOLD(afs_globalVFS);
#endif
}
/*
* gfs_root_create(): create a root vnode for a GFS filesystem
*
* Similar to gfs_dir_create(), this creates a root vnode for a filesystem. The
* only difference is that it takes a vfs_t instead of a vnode_t as its parent.
*/
vnode_t *
gfs_root_create(size_t size, vfs_t *vfsp, vnodeops_t *ops, ino64_t ino,
gfs_dirent_t *entries, gfs_inode_cb inode_cb, int maxlen,
gfs_readdir_cb readdir_cb, gfs_lookup_cb lookup_cb)
{
vnode_t *vp;
VFS_HOLD(vfsp);
vp = gfs_dir_create(size, NULL, vfsp, ops, entries, inode_cb,
maxlen, readdir_cb, lookup_cb);
/* Manually set the inode */
((gfs_file_t *)vp->v_data)->gfs_ino = ino;
vp->v_flag |= VROOT;
return (vp);
}
/*
* gfs_root_create(): create a root vnode for a GFS filesystem
*
* Similar to gfs_dir_create(), this creates a root vnode for a filesystem. The
* only difference is that it takes a vfs_t instead of a vnode_t as its parent.
*/
vnode_t *
gfs_root_create(size_t size, vfs_t *vfsp, vnodeops_t *ops, ino64_t ino,
gfs_dirent_t *entries, gfs_inode_cb inode_cb, int maxlen,
gfs_readdir_cb readdir_cb, gfs_lookup_cb lookup_cb)
{
vnode_t *vp = gfs_dir_create(size, NULL, ops, entries, inode_cb,
maxlen, readdir_cb, lookup_cb);
/* Manually set the inode */
((gfs_file_t *)vp->v_data)->gfs_ino = ino;
VFS_HOLD(vfsp);
VN_SET_VFS_TYPE_DEV(vp, vfsp, VDIR, 0);
vp->v_flag |= VROOT | VNOCACHE | VNOMAP | VNOSWAP | VNOMOUNT;
return (vp);
}
/*
* gfs_root_create(): create a root vnode for a GFS filesystem
*
* Similar to gfs_dir_create(), this creates a root vnode for a filesystem. The
* only difference is that it takes a vfs_t instead of a struct vnode as its parent.
*/
struct vnode *
gfs_root_create(size_t size, vfs_t *vfsp, vnodeops_t *ops, ino64_t ino,
gfs_dirent_t *entries, gfs_inode_cb inode_cb, int maxlen,
gfs_readdir_cb readdir_cb, gfs_lookup_cb lookup_cb)
{
struct vnode *vp;
VFS_HOLD(vfsp);
vp = gfs_dir_create(size, NULL, vfsp, ops, entries, inode_cb,
maxlen, readdir_cb, lookup_cb,
ZFS_VNODE_SYSTEM);
/* Manually set the inode */
((gfs_file_t *)vnode_fsnode(vp))->gfs_ino = ino;
dprintf(".zfs created returning %p; ino %d\n", vp, ino);
/*
* Since we created the .zfs node as VSYSTEM, we have to manually
* call vnode_recycle() as done in zfsctl_destroy().
*/
return (vp);
}
struct pcnode *
pc_getnode(
struct pcfs *fsp, /* filsystem for node */
daddr_t blkno, /* phys block no of dir entry */
int offset, /* offset of dir entry in block */
struct pcdir *ep) /* node dir entry */
{
struct pcnode *pcp;
struct pchead *hp;
struct vnode *vp;
pc_cluster32_t scluster;
ASSERT(fsp->pcfs_flags & PCFS_LOCKED);
if (ep == (struct pcdir *)0) {
ep = &pcfs_rootdirentry;
scluster = 0;
} else {
scluster = pc_getstartcluster(fsp, ep);
}
/*
* First look for active nodes.
* File nodes are identified by the location (blkno, offset) of
* its directory entry.
* Directory nodes are identified by the starting cluster number
* for the entries.
*/
if (ep->pcd_attr & PCA_DIR) {
hp = &pcdhead[PCDHASH(fsp, scluster)];
rw_enter(&pcnodes_lock, RW_READER);
for (pcp = hp->pch_forw;
pcp != (struct pcnode *)hp; pcp = pcp->pc_forw) {
if ((fsp == VFSTOPCFS(PCTOV(pcp)->v_vfsp)) &&
(scluster == pcp->pc_scluster)) {
VN_HOLD(PCTOV(pcp));
rw_exit(&pcnodes_lock);
return (pcp);
}
}
rw_exit(&pcnodes_lock);
} else {
hp = &pcfhead[PCFHASH(fsp, blkno, offset)];
rw_enter(&pcnodes_lock, RW_READER);
for (pcp = hp->pch_forw;
pcp != (struct pcnode *)hp; pcp = pcp->pc_forw) {
if ((fsp == VFSTOPCFS(PCTOV(pcp)->v_vfsp)) &&
((pcp->pc_flags & PC_INVAL) == 0) &&
(blkno == pcp->pc_eblkno) &&
(offset == pcp->pc_eoffset)) {
VN_HOLD(PCTOV(pcp));
rw_exit(&pcnodes_lock);
return (pcp);
}
}
rw_exit(&pcnodes_lock);
}
/*
* Cannot find node in active list. Allocate memory for a new node
* initialize it, and put it on the active list.
*/
pcp = kmem_alloc(sizeof (struct pcnode), KM_SLEEP);
bzero(pcp, sizeof (struct pcnode));
vp = vn_alloc(KM_SLEEP);
pcp->pc_vn = vp;
pcp->pc_entry = *ep;
pcp->pc_eblkno = blkno;
pcp->pc_eoffset = offset;
pcp->pc_scluster = scluster;
pcp->pc_lcluster = scluster;
pcp->pc_lindex = 0;
pcp->pc_flags = 0;
if (ep->pcd_attr & PCA_DIR) {
vn_setops(vp, pcfs_dvnodeops);
vp->v_type = VDIR;
if (scluster == 0) {
vp->v_flag = VROOT;
blkno = offset = 0;
if (IS_FAT32(fsp)) {
pc_cluster32_t ncl = 0;
scluster = fsp->pcfs_rdirstart;
if (pc_fileclsize(fsp, scluster, &ncl)) {
PC_DPRINTF1(2, "cluster chain "
"corruption, scluster=%d\n",
scluster);
pcp->pc_flags |= PC_INVAL;
}
pcp->pc_size = fsp->pcfs_clsize * ncl;
} else {
pcp->pc_size =
fsp->pcfs_rdirsec * fsp->pcfs_secsize;
}
} else {
pc_cluster32_t ncl = 0;
if (pc_fileclsize(fsp, scluster, &ncl)) {
PC_DPRINTF1(2, "cluster chain corruption, "
"scluster=%d\n", scluster);
pcp->pc_flags |= PC_INVAL;
}
pcp->pc_size = fsp->pcfs_clsize * ncl;
}
} else {
vn_setops(vp, pcfs_fvnodeops);
vp->v_type = VREG;
vp->v_flag = VNOSWAP;
fsp->pcfs_frefs++;
pcp->pc_size = ltohi(ep->pcd_size);
}
fsp->pcfs_nrefs++;
VFS_HOLD(PCFSTOVFS(fsp));
vp->v_data = (caddr_t)pcp;
vp->v_vfsp = PCFSTOVFS(fsp);
vn_exists(vp);
rw_enter(&pcnodes_lock, RW_WRITER);
insque(pcp, hp);
rw_exit(&pcnodes_lock);
return (pcp);
}
/*
* Construct a new znode/vnode and intialize.
*
* This does not do a call to dmu_set_user() that is
* up to the caller to do, in case you don't want to
* return the znode
*/
static znode_t *
zfs_znode_alloc(zfsvfs_t *zfsvfs, dmu_buf_t *db, int blksz)
{
znode_t *zp;
vnode_t *vp;
zp = kmem_cache_alloc(znode_cache, KM_SLEEP);
zfs_znode_cache_constructor(zp, zfsvfs->z_parent->z_vfs, 0);
ASSERT(zp->z_dirlocks == NULL);
ASSERT(zp->z_dbuf == NULL);
ASSERT(!POINTER_IS_VALID(zp->z_zfsvfs));
/*
* Defer setting z_zfsvfs until the znode is ready to be a candidate for
* the zfs_znode_move() callback.
*/
zp->z_phys = NULL;
zp->z_unlinked = 0;
zp->z_atime_dirty = 0;
zp->z_mapcnt = 0;
zp->z_last_itx = 0;
zp->z_id = db->db_object;
zp->z_blksz = blksz;
zp->z_seq = 0x7A4653;
zp->z_sync_cnt = 0;
vp = ZTOV(zp);
#ifdef TODO
vn_reinit(vp);
#endif
zfs_znode_dmu_init(zfsvfs, zp, db);
zp->z_gen = zp->z_phys->zp_gen;
#if 0
if (vp == NULL)
return (zp);
#endif
vp->v_type = IFTOVT((mode_t)zp->z_phys->zp_mode);
switch (vp->v_type) {
case VDIR:
zp->z_zn_prefetch = B_TRUE; /* z_prefetch default is enabled */
break;
case VFIFO:
vp->v_op = &zfs_fifoops;
break;
}
if (vp->v_type != VFIFO)
VN_LOCK_ASHARE(vp);
mutex_enter(&zfsvfs->z_znodes_lock);
list_insert_tail(&zfsvfs->z_all_znodes, zp);
membar_producer();
/*
* Everything else must be valid before assigning z_zfsvfs makes the
* znode eligible for zfs_znode_move().
*/
zp->z_zfsvfs = zfsvfs;
mutex_exit(&zfsvfs->z_znodes_lock);
VFS_HOLD(zfsvfs->z_vfs);
return (zp);
}
/*
* Configure root file system.
*/
int
rootconf(void)
{
int error;
struct vfssw *vsw;
extern void pm_init(void);
BMDPRINTF(("rootconf: fstype %s\n", rootfs.bo_fstype));
BMDPRINTF(("rootconf: name %s\n", rootfs.bo_name));
BMDPRINTF(("rootconf: flags 0x%x\n", rootfs.bo_flags));
BMDPRINTF(("rootconf: obp_bootpath %s\n", obp_bootpath));
/*
* Install cluster modules that were only loaded during
* loadrootmodules().
*/
if (error = clboot_rootconf())
return (error);
if (root_is_svm) {
(void) strncpy(rootfs.bo_name, obp_bootpath, BO_MAXOBJNAME);
BMDPRINTF(("rootconf: svm: rootfs name %s\n", rootfs.bo_name));
BMDPRINTF(("rootconf: svm: svm name %s\n", svm_bootpath));
}
/*
* Run _init on the root filesystem (we already loaded it
* but we've been waiting until now to _init it) which will
* have the side-effect of running vsw_init() on this vfs.
* Because all the nfs filesystems are lumped into one
* module we need to special case it.
*/
if (strncmp(rootfs.bo_fstype, "nfs", 3) == 0) {
if (modload("fs", "nfs") == -1) {
cmn_err(CE_CONT, "Cannot initialize %s filesystem\n",
rootfs.bo_fstype);
return (ENXIO);
}
} else {
if (modload("fs", rootfs.bo_fstype) == -1) {
cmn_err(CE_CONT, "Cannot initialize %s filesystem\n",
rootfs.bo_fstype);
return (ENXIO);
}
}
RLOCK_VFSSW();
vsw = vfs_getvfsswbyname(rootfs.bo_fstype);
RUNLOCK_VFSSW();
VFS_INIT(rootvfs, &vsw->vsw_vfsops, (caddr_t)0);
VFS_HOLD(rootvfs);
if (root_is_svm) {
rootvfs->vfs_flag |= VFS_RDONLY;
}
/*
* This pm-releated call has to occur before root is mounted since we
* need to power up all devices. It is placed after VFS_INIT() such
* that opening a device via ddi_lyr_ interface just before root has
* been mounted would work.
*/
pm_init();
if (netboot) {
if ((error = strplumb()) != 0) {
cmn_err(CE_CONT, "Cannot plumb network device\n");
return (error);
}
}
/*
* ufs_mountroot() ends up calling getrootdev()
* (below) which actually triggers the _init, identify,
* probe and attach of the drivers that make up root device
* bush; these are also quietly waiting in memory.
*/
BMDPRINTF(("rootconf: calling VFS_MOUNTROOT %s\n", rootfs.bo_fstype));
error = VFS_MOUNTROOT(rootvfs, ROOT_INIT);
vfs_unrefvfssw(vsw);
rootdev = rootvfs->vfs_dev;
if (error)
cmn_err(CE_CONT, "Cannot mount root on %s fstype %s\n",
rootfs.bo_name, rootfs.bo_fstype);
else
cmn_err(CE_CONT, "?root on %s fstype %s\n",
rootfs.bo_name, rootfs.bo_fstype);
return (error);
}
int do_mount(char *spec, char *dir, int mflag, char *opt)
{
// VERIFY(mflag == 0);
vfs_t *vfs = kmem_zalloc(sizeof(vfs_t), KM_SLEEP);
if(vfs == NULL)
return ENOMEM;
VFS_INIT(vfs, zfs_vfsops, 0);
VFS_HOLD(vfs);
struct mounta uap = {
.spec = spec,
.dir = dir,
.flags = mflag | MS_SYSSPACE,
.fstype = "zfs-fuse",
.dataptr = "",
.datalen = 0,
.optptr = opt,
.optlen = strlen(opt)
};
int ret;
if ((ret = VFS_MOUNT(vfs, rootdir, &uap, kcred)) != 0) {
kmem_free(vfs, sizeof(vfs_t));
return ret;
}
/* Actually, optptr is totally ignored by VFS_MOUNT.
* So we are going to pass this with fuse_mount_options if possible */
if (fuse_mount_options == NULL)
fuse_mount_options = "";
char real_opts[1024];
*real_opts = 0;
if (*fuse_mount_options)
strcat(real_opts,fuse_mount_options); // comes with a starting ,
if (*opt)
sprintf(&real_opts[strlen(real_opts)],",%s",opt);
#ifdef DEBUG
atomic_inc_32(&mounted);;
fprintf(stderr, "mounting %s\n", dir);
#endif
char *fuse_opts = NULL;
int has_default_perm = 0;
if (fuse_version() <= 27) {
if(asprintf(&fuse_opts, FUSE_OPTIONS, spec, real_opts) == -1) {
VERIFY(do_umount(vfs, B_FALSE) == 0);
return ENOMEM;
}
} else {
if(asprintf(&fuse_opts, FUSE_OPTIONS ",big_writes", spec, real_opts) == -1) {
VERIFY(do_umount(vfs, B_FALSE) == 0);
return ENOMEM;
}
}
struct fuse_args args = FUSE_ARGS_INIT(0, NULL);
if(fuse_opt_add_arg(&args, "") == -1 ||
fuse_opt_add_arg(&args, "-o") == -1 ||
fuse_opt_add_arg(&args, fuse_opts) == -1) {
fuse_opt_free_args(&args);
free(fuse_opts);
VERIFY(do_umount(vfs, B_FALSE) == 0);
return ENOMEM;
}
has_default_perm = detect_fuseoption(fuse_opts,"default_permissions");
free(fuse_opts);
struct fuse_chan *ch = fuse_mount(dir, &args);
if(ch == NULL) {
VERIFY(do_umount(vfs, B_FALSE) == 0);
return EIO;
}
if (has_default_perm)
vfs->fuse_attribute = FUSE_VFS_HAS_DEFAULT_PERM;
struct fuse_session *se = fuse_lowlevel_new(&args, &zfs_operations, sizeof(zfs_operations), vfs);
fuse_opt_free_args(&args);
if(se == NULL) {
VERIFY(do_umount(vfs, B_FALSE) == 0); /* ZFSFUSE: FIXME?? */
fuse_unmount(dir,ch);
return EIO;
}
fuse_session_add_chan(se, ch);
if(zfsfuse_newfs(dir, ch) != 0) {
fuse_session_destroy(se);
fuse_unmount(dir,ch);
return EIO;
}
return 0;
}
/*
* Provide a shadow for a vnode. We create a new shadow before checking for an
* existing one, to minimize the amount of time we need to hold ftable_lock.
* If a vp already has a shadow in the hash list, return its shadow. If not,
* we hash the new vnode and return its pointer to the caller.
*/
vnode_t *
fifovp(vnode_t *vp, cred_t *crp)
{
fifonode_t *fnp;
fifonode_t *spec_fnp; /* Speculative fnode ptr. */
fifodata_t *fdp;
vnode_t *newvp;
struct vattr va;
vnode_t *rvp;
ASSERT(vp != NULL);
fdp = kmem_cache_alloc(fnode_cache, KM_SLEEP);
fdp->fifo_lock.flk_ref = 1;
fnp = &fdp->fifo_fnode[0];
/*
* Its possible that fifo nodes on different lofs mountpoints
* shadow the same real filesystem fifo node.
* In this case its necessary to get and store the realvp.
* This way different fifo nodes sharing the same real vnode
* can use realvp for communication.
*/
if (VOP_REALVP(vp, &rvp, NULL) == 0)
vp = rvp;
fnp->fn_realvp = vp;
fnp->fn_wcnt = 0;
fnp->fn_rcnt = 0;
#if FIFODEBUG
if (! Fifo_fastmode) {
fnp->fn_flag = 0;
} else {
fnp->fn_flag = FIFOFAST;
}
#else /* FIFODEBUG */
fnp->fn_flag = FIFOFAST;
#endif /* FIFODEBUG */
/*
* initialize the times from vp.
*/
va.va_mask = AT_TIMES;
if (VOP_GETATTR(vp, &va, 0, crp, NULL) == 0) {
fnp->fn_atime = va.va_atime.tv_sec;
fnp->fn_mtime = va.va_mtime.tv_sec;
fnp->fn_ctime = va.va_ctime.tv_sec;
} else {
fnp->fn_atime = 0;
fnp->fn_mtime = 0;
fnp->fn_ctime = 0;
}
/*
* Grab the VP here to avoid holding locks
* whilst trying to acquire others.
*/
VN_HOLD(vp);
mutex_enter(&ftable_lock);
if ((spec_fnp = fifofind(vp)) != NULL) {
mutex_exit(&ftable_lock);
/*
* Release the vnode and free up our pre-prepared fnode.
* Zero the lock reference just to explicitly signal
* this is unused.
*/
VN_RELE(vp);
fdp->fifo_lock.flk_ref = 0;
kmem_cache_free(fnode_cache, fdp);
return (FTOV(spec_fnp));
}
newvp = FTOV(fnp);
fifo_reinit_vp(newvp);
/*
* Since the fifo vnode's v_vfsp needs to point to the
* underlying filesystem's vfsp we need to bump up the
* underlying filesystem's vfs reference count.
* The count is decremented when the fifo node is
* inactivated.
*/
VFS_HOLD(vp->v_vfsp);
newvp->v_vfsp = vp->v_vfsp;
newvp->v_rdev = vp->v_rdev;
newvp->v_flag |= (vp->v_flag & VROOT);
fifoinsert(fnp);
mutex_exit(&ftable_lock);
return (newvp);
}
/*
* getflabel -
*
* Return pointer to the ts_label associated with the specified file,
* or returns NULL if error occurs. Caller is responsible for doing
* a label_rele of the ts_label.
*/
ts_label_t *
getflabel(vnode_t *vp)
{
vfs_t *vfsp, *rvfsp;
vnode_t *rvp, *rvp2;
zone_t *zone;
ts_label_t *zl;
int err;
boolean_t vfs_is_held = B_FALSE;
char vpath[MAXPATHLEN];
ASSERT(vp);
vfsp = vp->v_vfsp;
if (vfsp == NULL)
return (NULL);
rvp = vp;
/*
* Traverse lofs mounts and fattach'es to get the real vnode
*/
if (VOP_REALVP(rvp, &rvp2, NULL) == 0)
rvp = rvp2;
rvfsp = rvp->v_vfsp;
/* rvp/rvfsp now represent the real vnode/vfs we will be using */
/* Go elsewhere to handle all nfs files. */
if (strncmp(vfssw[rvfsp->vfs_fstype].vsw_name, "nfs", 3) == 0)
return (getflabel_nfs(rvfsp));
/*
* Fast path, for objects in a labeled zone: everything except
* for lofs/nfs will be just the label of that zone.
*/
if ((rvfsp->vfs_zone != NULL) && (rvfsp->vfs_zone != global_zone)) {
if ((strcmp(vfssw[rvfsp->vfs_fstype].vsw_name,
"lofs") != 0)) {
zone = rvfsp->vfs_zone;
zone_hold(zone);
goto zone_out; /* return this label */
}
}
/*
* Get the vnode path -- it may be missing or weird for some
* cases, like devices. In those cases use the label of the
* current zone.
*/
err = vnodetopath(rootdir, rvp, vpath, sizeof (vpath), kcred);
if ((err != 0) || (*vpath != '/')) {
zone = curproc->p_zone;
zone_hold(zone);
goto zone_out;
}
/*
* For zfs filesystem, return the explicit label property if a
* meaningful one exists.
*/
if (strncmp(vfssw[rvfsp->vfs_fstype].vsw_name, "zfs", 3) == 0) {
ts_label_t *tsl;
tsl = getflabel_zfs(rvfsp);
/* if label found, return it, otherwise continue... */
if (tsl != NULL)
return (tsl);
}
/*
* If a mountpoint exists, hold the vfs while we reference it.
* Otherwise if mountpoint is NULL it should not be held (e.g.,
* a hold/release on spec_vfs would result in an attempted free
* and panic.)
*/
if (vfsp->vfs_mntpt != NULL) {
VFS_HOLD(vfsp);
vfs_is_held = B_TRUE;
}
zone = zone_find_by_any_path(vpath, B_FALSE);
/*
* If the vnode source zone is properly set to a non-global zone, or
* any zone if the mount is R/W, then use the label of that zone.
*/
if ((zone != global_zone) || ((vfsp->vfs_flag & VFS_RDONLY) != 0))
goto zone_out; /* return this label */
/*
* Otherwise, if we're not in the global zone, use the label of
* our zone.
*/
if ((zone = curproc->p_zone) != global_zone) {
zone_hold(zone);
goto zone_out; /* return this label */
}
/*
* We're in the global zone and the mount is R/W ... so the file
* may actually be in the global zone -- or in the root of any zone.
* Always build our own path for the file, to be sure it's simplified
* (i.e., no ".", "..", "//", and so on).
*/
zone_rele(zone);
zone = zone_find_by_any_path(vpath, B_FALSE);
zone_out:
if ((curproc->p_zone == global_zone) && (zone == global_zone)) {
vfs_t *nvfs;
boolean_t exported = B_FALSE;
refstr_t *mntpt_ref;
char *mntpt;
/*
* File is in the global zone - check whether it's admin_high.
* If it's in a filesys that was exported from the global zone,
* it's admin_low by definition. Otherwise, if it's in a
* filesys that's NOT exported to any zone, it's admin_high.
*
* And for these files if there wasn't a valid mount resource,
* the file must be admin_high (not exported, probably a global
* zone device).
*/
if (!vfs_is_held)
goto out_high;
mntpt_ref = vfs_getmntpoint(vfsp);
mntpt = (char *)refstr_value(mntpt_ref);
if ((mntpt != NULL) && (*mntpt == '/')) {
zone_t *to_zone;
to_zone = zone_find_by_any_path(mntpt, B_FALSE);
zone_rele(to_zone);
if (to_zone != global_zone) {
/* force admin_low */
exported = B_TRUE;
}
}
if (mntpt_ref)
refstr_rele(mntpt_ref);
if (!exported) {
size_t plen = strlen(vpath);
vfs_list_read_lock();
nvfs = vfsp->vfs_next;
while (nvfs != vfsp) {
const char *rstr;
size_t rlen = 0;
/*
* Skip checking this vfs if it's not lofs
* (the only way to export from the global
* zone to a zone).
*/
if (strncmp(vfssw[nvfs->vfs_fstype].vsw_name,
"lofs", 4) != 0) {
nvfs = nvfs->vfs_next;
continue;
}
rstr = refstr_value(nvfs->vfs_resource);
if (rstr != NULL)
rlen = strlen(rstr);
/*
* Check for a match: does this vfs correspond
* to our global zone file path? I.e., check
* if the resource string of this vfs is a
* prefix of our path.
*/
if ((rlen > 0) && (rlen <= plen) &&
(strncmp(rstr, vpath, rlen) == 0) &&
(vpath[rlen] == '/' ||
vpath[rlen] == '\0')) {
/* force admin_low */
exported = B_TRUE;
break;
}
nvfs = nvfs->vfs_next;
}
vfs_list_unlock();
}
if (!exported)
goto out_high;
}
if (vfs_is_held)
VFS_RELE(vfsp);
/*
* Now that we have the "home" zone for the file, return the slabel
* of that zone.
*/
zl = zone->zone_slabel;
label_hold(zl);
zone_rele(zone);
return (zl);
out_high:
if (vfs_is_held)
VFS_RELE(vfsp);
label_hold(l_admin_high);
zone_rele(zone);
return (l_admin_high);
}
/*
* Mount a file descriptor onto the node in the file system.
* Create a new vnode, update the attributes with info from the
* file descriptor and the mount point. The mask, mode, uid, gid,
* atime, mtime and ctime are taken from the mountpt. Link count is
* set to one, the file system id is namedev and nodeid is unique
* for each mounted object. Other attributes are taken from mount point.
* Make sure user is owner (or root) with write permissions on mount point.
* Hash the new vnode and return 0.
* Upon entry to this routine, the file descriptor is in the
* fd field of a struct namefd. Copy that structure from user
* space and retrieve the file descriptor.
*/
static int
nm_mount(vfs_t *vfsp, vnode_t *mvp, struct mounta *uap, cred_t *crp)
{
struct namefd namefdp;
struct vnode *filevp; /* file descriptor vnode */
struct file *fp;
struct vnode *newvp; /* vnode representing this mount */
struct vnode *rvp; /* realvp (if any) for the mountpt */
struct namenode *nodep; /* namenode for this mount */
struct vattr filevattr; /* attributes of file dec. */
struct vattr *vattrp; /* attributes of this mount */
char *resource_name;
char *resource_nodetype;
statvfs64_t *svfsp;
int error = 0;
/*
* Get the file descriptor from user space.
* Make sure the file descriptor is valid and has an
* associated file pointer.
* If so, extract the vnode from the file pointer.
*/
if (uap->datalen != sizeof (struct namefd))
return (EINVAL);
if (copyin(uap->dataptr, &namefdp, uap->datalen))
return (EFAULT);
if ((fp = getf(namefdp.fd)) == NULL)
return (EBADF);
/*
* If the mount point already has something mounted
* on it, disallow this mount. (This restriction may
* be removed in a later release).
* Or unmount has completed but the namefs ROOT vnode
* count has not decremented to zero, disallow this mount.
*/
mutex_enter(&mvp->v_lock);
if ((mvp->v_flag & VROOT) ||
vfs_matchops(mvp->v_vfsp, namefs_vfsops)) {
mutex_exit(&mvp->v_lock);
releasef(namefdp.fd);
return (EBUSY);
}
mutex_exit(&mvp->v_lock);
/*
* Cannot allow users to fattach() in /dev/pts.
* First, there is no need for doing so and secondly
* we cannot allow arbitrary users to park on a node in
* /dev/pts or /dev/vt.
*/
rvp = NULLVP;
if (vn_matchops(mvp, spec_getvnodeops()) &&
VOP_REALVP(mvp, &rvp, NULL) == 0 && rvp &&
(vn_matchops(rvp, devpts_getvnodeops()) ||
vn_matchops(rvp, devvt_getvnodeops()))) {
releasef(namefdp.fd);
return (ENOTSUP);
}
filevp = fp->f_vnode;
if (filevp->v_type == VDIR || filevp->v_type == VPORT) {
releasef(namefdp.fd);
return (EINVAL);
}
/*
* If the fd being mounted refers to neither a door nor a stream,
* make sure the caller is privileged.
*/
if (filevp->v_type != VDOOR && filevp->v_stream == NULL) {
if (secpolicy_fs_mount(crp, filevp, vfsp) != 0) {
/* fd is neither a stream nor a door */
releasef(namefdp.fd);
return (EINVAL);
}
}
/*
* Make sure the file descriptor is not the root of some
* file system.
* If it's not, create a reference and allocate a namenode
* to represent this mount request.
*/
if (filevp->v_flag & VROOT) {
releasef(namefdp.fd);
return (EBUSY);
}
nodep = kmem_zalloc(sizeof (struct namenode), KM_SLEEP);
mutex_init(&nodep->nm_lock, NULL, MUTEX_DEFAULT, NULL);
vattrp = &nodep->nm_vattr;
vattrp->va_mask = AT_ALL;
if (error = VOP_GETATTR(mvp, vattrp, 0, crp, NULL))
goto out;
filevattr.va_mask = AT_ALL;
if (error = VOP_GETATTR(filevp, &filevattr, 0, crp, NULL))
goto out;
/*
* Make sure the user is the owner of the mount point
* or has sufficient privileges.
*/
if (error = secpolicy_vnode_owner(crp, vattrp->va_uid))
goto out;
/*
* Make sure the user has write permissions on the
* mount point (or has sufficient privileges).
*/
if (!(vattrp->va_mode & VWRITE) &&
secpolicy_vnode_access(crp, mvp, vattrp->va_uid, VWRITE) != 0) {
error = EACCES;
goto out;
}
/*
* If the file descriptor has file/record locking, don't
* allow the mount to succeed.
*/
if (vn_has_flocks(filevp)) {
error = EACCES;
goto out;
}
/*
* Initialize the namenode.
*/
if (filevp->v_stream) {
struct stdata *stp = filevp->v_stream;
mutex_enter(&stp->sd_lock);
stp->sd_flag |= STRMOUNT;
mutex_exit(&stp->sd_lock);
}
nodep->nm_filevp = filevp;
mutex_enter(&fp->f_tlock);
fp->f_count++;
mutex_exit(&fp->f_tlock);
releasef(namefdp.fd);
nodep->nm_filep = fp;
nodep->nm_mountpt = mvp;
/*
* The attributes for the mounted file descriptor were initialized
* above by applying VOP_GETATTR to the mount point. Some of
* the fields of the attributes structure will be overwritten
* by the attributes from the file descriptor.
*/
vattrp->va_type = filevattr.va_type;
vattrp->va_fsid = namedev;
vattrp->va_nodeid = namenodeno_alloc();
vattrp->va_nlink = 1;
vattrp->va_size = filevattr.va_size;
vattrp->va_rdev = filevattr.va_rdev;
vattrp->va_blksize = filevattr.va_blksize;
vattrp->va_nblocks = filevattr.va_nblocks;
vattrp->va_seq = 0;
/*
* Initialize new vnode structure for the mounted file descriptor.
*/
nodep->nm_vnode = vn_alloc(KM_SLEEP);
newvp = NMTOV(nodep);
newvp->v_flag = filevp->v_flag | VROOT | VNOMAP | VNOSWAP;
vn_setops(newvp, nm_vnodeops);
newvp->v_vfsp = vfsp;
newvp->v_stream = filevp->v_stream;
newvp->v_type = filevp->v_type;
newvp->v_rdev = filevp->v_rdev;
newvp->v_data = (caddr_t)nodep;
VFS_HOLD(vfsp);
vn_exists(newvp);
/*
* Initialize the vfs structure.
*/
vfsp->vfs_vnodecovered = NULL;
vfsp->vfs_flag |= VFS_UNLINKABLE;
vfsp->vfs_bsize = 1024;
vfsp->vfs_fstype = namefstype;
vfs_make_fsid(&vfsp->vfs_fsid, namedev, namefstype);
vfsp->vfs_data = (caddr_t)nodep;
vfsp->vfs_dev = namedev;
vfsp->vfs_bcount = 0;
/*
* Set the name we mounted from.
*/
switch (filevp->v_type) {
case VPROC: /* VOP_GETATTR() translates this to VREG */
case VREG: resource_nodetype = "file"; break;
case VDIR: resource_nodetype = "directory"; break;
case VBLK: resource_nodetype = "device"; break;
case VCHR: resource_nodetype = "device"; break;
case VLNK: resource_nodetype = "link"; break;
case VFIFO: resource_nodetype = "fifo"; break;
case VDOOR: resource_nodetype = "door"; break;
case VSOCK: resource_nodetype = "socket"; break;
default: resource_nodetype = "resource"; break;
}
#define RESOURCE_NAME_SZ 128 /* Maximum length of the resource name */
resource_name = kmem_alloc(RESOURCE_NAME_SZ, KM_SLEEP);
svfsp = kmem_alloc(sizeof (statvfs64_t), KM_SLEEP);
error = VFS_STATVFS(filevp->v_vfsp, svfsp);
if (error == 0) {
(void) snprintf(resource_name, RESOURCE_NAME_SZ,
"unspecified_%s_%s", svfsp->f_basetype, resource_nodetype);
} else {
(void) snprintf(resource_name, RESOURCE_NAME_SZ,
"unspecified_%s", resource_nodetype);
}
vfs_setresource(vfsp, resource_name);
kmem_free(svfsp, sizeof (statvfs64_t));
kmem_free(resource_name, RESOURCE_NAME_SZ);
#undef RESOURCE_NAME_SZ
/*
* Insert the namenode.
*/
mutex_enter(&ntable_lock);
nameinsert(nodep);
mutex_exit(&ntable_lock);
return (0);
out:
releasef(namefdp.fd);
kmem_free(nodep, sizeof (struct namenode));
return (error);
}
/*
* Get/Make vfs structure for given real vfs
*/
static struct vfs *
makelfsnode(struct vfs *vfsp, struct loinfo *li)
{
struct lfsnode *lfs;
struct lfsnode *tlfs;
/*
* Don't grab any locks for the fast (common) case.
*/
if (vfsp == li->li_realvfs)
return (li->li_mountvfs);
ASSERT(li->li_refct > 0);
mutex_enter(&li->li_lfslock);
if ((lfs = lfsfind(vfsp, li)) == NULL) {
mutex_exit(&li->li_lfslock);
lfs = kmem_zalloc(sizeof (*lfs), KM_SLEEP);
mutex_enter(&li->li_lfslock);
if ((tlfs = lfsfind(vfsp, li)) != NULL) {
kmem_free(lfs, sizeof (*lfs));
lfs = tlfs;
goto found_lfs;
}
lfs->lfs_realvfs = vfsp;
/*
* Even though the lfsnode is strictly speaking a private
* implementation detail of lofs, it should behave as a regular
* vfs_t for the benefit of the rest of the kernel.
*/
VFS_INIT(&lfs->lfs_vfs, lo_vfsops, (caddr_t)li);
lfs->lfs_vfs.vfs_fstype = li->li_mountvfs->vfs_fstype;
lfs->lfs_vfs.vfs_flag =
((vfsp->vfs_flag | li->li_mflag) & ~li->li_dflag) &
INHERIT_VFS_FLAG;
lfs->lfs_vfs.vfs_bsize = vfsp->vfs_bsize;
lfs->lfs_vfs.vfs_dev = vfsp->vfs_dev;
lfs->lfs_vfs.vfs_fsid = vfsp->vfs_fsid;
if (vfsp->vfs_mntpt != NULL) {
lfs->lfs_vfs.vfs_mntpt = vfs_getmntpoint(vfsp);
/* Leave a reference to the mountpoint */
}
(void) VFS_ROOT(vfsp, &lfs->lfs_realrootvp);
/*
* We use 1 instead of 0 as the value to associate with
* an idle lfs_vfs. This is to prevent VFS_RELE()
* trying to kmem_free() our lfs_t (which is the wrong
* size).
*/
VFS_HOLD(&lfs->lfs_vfs);
lfs->lfs_next = li->li_lfs;
li->li_lfs = lfs;
vfs_propagate_features(vfsp, &lfs->lfs_vfs);
}
found_lfs:
VFS_HOLD(&lfs->lfs_vfs);
mutex_exit(&li->li_lfslock);
return (&lfs->lfs_vfs);
}
static vnode_t *
make_rnode4(nfs4_sharedfh_t *fh, r4hashq_t *rhtp, struct vfs *vfsp,
struct vnodeops *vops,
int (*putapage)(vnode_t *, page_t *, u_offset_t *, size_t *, int, cred_t *),
int *newnode, cred_t *cr)
{
rnode4_t *rp;
rnode4_t *trp;
vnode_t *vp;
mntinfo4_t *mi;
ASSERT(RW_READ_HELD(&rhtp->r_lock));
mi = VFTOMI4(vfsp);
start:
if ((rp = r4find(rhtp, fh, vfsp)) != NULL) {
vp = RTOV4(rp);
*newnode = 0;
return (vp);
}
rw_exit(&rhtp->r_lock);
mutex_enter(&rp4freelist_lock);
if (rp4freelist != NULL && rnode4_new >= nrnode) {
rp = rp4freelist;
rp4_rmfree(rp);
mutex_exit(&rp4freelist_lock);
vp = RTOV4(rp);
if (rp->r_flags & R4HASHED) {
rw_enter(&rp->r_hashq->r_lock, RW_WRITER);
mutex_enter(&vp->v_lock);
if (vp->v_count > 1) {
vp->v_count--;
mutex_exit(&vp->v_lock);
rw_exit(&rp->r_hashq->r_lock);
rw_enter(&rhtp->r_lock, RW_READER);
goto start;
}
mutex_exit(&vp->v_lock);
rp4_rmhash_locked(rp);
rw_exit(&rp->r_hashq->r_lock);
}
r4inactive(rp, cr);
mutex_enter(&vp->v_lock);
if (vp->v_count > 1) {
vp->v_count--;
mutex_exit(&vp->v_lock);
rw_enter(&rhtp->r_lock, RW_READER);
goto start;
}
mutex_exit(&vp->v_lock);
vn_invalid(vp);
/*
* destroy old locks before bzero'ing and
* recreating the locks below.
*/
uninit_rnode4(rp);
/*
* Make sure that if rnode is recycled then
* VFS count is decremented properly before
* reuse.
*/
VFS_RELE(vp->v_vfsp);
vn_reinit(vp);
} else {
vnode_t *new_vp;
mutex_exit(&rp4freelist_lock);
rp = kmem_cache_alloc(rnode4_cache, KM_SLEEP);
new_vp = vn_alloc(KM_SLEEP);
atomic_add_long((ulong_t *)&rnode4_new, 1);
#ifdef DEBUG
clstat4_debug.nrnode.value.ui64++;
#endif
vp = new_vp;
}
bzero(rp, sizeof (*rp));
rp->r_vnode = vp;
nfs_rw_init(&rp->r_rwlock, NULL, RW_DEFAULT, NULL);
nfs_rw_init(&rp->r_lkserlock, NULL, RW_DEFAULT, NULL);
mutex_init(&rp->r_svlock, NULL, MUTEX_DEFAULT, NULL);
mutex_init(&rp->r_statelock, NULL, MUTEX_DEFAULT, NULL);
mutex_init(&rp->r_statev4_lock, NULL, MUTEX_DEFAULT, NULL);
mutex_init(&rp->r_os_lock, NULL, MUTEX_DEFAULT, NULL);
rp->created_v4 = 0;
list_create(&rp->r_open_streams, sizeof (nfs4_open_stream_t),
offsetof(nfs4_open_stream_t, os_node));
rp->r_lo_head.lo_prev_rnode = &rp->r_lo_head;
rp->r_lo_head.lo_next_rnode = &rp->r_lo_head;
cv_init(&rp->r_cv, NULL, CV_DEFAULT, NULL);
cv_init(&rp->r_commit.c_cv, NULL, CV_DEFAULT, NULL);
rp->r_flags = R4READDIRWATTR;
rp->r_fh = fh;
rp->r_hashq = rhtp;
sfh4_hold(rp->r_fh);
rp->r_server = mi->mi_curr_serv;
rp->r_deleg_type = OPEN_DELEGATE_NONE;
rp->r_deleg_needs_recovery = OPEN_DELEGATE_NONE;
nfs_rw_init(&rp->r_deleg_recall_lock, NULL, RW_DEFAULT, NULL);
rddir4_cache_create(rp);
rp->r_putapage = putapage;
vn_setops(vp, vops);
vp->v_data = (caddr_t)rp;
vp->v_vfsp = vfsp;
VFS_HOLD(vfsp);
vp->v_type = VNON;
if (isrootfh(fh, rp))
vp->v_flag = VROOT;
vn_exists(vp);
/*
* There is a race condition if someone else
* alloc's the rnode while no locks are held, so we
* check again and recover if found.
*/
rw_enter(&rhtp->r_lock, RW_WRITER);
if ((trp = r4find(rhtp, fh, vfsp)) != NULL) {
vp = RTOV4(trp);
*newnode = 0;
rw_exit(&rhtp->r_lock);
rp4_addfree(rp, cr);
rw_enter(&rhtp->r_lock, RW_READER);
return (vp);
}
rp4_addhash(rp);
*newnode = 1;
return (vp);
}