static void
eva_main_loop_select_config_fd(EvaMainLoopPollBase *main_loop,
int fd,
GIOCondition old_io_conditions,
GIOCondition io_conditions)
{
EvaMainLoopSelect *select_loop = (EvaMainLoopSelect *) main_loop;
#if DEBUG_SELECT
g_message ("select: config-fd: fd=%d: events:%s%s",
fd,
(io_conditions & G_IO_IN) ? " IN" : "",
(io_conditions & G_IO_OUT) ? " OUT" : "");
#endif
g_return_if_fail (IFF ((old_io_conditions & G_IO_IN) == G_IO_IN,
FD_ISSET (fd, &select_loop->read_set)));
g_return_if_fail (IFF ((old_io_conditions & G_IO_OUT) == G_IO_OUT,
FD_ISSET (fd, &select_loop->write_set)));
if (io_conditions == 0)
g_tree_remove (select_loop->fd_tree, GUINT_TO_POINTER (fd));
else
g_tree_insert (select_loop->fd_tree,
GUINT_TO_POINTER (fd),
GUINT_TO_POINTER (fd));
if ((io_conditions & G_IO_IN) == G_IO_IN)
FD_SET (fd, &select_loop->read_set);
else
FD_CLR (fd, &select_loop->read_set);
if ((io_conditions & G_IO_OUT) == G_IO_OUT)
FD_SET (fd, &select_loop->write_set);
else
FD_CLR (fd, &select_loop->write_set);
if ((io_conditions & G_IO_ERR) == G_IO_ERR)
FD_SET (fd, &select_loop->except_set);
else
FD_CLR (fd, &select_loop->except_set);
}
ParseTree* Parser::STMT()
{
ParseTree* retTree = new ParseTree();
if((*parser).get().token == ID)
{
(*retTree).SetLeaf1(ASSIGN()->getLeaf());
(*retTree).setAlt(1);
}
else if((*parser).get().token == IF)
{
(*retTree).SetLeaf1(IFF()->getLeaf());
(*retTree).setAlt(2);
}
else if((*parser).get().token == DO)
{
(*retTree).SetLeaf1(DOWHILE()->getLeaf());
(*retTree).setAlt(3);
}
else if((*parser).get().token == INPUT)
{
(*retTree).SetLeaf1(IN()->getLeaf());
(*retTree).setAlt(4);
}
else if((*parser).get().token == OUTPUT)
{
(*retTree).SetLeaf1(OUT()->getLeaf());
(*retTree).setAlt(5);
}
else if((*parser).get().token == CASE)
{
(*retTree).SetLeaf1(CASE_STMT()->getLeaf());
(*retTree).setAlt(6);
}
else
{
ThrowParserError();
}
return retTree;
}
static int
tmpfs_lookup(struct vop_cachedlookup_args *v)
{
struct vnode *dvp = v->a_dvp;
struct vnode **vpp = v->a_vpp;
struct componentname *cnp = v->a_cnp;
int error;
struct tmpfs_dirent *de;
struct tmpfs_node *dnode;
dnode = VP_TO_TMPFS_DIR(dvp);
*vpp = NULLVP;
/* Check accessibility of requested node as a first step. */
error = VOP_ACCESS(dvp, VEXEC, cnp->cn_cred, cnp->cn_thread);
if (error != 0)
goto out;
/* We cannot be requesting the parent directory of the root node. */
MPASS(IMPLIES(dnode->tn_type == VDIR &&
dnode->tn_dir.tn_parent == dnode,
!(cnp->cn_flags & ISDOTDOT)));
TMPFS_ASSERT_LOCKED(dnode);
if (dnode->tn_dir.tn_parent == NULL) {
error = ENOENT;
goto out;
}
if (cnp->cn_flags & ISDOTDOT) {
int ltype = 0;
ltype = VOP_ISLOCKED(dvp);
vhold(dvp);
VOP_UNLOCK(dvp, 0);
/* Allocate a new vnode on the matching entry. */
error = tmpfs_alloc_vp(dvp->v_mount, dnode->tn_dir.tn_parent,
cnp->cn_lkflags, vpp);
vn_lock(dvp, ltype | LK_RETRY);
vdrop(dvp);
} else if (cnp->cn_namelen == 1 && cnp->cn_nameptr[0] == '.') {
VREF(dvp);
*vpp = dvp;
error = 0;
} else {
de = tmpfs_dir_lookup(dnode, NULL, cnp);
if (de != NULL && de->td_node == NULL)
cnp->cn_flags |= ISWHITEOUT;
if (de == NULL || de->td_node == NULL) {
/* The entry was not found in the directory.
* This is OK if we are creating or renaming an
* entry and are working on the last component of
* the path name. */
if ((cnp->cn_flags & ISLASTCN) &&
(cnp->cn_nameiop == CREATE || \
cnp->cn_nameiop == RENAME ||
(cnp->cn_nameiop == DELETE &&
cnp->cn_flags & DOWHITEOUT &&
cnp->cn_flags & ISWHITEOUT))) {
error = VOP_ACCESS(dvp, VWRITE, cnp->cn_cred,
cnp->cn_thread);
if (error != 0)
goto out;
/* Keep the component name in the buffer for
* future uses. */
cnp->cn_flags |= SAVENAME;
error = EJUSTRETURN;
} else
error = ENOENT;
} else {
struct tmpfs_node *tnode;
/* The entry was found, so get its associated
* tmpfs_node. */
tnode = de->td_node;
/* If we are not at the last path component and
* found a non-directory or non-link entry (which
* may itself be pointing to a directory), raise
* an error. */
if ((tnode->tn_type != VDIR &&
tnode->tn_type != VLNK) &&
!(cnp->cn_flags & ISLASTCN)) {
error = ENOTDIR;
goto out;
}
/* If we are deleting or renaming the entry, keep
* track of its tmpfs_dirent so that it can be
* easily deleted later. */
if ((cnp->cn_flags & ISLASTCN) &&
(cnp->cn_nameiop == DELETE ||
cnp->cn_nameiop == RENAME)) {
error = VOP_ACCESS(dvp, VWRITE, cnp->cn_cred,
cnp->cn_thread);
if (error != 0)
goto out;
/* Allocate a new vnode on the matching entry. */
error = tmpfs_alloc_vp(dvp->v_mount, tnode,
cnp->cn_lkflags, vpp);
if (error != 0)
goto out;
if ((dnode->tn_mode & S_ISTXT) &&
VOP_ACCESS(dvp, VADMIN, cnp->cn_cred, cnp->cn_thread) &&
VOP_ACCESS(*vpp, VADMIN, cnp->cn_cred, cnp->cn_thread)) {
error = EPERM;
vput(*vpp);
*vpp = NULL;
goto out;
}
cnp->cn_flags |= SAVENAME;
} else {
error = tmpfs_alloc_vp(dvp->v_mount, tnode,
cnp->cn_lkflags, vpp);
}
}
}
/* 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 ((cnp->cn_flags & MAKEENTRY) && cnp->cn_nameiop != CREATE)
cache_enter(dvp, *vpp, cnp);
out:
/* If there were no errors, *vpp cannot be null and it must be
* locked. */
MPASS(IFF(error == 0, *vpp != NULLVP && VOP_ISLOCKED(*vpp)));
return error;
}
/*
* Allocates a new node of type 'type' inside the 'tmp' mount point, with
* its owner set to 'uid', its group to 'gid' and its mode set to 'mode',
* using the credentials of the process 'p'.
*
* If the node type is set to 'VDIR', then the parent parameter must point
* to the parent directory of the node being created. It may only be NULL
* while allocating the root node.
*
* If the node type is set to 'VBLK' or 'VCHR', then the rdev parameter
* specifies the device the node represents.
*
* If the node type is set to 'VLNK', then the parameter target specifies
* the file name of the target file for the symbolic link that is being
* created.
*
* Note that new nodes are retrieved from the available list if it has
* items or, if it is empty, from the node pool as long as there is enough
* space to create them.
*
* Returns zero on success or an appropriate error code on failure.
*/
int
tmpfs_alloc_node(struct tmpfs_mount *tmp, enum vtype type,
uid_t uid, gid_t gid, mode_t mode,
char *target, int rmajor, int rminor,
struct tmpfs_node **node)
{
struct tmpfs_node *nnode;
struct timespec ts;
udev_t rdev;
KKASSERT(IFF(type == VLNK, target != NULL));
KKASSERT(IFF(type == VBLK || type == VCHR, rmajor != VNOVAL));
if (tmp->tm_nodes_inuse >= tmp->tm_nodes_max)
return (ENOSPC);
nnode = objcache_get(tmp->tm_node_pool, M_WAITOK | M_NULLOK);
if (nnode == NULL)
return (ENOSPC);
/* Generic initialization. */
nnode->tn_type = type;
vfs_timestamp(&ts);
nnode->tn_ctime = nnode->tn_mtime = nnode->tn_atime
= ts.tv_sec;
nnode->tn_ctimensec = nnode->tn_mtimensec = nnode->tn_atimensec
= ts.tv_nsec;
nnode->tn_uid = uid;
nnode->tn_gid = gid;
nnode->tn_mode = mode;
nnode->tn_id = tmpfs_fetch_ino(tmp);
nnode->tn_advlock.init_done = 0;
KKASSERT(nnode->tn_links == 0);
/* Type-specific initialization. */
switch (nnode->tn_type) {
case VBLK:
case VCHR:
rdev = makeudev(rmajor, rminor);
if (rdev == NOUDEV) {
objcache_put(tmp->tm_node_pool, nnode);
return(EINVAL);
}
nnode->tn_rdev = rdev;
break;
case VDIR:
RB_INIT(&nnode->tn_dir.tn_dirtree);
RB_INIT(&nnode->tn_dir.tn_cookietree);
nnode->tn_size = 0;
break;
case VFIFO:
/* FALLTHROUGH */
case VSOCK:
break;
case VLNK:
nnode->tn_size = strlen(target);
nnode->tn_link = kmalloc(nnode->tn_size + 1, tmp->tm_name_zone,
M_WAITOK | M_NULLOK);
if (nnode->tn_link == NULL) {
objcache_put(tmp->tm_node_pool, nnode);
return (ENOSPC);
}
bcopy(target, nnode->tn_link, nnode->tn_size);
nnode->tn_link[nnode->tn_size] = '\0';
break;
case VREG:
nnode->tn_reg.tn_aobj = swap_pager_alloc(NULL, 0,
VM_PROT_DEFAULT, 0);
nnode->tn_reg.tn_aobj_pages = 0;
nnode->tn_size = 0;
vm_object_set_flag(nnode->tn_reg.tn_aobj, OBJ_NOPAGEIN);
break;
default:
panic("tmpfs_alloc_node: type %p %d", nnode, (int)nnode->tn_type);
}
TMPFS_NODE_LOCK(nnode);
TMPFS_LOCK(tmp);
LIST_INSERT_HEAD(&tmp->tm_nodes_used, nnode, tn_entries);
tmp->tm_nodes_inuse++;
TMPFS_UNLOCK(tmp);
TMPFS_NODE_UNLOCK(nnode);
*node = nnode;
return 0;
}
/*
* 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;
}
