source: rtems-libbsd/freebsd/sys/kern/sys_generic.c @ d4bf70e

55-freebsd-126-freebsd-12
Last change on this file since d4bf70e was d4bf70e, checked in by Sebastian Huber <sebastian.huber@…>, on Nov 15, 2018 at 9:06:00 AM

Disable or make static kern_* functions

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