struct vnode *
getsynthvnode(const char *devname)
{
struct vnode *vp;
struct nchandle nch;
struct nlookupdata nd;
struct ucred *cred = proc0.p_ucred;
int error;
KKASSERT(synth_inited != 0);
KKASSERT(synth_mp != NULL);
KKASSERT(synth_mp->mnt_ncmountpt.mount != NULL);
/* Sync devfs/disks twice to make sure all devices are around */
if (synth_synced < 2) {
sync_devs();
++synth_synced;
}
error = nlookup_init_root(&nd,
devname, UIO_SYSSPACE, NLC_FOLLOW,
cred, &synth_mp->mnt_ncmountpt,
&synth_mp->mnt_ncmountpt);
if (error) {
panic("synth: nlookup_init_root failed with %d", error);
/* NOTREACHED */
}
error = nlookup(&nd);
if (error == 0) {
if (nd.nl_nch.ncp->nc_vp == NULL) {
kprintf("synth: nc_vp == NULL\n");
return (NULL);
}
nch = nd.nl_nch;
cache_zero(&nd.nl_nch);
}
nlookup_done(&nd);
if (error) {
if (error != ENOENT) { /* Don't bother warning about ENOENT */
kprintf("synth: nlookup of %s failed with %d\n",
devname, error);
}
return (NULL);
}
vp = nch.ncp->nc_vp;
/* A VX locked & refd vnode must be returned. */
error = vget(vp, LK_EXCLUSIVE);
cache_unlock(&nch);
if (error) {
kprintf("synth: could not vget vnode\n");
return (NULL);
}
return (vp);
}
/* to be called first */
int cache_init() {
int i;
mylog("cache_init()\n");
for(i=0; i<CACHE_MAX; i++) {
cache_zero(&(caches[i]));
}
return(1);
}
/*
* Simple all-in-one nlookup. Returns a locked namecache structure or NULL
* if an error occured.
*
* Note that the returned ncp is not checked for permissions, though VEXEC
* is checked on the directory path leading up to the result. The caller
* must call naccess() to check the permissions of the returned leaf.
*/
struct nchandle
nlookup_simple(const char *str, enum uio_seg seg,
int niflags, int *error)
{
struct nlookupdata nd;
struct nchandle nch;
*error = nlookup_init(&nd, str, seg, niflags);
if (*error == 0) {
if ((*error = nlookup(&nd)) == 0) {
nch = nd.nl_nch; /* keep hold ref from structure */
cache_zero(&nd.nl_nch); /* and NULL out */
} else {
cache_zero(&nch);
}
nlookup_done(&nd);
} else {
cache_zero(&nch);
}
return(nch);
}
/* freed content of a cache */
void cache_free(Cache *cache) {
int i;
mylog("cache_free(%p)\n", cache);
/* cache itself */
if (cache->name != NULL)
free(cache->name);
if (cache->firstblock != NULL)
free(cache->firstblock);
/* chunks */
for(i=0; i<CACHE_MAX_CHUNK; i++) {
cache_chunk_free(cache->chunks[i]);
cache->chunks[i] = NULL;
}
/* connection */
cache_disconnect(&(cache->connection));
if (cache->connection.target != NULL)
free(cache->connection.target);
cache_zero(cache);
}
/*
* Common code for vnode open operations. Check permissions, and call
* the VOP_NOPEN or VOP_NCREATE routine.
*
* The caller is responsible for setting up nd with nlookup_init() and
* for cleaning it up with nlookup_done(), whether we return an error
* or not.
*
* On success nd->nl_open_vp will hold a referenced and, if requested,
* locked vnode. A locked vnode is requested via NLC_LOCKVP. If fp
* is non-NULL the vnode will be installed in the file pointer.
*
* NOTE: The vnode is referenced just once on return whether or not it
* is also installed in the file pointer.
*/
int
vn_open(struct nlookupdata *nd, struct file *fp, int fmode, int cmode)
{
struct vnode *vp;
struct ucred *cred = nd->nl_cred;
struct vattr vat;
struct vattr *vap = &vat;
int error;
u_int flags;
uint64_t osize;
struct mount *mp;
/*
* Certain combinations are illegal
*/
if ((fmode & (FWRITE | O_TRUNC)) == O_TRUNC)
return(EACCES);
/*
* Lookup the path and create or obtain the vnode. After a
* successful lookup a locked nd->nl_nch will be returned.
*
* The result of this section should be a locked vnode.
*
* XXX with only a little work we should be able to avoid locking
* the vnode if FWRITE, O_CREAT, and O_TRUNC are *not* set.
*/
nd->nl_flags |= NLC_OPEN;
if (fmode & O_APPEND)
nd->nl_flags |= NLC_APPEND;
if (fmode & O_TRUNC)
nd->nl_flags |= NLC_TRUNCATE;
if (fmode & FREAD)
nd->nl_flags |= NLC_READ;
if (fmode & FWRITE)
nd->nl_flags |= NLC_WRITE;
if ((fmode & O_EXCL) == 0 && (fmode & O_NOFOLLOW) == 0)
nd->nl_flags |= NLC_FOLLOW;
if (fmode & O_CREAT) {
/*
* CONDITIONAL CREATE FILE CASE
*
* Setting NLC_CREATE causes a negative hit to store
* the negative hit ncp and not return an error. Then
* nc_error or nc_vp may be checked to see if the ncp
* represents a negative hit. NLC_CREATE also requires
* write permission on the governing directory or EPERM
* is returned.
*/
nd->nl_flags |= NLC_CREATE;
nd->nl_flags |= NLC_REFDVP;
bwillinode(1);
error = nlookup(nd);
} else {
/*
* NORMAL OPEN FILE CASE
*/
error = nlookup(nd);
}
if (error)
return (error);
/*
* split case to allow us to re-resolve and retry the ncp in case
* we get ESTALE.
*/
again:
if (fmode & O_CREAT) {
if (nd->nl_nch.ncp->nc_vp == NULL) {
if ((error = ncp_writechk(&nd->nl_nch)) != 0)
return (error);
VATTR_NULL(vap);
vap->va_type = VREG;
vap->va_mode = cmode;
if (fmode & O_EXCL)
vap->va_vaflags |= VA_EXCLUSIVE;
error = VOP_NCREATE(&nd->nl_nch, nd->nl_dvp, &vp,
nd->nl_cred, vap);
if (error)
return (error);
fmode &= ~O_TRUNC;
/* locked vnode is returned */
} else {
if (fmode & O_EXCL) {
error = EEXIST;
} else {
error = cache_vget(&nd->nl_nch, cred,
LK_EXCLUSIVE, &vp);
}
if (error)
return (error);
fmode &= ~O_CREAT;
}
} else {
error = cache_vget(&nd->nl_nch, cred, LK_EXCLUSIVE, &vp);
if (error)
return (error);
}
/*
* We have a locked vnode and ncp now. Note that the ncp will
* be cleaned up by the caller if nd->nl_nch is left intact.
*/
if (vp->v_type == VLNK) {
error = EMLINK;
goto bad;
}
if (vp->v_type == VSOCK) {
error = EOPNOTSUPP;
goto bad;
}
if ((fmode & O_CREAT) == 0) {
if (fmode & (FWRITE | O_TRUNC)) {
if (vp->v_type == VDIR) {
error = EISDIR;
goto bad;
}
error = vn_writechk(vp, &nd->nl_nch);
if (error) {
/*
* Special stale handling, re-resolve the
* vnode.
*/
if (error == ESTALE) {
vput(vp);
vp = NULL;
cache_setunresolved(&nd->nl_nch);
error = cache_resolve(&nd->nl_nch, cred);
if (error == 0)
goto again;
}
goto bad;
}
}
}
if (fmode & O_TRUNC) {
vn_unlock(vp); /* XXX */
vn_lock(vp, LK_EXCLUSIVE | LK_RETRY); /* XXX */
osize = vp->v_filesize;
VATTR_NULL(vap);
vap->va_size = 0;
error = VOP_SETATTR(vp, vap, cred);
if (error)
goto bad;
error = VOP_GETATTR(vp, vap);
if (error)
goto bad;
mp = vq_vptomp(vp);
VFS_ACCOUNT(mp, vap->va_uid, vap->va_gid, -osize);
}
/*
* Set or clear VNSWAPCACHE on the vp based on nd->nl_nch.ncp->nc_flag.
* These particular bits a tracked all the way from the root.
*
* NOTE: Might not work properly on NFS servers due to the
* disconnected namecache.
*/
flags = nd->nl_nch.ncp->nc_flag;
if ((flags & (NCF_UF_CACHE | NCF_UF_PCACHE)) &&
(flags & (NCF_SF_NOCACHE | NCF_SF_PNOCACHE)) == 0) {
vsetflags(vp, VSWAPCACHE);
} else {
vclrflags(vp, VSWAPCACHE);
}
/*
* Setup the fp so VOP_OPEN can override it. No descriptor has been
* associated with the fp yet so we own it clean.
*
* f_nchandle inherits nl_nch. This used to be necessary only for
* directories but now we do it unconditionally so f*() ops
* such as fchmod() can access the actual namespace that was
* used to open the file.
*/
if (fp) {
if (nd->nl_flags & NLC_APPENDONLY)
fmode |= FAPPENDONLY;
fp->f_nchandle = nd->nl_nch;
cache_zero(&nd->nl_nch);
cache_unlock(&fp->f_nchandle);
}
/*
* Get rid of nl_nch. vn_open does not return it (it returns the
* vnode or the file pointer). Note: we can't leave nl_nch locked
* through the VOP_OPEN anyway since the VOP_OPEN may block, e.g.
* on /dev/ttyd0
*/
if (nd->nl_nch.ncp)
cache_put(&nd->nl_nch);
error = VOP_OPEN(vp, fmode, cred, fp);
if (error) {
/*
* setting f_ops to &badfileops will prevent the descriptor
* code from trying to close and release the vnode, since
* the open failed we do not want to call close.
*/
if (fp) {
fp->f_data = NULL;
fp->f_ops = &badfileops;
}
goto bad;
}
#if 0
/*
* Assert that VREG files have been setup for vmio.
*/
KASSERT(vp->v_type != VREG || vp->v_object != NULL,
("vn_open: regular file was not VMIO enabled!"));
#endif
/*
* Return the vnode. XXX needs some cleaning up. The vnode is
* only returned in the fp == NULL case.
*/
if (fp == NULL) {
nd->nl_open_vp = vp;
nd->nl_vp_fmode = fmode;
if ((nd->nl_flags & NLC_LOCKVP) == 0)
vn_unlock(vp);
} else {
vput(vp);
}
return (0);
bad:
if (vp)
vput(vp);
return (error);
}
int
vfs_mountroot_devfs(void)
{
struct vnode *vp;
struct nchandle nch;
struct nlookupdata nd;
struct mount *mp;
struct vfsconf *vfsp;
int error;
struct ucred *cred = proc0.p_ucred;
const char *devfs_path, *init_chroot;
char *dev_malloced = NULL;
if ((init_chroot = kgetenv("init_chroot")) != NULL) {
size_t l;
l = strlen(init_chroot) + sizeof("/dev");
dev_malloced = kmalloc(l, M_MOUNT, M_WAITOK);
ksnprintf(dev_malloced, l, "%s/dev", init_chroot);
devfs_path = dev_malloced;
} else {
devfs_path = "/dev";
}
/*
* Lookup the requested path and extract the nch and vnode.
*/
error = nlookup_init_raw(&nd,
devfs_path, UIO_SYSSPACE, NLC_FOLLOW,
cred, &rootnch);
if (error == 0) {
devfs_debug(DEVFS_DEBUG_DEBUG, "vfs_mountroot_devfs: nlookup_init is ok...\n");
if ((error = nlookup(&nd)) == 0) {
devfs_debug(DEVFS_DEBUG_DEBUG, "vfs_mountroot_devfs: nlookup is ok...\n");
if (nd.nl_nch.ncp->nc_vp == NULL) {
devfs_debug(DEVFS_DEBUG_SHOW, "vfs_mountroot_devfs: nlookup: simply not found\n");
error = ENOENT;
}
}
}
if (dev_malloced != NULL)
kfree(dev_malloced, M_MOUNT), dev_malloced = NULL;
devfs_path = NULL;
if (error) {
nlookup_done(&nd);
devfs_debug(DEVFS_DEBUG_SHOW, "vfs_mountroot_devfs: nlookup failed, error: %d\n", error);
return (error);
}
/*
* Extract the locked+refd ncp and cleanup the nd structure
*/
nch = nd.nl_nch;
cache_zero(&nd.nl_nch);
nlookup_done(&nd);
/*
* now we have the locked ref'd nch and unreferenced vnode.
*/
vp = nch.ncp->nc_vp;
if ((error = vget(vp, LK_EXCLUSIVE)) != 0) {
cache_put(&nch);
devfs_debug(DEVFS_DEBUG_SHOW, "vfs_mountroot_devfs: vget failed\n");
return (error);
}
cache_unlock(&nch);
if ((error = vinvalbuf(vp, V_SAVE, 0, 0)) != 0) {
cache_drop(&nch);
vput(vp);
devfs_debug(DEVFS_DEBUG_SHOW, "vfs_mountroot_devfs: vinvalbuf failed\n");
return (error);
}
if (vp->v_type != VDIR) {
cache_drop(&nch);
vput(vp);
devfs_debug(DEVFS_DEBUG_SHOW, "vfs_mountroot_devfs: vp is not VDIR\n");
return (ENOTDIR);
}
vfsp = vfsconf_find_by_name("devfs");
vsetflags(vp, VMOUNT);
/*
* Allocate and initialize the filesystem.
*/
mp = kmalloc(sizeof(struct mount), M_MOUNT, M_ZERO|M_WAITOK);
mount_init(mp);
vfs_busy(mp, LK_NOWAIT);
mp->mnt_op = vfsp->vfc_vfsops;
mp->mnt_vfc = vfsp;
vfsp->vfc_refcount++;
mp->mnt_stat.f_type = vfsp->vfc_typenum;
mp->mnt_flag |= vfsp->vfc_flags & MNT_VISFLAGMASK;
strncpy(mp->mnt_stat.f_fstypename, vfsp->vfc_name, MFSNAMELEN);
mp->mnt_stat.f_owner = cred->cr_uid;
vn_unlock(vp);
/*
* Mount the filesystem.
*/
error = VFS_MOUNT(mp, "/dev", NULL, cred);
vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
/*
* Put the new filesystem on the mount list after root. The mount
* point gets its own mnt_ncmountpt (unless the VFS already set one
* up) which represents the root of the mount. The lookup code
* detects the mount point going forward and checks the root of
* the mount going backwards.
*
* It is not necessary to invalidate or purge the vnode underneath
* because elements under the mount will be given their own glue
* namecache record.
*/
if (!error) {
if (mp->mnt_ncmountpt.ncp == NULL) {
/*
* allocate, then unlock, but leave the ref intact
*/
cache_allocroot(&mp->mnt_ncmountpt, mp, NULL);
cache_unlock(&mp->mnt_ncmountpt);
}
mp->mnt_ncmounton = nch; /* inherits ref */
nch.ncp->nc_flag |= NCF_ISMOUNTPT;
/* XXX get the root of the fs and cache_setvp(mnt_ncmountpt...) */
vclrflags(vp, VMOUNT);
mountlist_insert(mp, MNTINS_LAST);
vn_unlock(vp);
//checkdirs(&mp->mnt_ncmounton, &mp->mnt_ncmountpt);
error = vfs_allocate_syncvnode(mp);
if (error) {
devfs_debug(DEVFS_DEBUG_SHOW, "vfs_mountroot_devfs: vfs_allocate_syncvnode failed\n");
}
vfs_unbusy(mp);
error = VFS_START(mp, 0);
vrele(vp);
} else {
vfs_rm_vnodeops(mp, NULL, &mp->mnt_vn_coherency_ops);
vfs_rm_vnodeops(mp, NULL, &mp->mnt_vn_journal_ops);
vfs_rm_vnodeops(mp, NULL, &mp->mnt_vn_norm_ops);
vfs_rm_vnodeops(mp, NULL, &mp->mnt_vn_spec_ops);
vfs_rm_vnodeops(mp, NULL, &mp->mnt_vn_fifo_ops);
vclrflags(vp, VMOUNT);
mp->mnt_vfc->vfc_refcount--;
vfs_unbusy(mp);
kfree(mp, M_MOUNT);
cache_drop(&nch);
vput(vp);
devfs_debug(DEVFS_DEBUG_SHOW, "vfs_mountroot_devfs: mount failed\n");
}
devfs_debug(DEVFS_DEBUG_DEBUG, "rootmount_devfs done with error: %d\n", error);
return (error);
}