OpenSolaris_b135/uts/common/io/devpoll.c
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2008 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#include <sys/types.h>
#include <sys/devops.h>
#include <sys/conf.h>
#include <sys/modctl.h>
#include <sys/sunddi.h>
#include <sys/stat.h>
#include <sys/poll_impl.h>
#include <sys/errno.h>
#include <sys/kmem.h>
#include <sys/mkdev.h>
#include <sys/debug.h>
#include <sys/file.h>
#include <sys/sysmacros.h>
#include <sys/systm.h>
#include <sys/bitmap.h>
#include <sys/devpoll.h>
#include <sys/rctl.h>
#include <sys/resource.h>
#define RESERVED 1
/* local data struct */
static dp_entry_t **devpolltbl; /* dev poll entries */
static size_t dptblsize;
static kmutex_t devpoll_lock; /* lock protecting dev tbl */
int devpoll_init; /* is /dev/poll initialized already */
/* device local functions */
static int dpopen(dev_t *devp, int flag, int otyp, cred_t *credp);
static int dpwrite(dev_t dev, struct uio *uiop, cred_t *credp);
static int dpioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *credp,
int *rvalp);
static int dppoll(dev_t dev, short events, int anyyet, short *reventsp,
struct pollhead **phpp);
static int dpclose(dev_t dev, int flag, int otyp, cred_t *credp);
static dev_info_t *dpdevi;
static struct cb_ops dp_cb_ops = {
dpopen, /* open */
dpclose, /* close */
nodev, /* strategy */
nodev, /* print */
nodev, /* dump */
nodev, /* read */
dpwrite, /* write */
dpioctl, /* ioctl */
nodev, /* devmap */
nodev, /* mmap */
nodev, /* segmap */
dppoll, /* poll */
ddi_prop_op, /* prop_op */
(struct streamtab *)0, /* streamtab */
D_MP, /* flags */
CB_REV, /* cb_ops revision */
nodev, /* aread */
nodev /* awrite */
};
static int dpattach(dev_info_t *, ddi_attach_cmd_t);
static int dpdetach(dev_info_t *, ddi_detach_cmd_t);
static int dpinfo(dev_info_t *, ddi_info_cmd_t, void *, void **);
static struct dev_ops dp_ops = {
DEVO_REV, /* devo_rev */
0, /* refcnt */
dpinfo, /* info */
nulldev, /* identify */
nulldev, /* probe */
dpattach, /* attach */
dpdetach, /* detach */
nodev, /* reset */
&dp_cb_ops, /* driver operations */
(struct bus_ops *)NULL, /* bus operations */
nulldev, /* power */
ddi_quiesce_not_needed, /* quiesce */
};
static struct modldrv modldrv = {
&mod_driverops, /* type of module - a driver */
"/dev/poll driver",
&dp_ops,
};
static struct modlinkage modlinkage = {
MODREV_1,
(void *)&modldrv,
NULL
};
/*
* Locking Design
*
* The /dev/poll driver shares most of its code with poll sys call whose
* code is in common/syscall/poll.c. In poll(2) design, the pollcache
* structure is per lwp. An implicit assumption is made there that some
* portion of pollcache will never be touched by other lwps. E.g., in
* poll(2) design, no lwp will ever need to grow bitmap of other lwp.
* This assumption is not true for /dev/poll; hence the need for extra
* locking.
*
* To allow more parallelism, each /dev/poll file descriptor (indexed by
* minor number) has its own lock. Since read (dpioctl) is a much more
* frequent operation than write, we want to allow multiple reads on same
* /dev/poll fd. However, we prevent writes from being starved by giving
* priority to write operation. Theoretically writes can starve reads as
* well. But in practical sense this is not important because (1) writes
* happens less often than reads, and (2) write operation defines the
* content of poll fd a cache set. If writes happens so often that they
* can starve reads, that means the cached set is very unstable. It may
* not make sense to read an unstable cache set anyway. Therefore, the
* writers starving readers case is not handled in this design.
*/
int
_init()
{
int error;
dptblsize = DEVPOLLSIZE;
devpolltbl = kmem_zalloc(sizeof (caddr_t) * dptblsize, KM_SLEEP);
mutex_init(&devpoll_lock, NULL, MUTEX_DEFAULT, NULL);
devpoll_init = 1;
if ((error = mod_install(&modlinkage)) != 0) {
mutex_destroy(&devpoll_lock);
kmem_free(devpolltbl, sizeof (caddr_t) * dptblsize);
devpoll_init = 0;
}
return (error);
}
int
_fini()
{
int error;
if ((error = mod_remove(&modlinkage)) != 0) {
return (error);
}
mutex_destroy(&devpoll_lock);
kmem_free(devpolltbl, sizeof (caddr_t) * dptblsize);
return (0);
}
int
_info(struct modinfo *modinfop)
{
return (mod_info(&modlinkage, modinfop));
}
/*ARGSUSED*/
static int
dpattach(dev_info_t *devi, ddi_attach_cmd_t cmd)
{
if (ddi_create_minor_node(devi, "poll", S_IFCHR, 0, DDI_PSEUDO, NULL)
== DDI_FAILURE) {
ddi_remove_minor_node(devi, NULL);
return (DDI_FAILURE);
}
dpdevi = devi;
return (DDI_SUCCESS);
}
static int
dpdetach(dev_info_t *devi, ddi_detach_cmd_t cmd)
{
if (cmd != DDI_DETACH)
return (DDI_FAILURE);
ddi_remove_minor_node(devi, NULL);
return (DDI_SUCCESS);
}
/* ARGSUSED */
static int
dpinfo(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result)
{
int error;
switch (infocmd) {
case DDI_INFO_DEVT2DEVINFO:
*result = (void *)dpdevi;
error = DDI_SUCCESS;
break;
case DDI_INFO_DEVT2INSTANCE:
*result = (void *)0;
error = DDI_SUCCESS;
break;
default:
error = DDI_FAILURE;
}
return (error);
}
/*
* dp_pcache_poll has similar logic to pcache_poll() in poll.c. The major
* differences are: (1) /dev/poll requires scanning the bitmap starting at
* where it was stopped last time, instead of always starting from 0,
* (2) since user may not have cleaned up the cached fds when they are
* closed, some polldats in cache may refer to closed or reused fds. We
* need to check for those cases.
*
* NOTE: Upon closing an fd, automatic poll cache cleanup is done for
* poll(2) caches but NOT for /dev/poll caches. So expect some
* stale entries!
*/
static int
dp_pcache_poll(pollfd_t *pfdp, pollcache_t *pcp, nfds_t nfds, int *fdcntp)
{
int start, ostart, end;
int fdcnt, fd;
boolean_t done;
file_t *fp;
short revent;
boolean_t no_wrap;
pollhead_t *php;
polldat_t *pdp;
int error = 0;
ASSERT(MUTEX_HELD(&pcp->pc_lock));
if (pcp->pc_bitmap == NULL) {
/*
* No Need to search because no poll fd
* has been cached.
*/
return (error);
}
retry:
start = ostart = pcp->pc_mapstart;
end = pcp->pc_mapend;
php = NULL;
if (start == 0) {
/*
* started from every begining, no need to wrap around.
*/
no_wrap = B_TRUE;
} else {
no_wrap = B_FALSE;
}
done = B_FALSE;
fdcnt = 0;
while ((fdcnt < nfds) && !done) {
php = NULL;
revent = 0;
/*
* Examine the bit map in a circular fashion
* to avoid starvation. Always resume from
* last stop. Scan till end of the map. Then
* wrap around.
*/
fd = bt_getlowbit(pcp->pc_bitmap, start, end);
ASSERT(fd <= end);
if (fd >= 0) {
if (fd == end) {
if (no_wrap) {
done = B_TRUE;
} else {
start = 0;
end = ostart - 1;
no_wrap = B_TRUE;
}
} else {
start = fd + 1;
}
pdp = pcache_lookup_fd(pcp, fd);
repoll:
ASSERT(pdp != NULL);
ASSERT(pdp->pd_fd == fd);
if (pdp->pd_fp == NULL) {
/*
* The fd is POLLREMOVed. This fd is
* logically no longer cached. So move
* on to the next one.
*/
continue;
}
if ((fp = getf(fd)) == NULL) {
/*
* The fd has been closed, but user has not
* done a POLLREMOVE on this fd yet. Instead
* of cleaning it here implicitly, we return
* POLLNVAL. This is consistent with poll(2)
* polling a closed fd. Hope this will remind
* user to do a POLLREMOVE.
*/
pfdp[fdcnt].fd = fd;
pfdp[fdcnt].revents = POLLNVAL;
fdcnt++;
continue;
}
if (fp != pdp->pd_fp) {
/*
* user is polling on a cached fd which was
* closed and then reused. Unfortunately
* there is no good way to inform user.
* If the file struct is also reused, we
* may not be able to detect the fd reuse
* at all. As long as this does not
* cause system failure and/or memory leak,
* we will play along. Man page states if
* user does not clean up closed fds, polling
* results will be indeterministic.
*
* XXX - perhaps log the detection of fd
* reuse?
*/
pdp->pd_fp = fp;
}
/*
* XXX - pollrelock() logic needs to know which
* which pollcache lock to grab. It'd be a
* cleaner solution if we could pass pcp as
* an arguement in VOP_POLL interface instead
* of implicitly passing it using thread_t
* struct. On the other hand, changing VOP_POLL
* interface will require all driver/file system
* poll routine to change. May want to revisit
* the tradeoff later.
*/
curthread->t_pollcache = pcp;
error = VOP_POLL(fp->f_vnode, pdp->pd_events, 0,
&revent, &php, NULL);
curthread->t_pollcache = NULL;
releasef(fd);
if (error != 0) {
break;
}
/*
* layered devices (e.g. console driver)
* may change the vnode and thus the pollhead
* pointer out from underneath us.
*/
if (php != NULL && pdp->pd_php != NULL &&
php != pdp->pd_php) {
pollhead_delete(pdp->pd_php, pdp);
pdp->pd_php = php;
pollhead_insert(php, pdp);
/*
* The bit should still be set.
*/
ASSERT(BT_TEST(pcp->pc_bitmap, fd));
goto retry;
}
if (revent != 0) {
pfdp[fdcnt].fd = fd;
pfdp[fdcnt].events = pdp->pd_events;
pfdp[fdcnt].revents = revent;
fdcnt++;
} else if (php != NULL) {
/*
* We clear a bit or cache a poll fd if
* the driver returns a poll head ptr,
* which is expected in the case of 0
* revents. Some buggy driver may return
* NULL php pointer with 0 revents. In
* this case, we just treat the driver as
* "noncachable" and not clearing the bit
* in bitmap.
*/
if ((pdp->pd_php != NULL) &&
((pcp->pc_flag & T_POLLWAKE) == 0)) {
BT_CLEAR(pcp->pc_bitmap, fd);
}
if (pdp->pd_php == NULL) {
pollhead_insert(php, pdp);
pdp->pd_php = php;
/*
* An event of interest may have
* arrived between the VOP_POLL() and
* the pollhead_insert(); check again.
*/
goto repoll;
}
}
} else {
/*
* No bit set in the range. Check for wrap around.
*/
if (!no_wrap) {
start = 0;
end = ostart - 1;
no_wrap = B_TRUE;
} else {
done = B_TRUE;
}
}
}
if (!done) {
pcp->pc_mapstart = start;
}
ASSERT(*fdcntp == 0);
*fdcntp = fdcnt;
return (error);
}
/*ARGSUSED*/
static int
dpopen(dev_t *devp, int flag, int otyp, cred_t *credp)
{
minor_t minordev;
dp_entry_t *dpep;
pollcache_t *pcp;
ASSERT(devpoll_init);
ASSERT(dptblsize <= MAXMIN);
mutex_enter(&devpoll_lock);
for (minordev = 0; minordev < dptblsize; minordev++) {
if (devpolltbl[minordev] == NULL) {
devpolltbl[minordev] = (dp_entry_t *)RESERVED;
break;
}
}
if (minordev == dptblsize) {
dp_entry_t **newtbl;
size_t oldsize;
/*
* Used up every entry in the existing devpoll table.
* Grow the table by DEVPOLLSIZE.
*/
if ((oldsize = dptblsize) >= MAXMIN) {
mutex_exit(&devpoll_lock);
return (ENXIO);
}
dptblsize += DEVPOLLSIZE;
if (dptblsize > MAXMIN) {
dptblsize = MAXMIN;
}
newtbl = kmem_zalloc(sizeof (caddr_t) * dptblsize, KM_SLEEP);
bcopy(devpolltbl, newtbl, sizeof (caddr_t) * oldsize);
kmem_free(devpolltbl, sizeof (caddr_t) * oldsize);
devpolltbl = newtbl;
devpolltbl[minordev] = (dp_entry_t *)RESERVED;
}
mutex_exit(&devpoll_lock);
dpep = kmem_zalloc(sizeof (dp_entry_t), KM_SLEEP);
/*
* allocate a pollcache skeleton here. Delay allocating bitmap
* structures until dpwrite() time, since we don't know the
* optimal size yet.
*/
pcp = pcache_alloc();
dpep->dpe_pcache = pcp;
pcp->pc_pid = curproc->p_pid;
*devp = makedevice(getmajor(*devp), minordev); /* clone the driver */
mutex_enter(&devpoll_lock);
ASSERT(minordev < dptblsize);
ASSERT(devpolltbl[minordev] == (dp_entry_t *)RESERVED);
devpolltbl[minordev] = dpep;
mutex_exit(&devpoll_lock);
return (0);
}
/*
* Write to dev/poll add/remove fd's to/from a cached poll fd set,
* or change poll events for a watched fd.
*/
/*ARGSUSED*/
static int
dpwrite(dev_t dev, struct uio *uiop, cred_t *credp)
{
minor_t minor;
dp_entry_t *dpep;
pollcache_t *pcp;
pollfd_t *pollfdp, *pfdp;
int error;
ssize_t uiosize;
nfds_t pollfdnum;
struct pollhead *php = NULL;
polldat_t *pdp;
int fd;
file_t *fp;
minor = getminor(dev);
mutex_enter(&devpoll_lock);
ASSERT(minor < dptblsize);
dpep = devpolltbl[minor];
ASSERT(dpep != NULL);
mutex_exit(&devpoll_lock);
pcp = dpep->dpe_pcache;
if (curproc->p_pid != pcp->pc_pid) {
return (EACCES);
}
uiosize = uiop->uio_resid;
pollfdnum = uiosize / sizeof (pollfd_t);
mutex_enter(&curproc->p_lock);
if (pollfdnum > (uint_t)rctl_enforced_value(
rctlproc_legacy[RLIMIT_NOFILE], curproc->p_rctls, curproc)) {
(void) rctl_action(rctlproc_legacy[RLIMIT_NOFILE],
curproc->p_rctls, curproc, RCA_SAFE);
mutex_exit(&curproc->p_lock);
return (set_errno(EINVAL));
}
mutex_exit(&curproc->p_lock);
/*
* Copy in the pollfd array. Walk through the array and add
* each polled fd to the cached set.
*/
pollfdp = kmem_alloc(uiosize, KM_SLEEP);
/*
* Although /dev/poll uses the write(2) interface to cache fds, it's
* not supposed to function as a seekable device. To prevent offset
* from growing and eventually exceed the maximum, reset the offset
* here for every call.
*/
uiop->uio_loffset = 0;
if ((error = uiomove((caddr_t)pollfdp, uiosize, UIO_WRITE, uiop))
!= 0) {
kmem_free(pollfdp, uiosize);
return (error);
}
/*
* We are about to enter the core portion of dpwrite(). Make sure this
* write has exclusive access in this portion of the code, i.e., no
* other writers in this code and no other readers in dpioctl.
*/
mutex_enter(&dpep->dpe_lock);
dpep->dpe_writerwait++;
while (dpep->dpe_refcnt != 0) {
if (!cv_wait_sig_swap(&dpep->dpe_cv, &dpep->dpe_lock)) {
dpep->dpe_writerwait--;
mutex_exit(&dpep->dpe_lock);
kmem_free(pollfdp, uiosize);
return (set_errno(EINTR));
}
}
dpep->dpe_writerwait--;
dpep->dpe_flag |= DP_WRITER_PRESENT;
dpep->dpe_refcnt++;
mutex_exit(&dpep->dpe_lock);
mutex_enter(&pcp->pc_lock);
if (pcp->pc_bitmap == NULL) {
pcache_create(pcp, pollfdnum);
}
for (pfdp = pollfdp; pfdp < pollfdp + pollfdnum; pfdp++) {
fd = pfdp->fd;
if ((uint_t)fd >= P_FINFO(curproc)->fi_nfiles)
continue;
pdp = pcache_lookup_fd(pcp, fd);
if (pfdp->events != POLLREMOVE) {
if (pdp == NULL) {
pdp = pcache_alloc_fd(0);
pdp->pd_fd = fd;
pdp->pd_pcache = pcp;
pcache_insert_fd(pcp, pdp, pollfdnum);
}
ASSERT(pdp->pd_fd == fd);
ASSERT(pdp->pd_pcache == pcp);
if (fd >= pcp->pc_mapsize) {
mutex_exit(&pcp->pc_lock);
pcache_grow_map(pcp, fd);
mutex_enter(&pcp->pc_lock);
}
if (fd > pcp->pc_mapend) {
pcp->pc_mapend = fd;
}
if ((fp = getf(fd)) == NULL) {
/*
* The fd is not valid. Since we can't pass
* this error back in the write() call, set
* the bit in bitmap to force DP_POLL ioctl
* to examine it.
*/
BT_SET(pcp->pc_bitmap, fd);
pdp->pd_events |= pfdp->events;
continue;
}
/*
* Don't do VOP_POLL for an already cached fd with
* same poll events.
*/
if ((pdp->pd_events == pfdp->events) &&
(pdp->pd_fp != NULL)) {
/*
* the events are already cached
*/
releasef(fd);
continue;
}
/*
* do VOP_POLL and cache this poll fd.
*/
/*
* XXX - pollrelock() logic needs to know which
* which pollcache lock to grab. It'd be a
* cleaner solution if we could pass pcp as
* an arguement in VOP_POLL interface instead
* of implicitly passing it using thread_t
* struct. On the other hand, changing VOP_POLL
* interface will require all driver/file system
* poll routine to change. May want to revisit
* the tradeoff later.
*/
curthread->t_pollcache = pcp;
error = VOP_POLL(fp->f_vnode, pfdp->events, 0,
&pfdp->revents, &php, NULL);
curthread->t_pollcache = NULL;
/*
* We always set the bit when this fd is cached;
* this forces the first DP_POLL to poll this fd.
* Real performance gain comes from subsequent
* DP_POLL. We also attempt a pollhead_insert();
* if it's not possible, we'll do it in dpioctl().
*/
BT_SET(pcp->pc_bitmap, fd);
if (error != 0) {
releasef(fd);
break;
}
pdp->pd_fp = fp;
pdp->pd_events |= pfdp->events;
if (php != NULL) {
if (pdp->pd_php == NULL) {
pollhead_insert(php, pdp);
pdp->pd_php = php;
} else {
if (pdp->pd_php != php) {
pollhead_delete(pdp->pd_php,
pdp);
pollhead_insert(php, pdp);
pdp->pd_php = php;
}
}
}
releasef(fd);
} else {
if (pdp == NULL) {
continue;
}
ASSERT(pdp->pd_fd == fd);
pdp->pd_fp = NULL;
pdp->pd_events = 0;
ASSERT(pdp->pd_thread == NULL);
if (pdp->pd_php != NULL) {
pollhead_delete(pdp->pd_php, pdp);
pdp->pd_php = NULL;
}
BT_CLEAR(pcp->pc_bitmap, fd);
}
}
mutex_exit(&pcp->pc_lock);
mutex_enter(&dpep->dpe_lock);
dpep->dpe_flag &= ~DP_WRITER_PRESENT;
ASSERT(dpep->dpe_refcnt == 1);
dpep->dpe_refcnt--;
cv_broadcast(&dpep->dpe_cv);
mutex_exit(&dpep->dpe_lock);
kmem_free(pollfdp, uiosize);
return (error);
}
/*ARGSUSED*/
static int
dpioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *credp, int *rvalp)
{
timestruc_t now;
timestruc_t rqtime;
timestruc_t *rqtp = NULL;
int timecheck = 0;
minor_t minor;
dp_entry_t *dpep;
pollcache_t *pcp;
int error = 0;
STRUCT_DECL(dvpoll, dvpoll);
if (cmd == DP_POLL) {
/* do this now, before we sleep on DP_WRITER_PRESENT below */
timecheck = timechanged;
gethrestime(&now);
}
minor = getminor(dev);
mutex_enter(&devpoll_lock);
ASSERT(minor < dptblsize);
dpep = devpolltbl[minor];
mutex_exit(&devpoll_lock);
ASSERT(dpep != NULL);
pcp = dpep->dpe_pcache;
if (curproc->p_pid != pcp->pc_pid)
return (EACCES);
mutex_enter(&dpep->dpe_lock);
while ((dpep->dpe_flag & DP_WRITER_PRESENT) ||
(dpep->dpe_writerwait != 0)) {
if (!cv_wait_sig_swap(&dpep->dpe_cv, &dpep->dpe_lock)) {
mutex_exit(&dpep->dpe_lock);
return (EINTR);
}
}
dpep->dpe_refcnt++;
mutex_exit(&dpep->dpe_lock);
switch (cmd) {
case DP_POLL:
{
pollstate_t *ps;
nfds_t nfds;
int fdcnt = 0;
int time_out;
int rval;
STRUCT_INIT(dvpoll, mode);
error = copyin((caddr_t)arg, STRUCT_BUF(dvpoll),
STRUCT_SIZE(dvpoll));
if (error) {
DP_REFRELE(dpep);
return (EFAULT);
}
time_out = STRUCT_FGET(dvpoll, dp_timeout);
if (time_out > 0) {
/*
* Determine the future time of the requested timeout.
*/
rqtp = &rqtime;
rqtp->tv_sec = time_out / MILLISEC;
rqtp->tv_nsec = (time_out % MILLISEC) * MICROSEC;
timespecadd(rqtp, &now);
}
if ((nfds = STRUCT_FGET(dvpoll, dp_nfds)) == 0) {
/*
* We are just using DP_POLL to sleep, so
* we don't any of the devpoll apparatus.
* Do not check for signals if we have a zero timeout.
*/
DP_REFRELE(dpep);
if (time_out == 0)
return (0);
mutex_enter(&curthread->t_delay_lock);
while ((rval = cv_waituntil_sig(&curthread->t_delay_cv,
&curthread->t_delay_lock, rqtp, timecheck)) > 0)
continue;
mutex_exit(&curthread->t_delay_lock);
return ((rval == 0)? EINTR : 0);
}
/*
* XXX It'd be nice not to have to alloc each time.
* But it requires another per thread structure hook.
* Do it later if there is data suggest that.
*/
if ((ps = curthread->t_pollstate) == NULL) {
curthread->t_pollstate = pollstate_create();
ps = curthread->t_pollstate;
}
if (ps->ps_dpbufsize < nfds) {
struct proc *p = ttoproc(curthread);
/*
* The maximum size should be no large than
* current maximum open file count.
*/
mutex_enter(&p->p_lock);
if (nfds > p->p_fno_ctl) {
mutex_exit(&p->p_lock);
DP_REFRELE(dpep);
return (EINVAL);
}
mutex_exit(&p->p_lock);
kmem_free(ps->ps_dpbuf, sizeof (pollfd_t) *
ps->ps_dpbufsize);
ps->ps_dpbuf = kmem_zalloc(sizeof (pollfd_t) *
nfds, KM_SLEEP);
ps->ps_dpbufsize = nfds;
}
mutex_enter(&pcp->pc_lock);
for (;;) {
pcp->pc_flag = 0;
error = dp_pcache_poll(ps->ps_dpbuf, pcp, nfds, &fdcnt);
if (fdcnt > 0 || error != 0)
break;
/*
* A pollwake has happened since we polled cache.
*/
if (pcp->pc_flag & T_POLLWAKE)
continue;
/*
* Sleep until we are notified, signaled, or timed out.
* Do not check for signals if we have a zero timeout.
*/
if (time_out == 0) /* immediate timeout */
break;
rval = cv_waituntil_sig(&pcp->pc_cv, &pcp->pc_lock,
rqtp, timecheck);
/*
* If we were awakened by a signal or timeout
* then break the loop, else poll again.
*/
if (rval <= 0) {
if (rval == 0) /* signal */
error = EINTR;
break;
}
}
mutex_exit(&pcp->pc_lock);
if (error == 0 && fdcnt > 0) {
if (copyout(ps->ps_dpbuf, STRUCT_FGETP(dvpoll,
dp_fds), sizeof (pollfd_t) * fdcnt)) {
DP_REFRELE(dpep);
return (EFAULT);
}
*rvalp = fdcnt;
}
break;
}
case DP_ISPOLLED:
{
pollfd_t pollfd;
polldat_t *pdp;
STRUCT_INIT(dvpoll, mode);
error = copyin((caddr_t)arg, &pollfd, sizeof (pollfd_t));
if (error) {
DP_REFRELE(dpep);
return (EFAULT);
}
mutex_enter(&pcp->pc_lock);
if (pcp->pc_hash == NULL) {
/*
* No Need to search because no poll fd
* has been cached.
*/
mutex_exit(&pcp->pc_lock);
DP_REFRELE(dpep);
return (0);
}
if (pollfd.fd < 0) {
mutex_exit(&pcp->pc_lock);
break;
}
pdp = pcache_lookup_fd(pcp, pollfd.fd);
if ((pdp != NULL) && (pdp->pd_fd == pollfd.fd) &&
(pdp->pd_fp != NULL)) {
pollfd.revents = pdp->pd_events;
if (copyout(&pollfd, (caddr_t)arg, sizeof (pollfd_t))) {
mutex_exit(&pcp->pc_lock);
DP_REFRELE(dpep);
return (EFAULT);
}
*rvalp = 1;
}
mutex_exit(&pcp->pc_lock);
break;
}
default:
DP_REFRELE(dpep);
return (EINVAL);
}
DP_REFRELE(dpep);
return (error);
}
/*ARGSUSED*/
static int
dppoll(dev_t dev, short events, int anyyet, short *reventsp,
struct pollhead **phpp)
{
/*
* Polling on a /dev/poll fd is not fully supported yet.
*/
*reventsp = POLLERR;
return (0);
}
/*
* devpoll close should do enough clean up before the pollcache is deleted,
* i.e., it should ensure no one still references the pollcache later.
* There is no "permission" check in here. Any process having the last
* reference of this /dev/poll fd can close.
*/
/*ARGSUSED*/
static int
dpclose(dev_t dev, int flag, int otyp, cred_t *credp)
{
minor_t minor;
dp_entry_t *dpep;
pollcache_t *pcp;
int i;
polldat_t **hashtbl;
polldat_t *pdp;
minor = getminor(dev);
mutex_enter(&devpoll_lock);
dpep = devpolltbl[minor];
ASSERT(dpep != NULL);
devpolltbl[minor] = NULL;
mutex_exit(&devpoll_lock);
pcp = dpep->dpe_pcache;
ASSERT(pcp != NULL);
/*
* At this point, no other lwp can access this pollcache via the
* /dev/poll fd. This pollcache is going away, so do the clean
* up without the pc_lock.
*/
hashtbl = pcp->pc_hash;
for (i = 0; i < pcp->pc_hashsize; i++) {
for (pdp = hashtbl[i]; pdp; pdp = pdp->pd_hashnext) {
if (pdp->pd_php != NULL) {
pollhead_delete(pdp->pd_php, pdp);
pdp->pd_php = NULL;
pdp->pd_fp = NULL;
}
}
}
/*
* pollwakeup() may still interact with this pollcache. Wait until
* it is done.
*/
mutex_enter(&pcp->pc_no_exit);
ASSERT(pcp->pc_busy >= 0);
while (pcp->pc_busy > 0)
cv_wait(&pcp->pc_busy_cv, &pcp->pc_no_exit);
mutex_exit(&pcp->pc_no_exit);
pcache_destroy(pcp);
ASSERT(dpep->dpe_refcnt == 0);
kmem_free(dpep, sizeof (dp_entry_t));
return (0);
}