root/kern/sys_generic.c

DEFINITIONS

1. sys_read
2. dofileread
3. sys_readv
4. dofilereadv
5. sys_write
6. dofilewrite
7. sys_writev
8. dofilewritev
9. sys_ioctl
10. sys_select
11. selscan
12. seltrue
13. selrecord
14. selwakeup
15. pollscan
16. sys_poll

    1 /*      $OpenBSD: sys_generic.c,v 1.57 2007/07/25 23:11:52 art Exp $    */
    2 /*      $NetBSD: sys_generic.c,v 1.24 1996/03/29 00:25:32 cgd Exp $     */
    4 /*
    5  * Copyright (c) 1996 Theo de Raadt
    6  * Copyright (c) 1982, 1986, 1989, 1993
    7  *      The Regents of the University of California.  All rights reserved.
    8  * (c) UNIX System Laboratories, Inc.
    9  * All or some portions of this file are derived from material licensed
   10  * to the University of California by American Telephone and Telegraph
   11  * Co. or Unix System Laboratories, Inc. and are reproduced herein with
   12  * the permission of UNIX System Laboratories, Inc.
   13  *
   14  * Redistribution and use in source and binary forms, with or without
   15  * modification, are permitted provided that the following conditions
   16  * are met:
   17  * 1. Redistributions of source code must retain the above copyright
   18  *    notice, this list of conditions and the following disclaimer.
   19  * 2. Redistributions in binary form must reproduce the above copyright
   20  *    notice, this list of conditions and the following disclaimer in the
   21  *    documentation and/or other materials provided with the distribution.
   22  * 3. Neither the name of the University nor the names of its contributors
   23  *    may be used to endorse or promote products derived from this software
   24  *    without specific prior written permission.
   25  *
   26  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   27  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   28  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   29  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   30  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   31  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   32  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   33  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   34  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   35  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   36  * SUCH DAMAGE.
   37  *
   38  *      @(#)sys_generic.c       8.5 (Berkeley) 1/21/94
   39  */
   41 #include <sys/param.h>
   42 #include <sys/systm.h>
   43 #include <sys/filedesc.h>
   44 #include <sys/ioctl.h>
   45 #include <sys/file.h>
   46 #include <sys/proc.h>
   47 #include <sys/resourcevar.h>
   48 #include <sys/socketvar.h>
   49 #include <sys/signalvar.h>
   50 #include <sys/uio.h>
   51 #include <sys/kernel.h>
   52 #include <sys/stat.h>
   53 #include <sys/malloc.h>
   54 #include <sys/poll.h>
   55 #ifdef KTRACE
   56 #include <sys/ktrace.h>
   57 #endif
   58 #include <sys/sched.h>
   60 #include <sys/mount.h>
   61 #include <sys/syscallargs.h>
   63 #include <uvm/uvm_extern.h>
   65 int selscan(struct proc *, fd_set *, fd_set *, int, int, register_t *);
   66 int seltrue(dev_t, int, struct proc *);
   67 void pollscan(struct proc *, struct pollfd *, u_int, register_t *);
   69 /*
   70  * Read system call.
   71  */
   72 /* ARGSUSED */
   73 int
sys_read(struct proc *p, void *v, register_t *retval)
   75 {
   76         struct sys_read_args /* {
   77                 syscallarg(int) fd;
   78                 syscallarg(void *) buf;
   79                 syscallarg(size_t) nbyte;
   80         } */ *uap = v;
   81         int fd = SCARG(uap, fd);
   82         struct file *fp;
   83         struct filedesc *fdp = p->p_fd;
   85         if ((fp = fd_getfile(fdp, fd)) == NULL)
   86                 return (EBADF);
   87         if ((fp->f_flag & FREAD) == 0)
   88                 return (EBADF);
FREF(fp);
   92         /* dofileread() will FRELE the descriptor for us */
   93         return (dofileread(p, fd, fp, SCARG(uap, buf), SCARG(uap, nbyte),
   94             &fp->f_offset, retval));
   95 }
   97 int
