static int
filt_tmpfsread(struct knote *kn, long hint)
{
struct vnode *vp = (void *)kn->kn_hook;
struct tmpfs_node *node = VP_TO_TMPFS_NODE(vp);
off_t off;
if (hint == NOTE_REVOKE) {
kn->kn_flags |= (EV_EOF | EV_NODATA | EV_ONESHOT);
return(1);
}
/*
* Interlock against MP races when performing this function.
*/
TMPFS_NODE_LOCK_SH(node);
off = node->tn_size - kn->kn_fp->f_offset;
kn->kn_data = (off < INTPTR_MAX) ? off : INTPTR_MAX;
if (kn->kn_sfflags & NOTE_OLDAPI) {
TMPFS_NODE_UNLOCK(node);
return(1);
}
if (kn->kn_data == 0) {
kn->kn_data = (off < INTPTR_MAX) ? off : INTPTR_MAX;
}
TMPFS_NODE_UNLOCK(node);
return (kn->kn_data != 0);
}
static int
tmpfs_nresolve(struct vop_nresolve_args *v)
{
struct vnode *dvp = v->a_dvp;
struct vnode *vp = NULL;
struct namecache *ncp = v->a_nch->ncp;
struct tmpfs_node *tnode;
struct mount *mp;
struct tmpfs_dirent *de;
struct tmpfs_node *dnode;
int error;
mp = dvp->v_mount;
dnode = VP_TO_TMPFS_DIR(dvp);
TMPFS_NODE_LOCK_SH(dnode);
de = tmpfs_dir_lookup(dnode, NULL, ncp);
if (de == NULL) {
error = ENOENT;
} else {
/*
* Allocate a vnode for the node we found.
*/
tnode = de->td_node;
error = tmpfs_alloc_vp(dvp->v_mount, tnode,
LK_EXCLUSIVE | LK_RETRY, &vp);
if (error)
goto out;
KKASSERT(vp);
}
out:
TMPFS_NODE_UNLOCK(dnode);
if ((dnode->tn_status & TMPFS_NODE_ACCESSED) == 0) {
TMPFS_NODE_LOCK(dnode);
dnode->tn_status |= TMPFS_NODE_ACCESSED;
TMPFS_NODE_UNLOCK(dnode);
}
/*
* Store the result of this lookup in the cache. Avoid this if the
* request was for creation, as it does not improve timings on
* emprical tests.
*/
if (vp) {
vn_unlock(vp);
cache_setvp(v->a_nch, vp);
vrele(vp);
} else if (error == ENOENT) {
cache_setvp(v->a_nch, NULL);
}
return (error);
}
int
tmpfs_getattr(struct vop_getattr_args *v)
{
struct vnode *vp = v->a_vp;
struct vattr *vap = v->a_vap;
struct tmpfs_node *node;
node = VP_TO_TMPFS_NODE(vp);
tmpfs_update(vp);
TMPFS_NODE_LOCK_SH(node);
vap->va_type = vp->v_type;
vap->va_mode = node->tn_mode;
vap->va_nlink = node->tn_links;
vap->va_uid = node->tn_uid;
vap->va_gid = node->tn_gid;
vap->va_fsid = vp->v_mount->mnt_stat.f_fsid.val[0];
vap->va_fileid = node->tn_id;
vap->va_size = node->tn_size;
vap->va_blocksize = PAGE_SIZE;
vap->va_atime.tv_sec = node->tn_atime;
vap->va_atime.tv_nsec = node->tn_atimensec;
vap->va_mtime.tv_sec = node->tn_mtime;
vap->va_mtime.tv_nsec = node->tn_mtimensec;
vap->va_ctime.tv_sec = node->tn_ctime;
vap->va_ctime.tv_nsec = node->tn_ctimensec;
vap->va_gen = node->tn_gen;
vap->va_flags = node->tn_flags;
if (vp->v_type == VBLK || vp->v_type == VCHR) {
vap->va_rmajor = umajor(node->tn_rdev);
vap->va_rminor = uminor(node->tn_rdev);
}
vap->va_bytes = round_page(node->tn_size);
vap->va_filerev = 0;
TMPFS_NODE_UNLOCK(node);
return 0;
}
static int
tmpfs_readlink(struct vop_readlink_args *v)
{
struct vnode *vp = v->a_vp;
struct uio *uio = v->a_uio;
int error;
struct tmpfs_node *node;
KKASSERT(uio->uio_offset == 0);
KKASSERT(vp->v_type == VLNK);
node = VP_TO_TMPFS_NODE(vp);
TMPFS_NODE_LOCK_SH(node);
error = uiomove(node->tn_link,
MIN(node->tn_size, uio->uio_resid), uio);
TMPFS_NODE_UNLOCK(node);
if ((node->tn_status & TMPFS_NODE_ACCESSED) == 0) {
TMPFS_NODE_LOCK(node);
node->tn_status |= TMPFS_NODE_ACCESSED;
TMPFS_NODE_UNLOCK(node);
}
return error;
}
static int
tmpfs_readdir(struct vop_readdir_args *v)
{
struct vnode *vp = v->a_vp;
struct uio *uio = v->a_uio;
int *eofflag = v->a_eofflag;
off_t **cookies = v->a_cookies;
int *ncookies = v->a_ncookies;
struct tmpfs_mount *tmp;
int error;
off_t startoff;
off_t cnt = 0;
struct tmpfs_node *node;
/* This operation only makes sense on directory nodes. */
if (vp->v_type != VDIR) {
return ENOTDIR;
}
tmp = VFS_TO_TMPFS(vp->v_mount);
node = VP_TO_TMPFS_DIR(vp);
startoff = uio->uio_offset;
if (uio->uio_offset == TMPFS_DIRCOOKIE_DOT) {
error = tmpfs_dir_getdotdent(node, uio);
if (error != 0) {
TMPFS_NODE_LOCK_SH(node);
goto outok;
}
cnt++;
}
if (uio->uio_offset == TMPFS_DIRCOOKIE_DOTDOT) {
/* may lock parent, cannot hold node lock */
error = tmpfs_dir_getdotdotdent(tmp, node, uio);
if (error != 0) {
TMPFS_NODE_LOCK_SH(node);
goto outok;
}
cnt++;
}
TMPFS_NODE_LOCK_SH(node);
error = tmpfs_dir_getdents(node, uio, &cnt);
outok:
KKASSERT(error >= -1);
if (error == -1)
error = 0;
if (eofflag != NULL)
*eofflag =
(error == 0 && uio->uio_offset == TMPFS_DIRCOOKIE_EOF);
/* Update NFS-related variables. */
if (error == 0 && cookies != NULL && ncookies != NULL) {
off_t i;
off_t off = startoff;
struct tmpfs_dirent *de = NULL;
*ncookies = cnt;
*cookies = kmalloc(cnt * sizeof(off_t), M_TEMP, M_WAITOK);
for (i = 0; i < cnt; i++) {
KKASSERT(off != TMPFS_DIRCOOKIE_EOF);
if (off == TMPFS_DIRCOOKIE_DOT) {
off = TMPFS_DIRCOOKIE_DOTDOT;
} else {
if (off == TMPFS_DIRCOOKIE_DOTDOT) {
de = RB_MIN(tmpfs_dirtree_cookie,
&node->tn_dir.tn_cookietree);
} else if (de != NULL) {
de = RB_NEXT(tmpfs_dirtree_cookie,
&node->tn_dir.tn_cookietree, de);
} else {
de = tmpfs_dir_lookupbycookie(node,
off);
KKASSERT(de != NULL);
de = RB_NEXT(tmpfs_dirtree_cookie,
&node->tn_dir.tn_cookietree, de);
}
if (de == NULL)
off = TMPFS_DIRCOOKIE_EOF;
else
off = tmpfs_dircookie(de);
}
(*cookies)[i] = off;
}
KKASSERT(uio->uio_offset == off);
}
TMPFS_NODE_UNLOCK(node);
if ((node->tn_status & TMPFS_NODE_ACCESSED) == 0) {
TMPFS_NODE_LOCK(node);
node->tn_status |= TMPFS_NODE_ACCESSED;
TMPFS_NODE_UNLOCK(node);
}
return error;
}
/*
* Allocates a new vnode for the node node or returns a new reference to
* an existing one if the node had already a vnode referencing it. The
* resulting locked vnode is returned in *vpp.
*
* Returns zero on success or an appropriate error code on failure.
*
* The caller must ensure that node cannot go away (usually by holding
* the related directory entry).
*
* If dnode is non-NULL this routine avoids deadlocking against it but
* can return EAGAIN. Caller must try again. The dnode lock will cycle
* in this case, it remains locked on return in all cases. dnode must
* be shared-locked.
*/
int
tmpfs_alloc_vp(struct mount *mp,
struct tmpfs_node *dnode, struct tmpfs_node *node, int lkflag,
struct vnode **vpp)
{
int error = 0;
struct vnode *vp;
loop:
/*
* Interlocked extraction from node. This can race many things.
* We have to get a soft reference on the vnode while we hold
* the node locked, then acquire it properly and check for races.
*/
TMPFS_NODE_LOCK(node);
if ((vp = node->tn_vnode) != NULL) {
KKASSERT((node->tn_vpstate & TMPFS_VNODE_DOOMED) == 0);
vhold(vp);
TMPFS_NODE_UNLOCK(node);
if (dnode) {
/*
* Special-case handling to avoid deadlocking against
* dnode. This case has been validated and occurs
* every so often during synth builds.
*/
if (vget(vp, (lkflag & ~LK_RETRY) |
LK_NOWAIT |
LK_EXCLUSIVE) != 0) {
TMPFS_NODE_UNLOCK(dnode);
if (vget(vp, (lkflag & ~LK_RETRY) |
LK_SLEEPFAIL |
LK_EXCLUSIVE) == 0) {
vn_unlock(vp);
}
vdrop(vp);
TMPFS_NODE_LOCK_SH(dnode);
return EAGAIN;
}
} else {
/*
* Normal path
*/
if (vget(vp, lkflag | LK_EXCLUSIVE) != 0) {
vdrop(vp);
goto loop;
}
}
if (node->tn_vnode != vp) {
vput(vp);
vdrop(vp);
goto loop;
}
vdrop(vp);
goto out;
}
/* vp is NULL */
/*
* This should never happen.
*/
if (node->tn_vpstate & TMPFS_VNODE_DOOMED) {
TMPFS_NODE_UNLOCK(node);
error = ENOENT;
goto out;
}
/*
* Interlock against other calls to tmpfs_alloc_vp() trying to
* allocate and assign a vp to node.
*/
if (node->tn_vpstate & TMPFS_VNODE_ALLOCATING) {
node->tn_vpstate |= TMPFS_VNODE_WANT;
error = tsleep(&node->tn_vpstate, PINTERLOCKED | PCATCH,
"tmpfs_alloc_vp", 0);
TMPFS_NODE_UNLOCK(node);
if (error)
return error;
goto loop;
}
node->tn_vpstate |= TMPFS_VNODE_ALLOCATING;
TMPFS_NODE_UNLOCK(node);
/*
* Allocate a new vnode (may block). The ALLOCATING flag should
* prevent a race against someone else assigning node->tn_vnode.
*/
error = getnewvnode(VT_TMPFS, mp, &vp, VLKTIMEOUT, LK_CANRECURSE);
if (error != 0)
goto unlock;
KKASSERT(node->tn_vnode == NULL);
KKASSERT(vp != NULL);
vp->v_data = node;
vp->v_type = node->tn_type;
/* Type-specific initialization. */
switch (node->tn_type) {
case VBLK:
/* FALLTHROUGH */
case VCHR:
/* FALLTHROUGH */
case VSOCK:
break;
case VREG:
/*
* VMIO is mandatory. Tmpfs also supports KVABIO
* for its tmpfs_strategy().
*/
vsetflags(vp, VKVABIO);
vinitvmio(vp, node->tn_size, TMPFS_BLKSIZE, -1);
break;
case VLNK:
break;
case VFIFO:
vp->v_ops = &mp->mnt_vn_fifo_ops;
break;
case VDIR:
break;
default:
panic("tmpfs_alloc_vp: type %p %d", node, (int)node->tn_type);
}
unlock:
TMPFS_NODE_LOCK(node);
KKASSERT(node->tn_vpstate & TMPFS_VNODE_ALLOCATING);
node->tn_vpstate &= ~TMPFS_VNODE_ALLOCATING;
node->tn_vnode = vp;
if (node->tn_vpstate & TMPFS_VNODE_WANT) {
node->tn_vpstate &= ~TMPFS_VNODE_WANT;
TMPFS_NODE_UNLOCK(node);
wakeup(&node->tn_vpstate);
} else {
TMPFS_NODE_UNLOCK(node);
}
out:
*vpp = vp;
KKASSERT(IFF(error == 0, *vpp != NULL && vn_islocked(*vpp)));
return error;
}
