Merge from vendor branch TCSH:
[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.47 2008/01/10 22:30:27 nth 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      doselect(int nd, fd_set *in, fd_set *ou, fd_set *ex,
81                         struct timeval *tv, int *res);
82 static int      pollscan (struct proc *, struct pollfd *, u_int, int *);
83 static int      selscan (struct proc *, fd_mask **, fd_mask **,
84                         int, int *);
85 static int      dofileread(int, struct file *, struct uio *, int, int *);
86 static int      dofilewrite(int, struct file *, struct uio *, int, int *);
87
88 /*
89  * Read system call.
90  *
91  * MPSAFE
92  */
93 int
94 sys_read(struct read_args *uap)
95 {
96         struct thread *td = curthread;
97         struct uio auio;
98         struct iovec aiov;
99         int error;
100
101         aiov.iov_base = uap->buf;
102         aiov.iov_len = uap->nbyte;
103         auio.uio_iov = &aiov;
104         auio.uio_iovcnt = 1;
105         auio.uio_offset = -1;
106         auio.uio_resid = uap->nbyte;
107         auio.uio_rw = UIO_READ;
108         auio.uio_segflg = UIO_USERSPACE;
109         auio.uio_td = td;
110
111         if (auio.uio_resid < 0)
112                 error = EINVAL;
113         else
114                 error = kern_preadv(uap->fd, &auio, 0, &uap->sysmsg_result);
115         return(error);
116 }
117
118 /*
119  * Positioned (Pread) read system call
120  *
121  * MPSAFE
122  */
123 int
124 sys_extpread(struct extpread_args *uap)
125 {
126         struct thread *td = curthread;
127         struct uio auio;
128         struct iovec aiov;
129         int error;
130         int flags;
131
132         aiov.iov_base = uap->buf;
133         aiov.iov_len = uap->nbyte;
134         auio.uio_iov = &aiov;
135         auio.uio_iovcnt = 1;
136         auio.uio_offset = uap->offset;
137         auio.uio_resid = uap->nbyte;
138         auio.uio_rw = UIO_READ;
139         auio.uio_segflg = UIO_USERSPACE;
140         auio.uio_td = td;
141
142         flags = uap->flags & O_FMASK;
143         if (uap->offset != (off_t)-1)
144                 flags |= O_FOFFSET;
145
146         if (auio.uio_resid < 0)
147                 error = EINVAL;
148         else
149                 error = kern_preadv(uap->fd, &auio, flags, &uap->sysmsg_result);
150         return(error);
151 }
152
153 /*
154  * Scatter read system call.
155  *
156  * MPSAFE
157  */
158 int
159 sys_readv(struct readv_args *uap)
160 {
161         struct thread *td = curthread;
162         struct uio auio;
163         struct iovec aiov[UIO_SMALLIOV], *iov = NULL;
164         int error;
165
166         error = iovec_copyin(uap->iovp, &iov, aiov, uap->iovcnt,
167                              &auio.uio_resid);
168         if (error)
169                 return (error);
170         auio.uio_iov = iov;
171         auio.uio_iovcnt = uap->iovcnt;
172         auio.uio_offset = -1;
173         auio.uio_rw = UIO_READ;
174         auio.uio_segflg = UIO_USERSPACE;
175         auio.uio_td = td;
176
177         error = kern_preadv(uap->fd, &auio, 0, &uap->sysmsg_result);
178
179         iovec_free(&iov, aiov);
180         return (error);
181 }
182
183
184 /*
185  * Scatter positioned read system call.
186  *
187  * MPSAFE
188  */
189 int
190 sys_extpreadv(struct extpreadv_args *uap)
191 {
192         struct thread *td = curthread;
193         struct uio auio;
194         struct iovec aiov[UIO_SMALLIOV], *iov = NULL;
195         int error;
196         int flags;
197
198         error = iovec_copyin(uap->iovp, &iov, aiov, uap->iovcnt,
199                              &auio.uio_resid);
200         if (error)
201                 return (error);
202         auio.uio_iov = iov;
203         auio.uio_iovcnt = uap->iovcnt;
204         auio.uio_offset = uap->offset;
205         auio.uio_rw = UIO_READ;
206         auio.uio_segflg = UIO_USERSPACE;
207         auio.uio_td = td;
208
209         flags = uap->flags & O_FMASK;
210         if (uap->offset != (off_t)-1)
211                 flags |= O_FOFFSET;
212
213         error = kern_preadv(uap->fd, &auio, flags, &uap->sysmsg_result);
214
215         iovec_free(&iov, aiov);
216         return(error);
217 }
218
219 /*
220  * MPSAFE
221  */
222 int
223 kern_preadv(int fd, struct uio *auio, int flags, int *res)
224 {
225         struct thread *td = curthread;
226         struct proc *p = td->td_proc;
227         struct file *fp;
228         int error;
229
230         KKASSERT(p);
231
232         fp = holdfp(p->p_fd, fd, FREAD);
233         if (fp == NULL)
234                 return (EBADF);
235         if (flags & O_FOFFSET && fp->f_type != DTYPE_VNODE) {
236                 error = ESPIPE;
237         } else if (auio->uio_resid < 0) {
238                 error = EINVAL;
239         } else {
240                 error = dofileread(fd, fp, auio, flags, res);
241         }
242         fdrop(fp);
243         return(error);
244 }
245
246 /*
247  * Common code for readv and preadv that reads data in
248  * from a file using the passed in uio, offset, and flags.
249  *
250  * MPALMOSTSAFE - ktrace needs help
251  */
252 static int
253 dofileread(int fd, struct file *fp, struct uio *auio, int flags, int *res)
254 {
255         struct thread *td = curthread;
256         struct proc *p = td->td_proc;
257         int error;
258         int len;
259 #ifdef KTRACE
260         struct iovec *ktriov = NULL;
261         struct uio ktruio;
262 #endif
263
264 #ifdef KTRACE
265         /*
266          * if tracing, save a copy of iovec
267          */
268         if (KTRPOINT(td, KTR_GENIO))  {
269                 int iovlen = auio->uio_iovcnt * sizeof(struct iovec);
270
271                 MALLOC(ktriov, struct iovec *, iovlen, M_TEMP, M_WAITOK);
272                 bcopy((caddr_t)auio->uio_iov, (caddr_t)ktriov, iovlen);
273                 ktruio = *auio;
274         }
275 #endif
276         len = auio->uio_resid;
277         error = fo_read(fp, auio, fp->f_cred, flags);
278         if (error) {
279                 if (auio->uio_resid != len && (error == ERESTART ||
280                     error == EINTR || error == EWOULDBLOCK))
281                         error = 0;
282         }
283 #ifdef KTRACE
284         if (ktriov != NULL) {
285                 if (error == 0) {
286                         ktruio.uio_iov = ktriov;
287                         ktruio.uio_resid = len - auio->uio_resid;
288                         get_mplock();
289                         ktrgenio(p, fd, UIO_READ, &ktruio, error);
290                         rel_mplock();
291                 }
292                 FREE(ktriov, M_TEMP);
293         }
294 #endif
295         if (error == 0)
296                 *res = len - auio->uio_resid;
297
298         return(error);
299 }
300
301 /*
302  * Write system call
303  *
304  * MPSAFE
305  */
306 int
307 sys_write(struct write_args *uap)
308 {
309         struct thread *td = curthread;
310         struct uio auio;
311         struct iovec aiov;
312         int error;
313
314         aiov.iov_base = (void *)(uintptr_t)uap->buf;
315         aiov.iov_len = uap->nbyte;
316         auio.uio_iov = &aiov;
317         auio.uio_iovcnt = 1;
318         auio.uio_offset = -1;
319         auio.uio_resid = uap->nbyte;
320         auio.uio_rw = UIO_WRITE;
321         auio.uio_segflg = UIO_USERSPACE;
322         auio.uio_td = td;
323
324         if (auio.uio_resid < 0)
325                 error = EINVAL;
326         else
327                 error = kern_pwritev(uap->fd, &auio, 0, &uap->sysmsg_result);
328
329         return(error);
330 }
331
332 /*
333  * Pwrite system call
334  *
335  * MPSAFE
336  */
337 int
338 sys_extpwrite(struct extpwrite_args *uap)
339 {
340         struct thread *td = curthread;
341         struct uio auio;
342         struct iovec aiov;
343         int error;
344         int flags;
345
346         aiov.iov_base = (void *)(uintptr_t)uap->buf;
347         aiov.iov_len = uap->nbyte;
348         auio.uio_iov = &aiov;
349         auio.uio_iovcnt = 1;
350         auio.uio_offset = uap->offset;
351         auio.uio_resid = uap->nbyte;
352         auio.uio_rw = UIO_WRITE;
353         auio.uio_segflg = UIO_USERSPACE;
354         auio.uio_td = td;
355
356         flags = uap->flags & O_FMASK;
357         if (uap->offset != (off_t)-1)
358                 flags |= O_FOFFSET;
359
360         if (auio.uio_resid < 0)
361                 error = EINVAL;
362         else
363                 error = kern_pwritev(uap->fd, &auio, flags, &uap->sysmsg_result);
364
365         return(error);
366 }
367
368 /*
369  * MPSAFE
370  */
371 int
372 sys_writev(struct writev_args *uap)
373 {
374         struct thread *td = curthread;
375         struct uio auio;
376         struct iovec aiov[UIO_SMALLIOV], *iov = NULL;
377         int error;
378
379         error = iovec_copyin(uap->iovp, &iov, aiov, uap->iovcnt,
380                              &auio.uio_resid);
381         if (error)
382                 return (error);
383         auio.uio_iov = iov;
384         auio.uio_iovcnt = uap->iovcnt;
385         auio.uio_offset = -1;
386         auio.uio_rw = UIO_WRITE;
387         auio.uio_segflg = UIO_USERSPACE;
388         auio.uio_td = td;
389
390         error = kern_pwritev(uap->fd, &auio, 0, &uap->sysmsg_result);
391
392         iovec_free(&iov, aiov);
393         return (error);
394 }
395
396
397 /*
398  * Gather positioned write system call
399  *
400  * MPSAFE
401  */
402 int
403 sys_extpwritev(struct extpwritev_args *uap)
404 {
405         struct thread *td = curthread;
406         struct uio auio;
407         struct iovec aiov[UIO_SMALLIOV], *iov = NULL;
408         int error;
409         int flags;
410
411         error = iovec_copyin(uap->iovp, &iov, aiov, uap->iovcnt,
412                              &auio.uio_resid);
413         if (error)
414                 return (error);
415         auio.uio_iov = iov;
416         auio.uio_iovcnt = uap->iovcnt;
417         auio.uio_offset = uap->offset;
418         auio.uio_rw = UIO_WRITE;
419         auio.uio_segflg = UIO_USERSPACE;
420         auio.uio_td = td;
421
422         flags = uap->flags & O_FMASK;
423         if (uap->offset != (off_t)-1)
424                 flags |= O_FOFFSET;
425
426         error = kern_pwritev(uap->fd, &auio, flags, &uap->sysmsg_result);
427
428         iovec_free(&iov, aiov);
429         return(error);
430 }
431
432 /*
433  * MPSAFE
434  */
435 int
436 kern_pwritev(int fd, struct uio *auio, int flags, int *res)
437 {
438         struct thread *td = curthread;
439         struct proc *p = td->td_proc;
440         struct file *fp;
441         int error;
442
443         KKASSERT(p);
444
445         fp = holdfp(p->p_fd, fd, FWRITE);
446         if (fp == NULL)
447                 return (EBADF);
448         else if ((flags & O_FOFFSET) && fp->f_type != DTYPE_VNODE) {
449                 error = ESPIPE;
450         } else {
451                 error = dofilewrite(fd, fp, auio, flags, res);
452         }
453         
454         fdrop(fp);
455         return (error);
456 }
457
458 /*
459  * Common code for writev and pwritev that writes data to
460  * a file using the passed in uio, offset, and flags.
461  *
462  * MPALMOSTSAFE - ktrace needs help
463  */
464 static int
465 dofilewrite(int fd, struct file *fp, struct uio *auio, int flags, int *res)
466 {       
467         struct thread *td = curthread;
468         struct lwp *lp = td->td_lwp;
469         struct proc *p = td->td_proc;
470         int error;
471         int len;
472 #ifdef KTRACE
473         struct iovec *ktriov = NULL;
474         struct uio ktruio;
475 #endif
476
477 #ifdef KTRACE
478         /*
479          * if tracing, save a copy of iovec and uio
480          */
481         if (KTRPOINT(td, KTR_GENIO))  {
482                 int iovlen = auio->uio_iovcnt * sizeof(struct iovec);
483
484                 MALLOC(ktriov, struct iovec *, iovlen, M_TEMP, M_WAITOK);
485                 bcopy((caddr_t)auio->uio_iov, (caddr_t)ktriov, iovlen);
486                 ktruio = *auio;
487         }
488 #endif
489         len = auio->uio_resid;
490         if (fp->f_type == DTYPE_VNODE)
491                 bwillwrite();
492         error = fo_write(fp, auio, fp->f_cred, flags);
493         if (error) {
494                 if (auio->uio_resid != len && (error == ERESTART ||
495                     error == EINTR || error == EWOULDBLOCK))
496                         error = 0;
497                 /* Socket layer is responsible for issuing SIGPIPE. */
498                 if (error == EPIPE) {
499                         get_mplock();
500                         lwpsignal(p, lp, SIGPIPE);
501                         rel_mplock();
502                 }
503         }
504 #ifdef KTRACE
505         if (ktriov != NULL) {
506                 if (error == 0) {
507                         ktruio.uio_iov = ktriov;
508                         ktruio.uio_resid = len - auio->uio_resid;
509                         get_mplock();
510                         ktrgenio(p, fd, UIO_WRITE, &ktruio, error);
511                         rel_mplock();
512                 }
513                 FREE(ktriov, M_TEMP);
514         }
515 #endif
516         if (error == 0)
517                 *res = len - auio->uio_resid;
518
519         return(error);
520 }
521
522 /*
523  * Ioctl system call
524  */
525 /* ARGSUSED */
526 int
527 sys_ioctl(struct ioctl_args *uap)
528 {
529         return(mapped_ioctl(uap->fd, uap->com, uap->data, NULL));
530 }
531
532 struct ioctl_map_entry {
533         const char *subsys;
534         struct ioctl_map_range *cmd_ranges;
535         LIST_ENTRY(ioctl_map_entry) entries;
536 };
537
538 /*
539  * The true heart of all ioctl syscall handlers (native, emulation).
540  * If map != NULL, it will be searched for a matching entry for com,
541  * and appropriate conversions/conversion functions will be utilized.
542  */
543 int
544 mapped_ioctl(int fd, u_long com, caddr_t uspc_data, struct ioctl_map *map)
545 {
546         struct thread *td = curthread;
547         struct proc *p = td->td_proc;
548         struct ucred *cred;
549         struct file *fp;
550         struct ioctl_map_range *iomc = NULL;
551         int error;
552         u_int size;
553         u_long ocom = com;
554         caddr_t data, memp;
555         int tmp;
556 #define STK_PARAMS      128
557         union {
558             char stkbuf[STK_PARAMS];
559             long align;
560         } ubuf;
561
562         KKASSERT(p);
563         cred = p->p_ucred;
564
565         fp = holdfp(p->p_fd, fd, FREAD|FWRITE);
566         if (fp == NULL)
567                 return(EBADF);
568
569         if (map != NULL) {      /* obey translation map */
570                 u_long maskcmd;
571                 struct ioctl_map_entry *e;
572
573                 maskcmd = com & map->mask;
574
575                 LIST_FOREACH(e, &map->mapping, entries) {
576                         for (iomc = e->cmd_ranges; iomc->start != 0 ||
577                              iomc->maptocmd != 0 || iomc->wrapfunc != NULL ||
578                              iomc->mapfunc != NULL;
579                              iomc++) {
580                                 if (maskcmd >= iomc->start &&
581                                     maskcmd <= iomc->end)
582                                         break;
583                         }
584
585                         /* Did we find a match? */
586                         if (iomc->start != 0 || iomc->maptocmd != 0 ||
587                             iomc->wrapfunc != NULL || iomc->mapfunc != NULL)
588                                 break;
589                 }
590
591                 if (iomc == NULL ||
592                     (iomc->start == 0 && iomc->maptocmd == 0
593                      && iomc->wrapfunc == NULL && iomc->mapfunc == NULL)) {
594                         kprintf("%s: 'ioctl' fd=%d, cmd=0x%lx ('%c',%d) not implemented\n",
595                                map->sys, fd, maskcmd,
596                                (int)((maskcmd >> 8) & 0xff),
597                                (int)(maskcmd & 0xff));
598                         error = EINVAL;
599                         goto done;
600                 }
601
602                 /*
603                  * If it's a non-range one to one mapping, maptocmd should be
604                  * correct. If it's a ranged one to one mapping, we pass the
605                  * original value of com, and for a range mapped to a different
606                  * range, we always need a mapping function to translate the
607                  * ioctl to our native ioctl. Ex. 6500-65ff <-> 9500-95ff
608                  */
609                 if (iomc->start == iomc->end && iomc->maptocmd == iomc->maptoend) {
610                         com = iomc->maptocmd;
611                 } else if (iomc->start == iomc->maptocmd && iomc->end == iomc->maptoend) {
612                         if (iomc->mapfunc != NULL)
613                                 com = iomc->mapfunc(iomc->start, iomc->end,
614                                                     iomc->start, iomc->end,
615                                                     com, com);
616                 } else {
617                         if (iomc->mapfunc != NULL) {
618                                 com = iomc->mapfunc(iomc->start, iomc->end,
619                                                     iomc->maptocmd, iomc->maptoend,
620                                                     com, ocom);
621                         } else {
622                                 kprintf("%s: Invalid mapping for fd=%d, cmd=%#lx ('%c',%d)\n",
623                                        map->sys, fd, maskcmd,
624                                        (int)((maskcmd >> 8) & 0xff),
625                                        (int)(maskcmd & 0xff));
626                                 error = EINVAL;
627                                 goto done;
628                         }
629                 }
630         }
631
632         switch (com) {
633         case FIONCLEX:
634                 error = fclrfdflags(p->p_fd, fd, UF_EXCLOSE);
635                 goto done;
636         case FIOCLEX:
637                 error = fsetfdflags(p->p_fd, fd, UF_EXCLOSE);
638                 goto done;
639         }
640
641         /*
642          * Interpret high order word to find amount of data to be
643          * copied to/from the user's address space.
644          */
645         size = IOCPARM_LEN(com);
646         if (size > IOCPARM_MAX) {
647                 error = ENOTTY;
648                 goto done;
649         }
650
651         memp = NULL;
652         if (size > sizeof (ubuf.stkbuf)) {
653                 memp = kmalloc(size, M_IOCTLOPS, M_WAITOK);
654                 data = memp;
655         } else {
656                 data = ubuf.stkbuf;
657         }
658         if ((com & IOC_IN) != 0) {
659                 if (size != 0) {
660                         error = copyin(uspc_data, data, (u_int)size);
661                         if (error) {
662                                 if (memp != NULL)
663                                         kfree(memp, M_IOCTLOPS);
664                                 goto done;
665                         }
666                 } else {
667                         *(caddr_t *)data = uspc_data;
668                 }
669         } else if ((com & IOC_OUT) != 0 && size) {
670                 /*
671                  * Zero the buffer so the user always
672                  * gets back something deterministic.
673                  */
674                 bzero(data, size);
675         } else if ((com & IOC_VOID) != 0) {
676                 *(caddr_t *)data = uspc_data;
677         }
678
679         switch (com) {
680         case FIONBIO:
681                 if ((tmp = *(int *)data))
682                         fp->f_flag |= FNONBLOCK;
683                 else
684                         fp->f_flag &= ~FNONBLOCK;
685                 error = 0;
686                 break;
687
688         case FIOASYNC:
689                 if ((tmp = *(int *)data))
690                         fp->f_flag |= FASYNC;
691                 else
692                         fp->f_flag &= ~FASYNC;
693                 error = fo_ioctl(fp, FIOASYNC, (caddr_t)&tmp, cred);
694                 break;
695
696         default:
697                 /*
698                  *  If there is a override function,
699                  *  call it instead of directly routing the call
700                  */
701                 if (map != NULL && iomc->wrapfunc != NULL)
702                         error = iomc->wrapfunc(fp, com, ocom, data, cred);
703                 else
704                         error = fo_ioctl(fp, com, data, cred);
705                 /*
706                  * Copy any data to user, size was
707                  * already set and checked above.
708                  */
709                 if (error == 0 && (com & IOC_OUT) != 0 && size != 0)
710                         error = copyout(data, uspc_data, (u_int)size);
711                 break;
712         }
713         if (memp != NULL)
714                 kfree(memp, M_IOCTLOPS);
715 done:
716         fdrop(fp);
717         return(error);
718 }
719
720 int
721 mapped_ioctl_register_handler(struct ioctl_map_handler *he)
722 {
723         struct ioctl_map_entry *ne;
724
725         KKASSERT(he != NULL && he->map != NULL && he->cmd_ranges != NULL &&
726                  he->subsys != NULL && *he->subsys != '\0');
727
728         ne = kmalloc(sizeof(struct ioctl_map_entry), M_IOCTLMAP, M_WAITOK);
729
730         ne->subsys = he->subsys;
731         ne->cmd_ranges = he->cmd_ranges;
732
733         LIST_INSERT_HEAD(&he->map->mapping, ne, entries);
734
735         return(0);
736 }
737
738 int
739 mapped_ioctl_unregister_handler(struct ioctl_map_handler *he)
740 {
741         struct ioctl_map_entry *ne;
742
743         KKASSERT(he != NULL && he->map != NULL && he->cmd_ranges != NULL);
744
745         LIST_FOREACH(ne, &he->map->mapping, entries) {
746                 if (ne->cmd_ranges != he->cmd_ranges)
747                         continue;
748                 LIST_REMOVE(ne, entries);
749                 kfree(ne, M_IOCTLMAP);
750                 return(0);
751         }
752         return(EINVAL);
753 }
754
755 static int      nselcoll;       /* Select collisions since boot */
756 int     selwait;
757 SYSCTL_INT(_kern, OID_AUTO, nselcoll, CTLFLAG_RD, &nselcoll, 0, "");
758
759 /*
760  * Select system call.
761  */
762 int
763 sys_select(struct select_args *uap)
764 {
765         struct timeval ktv;
766         struct timeval *ktvp;
767         int error;
768
769         /*
770          * Get timeout if any.
771          */
772         if (uap->tv != NULL) {
773                 error = copyin(uap->tv, &ktv, sizeof (ktv));
774                 if (error)
775                         return (error);
776                 error = itimerfix(&ktv);
777                 if (error)
778                         return (error);
779                 ktvp = &ktv;
780         } else {
781                 ktvp = NULL;
782         }
783
784         /*
785          * Do real work.
786          */
787         error = doselect(uap->nd, uap->in, uap->ou, uap->ex, ktvp,
788                         &uap->sysmsg_result);
789
790         return (error);
791 }
792
793
794 /*
795  * Pselect system call.
796  */
797 int
798 sys_pselect(struct pselect_args *uap)
799 {
800         struct thread *td = curthread;
801         struct lwp *lp = td->td_lwp;
802         struct timespec kts;
803         struct timeval ktv;
804         struct timeval *ktvp;
805         sigset_t sigmask;
806         int error;
807
808         /*
809          * Get timeout if any and convert it.
810          * Round up during conversion to avoid timeout going off early.
811          */
812         if (uap->ts != NULL) {
813                 error = copyin(uap->ts, &kts, sizeof (kts));
814                 if (error)
815                         return (error);
816                 ktv.tv_sec = kts.tv_sec;
817                 ktv.tv_usec = (kts.tv_nsec + 999) / 1000;
818                 error = itimerfix(&ktv);
819                 if (error)
820                         return (error);
821                 ktvp = &ktv;
822         } else {
823                 ktvp = NULL;
824         }
825
826         /*
827          * Install temporary signal mask if any provided.
828          */
829         if (uap->sigmask != NULL) {
830                 error = copyin(uap->sigmask, &sigmask, sizeof(sigmask));
831                 if (error)
832                         return (error);
833                 lp->lwp_oldsigmask = lp->lwp_sigmask;
834                 SIG_CANTMASK(sigmask);
835                 lp->lwp_sigmask = sigmask;
836         }
837
838         /*
839          * Do real job.
840          */
841         error = doselect(uap->nd, uap->in, uap->ou, uap->ex, ktvp,
842                         &uap->sysmsg_result);
843
844         if (uap->sigmask != NULL) {
845                 /* doselect() responsible for turning ERESTART into EINTR */
846                 KKASSERT(error != ERESTART);
847                 if (error == EINTR) {
848                         /*
849                          * We can't restore the previous signal mask now
850                          * because it could block the signal that interrupted
851                          * us.  So make a note to restore it after executing
852                          * the handler.
853                          */
854                         lp->lwp_flag |= LWP_OLDMASK;
855                 } else {
856                         /*
857                          * No handler to run. Restore previous mask immediately.
858                          */
859                         lp->lwp_sigmask = lp->lwp_oldsigmask;
860                 }
861         }
862
863         return (error);
864 }
865
866 /*
867  * Common code for sys_select() and sys_pselect().
868  *
869  * in, out and ex are userland pointers.  tv must point to validated
870  * kernel-side timeout value or NULL for infinite timeout.  res must
871  * point to syscall return value.
872  */
873 static int
874 doselect(int nd, fd_set *in, fd_set *ou, fd_set *ex, struct timeval *tv,
875                 int *res)
876 {
877         struct lwp *lp = curthread->td_lwp;
878         struct proc *p = curproc;
879
880         /*
881          * The magic 2048 here is chosen to be just enough for FD_SETSIZE
882          * infds with the new FD_SETSIZE of 1024, and more than enough for
883          * FD_SETSIZE infds, outfds and exceptfds with the old FD_SETSIZE
884          * of 256.
885          */
886         fd_mask s_selbits[howmany(2048, NFDBITS)];
887         fd_mask *ibits[3], *obits[3], *selbits, *sbp;
888         struct timeval atv, rtv, ttv;
889         int ncoll, error, timo;
890         u_int nbufbytes, ncpbytes, nfdbits;
891
892         if (nd < 0)
893                 return (EINVAL);
894         if (nd > p->p_fd->fd_nfiles)
895                 nd = p->p_fd->fd_nfiles;   /* forgiving; slightly wrong */
896
897         /*
898          * Allocate just enough bits for the non-null fd_sets.  Use the
899          * preallocated auto buffer if possible.
900          */
901         nfdbits = roundup(nd, NFDBITS);
902         ncpbytes = nfdbits / NBBY;
903         nbufbytes = 0;
904         if (in != NULL)
905                 nbufbytes += 2 * ncpbytes;
906         if (ou != NULL)
907                 nbufbytes += 2 * ncpbytes;
908         if (ex != NULL)
909                 nbufbytes += 2 * ncpbytes;
910         if (nbufbytes <= sizeof s_selbits)
911                 selbits = &s_selbits[0];
912         else
913                 selbits = kmalloc(nbufbytes, M_SELECT, M_WAITOK);
914
915         /*
916          * Assign pointers into the bit buffers and fetch the input bits.
917          * Put the output buffers together so that they can be bzeroed
918          * together.
919          */
920         sbp = selbits;
921 #define getbits(name, x) \
922         do {                                                            \
923                 if (name == NULL)                                       \
924                         ibits[x] = NULL;                                \
925                 else {                                                  \
926                         ibits[x] = sbp + nbufbytes / 2 / sizeof *sbp;   \
927                         obits[x] = sbp;                                 \
928                         sbp += ncpbytes / sizeof *sbp;                  \
929                         error = copyin(name, ibits[x], ncpbytes);       \
930                         if (error != 0)                                 \
931                                 goto done;                              \
932                 }                                                       \
933         } while (0)
934         getbits(in, 0);
935         getbits(ou, 1);
936         getbits(ex, 2);
937 #undef  getbits
938         if (nbufbytes != 0)
939                 bzero(selbits, nbufbytes / 2);
940
941         if (tv != NULL) {
942                 atv = *tv;
943                 getmicrouptime(&rtv);
944                 timevaladd(&atv, &rtv);
945         } else {
946                 atv.tv_sec = 0;
947                 atv.tv_usec = 0;
948         }
949         timo = 0;
950 retry:
951         ncoll = nselcoll;
952         lp->lwp_flag |= LWP_SELECT;
953         error = selscan(p, ibits, obits, nd, res);
954         if (error || *res)
955                 goto done;
956         if (atv.tv_sec || atv.tv_usec) {
957                 getmicrouptime(&rtv);
958                 if (timevalcmp(&rtv, &atv, >=))
959                         goto done;
960                 ttv = atv;
961                 timevalsub(&ttv, &rtv);
962                 timo = ttv.tv_sec > 24 * 60 * 60 ?
963                     24 * 60 * 60 * hz : tvtohz_high(&ttv);
964         }
965         crit_enter();
966         if ((lp->lwp_flag & LWP_SELECT) == 0 || nselcoll != ncoll) {
967                 crit_exit();
968                 goto retry;
969         }
970         lp->lwp_flag &= ~LWP_SELECT;
971
972         error = tsleep((caddr_t)&selwait, PCATCH, "select", timo);
973         
974         crit_exit();
975         if (error == 0)
976                 goto retry;
977 done:
978         lp->lwp_flag &= ~LWP_SELECT;
979         /* select is not restarted after signals... */
980         if (error == ERESTART)
981                 error = EINTR;
982         if (error == EWOULDBLOCK)
983                 error = 0;
984 #define putbits(name, x) \
985         if (name && (error2 = copyout(obits[x], name, ncpbytes))) \
986                 error = error2;
987         if (error == 0) {
988                 int error2;
989
990                 putbits(in, 0);
991                 putbits(ou, 1);
992                 putbits(ex, 2);
993 #undef putbits
994         }
995         if (selbits != &s_selbits[0])
996                 kfree(selbits, M_SELECT);
997         return (error);
998 }
999
1000 static int
1001 selscan(struct proc *p, fd_mask **ibits, fd_mask **obits, int nfd, int *res)
1002 {
1003         int msk, i, fd;
1004         fd_mask bits;
1005         struct file *fp;
1006         int n = 0;
1007         /* Note: backend also returns POLLHUP/POLLERR if appropriate. */
1008         static int flag[3] = { POLLRDNORM, POLLWRNORM, POLLRDBAND };
1009
1010         for (msk = 0; msk < 3; msk++) {
1011                 if (ibits[msk] == NULL)
1012                         continue;
1013                 for (i = 0; i < nfd; i += NFDBITS) {
1014                         bits = ibits[msk][i/NFDBITS];
1015                         /* ffs(int mask) not portable, fd_mask is long */
1016                         for (fd = i; bits && fd < nfd; fd++, bits >>= 1) {
1017                                 if (!(bits & 1))
1018                                         continue;
1019                                 fp = holdfp(p->p_fd, fd, -1);
1020                                 if (fp == NULL)
1021                                         return (EBADF);
1022                                 if (fo_poll(fp, flag[msk], fp->f_cred)) {
1023                                         obits[msk][(fd)/NFDBITS] |=
1024                                             ((fd_mask)1 << ((fd) % NFDBITS));
1025                                         n++;
1026                                 }
1027                                 fdrop(fp);
1028                         }
1029                 }
1030         }
1031         *res = n;
1032         return (0);
1033 }
1034
1035 /*
1036  * Poll system call.
1037  */
1038 int
1039 sys_poll(struct poll_args *uap)
1040 {
1041         struct pollfd *bits;
1042         struct pollfd smallbits[32];
1043         struct timeval atv, rtv, ttv;
1044         int ncoll, error = 0, timo;
1045         u_int nfds;
1046         size_t ni;
1047         struct lwp *lp = curthread->td_lwp;
1048         struct proc *p = curproc;
1049
1050         nfds = uap->nfds;
1051         /*
1052          * This is kinda bogus.  We have fd limits, but that is not
1053          * really related to the size of the pollfd array.  Make sure
1054          * we let the process use at least FD_SETSIZE entries and at
1055          * least enough for the current limits.  We want to be reasonably
1056          * safe, but not overly restrictive.
1057          */
1058         if (nfds > p->p_rlimit[RLIMIT_NOFILE].rlim_cur && nfds > FD_SETSIZE)
1059                 return (EINVAL);
1060         ni = nfds * sizeof(struct pollfd);
1061         if (ni > sizeof(smallbits))
1062                 bits = kmalloc(ni, M_TEMP, M_WAITOK);
1063         else
1064                 bits = smallbits;
1065         error = copyin(uap->fds, bits, ni);
1066         if (error)
1067                 goto done;
1068         if (uap->timeout != INFTIM) {
1069                 atv.tv_sec = uap->timeout / 1000;
1070                 atv.tv_usec = (uap->timeout % 1000) * 1000;
1071                 if (itimerfix(&atv)) {
1072                         error = EINVAL;
1073                         goto done;
1074                 }
1075                 getmicrouptime(&rtv);
1076                 timevaladd(&atv, &rtv);
1077         } else {
1078                 atv.tv_sec = 0;
1079                 atv.tv_usec = 0;
1080         }
1081         timo = 0;
1082 retry:
1083         ncoll = nselcoll;
1084         lp->lwp_flag |= LWP_SELECT;
1085         error = pollscan(p, bits, nfds, &uap->sysmsg_result);
1086         if (error || uap->sysmsg_result)
1087                 goto done;
1088         if (atv.tv_sec || atv.tv_usec) {
1089                 getmicrouptime(&rtv);
1090                 if (timevalcmp(&rtv, &atv, >=))
1091                         goto done;
1092                 ttv = atv;
1093                 timevalsub(&ttv, &rtv);
1094                 timo = ttv.tv_sec > 24 * 60 * 60 ?
1095                     24 * 60 * 60 * hz : tvtohz_high(&ttv);
1096         } 
1097         crit_enter();
1098         if ((lp->lwp_flag & LWP_SELECT) == 0 || nselcoll != ncoll) {
1099                 crit_exit();
1100                 goto retry;
1101         }
1102         lp->lwp_flag &= ~LWP_SELECT;
1103         error = tsleep((caddr_t)&selwait, PCATCH, "poll", timo);
1104         crit_exit();
1105         if (error == 0)
1106                 goto retry;
1107 done:
1108         lp->lwp_flag &= ~LWP_SELECT;
1109         /* poll is not restarted after signals... */
1110         if (error == ERESTART)
1111                 error = EINTR;
1112         if (error == EWOULDBLOCK)
1113                 error = 0;
1114         if (error == 0) {
1115                 error = copyout(bits, uap->fds, ni);
1116                 if (error)
1117                         goto out;
1118         }
1119 out:
1120         if (ni > sizeof(smallbits))
1121                 kfree(bits, M_TEMP);
1122         return (error);
1123 }
1124
1125 static int
1126 pollscan(struct proc *p, struct pollfd *fds, u_int nfd, int *res)
1127 {
1128         int i;
1129         struct file *fp;
1130         int n = 0;
1131
1132         for (i = 0; i < nfd; i++, fds++) {
1133                 if (fds->fd >= p->p_fd->fd_nfiles) {
1134                         fds->revents = POLLNVAL;
1135                         n++;
1136                 } else if (fds->fd < 0) {
1137                         fds->revents = 0;
1138                 } else {
1139                         fp = holdfp(p->p_fd, fds->fd, -1);
1140                         if (fp == NULL) {
1141                                 fds->revents = POLLNVAL;
1142                                 n++;
1143                         } else {
1144                                 /*
1145                                  * Note: backend also returns POLLHUP and
1146                                  * POLLERR if appropriate.
1147                                  */
1148                                 fds->revents = fo_poll(fp, fds->events,
1149                                                         fp->f_cred);
1150                                 if (fds->revents != 0)
1151                                         n++;
1152                                 fdrop(fp);
1153                         }
1154                 }
1155         }
1156         *res = n;
1157         return (0);
1158 }
1159
1160 /*
1161  * OpenBSD poll system call.
1162  * XXX this isn't quite a true representation..  OpenBSD uses select ops.
1163  */
1164 int
1165 sys_openbsd_poll(struct openbsd_poll_args *uap)
1166 {
1167         return (sys_poll((struct poll_args *)uap));
1168 }
1169
1170 /*ARGSUSED*/
1171 int
1172 seltrue(cdev_t dev, int events)
1173 {
1174         return (events & (POLLIN | POLLOUT | POLLRDNORM | POLLWRNORM));
1175 }
1176
1177 /*
1178  * Record a select request.  A global wait must be used since a process/thread
1179  * might go away after recording its request.
1180  */
1181 void
1182 selrecord(struct thread *selector, struct selinfo *sip)
1183 {
1184         struct proc *p;
1185         struct lwp *lp = NULL;
1186
1187         if (selector->td_lwp == NULL)
1188                 panic("selrecord: thread needs a process");
1189
1190         if (sip->si_pid == selector->td_proc->p_pid &&
1191             sip->si_tid == selector->td_lwp->lwp_tid)
1192                 return;
1193         if (sip->si_pid && (p = pfind(sip->si_pid)))
1194                 lp = lwp_rb_tree_RB_LOOKUP(&p->p_lwp_tree, sip->si_tid);
1195         if (lp != NULL && lp->lwp_wchan == (caddr_t)&selwait) {
1196                 sip->si_flags |= SI_COLL;
1197         } else {
1198                 sip->si_pid = selector->td_proc->p_pid;
1199                 sip->si_tid = selector->td_lwp->lwp_tid;
1200         }
1201 }
1202
1203 /*
1204  * Do a wakeup when a selectable event occurs.
1205  */
1206 void
1207 selwakeup(struct selinfo *sip)
1208 {
1209         struct proc *p;
1210         struct lwp *lp = NULL;
1211
1212         if (sip->si_pid == 0)
1213                 return;
1214         if (sip->si_flags & SI_COLL) {
1215                 nselcoll++;
1216                 sip->si_flags &= ~SI_COLL;
1217                 wakeup((caddr_t)&selwait);      /* YYY fixable */
1218         }
1219         p = pfind(sip->si_pid);
1220         sip->si_pid = 0;
1221         if (p == NULL)
1222                 return;
1223         lp = lwp_rb_tree_RB_LOOKUP(&p->p_lwp_tree, sip->si_tid);
1224         if (lp == NULL)
1225                 return;
1226
1227         crit_enter();
1228         if (lp->lwp_wchan == (caddr_t)&selwait) {
1229                 /*
1230                  * Flag the process to break the tsleep when
1231                  * setrunnable is called, but only call setrunnable
1232                  * here if the process is not in a stopped state.
1233                  */
1234                 lp->lwp_flag |= LWP_BREAKTSLEEP;
1235                 if (p->p_stat != SSTOP)
1236                         setrunnable(lp);
1237         } else if (lp->lwp_flag & LWP_SELECT) {
1238                 lp->lwp_flag &= ~LWP_SELECT;
1239         }
1240         crit_exit();
1241 }
1242