dofileread(struct proc *p, int fd, struct file *fp, void *buf, size_t nbyte,
off_t *offset, register_t *retval)
  100 {
  101         struct uio auio;
  102         struct iovec aiov;
  103         long cnt, error = 0;
  104 #ifdef KTRACE
  105         struct iovec ktriov;
  106 #endif
aiov.iov_base = buf;
aiov.iov_len = nbyte;
auio.uio_iov = &aiov;
auio.uio_iovcnt = 1;
auio.uio_resid = nbyte;
auio.uio_rw = UIO_READ;
auio.uio_segflg = UIO_USERSPACE;
auio.uio_procp = p;
  117         /*
  118          * Reads return ssize_t because -1 is returned on error.  Therefore
  119          * we must restrict the length to SSIZE_MAX to avoid garbage return
  120          * values.
  121          */
  122         if (auio.uio_resid > SSIZE_MAX) {
error = EINVAL;
  124                 goto out;
  125         }
  127 #ifdef KTRACE
  128         /*
  129          * if tracing, save a copy of iovec
  130          */
  131         if (KTRPOINT(p, KTR_GENIO))
ktriov = aiov;
  133 #endif
cnt = auio.uio_resid;
error = (*fp->f_ops->fo_read)(fp, offset, &auio, fp->f_cred);
  136         if (error)
  137                 if (auio.uio_resid != cnt && (error == ERESTART ||
error == EINTR || error == EWOULDBLOCK))
error = 0;
cnt -= auio.uio_resid;
fp->f_rxfer++;
fp->f_rbytes += cnt;
  144 #ifdef KTRACE
  145         if (KTRPOINT(p, KTR_GENIO) && error == 0)
ktrgenio(p, fd, UIO_READ, &ktriov, cnt, error);
  147 #endif
  148         *retval = cnt;
out:
FRELE(fp);
  151         return (error);
  152 }
  154 /*
  155  * Scatter read system call.
  156  */
  157 int
sys_readv(struct proc *p, void *v, register_t *retval)
  159 {
  160         struct sys_readv_args /* {
  161                 syscallarg(int) fd;
  162                 syscallarg(const struct iovec *) iovp;
  163                 syscallarg(int) iovcnt;
  164         } */ *uap = v;
  165         int fd = SCARG(uap, fd);
  166         struct file *fp;
  167         struct filedesc *fdp = p->p_fd;
  169         if ((fp = fd_getfile(fdp, fd)) == NULL)
  170                 return (EBADF);
  171         if ((fp->f_flag & FREAD) == 0)
  172                 return (EBADF);
FREF(fp);
  176         /* dofilereadv() will FRELE the descriptor for us */
  177         return (dofilereadv(p, fd, fp, SCARG(uap, iovp), SCARG(uap, iovcnt),
  178             &fp->f_offset, retval));
  179 }
  181 int
