Consolidate the file descriptor destruction code used when a newly created
[dragonfly.git] / sys / kern / sys_generic.c
1 /*
2  * Copyright (c) 1982, 1986, 1989, 1993
3  *      The Regents of the University of California.  All rights reserved.
4  * (c) UNIX System Laboratories, Inc.
5  * All or some portions of this file are derived from material licensed
6  * to the University of California by American Telephone and Telegraph
7  * Co. or Unix System Laboratories, Inc. and are reproduced herein with
8  * the permission of UNIX System Laboratories, Inc.
9  *
10  * Redistribution and use in source and binary forms, with or without
11  * modification, are permitted provided that the following conditions
12  * are met:
13  * 1. Redistributions of source code must retain the above copyright
14  *    notice, this list of conditions and the following disclaimer.
15  * 2. Redistributions in binary form must reproduce the above copyright
16  *    notice, this list of conditions and the following disclaimer in the
17  *    documentation and/or other materials provided with the distribution.
18  * 3. All advertising materials mentioning features or use of this software
19  *    must display the following acknowledgement:
20  *      This product includes software developed by the University of
21  *      California, Berkeley and its contributors.
22  * 4. 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  * $FreeBSD: src/sys/kern/sys_generic.c,v 1.55.2.10 2001/03/17 10:39:32 peter Exp $
40  * $DragonFly: src/sys/kern/sys_generic.c,v 1.29 2006/05/19 05:15:34 dillon Exp $
41  */
42
43 #include "opt_ktrace.h"
44
45 #include <sys/param.h>
46 #include <sys/systm.h>
47 #include <sys/sysproto.h>
48 #include <sys/filedesc.h>
49 #include <sys/filio.h>
50 #include <sys/fcntl.h>
51 #include <sys/file.h>
52 #include <sys/proc.h>
53 #include <sys/signalvar.h>
54 #include <sys/socketvar.h>
55 #include <sys/uio.h>
56 #include <sys/kernel.h>
57 #include <sys/kern_syscall.h>
58 #include <sys/malloc.h>
59 #include <sys/mapped_ioctl.h>
60 #include <sys/poll.h>
61 #include <sys/queue.h>
62 #include <sys/resourcevar.h>
63 #include <sys/sysctl.h>
64 #include <sys/sysent.h>
65 #include <sys/buf.h>
66 #ifdef KTRACE
67 #include <sys/ktrace.h>
68 #endif
69 #include <vm/vm.h>
70 #include <vm/vm_page.h>
71 #include <sys/file2.h>
72
73 #include <machine/limits.h>
74
75 static MALLOC_DEFINE(M_IOCTLOPS, "ioctlops", "ioctl data buffer");
76 static MALLOC_DEFINE(M_IOCTLMAP, "ioctlmap", "mapped ioctl handler buffer");
77 static MALLOC_DEFINE(M_SELECT, "select", "select() buffer");
78 MALLOC_DEFINE(M_IOV, "iov", "large iov's");
79
80 static int      pollscan (struct proc *, struct pollfd *, u_int, int *);
81 static int      selscan (struct proc *, fd_mask **, fd_mask **,
82                         int, int *);
83 static int      dofileread(int, struct file *, struct uio *, int, int *);
84 static int      dofilewrite(int, struct file *, struct uio *, int, int *);
85
86 /*
87  * Read system call.
88  */
89 int
90 read(struct read_args *uap)
91 {
92         struct thread *td = curthread;
93         struct uio auio;
94         struct iovec aiov;
95         int error;
96
97         aiov.iov_base = uap->buf;
98         aiov.iov_len = uap->nbyte;
99         auio.uio_iov = &aiov;
100         auio.uio_iovcnt = 1;
101         auio.uio_offset = -1;
102         auio.uio_resid = uap->nbyte;
103         auio.uio_rw = UIO_READ;
104         auio.uio_segflg = UIO_USERSPACE;
105         auio.uio_td = td;
106
107         if (auio.uio_resid < 0)
108                 error = EINVAL;
109         else
110                 error = kern_preadv(uap->fd, &auio, 0, &uap->sysmsg_result);
111         return(error);
112 }
113
114 /*
115  * Positioned (Pread) read system call
116  */
117 int
118 pread(struct pread_args *uap)
119 {
120         struct thread *td = curthread;
121         struct uio auio;
122         struct iovec aiov;
123         int error;
124
125         aiov.iov_base = uap->buf;
126         aiov.iov_len = uap->nbyte;
127         auio.uio_iov = &aiov;
128         auio.uio_iovcnt = 1;
129         auio.uio_offset = uap->offset;
130         auio.uio_resid = uap->nbyte;
131         auio.uio_rw = UIO_READ;
132         auio.uio_segflg = UIO_USERSPACE;
133         auio.uio_td = td;
134
135         if (auio.uio_resid < 0)
136                 error = EINVAL;
137         else
138                 error = kern_preadv(uap->fd, &auio, FOF_OFFSET, &uap->sysmsg_result);
139         return(error);
140 }
141
142 /*
143  * Scatter read system call.
144  */
145 int
146 readv(struct readv_args *uap)
147 {
148         struct thread *td = curthread;
149         struct uio auio;
150         struct iovec aiov[UIO_SMALLIOV], *iov = NULL;
151         int error;
152
153         error = iovec_copyin(uap->iovp, &iov, aiov, uap->iovcnt,
154                              &auio.uio_resid);
155         if (error)
156                 return (error);
157         auio.uio_iov = iov;
158         auio.uio_iovcnt = uap->iovcnt;
159         auio.uio_offset = -1;
160         auio.uio_rw = UIO_READ;
161         auio.uio_segflg = UIO_USERSPACE;
162         auio.uio_td = td;
163
164         error = kern_preadv(uap->fd, &auio, 0, &uap->sysmsg_result);
165
166         iovec_free(&iov, aiov);
167         return (error);
168 }
169
170
171 /*
172  * Scatter positioned read system call.
173  */
174 int
175 preadv(struct preadv_args *uap)
176 {
177         struct thread *td = curthread;
178         struct uio auio;
179         struct iovec aiov[UIO_SMALLIOV], *iov = NULL;
180         int error;
181
182         error = iovec_copyin(uap->iovp, &iov, aiov, uap->iovcnt,
183                              &auio.uio_resid);
184         if (error)
185                 return (error);
186         auio.uio_iov = iov;
187         auio.uio_iovcnt = uap->iovcnt;
188         auio.uio_offset = uap->offset;
189         auio.uio_rw = UIO_READ;
190         auio.uio_segflg = UIO_USERSPACE;
191         auio.uio_td = td;
192
193         error = kern_preadv(uap->fd, &auio, FOF_OFFSET, &uap->sysmsg_result);
194
195         iovec_free(&iov, aiov);
196         return(error);
197 }
198
199 int
200 kern_preadv(int fd, struct uio *auio, int flags, int *res)
201 {
202         struct thread *td = curthread;
203         struct proc *p = td->td_proc;
204         struct file *fp;
205         struct filedesc *fdp = p->p_fd;
206         int error;
207
208         KKASSERT(p);
209
210         fp = holdfp(fdp, fd, FREAD);
211         if (fp == NULL)
212                 return (EBADF);
213         if (flags & FOF_OFFSET && fp->f_type != DTYPE_VNODE) {
214                 error = ESPIPE;
215         } else if (auio->uio_resid < 0) {
216                 error = EINVAL;
217         } else {
218                 error = dofileread(fd, fp, auio, flags, res);
219         }
220         fdrop(fp);
221         return(error);
222 }
223
224 /*
225  * Common code for readv and preadv that reads data in
226  * from a file using the passed in uio, offset, and flags.
227  */
228 static int
229 dofileread(int fd, struct file *fp, struct uio *auio, int flags, int *res)
230 {
231         struct thread *td = curthread;
232         struct proc *p = td->td_proc;
233         int error;
234         int len;
235 #ifdef KTRACE
236         struct iovec *ktriov = NULL;
237         struct uio ktruio;
238 #endif
239
240 #ifdef KTRACE
241         /*
242          * if tracing, save a copy of iovec
243          */
244         if (KTRPOINT(td, KTR_GENIO))  {
245                 int iovlen = auio->uio_iovcnt * sizeof(struct iovec);
246
247                 MALLOC(ktriov, struct iovec *, iovlen, M_TEMP, M_WAITOK);
248                 bcopy((caddr_t)auio->uio_iov, (caddr_t)ktriov, iovlen);
249                 ktruio = *auio;
250         }
251 #endif
252         len = auio->uio_resid;
253         error = fo_read(fp, auio, fp->f_cred, flags);
254         if (error) {
255                 if (auio->uio_resid != len && (error == ERESTART ||
256                     error == EINTR || error == EWOULDBLOCK))
257                         error = 0;
258         }
259 #ifdef KTRACE
260         if (ktriov != NULL) {
261                 if (error == 0) {
262                         ktruio.uio_iov = ktriov;
263                         ktruio.uio_resid = len - auio->uio_resid;
264                         ktrgenio(p, fd, UIO_READ, &ktruio, error);
265                 }
266                 FREE(ktriov, M_TEMP);
267         }
268 #endif
269         if (error == 0)
270                 *res = len - auio->uio_resid;
271
272         return(error);
273 }
274
275 /*
276  * Write system call
277  */
278 int
279 write(struct write_args *uap)
280 {
281         struct thread *td = curthread;
282         struct uio auio;
283         struct iovec aiov;
284         int error;
285
286         aiov.iov_base = (void *)(uintptr_t)uap->buf;
287         aiov.iov_len = uap->nbyte;
288         auio.uio_iov = &aiov;
289         auio.uio_iovcnt = 1;
290         auio.uio_offset = -1;
291         auio.uio_resid = uap->nbyte;
292         auio.uio_rw = UIO_WRITE;
293         auio.uio_segflg = UIO_USERSPACE;
294         auio.uio_td = td;
295
296         if (auio.uio_resid < 0)
297                 error = EINVAL;
298         else
299                 error = kern_pwritev(uap->fd, &auio, 0, &uap->sysmsg_result);
300
301         return(error);
302 }
303
304 /*
305  * Pwrite system call
306  */
307 int
308 pwrite(struct pwrite_args *uap)
309 {
310         struct thread *td = curthread;
311         struct uio auio;
312         struct iovec aiov;
313         int error;
314
315         aiov.iov_base = (void *)(uintptr_t)uap->buf;
316         aiov.iov_len = uap->nbyte;
317         auio.uio_iov = &aiov;
318         auio.uio_iovcnt = 1;
319         auio.uio_offset = uap->offset;
320         auio.uio_resid = uap->nbyte;
321         auio.uio_rw = UIO_WRITE;
322         auio.uio_segflg = UIO_USERSPACE;
323         auio.uio_td = td;
324
325         if (auio.uio_resid < 0)
326                 error = EINVAL;
327         else
328                 error = kern_pwritev(uap->fd, &auio, FOF_OFFSET, &uap->sysmsg_result);
329
330         return(error);
331 }
332
333 int
334 writev(struct writev_args *uap)
335 {
336         struct thread *td = curthread;
337         struct uio auio;
338         struct iovec aiov[UIO_SMALLIOV], *iov = NULL;
339         int error;
340
341         error = iovec_copyin(uap->iovp, &iov, aiov, uap->iovcnt,
342                              &auio.uio_resid);
343         if (error)
344                 return (error);
345         auio.uio_iov = iov;
346         auio.uio_iovcnt = uap->iovcnt;
347         auio.uio_offset = -1;
348         auio.uio_rw = UIO_WRITE;
349         auio.uio_segflg = UIO_USERSPACE;
350         auio.uio_td = td;
351
352         error = kern_pwritev(uap->fd, &auio, 0, &uap->sysmsg_result);
353
354         iovec_free(&iov, aiov);
355         return (error);
356 }
357
358
359 /*
360  * Gather positioned write system call
361  */
362 int
363 pwritev(struct pwritev_args *uap)
364 {
365         struct thread *td = curthread;
366         struct uio auio;
367         struct iovec aiov[UIO_SMALLIOV], *iov = NULL;
368         int error;
369
370         error = iovec_copyin(uap->iovp, &iov, aiov, uap->iovcnt,
371                              &auio.uio_resid);
372         if (error)
373                 return (error);
374         auio.uio_iov = iov;
375         auio.uio_iovcnt = uap->iovcnt;
376         auio.uio_offset = uap->offset;
377         auio.uio_rw = UIO_WRITE;
378         auio.uio_segflg = UIO_USERSPACE;
379         auio.uio_td = td;
380
381         error = kern_pwritev(uap->fd, &auio, FOF_OFFSET, &uap->sysmsg_result);
382
383         iovec_free(&iov, aiov);
384         return(error);
385 }
386
387 int
388 kern_pwritev(int fd, struct uio *auio, int flags, int *res)
389 {
390         struct thread *td = curthread;
391         struct proc *p = td->td_proc;
392         struct file *fp;
393         struct filedesc *fdp = p->p_fd;
394         int error;
395
396         KKASSERT(p);
397
398         fp = holdfp(fdp, fd, FWRITE);
399         if (fp == NULL)
400                 return (EBADF);
401         else if ((flags & FOF_OFFSET) && fp->f_type != DTYPE_VNODE) {
402                 error = ESPIPE;
403         } else {
404                 error = dofilewrite(fd, fp, auio, flags, res);
405         }
406         
407         fdrop(fp);
408         return (error);
409 }
410
411 /*
412  * Common code for writev and pwritev that writes data to
413  * a file using the passed in uio, offset, and flags.
414  */
415 static int
416 dofilewrite(int fd, struct file *fp, struct uio *auio, int flags, int *res)
417 {       
418         struct thread *td = curthread;
419         struct proc *p = td->td_proc;
420         int error;
421         int len;
422 #ifdef KTRACE
423         struct iovec *ktriov = NULL;
424         struct uio ktruio;
425 #endif
426
427 #ifdef KTRACE
428         /*
429          * if tracing, save a copy of iovec and uio
430          */
431         if (KTRPOINT(td, KTR_GENIO))  {
432                 int iovlen = auio->uio_iovcnt * sizeof(struct iovec);
433
434                 MALLOC(ktriov, struct iovec *, iovlen, M_TEMP, M_WAITOK);
435                 bcopy((caddr_t)auio->uio_iov, (caddr_t)ktriov, iovlen);
436                 ktruio = *auio;
437         }
438 #endif
439         len = auio->uio_resid;
440         if (fp->f_type == DTYPE_VNODE)
441                 bwillwrite();
442         error = fo_write(fp, auio, fp->f_cred, flags);
443         if (error) {
444                 if (auio->uio_resid != len && (error == ERESTART ||
445                     error == EINTR || error == EWOULDBLOCK))
446                         error = 0;
447                 /* Socket layer is responsible for issuing SIGPIPE. */
448                 if (error == EPIPE)
449                         psignal(p, SIGPIPE);
450         }
451 #ifdef KTRACE
452         if (ktriov != NULL) {
453                 if (error == 0) {
454                         ktruio.uio_iov = ktriov;
455                         ktruio.uio_resid = len - auio->uio_resid;
456                         ktrgenio(p, fd, UIO_WRITE, &ktruio, error);
457                 }
458                 FREE(ktriov, M_TEMP);
459         }
460 #endif
461         if (error == 0)
462                 *res = len - auio->uio_resid;
463
464         return(error);
465 }
466
467 /*
468  * Ioctl system call
469  */
470 /* ARGSUSED */
471 int
472 ioctl(struct ioctl_args *uap)
473 {
474         return(mapped_ioctl(uap->fd, uap->com, uap->data, NULL));
475 }
476
477 struct ioctl_map_entry {
478         const char *subsys;
479         struct ioctl_map_range *cmd_ranges;
480         LIST_ENTRY(ioctl_map_entry) entries;
481 };
482
483 /*
484  * The true heart of all ioctl syscall handlers (native, emulation).
485  * If map != NULL, it will be searched for a matching entry for com,
486  * and appropriate conversions/conversion functions will be utilized.
487  */
488 int
489 mapped_ioctl(int fd, u_long com, caddr_t uspc_data, struct ioctl_map *map)
490 {
491         struct thread *td = curthread;
492         struct proc *p = td->td_proc;
493         struct ucred *cred;
494         struct file *fp;
495         struct filedesc *fdp;
496         struct ioctl_map_range *iomc = NULL;
497         int error;
498         u_int size;
499         u_long ocom = com;
500         caddr_t data, memp;
501         int tmp;
502 #define STK_PARAMS      128
503         union {
504             char stkbuf[STK_PARAMS];
505             long align;
506         } ubuf;
507
508         KKASSERT(p);
509         cred = p->p_ucred;
510         fdp = p->p_fd;
511         if ((u_int)fd >= fdp->fd_nfiles ||
512             (fp = fdp->fd_files[fd].fp) == NULL)
513                 return(EBADF);
514
515         if ((fp->f_flag & (FREAD | FWRITE)) == 0)
516                 return(EBADF);
517
518         if (map != NULL) {      /* obey translation map */
519                 u_long maskcmd;
520                 struct ioctl_map_entry *e;
521
522                 maskcmd = com & map->mask;
523
524                 LIST_FOREACH(e, &map->mapping, entries) {
525                         for (iomc = e->cmd_ranges; iomc->start != 0 ||
526                              iomc->maptocmd != 0 || iomc->wrapfunc != NULL ||
527                              iomc->mapfunc != NULL;
528                              iomc++) {
529                                 if (maskcmd >= iomc->start &&
530                                     maskcmd <= iomc->end)
531                                         break;
532                         }
533
534                         /* Did we find a match? */
535                         if (iomc->start != 0 || iomc->maptocmd != 0 ||
536                             iomc->wrapfunc != NULL || iomc->mapfunc != NULL)
537                                 break;
538                 }
539
540                 if (iomc == NULL ||
541                     (iomc->start == 0 && iomc->maptocmd == 0
542                      && iomc->wrapfunc == NULL && iomc->mapfunc == NULL)) {
543                         printf("%s: 'ioctl' fd=%d, cmd=0x%lx ('%c',%d) not implemented\n",
544                                map->sys, fd, maskcmd,
545                                (int)((maskcmd >> 8) & 0xff),
546                                (int)(maskcmd & 0xff));
547                         return(EINVAL);
548                 }
549
550                 /*
551                  * If it's a non-range one to one mapping, maptocmd should be
552                  * correct. If it's a ranged one to one mapping, we pass the
553                  * original value of com, and for a range mapped to a different
554                  * range, we always need a mapping function to translate the
555                  * ioctl to our native ioctl. Ex. 6500-65ff <-> 9500-95ff
556                  */
557                 if (iomc->start == iomc->end && iomc->maptocmd == iomc->maptoend) {
558                         com = iomc->maptocmd;
559                 } else if (iomc->start == iomc->maptocmd && iomc->end == iomc->maptoend) {
560                         if (iomc->mapfunc != NULL)
561                                 com = iomc->mapfunc(iomc->start, iomc->end,
562                                                     iomc->start, iomc->end,
563                                                     com, com);
564                 } else {
565                         if (iomc->mapfunc != NULL) {
566                                 com = iomc->mapfunc(iomc->start, iomc->end,
567                                                     iomc->maptocmd, iomc->maptoend,
568                                                     com, ocom);
569                         } else {
570                                 printf("%s: Invalid mapping for fd=%d, cmd=%#lx ('%c',%d)\n",
571                                        map->sys, fd, maskcmd,
572                                        (int)((maskcmd >> 8) & 0xff),
573                                        (int)(maskcmd & 0xff));
574                                 return(EINVAL);
575                         }
576                 }
577         }
578
579         switch (com) {
580         case FIONCLEX:
581                 fdp->fd_files[fd].fileflags &= ~UF_EXCLOSE;
582                 return(0);
583         case FIOCLEX:
584                 fdp->fd_files[fd].fileflags |= UF_EXCLOSE;
585                 return(0);
586         }
587
588         /*
589          * Interpret high order word to find amount of data to be
590          * copied to/from the user's address space.
591          */
592         size = IOCPARM_LEN(com);
593         if (size > IOCPARM_MAX)
594                 return(ENOTTY);
595
596         fhold(fp);
597
598         memp = NULL;
599         if (size > sizeof (ubuf.stkbuf)) {
600                 memp = malloc(size, M_IOCTLOPS, M_WAITOK);
601                 data = memp;
602         } else {
603                 data = ubuf.stkbuf;
604         }
605         if ((com & IOC_IN) != 0) {
606                 if (size != 0) {
607                         error = copyin(uspc_data, data, (u_int)size);
608                         if (error) {
609                                 if (memp != NULL)
610                                         free(memp, M_IOCTLOPS);
611                                 fdrop(fp);
612                                 return(error);
613                         }
614                 } else {
615                         *(caddr_t *)data = uspc_data;
616                 }
617         } else if ((com & IOC_OUT) != 0 && size) {
618                 /*
619                  * Zero the buffer so the user always
620                  * gets back something deterministic.
621                  */
622                 bzero(data, size);
623         } else if ((com & IOC_VOID) != 0) {
624                 *(caddr_t *)data = uspc_data;
625         }
626
627         switch (com) {
628
629         case FIONBIO:
630                 if ((tmp = *(int *)data))
631                         fp->f_flag |= FNONBLOCK;
632                 else
633                         fp->f_flag &= ~FNONBLOCK;
634                 error = fo_ioctl(fp, FIONBIO, (caddr_t)&tmp, cred);
635                 break;
636
637         case FIOASYNC:
638                 if ((tmp = *(int *)data))
639                         fp->f_flag |= FASYNC;
640                 else
641                         fp->f_flag &= ~FASYNC;
642                 error = fo_ioctl(fp, FIOASYNC, (caddr_t)&tmp, cred);
643                 break;
644
645         default:
646                 /*
647                  *  If there is a override function,
648                  *  call it instead of directly routing the call
649                  */
650                 if (map != NULL && iomc->wrapfunc != NULL)
651                         error = iomc->wrapfunc(fp, com, ocom, data, cred);
652                 else
653                         error = fo_ioctl(fp, com, data, cred);
654                 /*
655                  * Copy any data to user, size was
656                  * already set and checked above.
657                  */
658                 if (error == 0 && (com & IOC_OUT) != 0 && size != 0)
659                         error = copyout(data, uspc_data, (u_int)size);
660                 break;
661         }
662         if (memp != NULL)
663                 free(memp, M_IOCTLOPS);
664         fdrop(fp);
665         return(error);
666 }
667
668 int
669 mapped_ioctl_register_handler(struct ioctl_map_handler *he)
670 {
671         struct ioctl_map_entry *ne;
672
673         KKASSERT(he != NULL && he->map != NULL && he->cmd_ranges != NULL &&
674                  he->subsys != NULL && *he->subsys != '\0');
675
676         ne = malloc(sizeof(struct ioctl_map_entry), M_IOCTLMAP, M_WAITOK);
677
678         ne->subsys = he->subsys;
679         ne->cmd_ranges = he->cmd_ranges;
680
681         LIST_INSERT_HEAD(&he->map->mapping, ne, entries);
682
683         return(0);
684 }
685
686 int
687 mapped_ioctl_unregister_handler(struct ioctl_map_handler *he)
688 {
689         struct ioctl_map_entry *ne;
690
691         KKASSERT(he != NULL && he->map != NULL && he->cmd_ranges != NULL);
692
693         LIST_FOREACH(ne, &he->map->mapping, entries) {
694                 if (ne->cmd_ranges != he->cmd_ranges)
695                         continue;
696                 LIST_REMOVE(ne, entries);
697                 free(ne, M_IOCTLMAP);
698                 return(0);
699         }
700         return(EINVAL);
701 }
702
703 static int      nselcoll;       /* Select collisions since boot */
704 int     selwait;
705 SYSCTL_INT(_kern, OID_AUTO, nselcoll, CTLFLAG_RD, &nselcoll, 0, "");
706
707 /*
708  * Select system call.
709  */
710 int
711 select(struct select_args *uap)
712 {
713         struct proc *p = curproc;
714
715         /*
716          * The magic 2048 here is chosen to be just enough for FD_SETSIZE
717          * infds with the new FD_SETSIZE of 1024, and more than enough for
718          * FD_SETSIZE infds, outfds and exceptfds with the old FD_SETSIZE
719          * of 256.
720          */
721         fd_mask s_selbits[howmany(2048, NFDBITS)];
722         fd_mask *ibits[3], *obits[3], *selbits, *sbp;
723         struct timeval atv, rtv, ttv;
724         int ncoll, error, timo;
725         u_int nbufbytes, ncpbytes, nfdbits;
726
727         if (uap->nd < 0)
728                 return (EINVAL);
729         if (uap->nd > p->p_fd->fd_nfiles)
730                 uap->nd = p->p_fd->fd_nfiles;   /* forgiving; slightly wrong */
731
732         /*
733          * Allocate just enough bits for the non-null fd_sets.  Use the
734          * preallocated auto buffer if possible.
735          */
736         nfdbits = roundup(uap->nd, NFDBITS);
737         ncpbytes = nfdbits / NBBY;
738         nbufbytes = 0;
739         if (uap->in != NULL)
740                 nbufbytes += 2 * ncpbytes;
741         if (uap->ou != NULL)
742                 nbufbytes += 2 * ncpbytes;
743         if (uap->ex != NULL)
744                 nbufbytes += 2 * ncpbytes;
745         if (nbufbytes <= sizeof s_selbits)
746                 selbits = &s_selbits[0];
747         else
748                 selbits = malloc(nbufbytes, M_SELECT, M_WAITOK);
749
750         /*
751          * Assign pointers into the bit buffers and fetch the input bits.
752          * Put the output buffers together so that they can be bzeroed
753          * together.
754          */
755         sbp = selbits;
756 #define getbits(name, x) \
757         do {                                                            \
758                 if (uap->name == NULL)                                  \
759                         ibits[x] = NULL;                                \
760                 else {                                                  \
761                         ibits[x] = sbp + nbufbytes / 2 / sizeof *sbp;   \
762                         obits[x] = sbp;                                 \
763                         sbp += ncpbytes / sizeof *sbp;                  \
764                         error = copyin(uap->name, ibits[x], ncpbytes);  \
765                         if (error != 0)                                 \
766                                 goto done;                              \
767                 }                                                       \
768         } while (0)
769         getbits(in, 0);
770         getbits(ou, 1);
771         getbits(ex, 2);
772 #undef  getbits
773         if (nbufbytes != 0)
774                 bzero(selbits, nbufbytes / 2);
775
776         if (uap->tv) {
777                 error = copyin((caddr_t)uap->tv, (caddr_t)&atv,
778                         sizeof (atv));
779                 if (error)
780                         goto done;
781                 if (itimerfix(&atv)) {
782                         error = EINVAL;
783                         goto done;
784                 }
785                 getmicrouptime(&rtv);
786                 timevaladd(&atv, &rtv);
787         } else {
788                 atv.tv_sec = 0;
789                 atv.tv_usec = 0;
790         }
791         timo = 0;
792 retry:
793         ncoll = nselcoll;
794         p->p_flag |= P_SELECT;
795         error = selscan(p, ibits, obits, uap->nd, &uap->sysmsg_result);
796         if (error || uap->sysmsg_result)
797                 goto done;
798         if (atv.tv_sec || atv.tv_usec) {
799                 getmicrouptime(&rtv);
800                 if (timevalcmp(&rtv, &atv, >=)) 
801                         goto done;
802                 ttv = atv;
803                 timevalsub(&ttv, &rtv);
804                 timo = ttv.tv_sec > 24 * 60 * 60 ?
805                     24 * 60 * 60 * hz : tvtohz_high(&ttv);
806         }
807         crit_enter();
808         if ((p->p_flag & P_SELECT) == 0 || nselcoll != ncoll) {
809                 crit_exit();
810                 goto retry;
811         }
812         p->p_flag &= ~P_SELECT;
813
814         error = tsleep((caddr_t)&selwait, PCATCH, "select", timo);
815         
816         crit_exit();
817         if (error == 0)
818                 goto retry;
819 done:
820         p->p_flag &= ~P_SELECT;
821         /* select is not restarted after signals... */
822         if (error == ERESTART)
823                 error = EINTR;
824         if (error == EWOULDBLOCK)
825                 error = 0;
826 #define putbits(name, x) \
827         if (uap->name && (error2 = copyout(obits[x], uap->name, ncpbytes))) \
828                 error = error2;
829         if (error == 0) {
830                 int error2;
831
832                 putbits(in, 0);
833                 putbits(ou, 1);
834                 putbits(ex, 2);
835 #undef putbits
836         }
837         if (selbits != &s_selbits[0])
838                 free(selbits, M_SELECT);
839         return (error);
840 }
841
842 static int
843 selscan(struct proc *p, fd_mask **ibits, fd_mask **obits, int nfd, int *res)
844 {
845         struct filedesc *fdp = p->p_fd;
846         int msk, i, fd;
847         fd_mask bits;
848         struct file *fp;
849         int n = 0;
850         /* Note: backend also returns POLLHUP/POLLERR if appropriate. */
851         static int flag[3] = { POLLRDNORM, POLLWRNORM, POLLRDBAND };
852
853         for (msk = 0; msk < 3; msk++) {
854                 if (ibits[msk] == NULL)
855                         continue;
856                 for (i = 0; i < nfd; i += NFDBITS) {
857                         bits = ibits[msk][i/NFDBITS];
858                         /* ffs(int mask) not portable, fd_mask is long */
859                         for (fd = i; bits && fd < nfd; fd++, bits >>= 1) {
860                                 if (!(bits & 1))
861                                         continue;
862                                 fp = fdp->fd_files[fd].fp;
863                                 if (fp == NULL)
864                                         return (EBADF);
865                                 if (fo_poll(fp, flag[msk], fp->f_cred)) {
866                                         obits[msk][(fd)/NFDBITS] |=
867                                             ((fd_mask)1 << ((fd) % NFDBITS));
868                                         n++;
869                                 }
870                         }
871                 }
872         }
873         *res = n;
874         return (0);
875 }
876
877 /*
878  * Poll system call.
879  */
880 int
881 poll(struct poll_args *uap)
882 {
883         struct pollfd *bits;
884         struct pollfd smallbits[32];
885         struct timeval atv, rtv, ttv;
886         int ncoll, error = 0, timo;
887         u_int nfds;
888         size_t ni;
889         struct proc *p = curproc;
890
891         nfds = uap->nfds;
892         /*
893          * This is kinda bogus.  We have fd limits, but that is not
894          * really related to the size of the pollfd array.  Make sure
895          * we let the process use at least FD_SETSIZE entries and at
896          * least enough for the current limits.  We want to be reasonably
897          * safe, but not overly restrictive.
898          */
899         if (nfds > p->p_rlimit[RLIMIT_NOFILE].rlim_cur && nfds > FD_SETSIZE)
900                 return (EINVAL);
901         ni = nfds * sizeof(struct pollfd);
902         if (ni > sizeof(smallbits))
903                 bits = malloc(ni, M_TEMP, M_WAITOK);
904         else
905                 bits = smallbits;
906         error = copyin(uap->fds, bits, ni);
907         if (error)
908                 goto done;
909         if (uap->timeout != INFTIM) {
910                 atv.tv_sec = uap->timeout / 1000;
911                 atv.tv_usec = (uap->timeout % 1000) * 1000;
912                 if (itimerfix(&atv)) {
913                         error = EINVAL;
914                         goto done;
915                 }
916                 getmicrouptime(&rtv);
917                 timevaladd(&atv, &rtv);
918         } else {
919                 atv.tv_sec = 0;
920                 atv.tv_usec = 0;
921         }
922         timo = 0;
923 retry:
924         ncoll = nselcoll;
925         p->p_flag |= P_SELECT;
926         error = pollscan(p, bits, nfds, &uap->sysmsg_result);
927         if (error || uap->sysmsg_result)
928                 goto done;
929         if (atv.tv_sec || atv.tv_usec) {
930                 getmicrouptime(&rtv);
931                 if (timevalcmp(&rtv, &atv, >=))
932                         goto done;
933                 ttv = atv;
934                 timevalsub(&ttv, &rtv);
935                 timo = ttv.tv_sec > 24 * 60 * 60 ?
936                     24 * 60 * 60 * hz : tvtohz_high(&ttv);
937         } 
938         crit_enter();
939         if ((p->p_flag & P_SELECT) == 0 || nselcoll != ncoll) {
940                 crit_exit();
941                 goto retry;
942         }
943         p->p_flag &= ~P_SELECT;
944         error = tsleep((caddr_t)&selwait, PCATCH, "poll", timo);
945         crit_exit();
946         if (error == 0)
947                 goto retry;
948 done:
949         p->p_flag &= ~P_SELECT;
950         /* poll is not restarted after signals... */
951         if (error == ERESTART)
952                 error = EINTR;
953         if (error == EWOULDBLOCK)
954                 error = 0;
955         if (error == 0) {
956                 error = copyout(bits, uap->fds, ni);
957                 if (error)
958                         goto out;
959         }
960 out:
961         if (ni > sizeof(smallbits))
962                 free(bits, M_TEMP);
963         return (error);
964 }
965
966 static int
967 pollscan(struct proc *p, struct pollfd *fds, u_int nfd, int *res)
968 {
969         struct filedesc *fdp = p->p_fd;
970         int i;
971         struct file *fp;
972         int n = 0;
973
974         for (i = 0; i < nfd; i++, fds++) {
975                 if (fds->fd >= fdp->fd_nfiles) {
976                         fds->revents = POLLNVAL;
977                         n++;
978                 } else if (fds->fd < 0) {
979                         fds->revents = 0;
980                 } else {
981                         fp = fdp->fd_files[fds->fd].fp;
982                         if (fp == NULL) {
983                                 fds->revents = POLLNVAL;
984                                 n++;
985                         } else {
986                                 /*
987                                  * Note: backend also returns POLLHUP and
988                                  * POLLERR if appropriate.
989                                  */
990                                 fds->revents = fo_poll(fp, fds->events,
991                                                         fp->f_cred);
992                                 if (fds->revents != 0)
993                                         n++;
994                         }
995                 }
996         }
997         *res = n;
998         return (0);
999 }
1000
1001 /*
1002  * OpenBSD poll system call.
1003  * XXX this isn't quite a true representation..  OpenBSD uses select ops.
1004  */
1005 int
1006 openbsd_poll(struct openbsd_poll_args *uap)
1007 {
1008         return (poll((struct poll_args *)uap));
1009 }
1010
1011 /*ARGSUSED*/
1012 int
1013 seltrue(dev_t dev, int events, struct thread *td)
1014 {
1015         return (events & (POLLIN | POLLOUT | POLLRDNORM | POLLWRNORM));
1016 }
1017
1018 /*
1019  * Record a select request.  A global wait must be used since a process/thread
1020  * might go away after recording its request.
1021  */
1022 void
1023 selrecord(struct thread *selector, struct selinfo *sip)
1024 {
1025         struct proc *p;
1026         pid_t mypid;
1027
1028         if ((p = selector->td_proc) == NULL)
1029                 panic("selrecord: thread needs a process");
1030
1031         mypid = p->p_pid;
1032         if (sip->si_pid == mypid)
1033                 return;
1034         if (sip->si_pid && (p = pfind(sip->si_pid)) &&
1035             p->p_wchan == (caddr_t)&selwait) {
1036                 sip->si_flags |= SI_COLL;
1037         } else {
1038                 sip->si_pid = mypid;
1039         }
1040 }
1041
1042 /*
1043  * Do a wakeup when a selectable event occurs.
1044  */
1045 void
1046 selwakeup(struct selinfo *sip)
1047 {
1048         struct proc *p;
1049
1050         if (sip->si_pid == 0)
1051                 return;
1052         if (sip->si_flags & SI_COLL) {
1053                 nselcoll++;
1054                 sip->si_flags &= ~SI_COLL;
1055                 wakeup((caddr_t)&selwait);      /* YYY fixable */
1056         }
1057         p = pfind(sip->si_pid);
1058         sip->si_pid = 0;
1059         if (p != NULL) {
1060                 crit_enter();
1061                 if (p->p_wchan == (caddr_t)&selwait) {
1062                         /*
1063                          * Flag the process to break the tsleep when 
1064                          * setrunnable is called, but only call setrunnable
1065                          * here if the process is not in a stopped state.
1066                          */
1067                         p->p_flag |= P_BREAKTSLEEP;
1068                         if ((p->p_flag & P_STOPPED) == 0)
1069                                 setrunnable(p);
1070                 } else if (p->p_flag & P_SELECT) {
1071                         p->p_flag &= ~P_SELECT;
1072                 }
1073                 crit_exit();
1074         }
1075 }
1076