devpoll.c revision a5eb7107f06a6e23e8e77e8d3a84c1ff90a73ac6
/*
* 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
* 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.
*/
/*
* Copyright (c) 2012 by Delphix. All rights reserved.
* Copyright (c) 2015, Joyent, Inc. All rights reserved.
*/
#include <sys/poll_impl.h>
#include <sys/sysmacros.h>
#include <sys/resource.h>
#include <sys/schedctl.h>
#define RESERVED 1
/* local data struct */
int devpoll_init; /* is /dev/poll initialized already */
/* device local functions */
int *rvalp);
static dev_info_t *dpdevi;
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 */
};
DEVO_REV, /* devo_rev */
0, /* refcnt */
dpinfo, /* info */
nulldev, /* identify */
nulldev, /* probe */
dpattach, /* attach */
dpdetach, /* detach */
nodev, /* reset */
&dp_cb_ops, /* driver operations */
nulldev, /* power */
ddi_quiesce_not_needed, /* quiesce */
};
&mod_driverops, /* type of module - a driver */
&dp_ops,
};
static struct modlinkage modlinkage = {
(void *)&modldrv,
};
/*
* Locking Design
*
* 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.
* locking.
*
* 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
* 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;
devpoll_init = 1;
devpoll_init = 0;
}
return (error);
}
int
_fini()
{
int error;
return (error);
}
return (0);
}
int
{
}
/*ARGSUSED*/
static int
{
== DDI_FAILURE) {
return (DDI_FAILURE);
}
return (DDI_SUCCESS);
}
static int
{
if (cmd != DDI_DETACH)
return (DDI_FAILURE);
return (DDI_SUCCESS);
}
/* ARGSUSED */
static int
{
int error;
switch (infocmd) {
case DDI_INFO_DEVT2DEVINFO:
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
* 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
* stale entries!
*/
static int
{
short revent;
int error = 0;
/*
* No Need to search because no poll fd
* has been cached.
*/
return (error);
}
} else {
}
if (start == 0) {
/*
* started from every begining, no need to wrap around.
*/
} else {
}
fdcnt = 0;
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.
*/
if (fd >= 0) {
if (no_wrap) {
} else {
start = 0;
}
} else {
}
/*
* The fd is POLLREMOVed. This fd is
* logically no longer cached. So move
* on to the next one.
*/
continue;
}
/*
* 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.
*/
fdcnt++;
continue;
}
/*
* In the epoll compatibility case, we actually
* perform the implicit removal to remain
* closer to the epoll semantics.
*/
}
continue;
}
/*
* 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
* 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?
*/
}
/*
* 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
* poll routine to change. May want to revisit
* the tradeoff later.
*/
if (error != 0) {
break;
}
/*
* layered devices (e.g. console driver)
* may change the vnode and thus the pollhead
* pointer out from underneath us.
*/
/*
* The bit should still be set.
*/
goto retry;
}
if (revent != 0) {
} else {
/*
* If any of the event bits are set for
* which poll and epoll representations
* differ, swizzle in the native epoll
* values.
*/
EPOLLRDHUP : 0) |
((revent & POLLWRBAND) ?
EPOLLWRBAND : 0);
} else {
}
/*
* We define POLLWRNORM to be POLLOUT,
* but epoll has separate definitions
* for them; if POLLOUT is set and the
* user has asked for EPOLLWRNORM, set
* that as well.
*/
}
}
/*
* If POLLET is set, clear the bit in the
* bitmap -- which effectively latches the
* edge on a pollwakeup() from the driver.
*/
/*
* If POLLONESHOT is set, perform the implicit
* POLLREMOVE.
*/
}
}
fdcnt++;
/*
* 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.
*/
}
/*
* 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;
} else {
}
}
}
if (!done) {
}
return (error);
}
/*ARGSUSED*/
static int
{
break;
}
}
dp_entry_t **newtbl;
/*
* Used up every entry in the existing devpoll table.
* Grow the table by DEVPOLLSIZE.
*/
return (ENXIO);
}
dptblsize += DEVPOLLSIZE;
}
devpolltbl = newtbl;
}
/*
* allocate a pollcache skeleton here. Delay allocating bitmap
* structures until dpwrite() time, since we don't know the
* optimal size yet. We also delay setting the pid until either
* dpwrite() or attempt to poll on the instance, allowing parents
* epoll compatibility case, this check isn't performed to maintain
* semantic compatibility.)
*/
pcp = pcache_alloc();
return (0);
}
/*
* or change poll events for a watched fd.
*/
/*ARGSUSED*/
static int
{
int fd;
return (EACCES);
}
size = sizeof (dvpoll_epollfd_t);
} else {
}
}
/*
* Copy in the pollfd array. Walk through the array and add
* each polled fd to the cached set.
*/
/*
* 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;
!= 0) {
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.
*/
dpep->dpe_writerwait++;
while (dpep->dpe_refcnt != 0) {
/*
* We need to do a bit of a dance here: we need to drop
* our dpe_lock and grab the pc_lock to broadcast the pc_cv to
*/
if (dpep->dpe_refcnt == 0)
break;
dpep->dpe_writerwait--;
}
}
dpep->dpe_writerwait--;
dpep->dpe_refcnt++;
}
/*
* epoll semantics demand that we return EBADF if our
* specified fd is invalid.
*/
break;
}
continue;
}
/*
* If we're in epoll compatibility mode, check
* that the fd is valid before allocating
* anything for it; epoll semantics demand that
* we return EBADF if our specified fd is
* invalid.
*/
break;
}
}
pdp = pcache_alloc_fd(0);
} else {
/*
* epoll semantics demand that we error out if
* a file descriptor is added twice, which we
* check (imperfectly) by checking if we both
* have the file descriptor cached and the
* file pointer that correponds to the file
* descriptor matches our cached value. If
* there is a pointer mismatch, the file
* descriptor was closed without being removed.
* The converse is clearly not true, however,
* so to narrow the window by which a spurious
* EEXIST may be returned, we also check if
* this fp has been added to an epoll control
* descriptor in the past; if it hasn't, we
* know that this is due to fp reuse -- it's
* not a true EEXIST case. (By performing this
* additional check, we limit the window of
* spurious EEXIST to situations where a single
* file descriptor is being used across two or
* more epoll control descriptors -- and even
* then, the file descriptor must be closed and
* reused in a relatively tight time span.)
*/
break;
}
/*
* We have decided that the cached
* information was stale: it either
* didn't match, or the fp had never
* actually been epoll()'d on before.
* We need to now clear our pd_events
* to assure that we don't mistakenly
* operate on cached event disposition.
*/
}
}
}
}
}
/*
* 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.
*/
continue;
}
/*
* To (greatly) reduce EEXIST false positives, we
* denote that this fp has been epoll()'d. We do this
* regardless of epoll compatibility mode, as the flag
* is harmless if not in epoll compatibility mode.
*/
/*
* Don't do VOP_POLL for an already cached fd with
* same poll events.
*/
/*
* the events are already cached
*/
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
* poll routine to change. May want to revisit
* the tradeoff later.
*/
/*
* 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().
*/
if (error != 0) {
break;
}
} else {
pdp);
}
}
}
} else {
/*
* As with the add case (above), epoll
* semantics demand that we error out
* in this case.
*/
break;
}
continue;
}
}
}
}
dpep->dpe_refcnt--;
return (error);
}
#define DP_SIGMASK_RESTORE(ksetp) { \
mutex_enter(&p->p_lock); \
if (lwp->lwp_cursig == 0) { \
} \
mutex_exit(&p->p_lock); \
} \
}
/*ARGSUSED*/
static int
{
int error = 0;
/* do this now, before we sleep on DP_WRITER_PRESENT */
}
if (cmd == DP_EPOLLCOMPAT) {
if (dpep->dpe_refcnt != 0) {
/*
* We can't turn on epoll compatibility while there
* are outstanding operations.
*/
return (EBUSY);
}
/*
* epoll compatibility is a one-way street: there's no way
* to turn it off for a particular open.
*/
return (0);
}
return (EACCES);
}
}
(dpep->dpe_writerwait != 0)) {
return (EINTR);
}
}
dpep->dpe_refcnt++;
switch (cmd) {
case DP_POLL:
case DP_PPOLL:
{
int fdcnt = 0;
/*
* which otherwise uses the same structure as DP_POLL.
*/
} else {
}
/* Kernel-internal ioctl call */
error = 0;
} else {
dpsize);
}
if (error) {
return (EFAULT);
}
if (deadline > 0) {
/*
* Convert the deadline from relative milliseconds
* to absolute nanoseconds. They must wait for at
* least a tick.
*/
}
return (EFAULT);
}
mutex_enter(&p->p_lock);
/*
* Like ppoll() with a non-NULL sigset, we'll
* call cv_reltimedwait_sig() just to check for
* signals. This call will return immediately
* with either 0 (signalled) or -1 (no signal).
* There are some conditions whereby we can
* get 0 from cv_reltimedwait_sig() without
* a true signal (e.g., a directed stop), so
* we restore our signal mask in the unlikely
* event that lwp_cursig is 0.
*/
if (!cv_reltimedwait_sig(&t->t_delay_cv,
&p->p_lock, 0, TR_CLOCK_TICK)) {
if (lwp->lwp_cursig == 0) {
}
mutex_exit(&p->p_lock);
return (EINTR);
}
mutex_exit(&p->p_lock);
}
}
/*
* 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.
*/
if (deadline == 0) {
return (0);
}
while ((error =
continue;
}
} else {
}
/*
* XXX It would be nice not to have to alloc each time, but it
* requires another per thread structure hook. This can be
* implemented later if data suggests that it's necessary.
*/
}
/*
* If nfds is larger than twice the current maximum
* open file count, we'll silently clamp it. This
* only limits our exposure to allocating an
* inordinate amount of kernel memory; it doesn't
* otherwise affect the semantics. (We have this
* check at twice the maximum instead of merely the
* maximum because some applications pass an nfds that
* is only slightly larger than their limit.)
*/
mutex_enter(&p->p_lock);
}
mutex_exit(&p->p_lock);
}
}
for (;;) {
break;
/*
* A pollwake has happened since we polled cache.
*/
continue;
/*
* Sleep until we are notified, signaled, or timed out.
*/
if (deadline == 0) {
/* immediate timeout; do not check signals */
break;
}
} else {
error = 1;
}
/*
* We've been kicked off of our cv because a
* writer wants in. We're going to drop our
* reference count and then wait until the
* writer is gone -- at which point we'll
* reacquire the pc_lock and call into
* dp_pcache_poll() to get the updated state.
*/
dpep->dpe_refcnt--;
(dpep->dpe_writerwait != 0)) {
}
dpep->dpe_refcnt++;
}
/*
* If we were awakened by a signal or timeout
* then break the loop, else poll again.
*/
if (error <= 0) {
break;
} else {
error = 0;
}
}
return (EFAULT);
}
}
break;
}
case DP_ISPOLLED:
{
if (error) {
return (EFAULT);
}
/*
* No Need to search because no poll fd
* has been cached.
*/
return (0);
}
break;
}
return (EFAULT);
}
*rvalp = 1;
}
break;
}
default:
return (EINVAL);
}
return (error);
}
/*ARGSUSED*/
static int
{
/*
*/
/* no error in epoll compat. mode */
*reventsp = 0;
} else {
}
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
*/
/*ARGSUSED*/
static int
{
int i;
/*
* At this point, no other lwp can access this pollcache via the
* up without the pc_lock.
*/
for (i = 0; i < pcp->pc_hashsize; i++) {
}
}
}
/*
* pollwakeup() may still interact with this pollcache. Wait until
* it is done.
*/
return (0);
}