dofilereadv(struct proc *p, int fd, struct file *fp, const struct iovec *iovp,
  183     int iovcnt, off_t *offset, register_t *retval)
  184 {
  185         struct uio auio;
  186         struct iovec *iov;
  187         struct iovec *needfree;
  188         struct iovec aiov[UIO_SMALLIOV];
  189         long i, cnt, error = 0;
u_int iovlen;
  191 #ifdef KTRACE
  192         struct iovec *ktriov = NULL;
  193 #endif
  195         /* note: can't use iovlen until iovcnt is validated */
iovlen = iovcnt * sizeof(struct iovec);
  197         if ((u_int)iovcnt > UIO_SMALLIOV) {
  198                 if ((u_int)iovcnt > IOV_MAX) {
error = EINVAL;
  200                         goto out;
  201                 }
iov = needfree = malloc(iovlen, M_IOV, M_WAITOK);
  203         } else if ((u_int)iovcnt > 0) {
iov = aiov;
needfree = NULL;
  206         } else {
error = EINVAL;
  208                 goto out;
  209         }
auio.uio_iov = iov;
auio.uio_iovcnt = iovcnt;
auio.uio_rw = UIO_READ;
auio.uio_segflg = UIO_USERSPACE;
auio.uio_procp = p;
error = copyin(iovp, iov, iovlen);
  217         if (error)
  218                 goto done;
auio.uio_resid = 0;
  220         for (i = 0; i < iovcnt; i++) {
auio.uio_resid += iov->iov_len;
  222                 /*
  223                  * Reads return ssize_t because -1 is returned on error.
  224                  * Therefore we must restrict the length to SSIZE_MAX to
  225                  * avoid garbage return values.
  226                  */
  227                 if (iov->iov_len > SSIZE_MAX || auio.uio_resid > SSIZE_MAX) {
error = EINVAL;
  229                         goto done;
  230                 }
iov++;
  232         }
  233 #ifdef KTRACE
  234         /*
  235          * if tracing, save a copy of iovec
  236          */
  237         if (KTRPOINT(p, KTR_GENIO))  {
ktriov = malloc(iovlen, M_TEMP, M_WAITOK);
bcopy(auio.uio_iov, ktriov, iovlen);
  240         }
  241 #endif
cnt = auio.uio_resid;
error = (*fp->f_ops->fo_read)(fp, offset, &auio, fp->f_cred);
  244         if (error)
  245                 if (auio.uio_resid != cnt && (error == ERESTART ||
error == EINTR || error == EWOULDBLOCK))
error = 0;
cnt -= auio.uio_resid;
fp->f_rxfer++;
fp->f_rbytes += cnt;
  252 #ifdef KTRACE
  253         if (ktriov != NULL) {
  254                 if (error == 0) 
ktrgenio(p, fd, UIO_READ, ktriov, cnt,
error);
free(ktriov, M_TEMP);
  258         }
  259 #endif
  260         *retval = cnt;
done:
  262         if (needfree)
free(needfree, M_IOV);
out:
FRELE(fp);
  266         return (error);
  267 }
  269 /*
  270  * Write system call
  271  */
  272 int
sys_write(struct proc *p, void *v, register_t *retval)
  274 {
  275         struct sys_write_args /* {
  276                 syscallarg(int) fd;
  277                 syscallarg(const void *) buf;
  278                 syscallarg(size_t) nbyte;
  279         } */ *uap = v;
  280         int fd = SCARG(uap, fd);
  281         struct file *fp;
  282         struct filedesc *fdp = p->p_fd;
  284         if ((fp = fd_getfile(fdp, fd)) == NULL)
  285                 return (EBADF);
  286         if ((fp->f_flag & FWRITE) == 0)
  287                 return (EBADF);
FREF(fp);
  291         /* dofilewrite() will FRELE the descriptor for us */
  292         return (dofilewrite(p, fd, fp, SCARG(uap, buf), SCARG(uap, nbyte),
  293             &fp->f_offset, retval));
  294 }
  296 int
dofilewrite(struct proc *p, int fd, struct file *fp, const void *buf,
size_t nbyte, off_t *offset, register_t *retval)
  299 {
  300         struct uio auio;
  301         struct iovec aiov;
  302         long cnt, error = 0;
  303 #ifdef KTRACE
  304         struct iovec ktriov;
  305 #endif
aiov.iov_base = (void *)buf;            /* XXX kills const */
aiov.iov_len = nbyte;
auio.uio_iov = &aiov;
auio.uio_iovcnt = 1;
auio.uio_resid = nbyte;
auio.uio_rw = UIO_WRITE;
auio.uio_segflg = UIO_USERSPACE;
auio.uio_procp = p;
  316         /*
  317          * Writes return ssize_t because -1 is returned on error.  Therefore
  318          * we must restrict the length to SSIZE_MAX to avoid garbage return
  319          * values.
  320          */
  321         if (auio.uio_resid > SSIZE_MAX) {
error = EINVAL;
  323                 goto out;
  324         }
  326 #ifdef KTRACE
  327         /*
  328          * if tracing, save a copy of iovec
  329          */
  330         if (KTRPOINT(p, KTR_GENIO))
ktriov = aiov;
  332 #endif
cnt = auio.uio_resid;
error = (*fp->f_ops->fo_write)(fp, offset, &auio, fp->f_cred);
  335         if (error) {
  336                 if (auio.uio_resid != cnt && (error == ERESTART ||
error == EINTR || error == EWOULDBLOCK))
error = 0;
  339                 if (error == EPIPE)
psignal(p, SIGPIPE);
  341         }
cnt -= auio.uio_resid;
fp->f_wxfer++;
fp->f_wbytes += cnt;
  346 #ifdef KTRACE
  347         if (KTRPOINT(p, KTR_GENIO) && error == 0)
ktrgenio(p, fd, UIO_WRITE, &ktriov, cnt, error);
  349 #endif
  350         *retval = cnt;
out:
FRELE(fp);
  353         return (error);
  354 }
  356 /*
  357  * Gather write system call
  358  */
  359 int
