1 /*-
2 * SPDX-License-Identifier: BSD-3-Clause
3 *
4 * Copyright (c) 1982, 1986, 1989, 1993
5 * The Regents of the University of California. All rights reserved.
6 * (c) UNIX System Laboratories, Inc.
7 * All or some portions of this file are derived from material licensed
8 * to the University of California by American Telephone and Telegraph
9 * Co. or Unix System Laboratories, Inc. and are reproduced herein with
10 * the permission of UNIX System Laboratories, Inc.
11 *
12 * Redistribution and use in source and binary forms, with or without
13 * modification, are permitted provided that the following conditions
14 * are met:
15 * 1. Redistributions of source code must retain the above copyright
16 * notice, this list of conditions and the following disclaimer.
17 * 2. Redistributions in binary form must reproduce the above copyright
18 * notice, this list of conditions and the following disclaimer in the
19 * documentation and/or other materials provided with the distribution.
20 * 3. Neither the name of the University nor the names of its contributors
21 * may be used to endorse or promote products derived from this software
22 * without specific prior written permission.
23 *
24 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
25 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34 * SUCH DAMAGE.
35 *
36 * @(#)sys_generic.c 8.5 (Berkeley) 1/21/94
37 */
38
39 #include <sys/cdefs.h>
40 __FBSDID("$FreeBSD$");
41
42 #include "opt_capsicum.h"
43 #include "opt_ktrace.h"
44
45 #include <sys/param.h>
46 #include <sys/systm.h>
47 #include <sys/sysproto.h>
48 #include <sys/capsicum.h>
49 #include <sys/filedesc.h>
50 #include <sys/filio.h>
51 #include <sys/fcntl.h>
52 #include <sys/file.h>
53 #include <sys/lock.h>
54 #include <sys/proc.h>
55 #include <sys/signalvar.h>
56 #include <sys/socketvar.h>
57 #include <sys/uio.h>
58 #include <sys/kernel.h>
59 #include <sys/ktr.h>
60 #include <sys/limits.h>
61 #include <sys/malloc.h>
62 #include <sys/poll.h>
63 #include <sys/resourcevar.h>
64 #include <sys/selinfo.h>
65 #include <sys/sleepqueue.h>
66 #include <sys/syscallsubr.h>
67 #include <sys/sysctl.h>
68 #include <sys/sysent.h>
69 #include <sys/vnode.h>
70 #include <sys/bio.h>
71 #include <sys/buf.h>
72 #include <sys/condvar.h>
73 #ifdef KTRACE
74 #include <sys/ktrace.h>
75 #endif
76
77 #include <security/audit/audit.h>
78
79 /*
80 * The following macro defines how many bytes will be allocated from
81 * the stack instead of memory allocated when passing the IOCTL data
82 * structures from userspace and to the kernel. Some IOCTLs having
83 * small data structures are used very frequently and this small
84 * buffer on the stack gives a significant speedup improvement for
85 * those requests. The value of this define should be greater or equal
86 * to 64 bytes and should also be power of two. The data structure is
87 * currently hard-aligned to a 8-byte boundary on the stack. This
88 * should currently be sufficient for all supported platforms.
89 */
90 #define SYS_IOCTL_SMALL_SIZE 128 /* bytes */
91 #define SYS_IOCTL_SMALL_ALIGN 8 /* bytes */
92
93 #ifdef __LP64__
94 static int iosize_max_clamp = 0;
95 SYSCTL_INT(_debug, OID_AUTO, iosize_max_clamp, CTLFLAG_RW,
96 &iosize_max_clamp, 0, "Clamp max i/o size to INT_MAX");
97 static int devfs_iosize_max_clamp = 1;
98 SYSCTL_INT(_debug, OID_AUTO, devfs_iosize_max_clamp, CTLFLAG_RW,
99 &devfs_iosize_max_clamp, 0, "Clamp max i/o size to INT_MAX for devices");
100 #endif
101
102 /*
103 * Assert that the return value of read(2) and write(2) syscalls fits
104 * into a register. If not, an architecture will need to provide the
105 * usermode wrappers to reconstruct the result.
106 */
107 CTASSERT(sizeof(register_t) >= sizeof(size_t));
108
109 static MALLOC_DEFINE(M_IOCTLOPS, "ioctlops", "ioctl data buffer");
110 static MALLOC_DEFINE(M_SELECT, "select", "select() buffer");
111 MALLOC_DEFINE(M_IOV, "iov", "large iov's");
112
113 static int pollout(struct thread *, struct pollfd *, struct pollfd *,
114 u_int);
115 static int pollscan(struct thread *, struct pollfd *, u_int);
116 static int pollrescan(struct thread *);
117 static int selscan(struct thread *, fd_mask **, fd_mask **, int);
118 static int selrescan(struct thread *, fd_mask **, fd_mask **);
119 static void selfdalloc(struct thread *, void *);
120 static void selfdfree(struct seltd *, struct selfd *);
121 static int dofileread(struct thread *, int, struct file *, struct uio *,
122 off_t, int);
123 static int dofilewrite(struct thread *, int, struct file *, struct uio *,
124 off_t, int);
125 static void doselwakeup(struct selinfo *, int);
126 static void seltdinit(struct thread *);
127 static int seltdwait(struct thread *, sbintime_t, sbintime_t);
128 static void seltdclear(struct thread *);
129
130 /*
131 * One seltd per-thread allocated on demand as needed.
132 *
133 * t - protected by st_mtx
134 * k - Only accessed by curthread or read-only
135 */
136 struct seltd {
137 STAILQ_HEAD(, selfd) st_selq; /* (k) List of selfds. */
138 struct selfd *st_free1; /* (k) free fd for read set. */
139 struct selfd *st_free2; /* (k) free fd for write set. */
140 struct mtx st_mtx; /* Protects struct seltd */
141 struct cv st_wait; /* (t) Wait channel. */
142 int st_flags; /* (t) SELTD_ flags. */
143 };
144
145 #define SELTD_PENDING 0x0001 /* We have pending events. */
146 #define SELTD_RESCAN 0x0002 /* Doing a rescan. */
147
148 /*
149 * One selfd allocated per-thread per-file-descriptor.
150 * f - protected by sf_mtx
151 */
152 struct selfd {
153 STAILQ_ENTRY(selfd) sf_link; /* (k) fds owned by this td. */
154 TAILQ_ENTRY(selfd) sf_threads; /* (f) fds on this selinfo. */
155 struct selinfo *sf_si; /* (f) selinfo when linked. */
156 struct mtx *sf_mtx; /* Pointer to selinfo mtx. */
157 struct seltd *sf_td; /* (k) owning seltd. */
158 void *sf_cookie; /* (k) fd or pollfd. */
159 u_int sf_refs;
160 };
161
162 static uma_zone_t selfd_zone;
163 static struct mtx_pool *mtxpool_select;
164
165 #ifdef __LP64__
166 size_t
167 devfs_iosize_max(void)
168 {
169
170 return (devfs_iosize_max_clamp || SV_CURPROC_FLAG(SV_ILP32) ?
171 INT_MAX : SSIZE_MAX);
172 }
173
174 size_t
175 iosize_max(void)
176 {
177
178 return (iosize_max_clamp || SV_CURPROC_FLAG(SV_ILP32) ?
179 INT_MAX : SSIZE_MAX);
180 }
181 #endif
182
183 #ifndef _SYS_SYSPROTO_H_
184 struct read_args {
185 int fd;
186 void *buf;
187 size_t nbyte;
188 };
189 #endif
190 int
191 sys_read(struct thread *td, struct read_args *uap)
192 {
193 struct uio auio;
194 struct iovec aiov;
195 int error;
196
197 if (uap->nbyte > IOSIZE_MAX)
198 return (EINVAL);
199 aiov.iov_base = uap->buf;
200 aiov.iov_len = uap->nbyte;
201 auio.uio_iov = &aiov;
202 auio.uio_iovcnt = 1;
203 auio.uio_resid = uap->nbyte;
204 auio.uio_segflg = UIO_USERSPACE;
205 error = kern_readv(td, uap->fd, &auio);
206 return (error);
207 }
208
209 /*
210 * Positioned read system call
211 */
212 #ifndef _SYS_SYSPROTO_H_
213 struct pread_args {
214 int fd;
215 void *buf;
216 size_t nbyte;
217 int pad;
218 off_t offset;
219 };
220 #endif
221 int
222 sys_pread(struct thread *td, struct pread_args *uap)
223 {
224
225 return (kern_pread(td, uap->fd, uap->buf, uap->nbyte, uap->offset));
226 }
227
228 int
229 kern_pread(struct thread *td, int fd, void *buf, size_t nbyte, off_t offset)
230 {
231 struct uio auio;
232 struct iovec aiov;
233 int error;
234
235 if (nbyte > IOSIZE_MAX)
236 return (EINVAL);
237 aiov.iov_base = buf;
238 aiov.iov_len = nbyte;
239 auio.uio_iov = &aiov;
240 auio.uio_iovcnt = 1;
241 auio.uio_resid = nbyte;
242 auio.uio_segflg = UIO_USERSPACE;
243 error = kern_preadv(td, fd, &auio, offset);
244 return (error);
245 }
246
247 #if defined(COMPAT_FREEBSD6)
248 int
249 freebsd6_pread(struct thread *td, struct freebsd6_pread_args *uap)
250 {
251
252 return (kern_pread(td, uap->fd, uap->buf, uap->nbyte, uap->offset));
253 }
254 #endif
255
256 /*
257 * Scatter read system call.
258 */
259 #ifndef _SYS_SYSPROTO_H_
260 struct readv_args {
261 int fd;
262 struct iovec *iovp;
263 u_int iovcnt;
264 };
265 #endif
266 int
267 sys_readv(struct thread *td, struct readv_args *uap)
268 {
269 struct uio *auio;
270 int error;
271
272 error = copyinuio(uap->iovp, uap->iovcnt, &auio);
273 if (error)
274 return (error);
275 error = kern_readv(td, uap->fd, auio);
276 free(auio, M_IOV);
277 return (error);
278 }
279
280 int
281 kern_readv(struct thread *td, int fd, struct uio *auio)
282 {
283 struct file *fp;
284 int error;
285
286 error = fget_read(td, fd, &cap_read_rights, &fp);
287 if (error)
288 return (error);
289 error = dofileread(td, fd, fp, auio, (off_t)-1, 0);
290 fdrop(fp, td);
291 return (error);
292 }
293
294 /*
295 * Scatter positioned read system call.
296 */
297 #ifndef _SYS_SYSPROTO_H_
298 struct preadv_args {
299 int fd;
300 struct iovec *iovp;
301 u_int iovcnt;
302 off_t offset;
303 };
304 #endif
305 int
306 sys_preadv(struct thread *td, struct preadv_args *uap)
307 {
308 struct uio *auio;
309 int error;
310
311 error = copyinuio(uap->iovp, uap->iovcnt, &auio);
312 if (error)
313 return (error);
314 error = kern_preadv(td, uap->fd, auio, uap->offset);
315 free(auio, M_IOV);
316 return (error);
317 }
318
319 int
320 kern_preadv(struct thread *td, int fd, struct uio *auio, off_t offset)
321 {
322 struct file *fp;
323 int error;
324
325 error = fget_read(td, fd, &cap_pread_rights, &fp);
326 if (error)
327 return (error);
328 if (!(fp->f_ops->fo_flags & DFLAG_SEEKABLE))
329 error = ESPIPE;
330 else if (offset < 0 &&
331 (fp->f_vnode == NULL || fp->f_vnode->v_type != VCHR))
332 error = EINVAL;
333 else
334 error = dofileread(td, fd, fp, auio, offset, FOF_OFFSET);
335 fdrop(fp, td);
336 return (error);
337 }
338
339 /*
340 * Common code for readv and preadv that reads data in
341 * from a file using the passed in uio, offset, and flags.
342 */
343 static int
344 dofileread(struct thread *td, int fd, struct file *fp, struct uio *auio,
345 off_t offset, int flags)
346 {
347 ssize_t cnt;
348 int error;
349 #ifdef KTRACE
350 struct uio *ktruio = NULL;
351 #endif
352
353 AUDIT_ARG_FD(fd);
354
355 /* Finish zero length reads right here */
356 if (auio->uio_resid == 0) {
357 td->td_retval[0] = 0;
358 return (0);
359 }
360 auio->uio_rw = UIO_READ;
361 auio->uio_offset = offset;
362 auio->uio_td = td;
363 #ifdef KTRACE
364 if (KTRPOINT(td, KTR_GENIO))
365 ktruio = cloneuio(auio);
366 #endif
367 cnt = auio->uio_resid;
368 if ((error = fo_read(fp, auio, td->td_ucred, flags, td))) {
369 if (auio->uio_resid != cnt && (error == ERESTART ||
370 error == EINTR || error == EWOULDBLOCK))
371 error = 0;
372 }
373 cnt -= auio->uio_resid;
374 #ifdef KTRACE
375 if (ktruio != NULL) {
376 ktruio->uio_resid = cnt;
377 ktrgenio(fd, UIO_READ, ktruio, error);
378 }
379 #endif
380 td->td_retval[0] = cnt;
381 return (error);
382 }
383
384 #ifndef _SYS_SYSPROTO_H_
385 struct write_args {
386 int fd;
387 const void *buf;
388 size_t nbyte;
389 };
390 #endif
391 int
392 sys_write(struct thread *td, struct write_args *uap)
393 {
394 struct uio auio;
395 struct iovec aiov;
396 int error;
397
398 if (uap->nbyte > IOSIZE_MAX)
399 return (EINVAL);
400 aiov.iov_base = (void *)(uintptr_t)uap->buf;
401 aiov.iov_len = uap->nbyte;
402 auio.uio_iov = &aiov;
403 auio.uio_iovcnt = 1;
404 auio.uio_resid = uap->nbyte;
405 auio.uio_segflg = UIO_USERSPACE;
406 error = kern_writev(td, uap->fd, &auio);
407 return (error);
408 }
409
410 /*
411 * Positioned write system call.
412 */
413 #ifndef _SYS_SYSPROTO_H_
414 struct pwrite_args {
415 int fd;
416 const void *buf;
417 size_t nbyte;
418 int pad;
419 off_t offset;
420 };
421 #endif
422 int
423 sys_pwrite(struct thread *td, struct pwrite_args *uap)
424 {
425
426 return (kern_pwrite(td, uap->fd, uap->buf, uap->nbyte, uap->offset));
427 }
428
429 int
430 kern_pwrite(struct thread *td, int fd, const void *buf, size_t nbyte,
431 off_t offset)
432 {
433 struct uio auio;
434 struct iovec aiov;
435 int error;
436
437 if (nbyte > IOSIZE_MAX)
438 return (EINVAL);
439 aiov.iov_base = (void *)(uintptr_t)buf;
440 aiov.iov_len = nbyte;
441 auio.uio_iov = &aiov;
442 auio.uio_iovcnt = 1;
443 auio.uio_resid = nbyte;
444 auio.uio_segflg = UIO_USERSPACE;
445 error = kern_pwritev(td, fd, &auio, offset);
446 return (error);
447 }
448
449 #if defined(COMPAT_FREEBSD6)
450 int
451 freebsd6_pwrite(struct thread *td, struct freebsd6_pwrite_args *uap)
452 {
453
454 return (kern_pwrite(td, uap->fd, uap->buf, uap->nbyte, uap->offset));
455 }
456 #endif
457
458 /*
459 * Gather write system call.
460 */
461 #ifndef _SYS_SYSPROTO_H_
462 struct writev_args {
463 int fd;
464 struct iovec *iovp;
465 u_int iovcnt;
466 };
467 #endif
468 int
469 sys_writev(struct thread *td, struct writev_args *uap)
470 {
471 struct uio *auio;
472 int error;
473
474 error = copyinuio(uap->iovp, uap->iovcnt, &auio);
475 if (error)
476 return (error);
477 error = kern_writev(td, uap->fd, auio);
478 free(auio, M_IOV);
479 return (error);
480 }
481
482 int
483 kern_writev(struct thread *td, int fd, struct uio *auio)
484 {
485 struct file *fp;
486 int error;
487
488 error = fget_write(td, fd, &cap_write_rights, &fp);
489 if (error)
490 return (error);
491 error = dofilewrite(td, fd, fp, auio, (off_t)-1, 0);
492 fdrop(fp, td);
493 return (error);
494 }
495
496 /*
497 * Gather positioned write system call.
498 */
499 #ifndef _SYS_SYSPROTO_H_
500 struct pwritev_args {
501 int fd;
502 struct iovec *iovp;
503 u_int iovcnt;
504 off_t offset;
505 };
506 #endif
507 int
508 sys_pwritev(struct thread *td, struct pwritev_args *uap)
509 {
510 struct uio *auio;
511 int error;
512
513 error = copyinuio(uap->iovp, uap->iovcnt, &auio);
514 if (error)
515 return (error);
516 error = kern_pwritev(td, uap->fd, auio, uap->offset);
517 free(auio, M_IOV);
518 return (error);
519 }
520
521 int
522 kern_pwritev(struct thread *td, int fd, struct uio *auio, off_t offset)
523 {
524 struct file *fp;
525 int error;
526
527 error = fget_write(td, fd, &cap_pwrite_rights, &fp);
528 if (error)
529 return (error);
530 if (!(fp->f_ops->fo_flags & DFLAG_SEEKABLE))
531 error = ESPIPE;
532 else if (offset < 0 &&
533 (fp->f_vnode == NULL || fp->f_vnode->v_type != VCHR))
534 error = EINVAL;
535 else
536 error = dofilewrite(td, fd, fp, auio, offset, FOF_OFFSET);
537 fdrop(fp, td);
538 return (error);
539 }
540
541 /*
542 * Common code for writev and pwritev that writes data to
543 * a file using the passed in uio, offset, and flags.
544 */
545 static int
546 dofilewrite(struct thread *td, int fd, struct file *fp, struct uio *auio,
547 off_t offset, int flags)
548 {
549 ssize_t cnt;
550 int error;
551 #ifdef KTRACE
552 struct uio *ktruio = NULL;
553 #endif
554
555 AUDIT_ARG_FD(fd);
556 auio->uio_rw = UIO_WRITE;
557 auio->uio_td = td;
558 auio->uio_offset = offset;
559 #ifdef KTRACE
560 if (KTRPOINT(td, KTR_GENIO))
561 ktruio = cloneuio(auio);
562 #endif
563 cnt = auio->uio_resid;
564 if (fp->f_type == DTYPE_VNODE &&
565 (fp->f_vnread_flags & FDEVFS_VNODE) == 0)
566 bwillwrite();
567 if ((error = fo_write(fp, auio, td->td_ucred, flags, td))) {
568 if (auio->uio_resid != cnt && (error == ERESTART ||
569 error == EINTR || error == EWOULDBLOCK))
570 error = 0;
571 /* Socket layer is responsible for issuing SIGPIPE. */
572 if (fp->f_type != DTYPE_SOCKET && error == EPIPE) {
573 PROC_LOCK(td->td_proc);
574 tdsignal(td, SIGPIPE);
575 PROC_UNLOCK(td->td_proc);
576 }
577 }
578 cnt -= auio->uio_resid;
579 #ifdef KTRACE
580 if (ktruio != NULL) {
581 ktruio->uio_resid = cnt;
582 ktrgenio(fd, UIO_WRITE, ktruio, error);
583 }
584 #endif
585 td->td_retval[0] = cnt;
586 return (error);
587 }
588
589 /*
590 * Truncate a file given a file descriptor.
591 *
592 * Can't use fget_write() here, since must return EINVAL and not EBADF if the
593 * descriptor isn't writable.
594 */
595 int
596 kern_ftruncate(struct thread *td, int fd, off_t length)
597 {
598 struct file *fp;
599 int error;
600
601 AUDIT_ARG_FD(fd);
602 if (length < 0)
603 return (EINVAL);
604 error = fget(td, fd, &cap_ftruncate_rights, &fp);
605 if (error)
606 return (error);
607 AUDIT_ARG_FILE(td->td_proc, fp);
608 if (!(fp->f_flag & FWRITE)) {
609 fdrop(fp, td);
610 return (EINVAL);
611 }
612 error = fo_truncate(fp, length, td->td_ucred, td);
613 fdrop(fp, td);
614 return (error);
615 }
616
617 #ifndef _SYS_SYSPROTO_H_
618 struct ftruncate_args {
619 int fd;
620 int pad;
621 off_t length;
622 };
623 #endif
624 int
625 sys_ftruncate(struct thread *td, struct ftruncate_args *uap)
626 {
627
628 return (kern_ftruncate(td, uap->fd, uap->length));
629 }
630
631 #if defined(COMPAT_43)
632 #ifndef _SYS_SYSPROTO_H_
633 struct oftruncate_args {
634 int fd;
635 long length;
636 };
637 #endif
638 int
639 oftruncate(struct thread *td, struct oftruncate_args *uap)
640 {
641
642 return (kern_ftruncate(td, uap->fd, uap->length));
643 }
644 #endif /* COMPAT_43 */
645
646 #ifndef _SYS_SYSPROTO_H_
647 struct ioctl_args {
648 int fd;
649 u_long com;
650 caddr_t data;
651 };
652 #endif
653 /* ARGSUSED */
654 int
655 sys_ioctl(struct thread *td, struct ioctl_args *uap)
656 {
657 u_char smalldata[SYS_IOCTL_SMALL_SIZE] __aligned(SYS_IOCTL_SMALL_ALIGN);
658 uint32_t com;
659 int arg, error;
660 u_int size;
661 caddr_t data;
662
663 #ifdef INVARIANTS
664 if (uap->com > 0xffffffff) {
665 printf(
666 "WARNING pid %d (%s): ioctl sign-extension ioctl %lx\n",
667 td->td_proc->p_pid, td->td_name, uap->com);
668 }
669 #endif
670 com = (uint32_t)uap->com;
671
672 /*
673 * Interpret high order word to find amount of data to be
674 * copied to/from the user's address space.
675 */
676 size = IOCPARM_LEN(com);
677 if ((size > IOCPARM_MAX) ||
678 ((com & (IOC_VOID | IOC_IN | IOC_OUT)) == 0) ||
679 #if defined(COMPAT_FREEBSD5) || defined(COMPAT_FREEBSD4) || defined(COMPAT_43)
680 ((com & IOC_OUT) && size == 0) ||
681 #else
682 ((com & (IOC_IN | IOC_OUT)) && size == 0) ||
683 #endif
684 ((com & IOC_VOID) && size > 0 && size != sizeof(int)))
685 return (ENOTTY);
686
687 if (size > 0) {
688 if (com & IOC_VOID) {
689 /* Integer argument. */
690 arg = (intptr_t)uap->data;
691 data = (void *)&arg;
692 size = 0;
693 } else {
694 if (size > SYS_IOCTL_SMALL_SIZE)
695 data = malloc((u_long)size, M_IOCTLOPS, M_WAITOK);
696 else
697 data = smalldata;
698 }
699 } else
700 data = (void *)&uap->data;
701 if (com & IOC_IN) {
702 error = copyin(uap->data, data, (u_int)size);
703 if (error != 0)
704 goto out;
705 } else if (com & IOC_OUT) {
706 /*
707 * Zero the buffer so the user always
708 * gets back something deterministic.
709 */
710 bzero(data, size);
711 }
712
713 error = kern_ioctl(td, uap->fd, com, data);
714
715 if (error == 0 && (com & IOC_OUT))
716 error = copyout(data, uap->data, (u_int)size);
717
718 out:
719 if (size > SYS_IOCTL_SMALL_SIZE)
720 free(data, M_IOCTLOPS);
721 return (error);
722 }
723
724 int
725 kern_ioctl(struct thread *td, int fd, u_long com, caddr_t data)
726 {
727 struct file *fp;
728 struct filedesc *fdp;
729 int error, tmp, locked;
730
731 AUDIT_ARG_FD(fd);
732 AUDIT_ARG_CMD(com);
733
734 fdp = td->td_proc->p_fd;
735
736 switch (com) {
737 case FIONCLEX:
738 case FIOCLEX:
739 FILEDESC_XLOCK(fdp);
740 locked = LA_XLOCKED;
741 break;
742 default:
743 #ifdef CAPABILITIES
744 FILEDESC_SLOCK(fdp);
745 locked = LA_SLOCKED;
746 #else
747 locked = LA_UNLOCKED;
748 #endif
749 break;
750 }
751
752 #ifdef CAPABILITIES
753 if ((fp = fget_locked(fdp, fd)) == NULL) {
754 error = EBADF;
755 goto out;
756 }
757 if ((error = cap_ioctl_check(fdp, fd, com)) != 0) {
758 fp = NULL; /* fhold() was not called yet */
759 goto out;
760 }
761 if (!fhold(fp)) {
762 error = EBADF;
763 fp = NULL;
764 goto out;
765 }
766 if (locked == LA_SLOCKED) {
767 FILEDESC_SUNLOCK(fdp);
768 locked = LA_UNLOCKED;
769 }
770 #else
771 error = fget(td, fd, &cap_ioctl_rights, &fp);
772 if (error != 0) {
773 fp = NULL;
774 goto out;
775 }
776 #endif
777 if ((fp->f_flag & (FREAD | FWRITE)) == 0) {
778 error = EBADF;
779 goto out;
780 }
781
782 switch (com) {
783 case FIONCLEX:
784 fdp->fd_ofiles[fd].fde_flags &= ~UF_EXCLOSE;
785 goto out;
786 case FIOCLEX:
787 fdp->fd_ofiles[fd].fde_flags |= UF_EXCLOSE;
788 goto out;
789 case FIONBIO:
790 if ((tmp = *(int *)data))
791 atomic_set_int(&fp->f_flag, FNONBLOCK);
792 else
793 atomic_clear_int(&fp->f_flag, FNONBLOCK);
794 data = (void *)&tmp;
795 break;
796 case FIOASYNC:
797 if ((tmp = *(int *)data))
798 atomic_set_int(&fp->f_flag, FASYNC);
799 else
800 atomic_clear_int(&fp->f_flag, FASYNC);
801 data = (void *)&tmp;
802 break;
803 }
804
805 error = fo_ioctl(fp, com, data, td->td_ucred, td);
806 out:
807 switch (locked) {
808 case LA_XLOCKED:
809 FILEDESC_XUNLOCK(fdp);
810 break;
811 #ifdef CAPABILITIES
812 case LA_SLOCKED:
813 FILEDESC_SUNLOCK(fdp);
814 break;
815 #endif
816 default:
817 FILEDESC_UNLOCK_ASSERT(fdp);
818 break;
819 }
820 if (fp != NULL)
821 fdrop(fp, td);
822 return (error);
823 }
824
825 int
826 poll_no_poll(int events)
827 {
828 /*
829 * Return true for read/write. If the user asked for something
830 * special, return POLLNVAL, so that clients have a way of
831 * determining reliably whether or not the extended
832 * functionality is present without hard-coding knowledge
833 * of specific filesystem implementations.
834 */
835 if (events & ~POLLSTANDARD)
836 return (POLLNVAL);
837
838 return (events & (POLLIN | POLLOUT | POLLRDNORM | POLLWRNORM));
839 }
840
841 int
842 sys_pselect(struct thread *td, struct pselect_args *uap)
843 {
844 struct timespec ts;
845 struct timeval tv, *tvp;
846 sigset_t set, *uset;
847 int error;
848
849 if (uap->ts != NULL) {
850 error = copyin(uap->ts, &ts, sizeof(ts));
851 if (error != 0)
852 return (error);
853 TIMESPEC_TO_TIMEVAL(&tv, &ts);
854 tvp = &tv;
855 } else
856 tvp = NULL;
857 if (uap->sm != NULL) {
858 error = copyin(uap->sm, &set, sizeof(set));
859 if (error != 0)
860 return (error);
861 uset = &set;
862 } else
863 uset = NULL;
864 return (kern_pselect(td, uap->nd, uap->in, uap->ou, uap->ex, tvp,
865 uset, NFDBITS));
866 }
867
868 int
869 kern_pselect(struct thread *td, int nd, fd_set *in, fd_set *ou, fd_set *ex,
870 struct timeval *tvp, sigset_t *uset, int abi_nfdbits)
871 {
872 int error;
873
874 if (uset != NULL) {
875 error = kern_sigprocmask(td, SIG_SETMASK, uset,
876 &td->td_oldsigmask, 0);
877 if (error != 0)
878 return (error);
879 td->td_pflags |= TDP_OLDMASK;
880 /*
881 * Make sure that ast() is called on return to
882 * usermode and TDP_OLDMASK is cleared, restoring old
883 * sigmask.
884 */
885 thread_lock(td);
886 td->td_flags |= TDF_ASTPENDING;
887 thread_unlock(td);
888 }
889 error = kern_select(td, nd, in, ou, ex, tvp, abi_nfdbits);
890 return (error);
891 }
892
893 #ifndef _SYS_SYSPROTO_H_
894 struct select_args {
895 int nd;
896 fd_set *in, *ou, *ex;
897 struct timeval *tv;
898 };
899 #endif
900 int
901 sys_select(struct thread *td, struct select_args *uap)
902 {
903 struct timeval tv, *tvp;
904 int error;
905
906 if (uap->tv != NULL) {
907 error = copyin(uap->tv, &tv, sizeof(tv));
908 if (error)
909 return (error);
910 tvp = &tv;
911 } else
912 tvp = NULL;
913
914 return (kern_select(td, uap->nd, uap->in, uap->ou, uap->ex, tvp,
915 NFDBITS));
916 }
917
918 /*
919 * In the unlikely case when user specified n greater then the last
920 * open file descriptor, check that no bits are set after the last
921 * valid fd. We must return EBADF if any is set.
922 *
923 * There are applications that rely on the behaviour.
924 *
925 * nd is fd_lastfile + 1.
926 */
927 static int
928 select_check_badfd(fd_set *fd_in, int nd, int ndu, int abi_nfdbits)
929 {
930 char *addr, *oaddr;
931 int b, i, res;
932 uint8_t bits;
933
934 if (nd >= ndu || fd_in == NULL)
935 return (0);
936
937 oaddr = NULL;
938 bits = 0; /* silence gcc */
939 for (i = nd; i < ndu; i++) {
940 b = i / NBBY;
941 #if BYTE_ORDER == LITTLE_ENDIAN
942 addr = (char *)fd_in + b;
943 #else
944 addr = (char *)fd_in;
945 if (abi_nfdbits == NFDBITS) {
946 addr += rounddown(b, sizeof(fd_mask)) +
947 sizeof(fd_mask) - 1 - b % sizeof(fd_mask);
948 } else {
949 addr += rounddown(b, sizeof(uint32_t)) +
950 sizeof(uint32_t) - 1 - b % sizeof(uint32_t);
951 }
952 #endif
953 if (addr != oaddr) {
954 res = fubyte(addr);
955 if (res == -1)
956 return (EFAULT);
957 oaddr = addr;
958 bits = res;
959 }
960 if ((bits & (1 << (i % NBBY))) != 0)
961 return (EBADF);
962 }
963 return (0);
964 }
965
966 int
967 kern_select(struct thread *td, int nd, fd_set *fd_in, fd_set *fd_ou,
968 fd_set *fd_ex, struct timeval *tvp, int abi_nfdbits)
969 {
970 struct filedesc *fdp;
971 /*
972 * The magic 2048 here is chosen to be just enough for FD_SETSIZE
973 * infds with the new FD_SETSIZE of 1024, and more than enough for
974 * FD_SETSIZE infds, outfds and exceptfds with the old FD_SETSIZE
975 * of 256.
976 */
977 fd_mask s_selbits[howmany(2048, NFDBITS)];
978 fd_mask *ibits[3], *obits[3], *selbits, *sbp;
979 struct timeval rtv;
980 sbintime_t asbt, precision, rsbt;
981 u_int nbufbytes, ncpbytes, ncpubytes, nfdbits;
982 int error, lf, ndu;
983
984 if (nd < 0)
985 return (EINVAL);
986 fdp = td->td_proc->p_fd;
987 ndu = nd;
988 lf = fdp->fd_lastfile;
989 if (nd > lf + 1)
990 nd = lf + 1;
991
992 error = select_check_badfd(fd_in, nd, ndu, abi_nfdbits);
993 if (error != 0)
994 return (error);
995 error = select_check_badfd(fd_ou, nd, ndu, abi_nfdbits);
996 if (error != 0)
997 return (error);
998 error = select_check_badfd(fd_ex, nd, ndu, abi_nfdbits);
999 if (error != 0)
1000 return (error);
1001
1002 /*
1003 * Allocate just enough bits for the non-null fd_sets. Use the
1004 * preallocated auto buffer if possible.
1005 */
1006 nfdbits = roundup(nd, NFDBITS);
1007 ncpbytes = nfdbits / NBBY;
1008 ncpubytes = roundup(nd, abi_nfdbits) / NBBY;
1009 nbufbytes = 0;
1010 if (fd_in != NULL)
1011 nbufbytes += 2 * ncpbytes;
1012 if (fd_ou != NULL)
1013 nbufbytes += 2 * ncpbytes;
1014 if (fd_ex != NULL)
1015 nbufbytes += 2 * ncpbytes;
1016 if (nbufbytes <= sizeof s_selbits)
1017 selbits = &s_selbits[0];
1018 else
1019 selbits = malloc(nbufbytes, M_SELECT, M_WAITOK);
1020
1021 /*
1022 * Assign pointers into the bit buffers and fetch the input bits.
1023 * Put the output buffers together so that they can be bzeroed
1024 * together.
1025 */
1026 sbp = selbits;
1027 #define getbits(name, x) \
1028 do { \
1029 if (name == NULL) { \
1030 ibits[x] = NULL; \
1031 obits[x] = NULL; \
1032 } else { \
1033 ibits[x] = sbp + nbufbytes / 2 / sizeof *sbp; \
1034 obits[x] = sbp; \
1035 sbp += ncpbytes / sizeof *sbp; \
1036 error = copyin(name, ibits[x], ncpubytes); \
1037 if (error != 0) \
1038 goto done; \
1039 if (ncpbytes != ncpubytes) \
1040 bzero((char *)ibits[x] + ncpubytes, \
1041 ncpbytes - ncpubytes); \
1042 } \
1043 } while (0)
1044 getbits(fd_in, 0);
1045 getbits(fd_ou, 1);
1046 getbits(fd_ex, 2);
1047 #undef getbits
1048
1049 #if BYTE_ORDER == BIG_ENDIAN && defined(__LP64__)
1050 /*
1051 * XXX: swizzle_fdset assumes that if abi_nfdbits != NFDBITS,
1052 * we are running under 32-bit emulation. This should be more
1053 * generic.
1054 */
1055 #define swizzle_fdset(bits) \
1056 if (abi_nfdbits != NFDBITS && bits != NULL) { \
1057 int i; \
1058 for (i = 0; i < ncpbytes / sizeof *sbp; i++) \
1059 bits[i] = (bits[i] >> 32) | (bits[i] << 32); \
1060 }
1061 #else
1062 #define swizzle_fdset(bits)
1063 #endif
1064
1065 /* Make sure the bit order makes it through an ABI transition */
1066 swizzle_fdset(ibits[0]);
1067 swizzle_fdset(ibits[1]);
1068 swizzle_fdset(ibits[2]);
1069
1070 if (nbufbytes != 0)
1071 bzero(selbits, nbufbytes / 2);
1072
1073 precision = 0;
1074 if (tvp != NULL) {
1075 rtv = *tvp;
1076 if (rtv.tv_sec < 0 || rtv.tv_usec < 0 ||
1077 rtv.tv_usec >= 1000000) {
1078 error = EINVAL;
1079 goto done;
1080 }
1081 if (!timevalisset(&rtv))
1082 asbt = 0;
1083 else if (rtv.tv_sec <= INT32_MAX) {
1084 rsbt = tvtosbt(rtv);
1085 precision = rsbt;
1086 precision >>= tc_precexp;
1087 if (TIMESEL(&asbt, rsbt))
1088 asbt += tc_tick_sbt;
1089 if (asbt <= SBT_MAX - rsbt)
1090 asbt += rsbt;
1091 else
1092 asbt = -1;
1093 } else
1094 asbt = -1;
1095 } else
1096 asbt = -1;
1097 seltdinit(td);
1098 /* Iterate until the timeout expires or descriptors become ready. */
1099 for (;;) {
1100 error = selscan(td, ibits, obits, nd);
1101 if (error || td->td_retval[0] != 0)
1102 break;
1103 error = seltdwait(td, asbt, precision);
1104 if (error)
1105 break;
1106 error = selrescan(td, ibits, obits);
1107 if (error || td->td_retval[0] != 0)
1108 break;
1109 }
1110 seltdclear(td);
1111
1112 done:
1113 /* select is not restarted after signals... */
1114 if (error == ERESTART)
1115 error = EINTR;
1116 if (error == EWOULDBLOCK)
1117 error = 0;
1118
1119 /* swizzle bit order back, if necessary */
1120 swizzle_fdset(obits[0]);
1121 swizzle_fdset(obits[1]);
1122 swizzle_fdset(obits[2]);
1123 #undef swizzle_fdset
1124
1125 #define putbits(name, x) \
1126 if (name && (error2 = copyout(obits[x], name, ncpubytes))) \
1127 error = error2;
1128 if (error == 0) {
1129 int error2;
1130
1131 putbits(fd_in, 0);
1132 putbits(fd_ou, 1);
1133 putbits(fd_ex, 2);
1134 #undef putbits
1135 }
1136 if (selbits != &s_selbits[0])
1137 free(selbits, M_SELECT);
1138
1139 return (error);
1140 }
1141 /*
1142 * Convert a select bit set to poll flags.
1143 *
1144 * The backend always returns POLLHUP/POLLERR if appropriate and we
1145 * return this as a set bit in any set.
1146 */
1147 static int select_flags[3] = {
1148 POLLRDNORM | POLLHUP | POLLERR,
1149 POLLWRNORM | POLLHUP | POLLERR,
1150 POLLRDBAND | POLLERR
1151 };
1152
1153 /*
1154 * Compute the fo_poll flags required for a fd given by the index and
1155 * bit position in the fd_mask array.
1156 */
1157 static __inline int
1158 selflags(fd_mask **ibits, int idx, fd_mask bit)
1159 {
1160 int flags;
1161 int msk;
1162
1163 flags = 0;
1164 for (msk = 0; msk < 3; msk++) {
1165 if (ibits[msk] == NULL)
1166 continue;
1167 if ((ibits[msk][idx] & bit) == 0)
1168 continue;
1169 flags |= select_flags[msk];
1170 }
1171 return (flags);
1172 }
1173
1174 /*
1175 * Set the appropriate output bits given a mask of fired events and the
1176 * input bits originally requested.
1177 */
1178 static __inline int
1179 selsetbits(fd_mask **ibits, fd_mask **obits, int idx, fd_mask bit, int events)
1180 {
1181 int msk;
1182 int n;
1183
1184 n = 0;
1185 for (msk = 0; msk < 3; msk++) {
1186 if ((events & select_flags[msk]) == 0)
1187 continue;
1188 if (ibits[msk] == NULL)
1189 continue;
1190 if ((ibits[msk][idx] & bit) == 0)
1191 continue;
1192 /*
1193 * XXX Check for a duplicate set. This can occur because a
1194 * socket calls selrecord() twice for each poll() call
1195 * resulting in two selfds per real fd. selrescan() will
1196 * call selsetbits twice as a result.
1197 */
1198 if ((obits[msk][idx] & bit) != 0)
1199 continue;
1200 obits[msk][idx] |= bit;
1201 n++;
1202 }
1203
1204 return (n);
1205 }
1206
1207 static __inline int
1208 getselfd_cap(struct filedesc *fdp, int fd, struct file **fpp)
1209 {
1210
1211 return (fget_unlocked(fdp, fd, &cap_event_rights, fpp, NULL));
1212 }
1213
1214 /*
1215 * Traverse the list of fds attached to this thread's seltd and check for
1216 * completion.
1217 */
1218 static int
1219 selrescan(struct thread *td, fd_mask **ibits, fd_mask **obits)
1220 {
1221 struct filedesc *fdp;
1222 struct selinfo *si;
1223 struct seltd *stp;
1224 struct selfd *sfp;
1225 struct selfd *sfn;
1226 struct file *fp;
1227 fd_mask bit;
1228 int fd, ev, n, idx;
1229 int error;
1230
1231 fdp = td->td_proc->p_fd;
1232 stp = td->td_sel;
1233 n = 0;
1234 STAILQ_FOREACH_SAFE(sfp, &stp->st_selq, sf_link, sfn) {
1235 fd = (int)(uintptr_t)sfp->sf_cookie;
1236 si = sfp->sf_si;
1237 selfdfree(stp, sfp);
1238 /* If the selinfo wasn't cleared the event didn't fire. */
1239 if (si != NULL)
1240 continue;
1241 error = getselfd_cap(fdp, fd, &fp);
1242 if (error)
1243 return (error);
1244 idx = fd / NFDBITS;
1245 bit = (fd_mask)1 << (fd % NFDBITS);
1246 ev = fo_poll(fp, selflags(ibits, idx, bit), td->td_ucred, td);
1247 fdrop(fp, td);
1248 if (ev != 0)
1249 n += selsetbits(ibits, obits, idx, bit, ev);
1250 }
1251 stp->st_flags = 0;
1252 td->td_retval[0] = n;
1253 return (0);
1254 }
1255
1256 /*
1257 * Perform the initial filedescriptor scan and register ourselves with
1258 * each selinfo.
1259 */
1260 static int
1261 selscan(struct thread *td, fd_mask **ibits, fd_mask **obits, int nfd)
1262 {
1263 struct filedesc *fdp;
1264 struct file *fp;
1265 fd_mask bit;
1266 int ev, flags, end, fd;
1267 int n, idx;
1268 int error;
1269
1270 fdp = td->td_proc->p_fd;
1271 n = 0;
1272 for (idx = 0, fd = 0; fd < nfd; idx++) {
1273 end = imin(fd + NFDBITS, nfd);
1274 for (bit = 1; fd < end; bit <<= 1, fd++) {
1275 /* Compute the list of events we're interested in. */
1276 flags = selflags(ibits, idx, bit);
1277 if (flags == 0)
1278 continue;
1279 error = getselfd_cap(fdp, fd, &fp);
1280 if (error)
1281 return (error);
1282 selfdalloc(td, (void *)(uintptr_t)fd);
1283 ev = fo_poll(fp, flags, td->td_ucred, td);
1284 fdrop(fp, td);
1285 if (ev != 0)
1286 n += selsetbits(ibits, obits, idx, bit, ev);
1287 }
1288 }
1289
1290 td->td_retval[0] = n;
1291 return (0);
1292 }
1293
1294 int
1295 sys_poll(struct thread *td, struct poll_args *uap)
1296 {
1297 struct timespec ts, *tsp;
1298
1299 if (uap->timeout != INFTIM) {
1300 if (uap->timeout < 0)
1301 return (EINVAL);
1302 ts.tv_sec = uap->timeout / 1000;
1303 ts.tv_nsec = (uap->timeout % 1000) * 1000000;
1304 tsp = &ts;
1305 } else
1306 tsp = NULL;
1307
1308 return (kern_poll(td, uap->fds, uap->nfds, tsp, NULL));
1309 }
1310
1311 int
1312 kern_poll(struct thread *td, struct pollfd *fds, u_int nfds,
1313 struct timespec *tsp, sigset_t *uset)
1314 {
1315 struct pollfd *bits;
1316 struct pollfd smallbits[32];
1317 sbintime_t sbt, precision, tmp;
1318 time_t over;
1319 struct timespec ts;
1320 int error;
1321 size_t ni;
1322
1323 precision = 0;
1324 if (tsp != NULL) {
1325 if (tsp->tv_sec < 0)
1326 return (EINVAL);
1327 if (tsp->tv_nsec < 0 || tsp->tv_nsec >= 1000000000)
1328 return (EINVAL);
1329 if (tsp->tv_sec == 0 && tsp->tv_nsec == 0)
1330 sbt = 0;
1331 else {
1332 ts = *tsp;
1333 if (ts.tv_sec > INT32_MAX / 2) {
1334 over = ts.tv_sec - INT32_MAX / 2;
1335 ts.tv_sec -= over;
1336 } else
1337 over = 0;
1338 tmp = tstosbt(ts);
1339 precision = tmp;
1340 precision >>= tc_precexp;
1341 if (TIMESEL(&sbt, tmp))
1342 sbt += tc_tick_sbt;
1343 sbt += tmp;
1344 }
1345 } else
1346 sbt = -1;
1347
1348 if (nfds > maxfilesperproc && nfds > FD_SETSIZE)
1349 return (EINVAL);
1350 ni = nfds * sizeof(struct pollfd);
1351 if (ni > sizeof(smallbits))
1352 bits = malloc(ni, M_TEMP, M_WAITOK);
1353 else
1354 bits = smallbits;
1355 error = copyin(fds, bits, ni);
1356 if (error)
1357 goto done;
1358
1359 if (uset != NULL) {
1360 error = kern_sigprocmask(td, SIG_SETMASK, uset,
1361 &td->td_oldsigmask, 0);
1362 if (error)
1363 goto done;
1364 td->td_pflags |= TDP_OLDMASK;
1365 /*
1366 * Make sure that ast() is called on return to
1367 * usermode and TDP_OLDMASK is cleared, restoring old
1368 * sigmask.
1369 */
1370 thread_lock(td);
1371 td->td_flags |= TDF_ASTPENDING;
1372 thread_unlock(td);
1373 }
1374
1375 seltdinit(td);
1376 /* Iterate until the timeout expires or descriptors become ready. */
1377 for (;;) {
1378 error = pollscan(td, bits, nfds);
1379 if (error || td->td_retval[0] != 0)
1380 break;
1381 error = seltdwait(td, sbt, precision);
1382 if (error)
1383 break;
1384 error = pollrescan(td);
1385 if (error || td->td_retval[0] != 0)
1386 break;
1387 }
1388 seltdclear(td);
1389
1390 done:
1391 /* poll is not restarted after signals... */
1392 if (error == ERESTART)
1393 error = EINTR;
1394 if (error == EWOULDBLOCK)
1395 error = 0;
1396 if (error == 0) {
1397 error = pollout(td, bits, fds, nfds);
1398 if (error)
1399 goto out;
1400 }
1401 out:
1402 if (ni > sizeof(smallbits))
1403 free(bits, M_TEMP);
1404 return (error);
1405 }
1406
1407 int
1408 sys_ppoll(struct thread *td, struct ppoll_args *uap)
1409 {
1410 struct timespec ts, *tsp;
1411 sigset_t set, *ssp;
1412 int error;
1413
1414 if (uap->ts != NULL) {
1415 error = copyin(uap->ts, &ts, sizeof(ts));
1416 if (error)
1417 return (error);
1418 tsp = &ts;
1419 } else
1420 tsp = NULL;
1421 if (uap->set != NULL) {
1422 error = copyin(uap->set, &set, sizeof(set));
1423 if (error)
1424 return (error);
1425 ssp = &set;
1426 } else
1427 ssp = NULL;
1428 /*
1429 * fds is still a pointer to user space. kern_poll() will
1430 * take care of copyin that array to the kernel space.
1431 */
1432
1433 return (kern_poll(td, uap->fds, uap->nfds, tsp, ssp));
1434 }
1435
1436 static int
1437 pollrescan(struct thread *td)
1438 {
1439 struct seltd *stp;
1440 struct selfd *sfp;
1441 struct selfd *sfn;
1442 struct selinfo *si;
1443 struct filedesc *fdp;
1444 struct file *fp;
1445 struct pollfd *fd;
1446 int n;
1447
1448 n = 0;
1449 fdp = td->td_proc->p_fd;
1450 stp = td->td_sel;
1451 FILEDESC_SLOCK(fdp);
1452 STAILQ_FOREACH_SAFE(sfp, &stp->st_selq, sf_link, sfn) {
1453 fd = (struct pollfd *)sfp->sf_cookie;
1454 si = sfp->sf_si;
1455 selfdfree(stp, sfp);
1456 /* If the selinfo wasn't cleared the event didn't fire. */
1457 if (si != NULL)
1458 continue;
1459 fp = fdp->fd_ofiles[fd->fd].fde_file;
1460 #ifdef CAPABILITIES
1461 if (fp == NULL ||
1462 cap_check(cap_rights(fdp, fd->fd), &cap_event_rights) != 0)
1463 #else
1464 if (fp == NULL)
1465 #endif
1466 {
1467 fd->revents = POLLNVAL;
1468 n++;
1469 continue;
1470 }
1471
1472 /*
1473 * Note: backend also returns POLLHUP and
1474 * POLLERR if appropriate.
1475 */
1476 fd->revents = fo_poll(fp, fd->events, td->td_ucred, td);
1477 if (fd->revents != 0)
1478 n++;
1479 }
1480 FILEDESC_SUNLOCK(fdp);
1481 stp->st_flags = 0;
1482 td->td_retval[0] = n;
1483 return (0);
1484 }
1485
1486
1487 static int
1488 pollout(struct thread *td, struct pollfd *fds, struct pollfd *ufds, u_int nfd)
1489 {
1490 int error = 0;
1491 u_int i = 0;
1492 u_int n = 0;
1493
1494 for (i = 0; i < nfd; i++) {
1495 error = copyout(&fds->revents, &ufds->revents,
1496 sizeof(ufds->revents));
1497 if (error)
1498 return (error);
1499 if (fds->revents != 0)
1500 n++;
1501 fds++;
1502 ufds++;
1503 }
1504 td->td_retval[0] = n;
1505 return (0);
1506 }
1507
1508 static int
1509 pollscan(struct thread *td, struct pollfd *fds, u_int nfd)
1510 {
1511 struct filedesc *fdp = td->td_proc->p_fd;
1512 struct file *fp;
1513 int i, n = 0;
1514
1515 FILEDESC_SLOCK(fdp);
1516 for (i = 0; i < nfd; i++, fds++) {
1517 if (fds->fd > fdp->fd_lastfile) {
1518 fds->revents = POLLNVAL;
1519 n++;
1520 } else if (fds->fd < 0) {
1521 fds->revents = 0;
1522 } else {
1523 fp = fdp->fd_ofiles[fds->fd].fde_file;
1524 #ifdef CAPABILITIES
1525 if (fp == NULL ||
1526 cap_check(cap_rights(fdp, fds->fd), &cap_event_rights) != 0)
1527 #else
1528 if (fp == NULL)
1529 #endif
1530 {
1531 fds->revents = POLLNVAL;
1532 n++;
1533 } else {
1534 /*
1535 * Note: backend also returns POLLHUP and
1536 * POLLERR if appropriate.
1537 */
1538 selfdalloc(td, fds);
1539 fds->revents = fo_poll(fp, fds->events,
1540 td->td_ucred, td);
1541 /*
1542 * POSIX requires POLLOUT to be never
1543 * set simultaneously with POLLHUP.
1544 */
1545 if ((fds->revents & POLLHUP) != 0)
1546 fds->revents &= ~POLLOUT;
1547
1548 if (fds->revents != 0)
1549 n++;
1550 }
1551 }
1552 }
1553 FILEDESC_SUNLOCK(fdp);
1554 td->td_retval[0] = n;
1555 return (0);
1556 }
1557
1558 /*
1559 * XXX This was created specifically to support netncp and netsmb. This
1560 * allows the caller to specify a socket to wait for events on. It returns
1561 * 0 if any events matched and an error otherwise. There is no way to
1562 * determine which events fired.
1563 */
1564 int
1565 selsocket(struct socket *so, int events, struct timeval *tvp, struct thread *td)
1566 {
1567 struct timeval rtv;
1568 sbintime_t asbt, precision, rsbt;
1569 int error;
1570
1571 precision = 0; /* stupid gcc! */
1572 if (tvp != NULL) {
1573 rtv = *tvp;
1574 if (rtv.tv_sec < 0 || rtv.tv_usec < 0 ||
1575 rtv.tv_usec >= 1000000)
1576 return (EINVAL);
1577 if (!timevalisset(&rtv))
1578 asbt = 0;
1579 else if (rtv.tv_sec <= INT32_MAX) {
1580 rsbt = tvtosbt(rtv);
1581 precision = rsbt;
1582 precision >>= tc_precexp;
1583 if (TIMESEL(&asbt, rsbt))
1584 asbt += tc_tick_sbt;
1585 if (asbt <= SBT_MAX - rsbt)
1586 asbt += rsbt;
1587 else
1588 asbt = -1;
1589 } else
1590 asbt = -1;
1591 } else
1592 asbt = -1;
1593 seltdinit(td);
1594 /*
1595 * Iterate until the timeout expires or the socket becomes ready.
1596 */
1597 for (;;) {
1598 selfdalloc(td, NULL);
1599 if (sopoll(so, events, NULL, td) != 0) {
1600 error = 0;
1601 break;
1602 }
1603 error = seltdwait(td, asbt, precision);
1604 if (error)
1605 break;
1606 }
1607 seltdclear(td);
1608 /* XXX Duplicates ncp/smb behavior. */
1609 if (error == ERESTART)
1610 error = 0;
1611 return (error);
1612 }
1613
1614 /*
1615 * Preallocate two selfds associated with 'cookie'. Some fo_poll routines
1616 * have two select sets, one for read and another for write.
1617 */
1618 static void
1619 selfdalloc(struct thread *td, void *cookie)
1620 {
1621 struct seltd *stp;
1622
1623 stp = td->td_sel;
1624 if (stp->st_free1 == NULL)
1625 stp->st_free1 = uma_zalloc(selfd_zone, M_WAITOK|M_ZERO);
1626 stp->st_free1->sf_td = stp;
1627 stp->st_free1->sf_cookie = cookie;
1628 if (stp->st_free2 == NULL)
1629 stp->st_free2 = uma_zalloc(selfd_zone, M_WAITOK|M_ZERO);
1630 stp->st_free2->sf_td = stp;
1631 stp->st_free2->sf_cookie = cookie;
1632 }
1633
1634 static void
1635 selfdfree(struct seltd *stp, struct selfd *sfp)
1636 {
1637 STAILQ_REMOVE(&stp->st_selq, sfp, selfd, sf_link);
1638 if (sfp->sf_si != NULL) {
1639 mtx_lock(sfp->sf_mtx);
1640 if (sfp->sf_si != NULL) {
1641 TAILQ_REMOVE(&sfp->sf_si->si_tdlist, sfp, sf_threads);
1642 refcount_release(&sfp->sf_refs);
1643 }
1644 mtx_unlock(sfp->sf_mtx);
1645 }
1646 if (refcount_release(&sfp->sf_refs))
1647 uma_zfree(selfd_zone, sfp);
1648 }
1649
1650 /* Drain the waiters tied to all the selfd belonging the specified selinfo. */
1651 void
1652 seldrain(struct selinfo *sip)
1653 {
1654
1655 /*
1656 * This feature is already provided by doselwakeup(), thus it is
1657 * enough to go for it.
1658 * Eventually, the context, should take care to avoid races
1659 * between thread calling select()/poll() and file descriptor
1660 * detaching, but, again, the races are just the same as
1661 * selwakeup().
1662 */
1663 doselwakeup(sip, -1);
1664 }
1665
1666 /*
1667 * Record a select request.
1668 */
1669 void
1670 selrecord(struct thread *selector, struct selinfo *sip)
1671 {
1672 struct selfd *sfp;
1673 struct seltd *stp;
1674 struct mtx *mtxp;
1675
1676 stp = selector->td_sel;
1677 /*
1678 * Don't record when doing a rescan.
1679 */
1680 if (stp->st_flags & SELTD_RESCAN)
1681 return;
1682 /*
1683 * Grab one of the preallocated descriptors.
1684 */
1685 sfp = NULL;
1686 if ((sfp = stp->st_free1) != NULL)
1687 stp->st_free1 = NULL;
1688 else if ((sfp = stp->st_free2) != NULL)
1689 stp->st_free2 = NULL;
1690 else
1691 panic("selrecord: No free selfd on selq");
1692 mtxp = sip->si_mtx;
1693 if (mtxp == NULL)
1694 mtxp = mtx_pool_find(mtxpool_select, sip);
1695 /*
1696 * Initialize the sfp and queue it in the thread.
1697 */
1698 sfp->sf_si = sip;
1699 sfp->sf_mtx = mtxp;
1700 refcount_init(&sfp->sf_refs, 2);
1701 STAILQ_INSERT_TAIL(&stp->st_selq, sfp, sf_link);
1702 /*
1703 * Now that we've locked the sip, check for initialization.
1704 */
1705 mtx_lock(mtxp);
1706 if (sip->si_mtx == NULL) {
1707 sip->si_mtx = mtxp;
1708 TAILQ_INIT(&sip->si_tdlist);
1709 }
1710 /*
1711 * Add this thread to the list of selfds listening on this selinfo.
1712 */
1713 TAILQ_INSERT_TAIL(&sip->si_tdlist, sfp, sf_threads);
1714 mtx_unlock(sip->si_mtx);
1715 }
1716
1717 /* Wake up a selecting thread. */
1718 void
1719 selwakeup(struct selinfo *sip)
1720 {
1721 doselwakeup(sip, -1);
1722 }
1723
1724 /* Wake up a selecting thread, and set its priority. */
1725 void
1726 selwakeuppri(struct selinfo *sip, int pri)
1727 {
1728 doselwakeup(sip, pri);
1729 }
1730
1731 /*
1732 * Do a wakeup when a selectable event occurs.
1733 */
1734 static void
1735 doselwakeup(struct selinfo *sip, int pri)
1736 {
1737 struct selfd *sfp;
1738 struct selfd *sfn;
1739 struct seltd *stp;
1740
1741 /* If it's not initialized there can't be any waiters. */
1742 if (sip->si_mtx == NULL)
1743 return;
1744 /*
1745 * Locking the selinfo locks all selfds associated with it.
1746 */
1747 mtx_lock(sip->si_mtx);
1748 TAILQ_FOREACH_SAFE(sfp, &sip->si_tdlist, sf_threads, sfn) {
1749 /*
1750 * Once we remove this sfp from the list and clear the
1751 * sf_si seltdclear will know to ignore this si.
1752 */
1753 TAILQ_REMOVE(&sip->si_tdlist, sfp, sf_threads);
1754 sfp->sf_si = NULL;
1755 stp = sfp->sf_td;
1756 mtx_lock(&stp->st_mtx);
1757 stp->st_flags |= SELTD_PENDING;
1758 cv_broadcastpri(&stp->st_wait, pri);
1759 mtx_unlock(&stp->st_mtx);
1760 if (refcount_release(&sfp->sf_refs))
1761 uma_zfree(selfd_zone, sfp);
1762 }
1763 mtx_unlock(sip->si_mtx);
1764 }
1765
1766 static void
1767 seltdinit(struct thread *td)
1768 {
1769 struct seltd *stp;
1770
1771 if ((stp = td->td_sel) != NULL)
1772 goto out;
1773 td->td_sel = stp = malloc(sizeof(*stp), M_SELECT, M_WAITOK|M_ZERO);
1774 mtx_init(&stp->st_mtx, "sellck", NULL, MTX_DEF);
1775 cv_init(&stp->st_wait, "select");
1776 out:
1777 stp->st_flags = 0;
1778 STAILQ_INIT(&stp->st_selq);
1779 }
1780
1781 static int
1782 seltdwait(struct thread *td, sbintime_t sbt, sbintime_t precision)
1783 {
1784 struct seltd *stp;
1785 int error;
1786
1787 stp = td->td_sel;
1788 /*
1789 * An event of interest may occur while we do not hold the seltd
1790 * locked so check the pending flag before we sleep.
1791 */
1792 mtx_lock(&stp->st_mtx);
1793 /*
1794 * Any further calls to selrecord will be a rescan.
1795 */
1796 stp->st_flags |= SELTD_RESCAN;
1797 if (stp->st_flags & SELTD_PENDING) {
1798 mtx_unlock(&stp->st_mtx);
1799 return (0);
1800 }
1801 if (sbt == 0)
1802 error = EWOULDBLOCK;
1803 else if (sbt != -1)
1804 error = cv_timedwait_sig_sbt(&stp->st_wait, &stp->st_mtx,
1805 sbt, precision, C_ABSOLUTE);
1806 else
1807 error = cv_wait_sig(&stp->st_wait, &stp->st_mtx);
1808 mtx_unlock(&stp->st_mtx);
1809
1810 return (error);
1811 }
1812
1813 void
1814 seltdfini(struct thread *td)
1815 {
1816 struct seltd *stp;
1817
1818 stp = td->td_sel;
1819 if (stp == NULL)
1820 return;
1821 if (stp->st_free1)
1822 uma_zfree(selfd_zone, stp->st_free1);
1823 if (stp->st_free2)
1824 uma_zfree(selfd_zone, stp->st_free2);
1825 td->td_sel = NULL;
1826 cv_destroy(&stp->st_wait);
1827 mtx_destroy(&stp->st_mtx);
1828 free(stp, M_SELECT);
1829 }
1830
1831 /*
1832 * Remove the references to the thread from all of the objects we were
1833 * polling.
1834 */
1835 static void
1836 seltdclear(struct thread *td)
1837 {
1838 struct seltd *stp;
1839 struct selfd *sfp;
1840 struct selfd *sfn;
1841
1842 stp = td->td_sel;
1843 STAILQ_FOREACH_SAFE(sfp, &stp->st_selq, sf_link, sfn)
1844 selfdfree(stp, sfp);
1845 stp->st_flags = 0;
1846 }
1847
1848 static void selectinit(void *);
1849 SYSINIT(select, SI_SUB_SYSCALLS, SI_ORDER_ANY, selectinit, NULL);
1850 static void
1851 selectinit(void *dummy __unused)
1852 {
1853
1854 selfd_zone = uma_zcreate("selfd", sizeof(struct selfd), NULL, NULL,
1855 NULL, NULL, UMA_ALIGN_PTR, 0);
1856 mtxpool_select = mtx_pool_create("select mtxpool", 128, MTX_DEF);
1857 }
1858
1859 /*
1860 * Set up a syscall return value that follows the convention specified for
1861 * posix_* functions.
1862 */
1863 int
1864 kern_posix_error(struct thread *td, int error)
1865 {
1866
1867 if (error <= 0)
1868 return (error);
1869 td->td_errno = error;
1870 td->td_pflags |= TDP_NERRNO;
1871 td->td_retval[0] = error;
1872 return (0);
1873 }
Cache object: 3b76b8a964595d6a0ce234ab88732a82
|