sys_writev(struct proc *p, void *v, register_t *retval)
  361 {
  362         struct sys_writev_args /* {
  363                 syscallarg(int) fd;
  364                 syscallarg(const struct iovec *) iovp;
  365                 syscallarg(int) iovcnt;
  366         } */ *uap = v;
  367         int fd = SCARG(uap, fd);
  368         struct file *fp;
  369         struct filedesc *fdp = p->p_fd;
  371         if ((fp = fd_getfile(fdp, fd)) == NULL)
  372                 return (EBADF);
  373         if ((fp->f_flag & FWRITE) == 0)
  374                 return (EBADF);
FREF(fp);
  378         /* dofilewritev() will FRELE the descriptor for us */
  379         return (dofilewritev(p, fd, fp, SCARG(uap, iovp), SCARG(uap, iovcnt),
  380             &fp->f_offset, retval));
  381 }
  383 int
dofilewritev(struct proc *p, int fd, struct file *fp, const struct iovec *iovp,
  385     int iovcnt, off_t *offset, register_t *retval)
  386 {
  387         struct uio auio;
  388         struct iovec *iov;
  389         struct iovec *needfree;
  390         struct iovec aiov[UIO_SMALLIOV];
  391         long i, cnt, error = 0;
u_int iovlen;
  393 #ifdef KTRACE
  394         struct iovec *ktriov = NULL;
  395 #endif
  397         /* note: can't use iovlen until iovcnt is validated */
iovlen = iovcnt * sizeof(struct iovec);
  399         if ((u_int)iovcnt > UIO_SMALLIOV) {
  400                 if ((u_int)iovcnt > IOV_MAX) {
error = EINVAL;
  402                         goto out;
  403                 }
iov = needfree = malloc(iovlen, M_IOV, M_WAITOK);
  405         } else if ((u_int)iovcnt > 0) {
iov = aiov;
needfree = NULL;
  408         } else {
error = EINVAL;
  410                 goto out;
  411         }
auio.uio_iov = iov;
auio.uio_iovcnt = iovcnt;
auio.uio_rw = UIO_WRITE;
auio.uio_segflg = UIO_USERSPACE;
auio.uio_procp = p;
error = copyin(iovp, iov, iovlen);
  419         if (error)
  420                 goto done;
auio.uio_resid = 0;
  422         for (i = 0; i < iovcnt; i++) {
auio.uio_resid += iov->iov_len;
  424                 /*
  425                  * Writes return ssize_t because -1 is returned on error.
  426                  * Therefore we must restrict the length to SSIZE_MAX to
  427                  * avoid garbage return values.
  428                  */
  429                 if (iov->iov_len > SSIZE_MAX || auio.uio_resid > SSIZE_MAX) {
error = EINVAL;
  431                         goto done;
  432                 }
iov++;
  434         }
  435 #ifdef KTRACE
  436         /*
  437          * if tracing, save a copy of iovec
  438          */
  439         if (KTRPOINT(p, KTR_GENIO))  {
ktriov = malloc(iovlen, M_TEMP, M_WAITOK);
bcopy(auio.uio_iov, ktriov, iovlen);
  442         }
  443 #endif
cnt = auio.uio_resid;
error = (*fp->f_ops->fo_write)(fp, offset, &auio, fp->f_cred);
  446         if (error) {
  447                 if (auio.uio_resid != cnt && (error == ERESTART ||
error == EINTR || error == EWOULDBLOCK))
error = 0;
  450                 if (error == EPIPE)
psignal(p, SIGPIPE);
  452         }
cnt -= auio.uio_resid;
fp->f_wxfer++;
fp->f_wbytes += cnt;
  457 #ifdef KTRACE
  458         if (ktriov != NULL) {
  459                 if (error == 0) 
ktrgenio(p, fd, UIO_WRITE, ktriov, cnt, error);
free(ktriov, M_TEMP);
  462         }
  463 #endif
  464         *retval = cnt;
done:
  466         if (needfree)
free(needfree, M_IOV);
out:
FRELE(fp);
  470         return (error);
  471 }
  473 /*
  474  * Ioctl system call
  475  */
  476 /* ARGSUSED */
  477 int
sys_ioctl(struct proc *p, void *v, register_t *retval)
  479 {
  480         struct sys_ioctl_args /* {
  481                 syscallarg(int) fd;
  482                 syscallarg(u_long) com;
  483                 syscallarg(void *) data;
  484         } */ *uap = v;
  485         struct file *fp;
  486         struct filedesc *fdp;
u_long com;
  488         int error;
u_int size;
caddr_t data, memp;
  491         int tmp;
  492 #define STK_PARAMS      128
  493         char stkbuf[STK_PARAMS];
fdp = p->p_fd;
  496         if ((fp = fd_getfile(fdp, SCARG(uap, fd))) == NULL)
  497                 return (EBADF);
  499         if ((fp->f_flag & (FREAD | FWRITE)) == 0)
  500                 return (EBADF);
  502         switch (com = SCARG(uap, com)) {
  503         case FIONCLEX:
fdp->fd_ofileflags[SCARG(uap, fd)] &= ~UF_EXCLOSE;
  505                 return (0);
  506         case FIOCLEX:
fdp->fd_ofileflags[SCARG(uap, fd)] |= UF_EXCLOSE;
  508                 return (0);
  509         }
  511         /*
  512          * Interpret high order word to find amount of data to be
  513          * copied to/from the user's address space.
  514          */
size = IOCPARM_LEN(com);
  516         if (size > IOCPARM_MAX)
  517                 return (ENOTTY);
FREF(fp);
memp = NULL;
  520         if (size > sizeof (stkbuf)) {
memp = (caddr_t)malloc((u_long)size, M_IOCTLOPS, M_WAITOK);
data = memp;
  523         } else
data = stkbuf;
  525         if (com&IOC_IN) {
  526                 if (size) {
error = copyin(SCARG(uap, data), data, (u_int)size);
  528                         if (error) {
  529                                 goto out;
  530                         }
  531                 } else
  532                         *(caddr_t *)data = SCARG(uap, data);
  533         } else if ((com&IOC_OUT) && size)
  534                 /*
  535                  * Zero the buffer so the user always
  536                  * gets back something deterministic.
  537                  */
bzero(data, size);
  539         else if (com&IOC_VOID)
  540                 *(caddr_t *)data = SCARG(uap, data);
  542         switch (com) {
  544         case FIONBIO:
  545                 if ((tmp = *(int *)data) != 0)
fp->f_flag |= FNONBLOCK;
  547                 else
fp->f_flag &= ~FNONBLOCK;
error = (*fp->f_ops->fo_ioctl)(fp, FIONBIO, (caddr_t)&tmp, p);
  550                 break;
  552         case FIOASYNC:
  553                 if ((tmp = *(int *)data) != 0)
fp->f_flag |= FASYNC;
  555                 else
fp->f_flag &= ~FASYNC;
error = (*fp->f_ops->fo_ioctl)(fp, FIOASYNC, (caddr_t)&tmp, p);
  558                 break;
  560         case FIOSETOWN:
tmp = *(int *)data;
  562                 if (fp->f_type == DTYPE_SOCKET) {
  563                         struct socket *so = (struct socket *)fp->f_data;
so->so_pgid = tmp;
so->so_siguid = p->p_cred->p_ruid;
so->so_sigeuid = p->p_ucred->cr_uid;
error = 0;
  569                         break;
  570                 }
  571                 if (tmp <= 0) {
tmp = -tmp;
  573                 } else {
  574                         struct proc *p1 = pfind(tmp);
  575                         if (p1 == 0) {
error = ESRCH;
  577                                 break;
  578                         }
tmp = p1->p_pgrp->pg_id;
  580                 }
error = (*fp->f_ops->fo_ioctl)
  582                         (fp, TIOCSPGRP, (caddr_t)&tmp, p);
  583                 break;
  585         case FIOGETOWN:
  586                 if (fp->f_type == DTYPE_SOCKET) {
error = 0;
  588                         *(int *)data = ((struct socket *)fp->f_data)->so_pgid;
  589                         break;
  590                 }
error = (*fp->f_ops->fo_ioctl)(fp, TIOCGPGRP, data, p);
  592                 *(int *)data = -*(int *)data;
  593                 break;
  595         default:
error = (*fp->f_ops->fo_ioctl)(fp, com, data, p);
  597                 break;
  598         }
  599         /*
  600          * Copy any data to user, size was
  601          * already set and checked above.
  602          */
  603         if (error == 0 && (com&IOC_OUT) && size)
error = copyout(data, SCARG(uap, data), (u_int)size);
out:
FRELE(fp);
  607         if (memp)
free(memp, M_IOCTLOPS);
  609         return (error);
  610 }
  612 int     selwait, nselcoll;
  614 /*
  615  * Select system call.
  616  */
  617 int
sys_select(struct proc *p, void *v, register_t *retval)
  619 {
  620         struct sys_select_args /* {
  621                 syscallarg(int) nd;
  622                 syscallarg(fd_set *) in;
  623                 syscallarg(fd_set *) ou;
  624                 syscallarg(fd_set *) ex;
  625                 syscallarg(struct timeval *) tv;
  626         } */ *uap = v;
fd_mask bits[6];
fd_set *pibits[3], *pobits[3];
  629         struct timeval atv, rtv, ttv;
  630         int s, ncoll, error = 0, timo;
u_int nd, ni;
nd = SCARG(uap, nd);
  634         if (nd > p->p_fd->fd_nfiles) {
  635                 /* forgiving; slightly wrong */
nd = p->p_fd->fd_nfiles;
  637         }
ni = howmany(nd, NFDBITS) * sizeof(fd_mask);
  639         if (nd > sizeof(bits[0])) {
caddr_t mbits;
mbits = malloc(ni * 6, M_TEMP, M_WAITOK);
bzero(mbits, ni * 6);
pibits[0] = (fd_set *)&mbits[ni * 0];
pibits[1] = (fd_set *)&mbits[ni * 1];
pibits[2] = (fd_set *)&mbits[ni * 2];
pobits[0] = (fd_set *)&mbits[ni * 3];
pobits[1] = (fd_set *)&mbits[ni * 4];
pobits[2] = (fd_set *)&mbits[ni * 5];
  650         } else {
bzero(bits, sizeof(bits));
pibits[0] = (fd_set *)&bits[0];
pibits[1] = (fd_set *)&bits[1];
pibits[2] = (fd_set *)&bits[2];
pobits[0] = (fd_set *)&bits[3];
pobits[1] = (fd_set *)&bits[4];
pobits[2] = (fd_set *)&bits[5];
  658         }
  660 #define getbits(name, x) \
  661         if (SCARG(uap, name) && (error = copyin(SCARG(uap, name), \
pibits[x], ni))) \
  663                 goto done;
getbits(in, 0);
getbits(ou, 1);
getbits(ex, 2);
  667 #undef  getbits
  669         if (SCARG(uap, tv)) {
error = copyin(SCARG(uap, tv), &atv, sizeof (atv));
  671                 if (error)
  672                         goto done;
  673                 if (itimerfix(&atv)) {
error = EINVAL;
  675                         goto done;
  676                 }
getmicrouptime(&rtv);
timeradd(&atv, &rtv, &atv);
  679         } else {
atv.tv_sec = 0;
atv.tv_usec = 0;
  682         }
timo = 0;
retry:
ncoll = nselcoll;
atomic_setbits_int(&p->p_flag, P_SELECT);
error = selscan(p, pibits[0], pobits[0], nd, ni, retval);
  689         if (error || *retval)
  690                 goto done;
  691         if (SCARG(uap, tv)) {
getmicrouptime(&rtv);
  693                 if (timercmp(&rtv, &atv, >=))
  694                         goto done;
ttv = atv;
timersub(&ttv, &rtv, &ttv);
timo = ttv.tv_sec > 24 * 60 * 60 ?
  698                         24 * 60 * 60 * hz : tvtohz(&ttv);
  699         }
s = splhigh();
  701         if ((p->p_flag & P_SELECT) == 0 || nselcoll != ncoll) {
splx(s);
  703                 goto retry;
  704         }
atomic_clearbits_int(&p->p_flag, P_SELECT);
error = tsleep(&selwait, PSOCK | PCATCH, "select", timo);
splx(s);
  708         if (error == 0)
  709                 goto retry;
done:
atomic_clearbits_int(&p->p_flag, P_SELECT);
  712         /* select is not restarted after signals... */
  713         if (error == ERESTART)
error = EINTR;
  715         if (error == EWOULDBLOCK)
error = 0;
  717 #define putbits(name, x) \
  718         if (SCARG(uap, name) && (error2 = copyout(pobits[x], \
SCARG(uap, name), ni))) \
error = error2;
  721         if (error == 0) {
  722                 int error2;
putbits(in, 0);
putbits(ou, 1);
putbits(ex, 2);
  727 #undef putbits
  728         }
  730         if (pibits[0] != (fd_set *)&bits[0])
free(pibits[0], M_TEMP);
  732         return (error);
  733 }
  735 int
selscan(struct proc *p, fd_set *ibits, fd_set *obits, int nfd, int ni,
register_t *retval)
  738 {
caddr_t cibits = (caddr_t)ibits, cobits = (caddr_t)obits;
  740         struct filedesc *fdp = p->p_fd;
  741         int msk, i, j, fd;
fd_mask bits;
  743         struct file *fp;
  744         int n = 0;
  745         static const int flag[3] = { POLLIN, POLLOUT, POLLPRI };
  747         for (msk = 0; msk < 3; msk++) {
fd_set *pibits = (fd_set *)&cibits[msk*ni];
fd_set *pobits = (fd_set *)&cobits[msk*ni];
  751                 for (i = 0; i < nfd; i += NFDBITS) {
bits = pibits->fds_bits[i/NFDBITS];
  753                         while ((j = ffs(bits)) && (fd = i + --j) < nfd) {
bits &= ~(1 << j);
  755                                 if ((fp = fd_getfile(fdp, fd)) == NULL)
  756                                         return (EBADF);
FREF(fp);
  758                                 if ((*fp->f_ops->fo_poll)(fp, flag[msk], p)) {
FD_SET(fd, pobits);
n++;
  761                                 }
FRELE(fp);
  763                         }
  764                 }
  765         }
  766         *retval = n;
  767         return (0);
  768 }
  770 /*ARGSUSED*/
  771 int
seltrue(dev_t dev, int events, struct proc *p)
  773 {
  775         return (events & (POLLIN | POLLOUT | POLLRDNORM | POLLWRNORM));
  776 }
  778 /*
  779  * Record a select request.
  780  */
  781 void
selrecord(struct proc *selector, struct selinfo *sip)
  783 {
  784         struct proc *p;
pid_t mypid;
mypid = selector->p_pid;
  788         if (sip->si_selpid == mypid)
  789                 return;
  790         if (sip->si_selpid && (p = pfind(sip->si_selpid)) &&
p->p_wchan == (caddr_t)&selwait)
sip->si_flags |= SI_COLL;
  793         else
sip->si_selpid = mypid;
  795 }
  797 /*
  798  * Do a wakeup when a selectable event occurs.
  799  */
  800 void
selwakeup(struct selinfo *sip)
  802 {
  803         struct proc *p;
  804         int s;
  806         if (sip->si_selpid == 0)
  807                 return;
  808         if (sip->si_flags & SI_COLL) {
nselcoll++;
sip->si_flags &= ~SI_COLL;
wakeup(&selwait);
  812         }
p = pfind(sip->si_selpid);
sip->si_selpid = 0;
  815         if (p != NULL) {
SCHED_LOCK(s);
  817                 if (p->p_wchan == (caddr_t)&selwait) {
  818                         if (p->p_stat == SSLEEP)
setrunnable(p);
  820                         else
unsleep(p);
  822                 } else if (p->p_flag & P_SELECT)
atomic_clearbits_int(&p->p_flag, P_SELECT);
SCHED_UNLOCK(s);
  825         }
  826 }
  828 void
pollscan(struct proc *p, struct pollfd *pl, u_int nfd, register_t *retval)
  830 {
  831         struct filedesc *fdp = p->p_fd;
  832         struct file *fp;
u_int i;
  834         int n = 0;
  836         for (i = 0; i < nfd; i++, pl++) {
  837                 /* Check the file descriptor. */
  838                 if (pl->fd < 0) {
pl->revents = 0;
  840                         continue;
  841                 }
  842                 if ((fp = fd_getfile(fdp, pl->fd)) == NULL) {
pl->revents = POLLNVAL;
n++;
  845                         continue;
  846                 }
FREF(fp);
pl->revents = (*fp->f_ops->fo_poll)(fp, pl->events, p);
FRELE(fp);
  850                 if (pl->revents != 0)
n++;
  852         }
  853         *retval = n;
  854 }
  856 /*
  857  * We are using the same mechanism as select only we encode/decode args
  858  * differently.
  859  */
  860 int
sys_poll(struct proc *p, void *v, register_t *retval)
  862 {
  863         struct sys_poll_args /* {
  864                 syscallarg(struct pollfd *) fds;
  865                 syscallarg(u_int) nfds;
  866                 syscallarg(int) timeout;
  867         } */ *uap = v;
size_t sz;
  869         struct pollfd pfds[4], *pl = pfds;
  870         int msec = SCARG(uap, timeout);
  871         struct timeval atv, rtv, ttv;
  872         int timo, ncoll, i, s, error;
  873         extern int nselcoll, selwait;
u_int nfds = SCARG(uap, nfds);
  876         /* Standards say no more than MAX_OPEN; this is possibly better. */
  877         if (nfds > min((int)p->p_rlimit[RLIMIT_NOFILE].rlim_cur, maxfiles))
  878                 return (EINVAL);
sz = sizeof(struct pollfd) * nfds;
  882         /* optimize for the default case, of a small nfds value */
  883         if (sz > sizeof(pfds))
pl = (struct pollfd *) malloc(sz, M_TEMP, M_WAITOK);
  886         if ((error = copyin(SCARG(uap, fds), pl, sz)) != 0)
  887                 goto bad;
  889         for (i = 0; i < nfds; i++)
pl[i].revents = 0;
  892         if (msec != INFTIM) {
atv.tv_sec = msec / 1000;
atv.tv_usec = (msec - (atv.tv_sec * 1000)) * 1000;
  896                 if (itimerfix(&atv)) {
error = EINVAL;
  898                         goto done;
  899                 }
getmicrouptime(&rtv);
timeradd(&atv, &rtv, &atv);
  902         } else {
atv.tv_sec = 0;
atv.tv_usec = 0;
  905         }
timo = 0;
retry:
ncoll = nselcoll;
atomic_setbits_int(&p->p_flag, P_SELECT);
pollscan(p, pl, nfds, retval);
  912         if (*retval)
  913                 goto done;
  914         if (msec != INFTIM) {
getmicrouptime(&rtv);
  916                 if (timercmp(&rtv, &atv, >=))
  917                         goto done;
ttv = atv;
timersub(&ttv, &rtv, &ttv);
timo = ttv.tv_sec > 24 * 60 * 60 ?
  921                         24 * 60 * 60 * hz : tvtohz(&ttv);
  922         }
s = splhigh();
  924         if ((p->p_flag & P_SELECT) == 0 || nselcoll != ncoll) {
splx(s);
  926                 goto retry;
  927         }
atomic_clearbits_int(&p->p_flag, P_SELECT);
error = tsleep(&selwait, PSOCK | PCATCH, "poll", timo);
splx(s);
  931         if (error == 0)
  932                 goto retry;
done:
atomic_clearbits_int(&p->p_flag, P_SELECT);
  936         /*
  937          * NOTE: poll(2) is not restarted after a signal and EWOULDBLOCK is
  938          *       ignored (since the whole point is to see what would block).
  939          */
  940         switch (error) {
  941         case ERESTART:
error = copyout(pl, SCARG(uap, fds), sz);
  943                 if (error == 0)
error = EINTR;
  945                 break;
  946         case EWOULDBLOCK:
  947         case 0:
error = copyout(pl, SCARG(uap, fds), sz);
  949                 break;
  950         }
bad:
  952         if (pl != pfds)
free(pl, M_TEMP);
  954         return (error);
  955 }