File: | kern/sys_generic.c |
Warning: | line 501, column 12 Assigned value is garbage or undefined |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
1 | /* $OpenBSD: sys_generic.c,v 1.146 2021/12/11 09:28:26 visa Exp $ */ | |||
2 | /* $NetBSD: sys_generic.c,v 1.24 1996/03/29 00:25:32 cgd Exp $ */ | |||
3 | ||||
4 | /* | |||
5 | * Copyright (c) 1996 Theo de Raadt | |||
6 | * Copyright (c) 1982, 1986, 1989, 1993 | |||
7 | * The Regents of the University of California. All rights reserved. | |||
8 | * (c) UNIX System Laboratories, Inc. | |||
9 | * All or some portions of this file are derived from material licensed | |||
10 | * to the University of California by American Telephone and Telegraph | |||
11 | * Co. or Unix System Laboratories, Inc. and are reproduced herein with | |||
12 | * the permission of UNIX System Laboratories, Inc. | |||
13 | * | |||
14 | * Redistribution and use in source and binary forms, with or without | |||
15 | * modification, are permitted provided that the following conditions | |||
16 | * are met: | |||
17 | * 1. Redistributions of source code must retain the above copyright | |||
18 | * notice, this list of conditions and the following disclaimer. | |||
19 | * 2. Redistributions in binary form must reproduce the above copyright | |||
20 | * notice, this list of conditions and the following disclaimer in the | |||
21 | * documentation and/or other materials provided with the distribution. | |||
22 | * 3. Neither the name of the University nor the names of its contributors | |||
23 | * may be used to endorse or promote products derived from this software | |||
24 | * without specific prior written permission. | |||
25 | * | |||
26 | * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | |||
27 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | |||
28 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | |||
29 | * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | |||
30 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | |||
31 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | |||
32 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | |||
33 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | |||
34 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | |||
35 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | |||
36 | * SUCH DAMAGE. | |||
37 | * | |||
38 | * @(#)sys_generic.c 8.5 (Berkeley) 1/21/94 | |||
39 | */ | |||
40 | ||||
41 | #include <sys/param.h> | |||
42 | #include <sys/systm.h> | |||
43 | #include <sys/filedesc.h> | |||
44 | #include <sys/ioctl.h> | |||
45 | #include <sys/fcntl.h> | |||
46 | #include <sys/vnode.h> | |||
47 | #include <sys/file.h> | |||
48 | #include <sys/proc.h> | |||
49 | #include <sys/resourcevar.h> | |||
50 | #include <sys/socketvar.h> | |||
51 | #include <sys/signalvar.h> | |||
52 | #include <sys/uio.h> | |||
53 | #include <sys/kernel.h> | |||
54 | #include <sys/stat.h> | |||
55 | #include <sys/time.h> | |||
56 | #include <sys/malloc.h> | |||
57 | #include <sys/poll.h> | |||
58 | #include <sys/eventvar.h> | |||
59 | #ifdef KTRACE1 | |||
60 | #include <sys/ktrace.h> | |||
61 | #endif | |||
62 | #include <sys/sched.h> | |||
63 | #include <sys/pledge.h> | |||
64 | ||||
65 | #include <sys/mount.h> | |||
66 | #include <sys/syscallargs.h> | |||
67 | ||||
68 | #include <uvm/uvm_extern.h> | |||
69 | ||||
70 | /* | |||
71 | * Debug values: | |||
72 | * 1 - print implementation errors, things that should not happen. | |||
73 | * 2 - print ppoll(2) information, somewhat verbose | |||
74 | * 3 - print pselect(2) and ppoll(2) information, very verbose | |||
75 | */ | |||
76 | int kqpoll_debug = 0; | |||
77 | #define DPRINTFN(v, x...)if (kqpoll_debug > v) { printf("%s(%d): ", ({struct cpu_info *__ci; asm volatile("movq %%gs:%P1,%0" : "=r" (__ci) :"n" (__builtin_offsetof (struct cpu_info, ci_self))); __ci;})->ci_curproc->p_p-> ps_comm, ({struct cpu_info *__ci; asm volatile("movq %%gs:%P1,%0" : "=r" (__ci) :"n" (__builtin_offsetof(struct cpu_info, ci_self ))); __ci;})->ci_curproc->p_tid); printf(x...); } if (kqpoll_debug > v) { \ | |||
78 | printf("%s(%d): ", curproc({struct cpu_info *__ci; asm volatile("movq %%gs:%P1,%0" : "=r" (__ci) :"n" (__builtin_offsetof(struct cpu_info, ci_self))); __ci;})->ci_curproc->p_p->ps_comm, curproc({struct cpu_info *__ci; asm volatile("movq %%gs:%P1,%0" : "=r" (__ci) :"n" (__builtin_offsetof(struct cpu_info, ci_self))); __ci;})->ci_curproc->p_tid); \ | |||
79 | printf(x); \ | |||
80 | } | |||
81 | ||||
82 | int pselregister(struct proc *, fd_set *[], fd_set *[], int, int *, int *); | |||
83 | int pselcollect(struct proc *, struct kevent *, fd_set *[], int *); | |||
84 | ||||
85 | void pollscan(struct proc *, struct pollfd *, u_int, register_t *); | |||
86 | int pollout(struct pollfd *, struct pollfd *, u_int); | |||
87 | int dopselect(struct proc *, int, fd_set *, fd_set *, fd_set *, | |||
88 | struct timespec *, const sigset_t *, register_t *); | |||
89 | int doppoll(struct proc *, struct pollfd *, u_int, struct timespec *, | |||
90 | const sigset_t *, register_t *); | |||
91 | void doselwakeup(struct selinfo *); | |||
92 | ||||
93 | int | |||
94 | iovec_copyin(const struct iovec *uiov, struct iovec **iovp, struct iovec *aiov, | |||
95 | unsigned int iovcnt, size_t *residp) | |||
96 | { | |||
97 | #ifdef KTRACE1 | |||
98 | struct proc *p = curproc({struct cpu_info *__ci; asm volatile("movq %%gs:%P1,%0" : "=r" (__ci) :"n" (__builtin_offsetof(struct cpu_info, ci_self))); __ci;})->ci_curproc; | |||
99 | #endif | |||
100 | struct iovec *iov; | |||
101 | int error, i; | |||
102 | size_t resid = 0; | |||
103 | ||||
104 | if (iovcnt > UIO_SMALLIOV8) { | |||
105 | if (iovcnt > IOV_MAX1024) | |||
106 | return (EINVAL22); | |||
107 | iov = mallocarray(iovcnt, sizeof(*iov), M_IOV19, M_WAITOK0x0001); | |||
108 | } else if (iovcnt > 0) { | |||
109 | iov = aiov; | |||
110 | } else { | |||
111 | return (EINVAL22); | |||
112 | } | |||
113 | *iovp = iov; | |||
114 | ||||
115 | if ((error = copyin(uiov, iov, iovcnt * sizeof(*iov)))) | |||
116 | return (error); | |||
117 | ||||
118 | #ifdef KTRACE1 | |||
119 | if (KTRPOINT(p, KTR_STRUCT)((p)->p_p->ps_traceflag & (1<<(8)) && ((p)->p_flag & 0x00000001) == 0)) | |||
120 | ktriovec(p, iov, iovcnt)ktrstruct(p, "iovec", iov, (iovcnt) * sizeof(struct iovec)); | |||
121 | #endif | |||
122 | ||||
123 | for (i = 0; i < iovcnt; i++) { | |||
124 | resid += iov->iov_len; | |||
125 | /* | |||
126 | * Writes return ssize_t because -1 is returned on error. | |||
127 | * Therefore we must restrict the length to SSIZE_MAX to | |||
128 | * avoid garbage return values. Note that the addition is | |||
129 | * guaranteed to not wrap because SSIZE_MAX * 2 < SIZE_MAX. | |||
130 | */ | |||
131 | if (iov->iov_len > SSIZE_MAX0x7fffffffffffffffL || resid > SSIZE_MAX0x7fffffffffffffffL) | |||
132 | return (EINVAL22); | |||
133 | iov++; | |||
134 | } | |||
135 | ||||
136 | if (residp != NULL((void *)0)) | |||
137 | *residp = resid; | |||
138 | ||||
139 | return (0); | |||
140 | } | |||
141 | ||||
142 | void | |||
143 | iovec_free(struct iovec *iov, unsigned int iovcnt) | |||
144 | { | |||
145 | if (iovcnt > UIO_SMALLIOV8) | |||
146 | free(iov, M_IOV19, iovcnt * sizeof(*iov)); | |||
147 | } | |||
148 | ||||
149 | /* | |||
150 | * Read system call. | |||
151 | */ | |||
152 | int | |||
153 | sys_read(struct proc *p, void *v, register_t *retval) | |||
154 | { | |||
155 | struct sys_read_args /* { | |||
156 | syscallarg(int) fd; | |||
157 | syscallarg(void *) buf; | |||
158 | syscallarg(size_t) nbyte; | |||
159 | } */ *uap = v; | |||
160 | struct iovec iov; | |||
161 | struct uio auio; | |||
162 | ||||
163 | iov.iov_base = SCARG(uap, buf)((uap)->buf.le.datum); | |||
164 | iov.iov_len = SCARG(uap, nbyte)((uap)->nbyte.le.datum); | |||
165 | if (iov.iov_len > SSIZE_MAX0x7fffffffffffffffL) | |||
166 | return (EINVAL22); | |||
167 | ||||
168 | auio.uio_iov = &iov; | |||
169 | auio.uio_iovcnt = 1; | |||
170 | auio.uio_resid = iov.iov_len; | |||
171 | ||||
172 | return (dofilereadv(p, SCARG(uap, fd)((uap)->fd.le.datum), &auio, 0, retval)); | |||
173 | } | |||
174 | ||||
175 | /* | |||
176 | * Scatter read system call. | |||
177 | */ | |||
178 | int | |||
179 | sys_readv(struct proc *p, void *v, register_t *retval) | |||
180 | { | |||
181 | struct sys_readv_args /* { | |||
182 | syscallarg(int) fd; | |||
183 | syscallarg(const struct iovec *) iovp; | |||
184 | syscallarg(int) iovcnt; | |||
185 | } */ *uap = v; | |||
186 | struct iovec aiov[UIO_SMALLIOV8], *iov = NULL((void *)0); | |||
187 | int error, iovcnt = SCARG(uap, iovcnt)((uap)->iovcnt.le.datum); | |||
188 | struct uio auio; | |||
189 | size_t resid; | |||
190 | ||||
191 | error = iovec_copyin(SCARG(uap, iovp)((uap)->iovp.le.datum), &iov, aiov, iovcnt, &resid); | |||
192 | if (error) | |||
193 | goto done; | |||
194 | ||||
195 | auio.uio_iov = iov; | |||
196 | auio.uio_iovcnt = iovcnt; | |||
197 | auio.uio_resid = resid; | |||
198 | ||||
199 | error = dofilereadv(p, SCARG(uap, fd)((uap)->fd.le.datum), &auio, 0, retval); | |||
200 | done: | |||
201 | iovec_free(iov, iovcnt); | |||
202 | return (error); | |||
203 | } | |||
204 | ||||
205 | int | |||
206 | dofilereadv(struct proc *p, int fd, struct uio *uio, int flags, | |||
207 | register_t *retval) | |||
208 | { | |||
209 | struct filedesc *fdp = p->p_fd; | |||
210 | struct file *fp; | |||
211 | long cnt, error = 0; | |||
212 | u_int iovlen; | |||
213 | #ifdef KTRACE1 | |||
214 | struct iovec *ktriov = NULL((void *)0); | |||
215 | #endif | |||
216 | ||||
217 | KASSERT(uio->uio_iov != NULL && uio->uio_iovcnt > 0)((uio->uio_iov != ((void *)0) && uio->uio_iovcnt > 0) ? (void)0 : __assert("diagnostic ", "/usr/src/sys/kern/sys_generic.c" , 217, "uio->uio_iov != NULL && uio->uio_iovcnt > 0" )); | |||
218 | iovlen = uio->uio_iovcnt * sizeof(struct iovec); | |||
219 | ||||
220 | if ((fp = fd_getfile_mode(fdp, fd, FREAD0x0001)) == NULL((void *)0)) | |||
221 | return (EBADF9); | |||
222 | ||||
223 | /* Checks for positioned read. */ | |||
224 | if (flags & FO_POSITION0x00000001) { | |||
225 | struct vnode *vp = fp->f_data; | |||
226 | ||||
227 | if (fp->f_type != DTYPE_VNODE1 || vp->v_type == VFIFO || | |||
228 | (vp->v_flag & VISTTY0x0008)) { | |||
229 | error = ESPIPE29; | |||
230 | goto done; | |||
231 | } | |||
232 | ||||
233 | if (uio->uio_offset < 0 && vp->v_type != VCHR) { | |||
234 | error = EINVAL22; | |||
235 | goto done; | |||
236 | } | |||
237 | } | |||
238 | ||||
239 | uio->uio_rw = UIO_READ; | |||
240 | uio->uio_segflg = UIO_USERSPACE; | |||
241 | uio->uio_procp = p; | |||
242 | #ifdef KTRACE1 | |||
243 | /* | |||
244 | * if tracing, save a copy of iovec | |||
245 | */ | |||
246 | if (KTRPOINT(p, KTR_GENIO)((p)->p_p->ps_traceflag & (1<<(4)) && ((p)->p_flag & 0x00000001) == 0)) { | |||
247 | ktriov = malloc(iovlen, M_TEMP127, M_WAITOK0x0001); | |||
248 | memcpy(ktriov, uio->uio_iov, iovlen)__builtin_memcpy((ktriov), (uio->uio_iov), (iovlen)); | |||
249 | } | |||
250 | #endif | |||
251 | cnt = uio->uio_resid; | |||
252 | error = (*fp->f_ops->fo_read)(fp, uio, flags); | |||
253 | if (error) { | |||
254 | if (uio->uio_resid != cnt && (error == ERESTART-1 || | |||
255 | error == EINTR4 || error == EWOULDBLOCK35)) | |||
256 | error = 0; | |||
257 | } | |||
258 | cnt -= uio->uio_resid; | |||
259 | ||||
260 | mtx_enter(&fp->f_mtx); | |||
261 | fp->f_rxfer++; | |||
262 | fp->f_rbytes += cnt; | |||
263 | mtx_leave(&fp->f_mtx); | |||
264 | #ifdef KTRACE1 | |||
265 | if (ktriov != NULL((void *)0)) { | |||
266 | if (error == 0) | |||
267 | ktrgenio(p, fd, UIO_READ, ktriov, cnt); | |||
268 | free(ktriov, M_TEMP127, iovlen); | |||
269 | } | |||
270 | #endif | |||
271 | *retval = cnt; | |||
272 | done: | |||
273 | FRELE(fp, p)(_atomic_sub_int_nv((&fp->f_count), 1) == 0 ? fdrop(fp , p) : 0); | |||
274 | return (error); | |||
275 | } | |||
276 | ||||
277 | /* | |||
278 | * Write system call | |||
279 | */ | |||
280 | int | |||
281 | sys_write(struct proc *p, void *v, register_t *retval) | |||
282 | { | |||
283 | struct sys_write_args /* { | |||
284 | syscallarg(int) fd; | |||
285 | syscallarg(const void *) buf; | |||
286 | syscallarg(size_t) nbyte; | |||
287 | } */ *uap = v; | |||
288 | struct iovec iov; | |||
289 | struct uio auio; | |||
290 | ||||
291 | iov.iov_base = (void *)SCARG(uap, buf)((uap)->buf.le.datum); | |||
292 | iov.iov_len = SCARG(uap, nbyte)((uap)->nbyte.le.datum); | |||
293 | if (iov.iov_len > SSIZE_MAX0x7fffffffffffffffL) | |||
294 | return (EINVAL22); | |||
295 | ||||
296 | auio.uio_iov = &iov; | |||
297 | auio.uio_iovcnt = 1; | |||
298 | auio.uio_resid = iov.iov_len; | |||
299 | ||||
300 | return (dofilewritev(p, SCARG(uap, fd)((uap)->fd.le.datum), &auio, 0, retval)); | |||
301 | } | |||
302 | ||||
303 | /* | |||
304 | * Gather write system call | |||
305 | */ | |||
306 | int | |||
307 | sys_writev(struct proc *p, void *v, register_t *retval) | |||
308 | { | |||
309 | struct sys_writev_args /* { | |||
310 | syscallarg(int) fd; | |||
311 | syscallarg(const struct iovec *) iovp; | |||
312 | syscallarg(int) iovcnt; | |||
313 | } */ *uap = v; | |||
314 | struct iovec aiov[UIO_SMALLIOV8], *iov = NULL((void *)0); | |||
315 | int error, iovcnt = SCARG(uap, iovcnt)((uap)->iovcnt.le.datum); | |||
316 | struct uio auio; | |||
317 | size_t resid; | |||
318 | ||||
319 | error = iovec_copyin(SCARG(uap, iovp)((uap)->iovp.le.datum), &iov, aiov, iovcnt, &resid); | |||
320 | if (error) | |||
321 | goto done; | |||
322 | ||||
323 | auio.uio_iov = iov; | |||
324 | auio.uio_iovcnt = iovcnt; | |||
325 | auio.uio_resid = resid; | |||
326 | ||||
327 | error = dofilewritev(p, SCARG(uap, fd)((uap)->fd.le.datum), &auio, 0, retval); | |||
328 | done: | |||
329 | iovec_free(iov, iovcnt); | |||
330 | return (error); | |||
331 | } | |||
332 | ||||
333 | int | |||
334 | dofilewritev(struct proc *p, int fd, struct uio *uio, int flags, | |||
335 | register_t *retval) | |||
336 | { | |||
337 | struct filedesc *fdp = p->p_fd; | |||
338 | struct file *fp; | |||
339 | long cnt, error = 0; | |||
340 | u_int iovlen; | |||
341 | #ifdef KTRACE1 | |||
342 | struct iovec *ktriov = NULL((void *)0); | |||
343 | #endif | |||
344 | ||||
345 | KASSERT(uio->uio_iov != NULL && uio->uio_iovcnt > 0)((uio->uio_iov != ((void *)0) && uio->uio_iovcnt > 0) ? (void)0 : __assert("diagnostic ", "/usr/src/sys/kern/sys_generic.c" , 345, "uio->uio_iov != NULL && uio->uio_iovcnt > 0" )); | |||
346 | iovlen = uio->uio_iovcnt * sizeof(struct iovec); | |||
347 | ||||
348 | if ((fp = fd_getfile_mode(fdp, fd, FWRITE0x0002)) == NULL((void *)0)) | |||
349 | return (EBADF9); | |||
350 | ||||
351 | /* Checks for positioned write. */ | |||
352 | if (flags & FO_POSITION0x00000001) { | |||
353 | struct vnode *vp = fp->f_data; | |||
354 | ||||
355 | if (fp->f_type != DTYPE_VNODE1 || vp->v_type == VFIFO || | |||
356 | (vp->v_flag & VISTTY0x0008)) { | |||
357 | error = ESPIPE29; | |||
358 | goto done; | |||
359 | } | |||
360 | ||||
361 | if (uio->uio_offset < 0 && vp->v_type != VCHR) { | |||
362 | error = EINVAL22; | |||
363 | goto done; | |||
364 | } | |||
365 | } | |||
366 | ||||
367 | uio->uio_rw = UIO_WRITE; | |||
368 | uio->uio_segflg = UIO_USERSPACE; | |||
369 | uio->uio_procp = p; | |||
370 | #ifdef KTRACE1 | |||
371 | /* | |||
372 | * if tracing, save a copy of iovec | |||
373 | */ | |||
374 | if (KTRPOINT(p, KTR_GENIO)((p)->p_p->ps_traceflag & (1<<(4)) && ((p)->p_flag & 0x00000001) == 0)) { | |||
375 | ktriov = malloc(iovlen, M_TEMP127, M_WAITOK0x0001); | |||
376 | memcpy(ktriov, uio->uio_iov, iovlen)__builtin_memcpy((ktriov), (uio->uio_iov), (iovlen)); | |||
377 | } | |||
378 | #endif | |||
379 | cnt = uio->uio_resid; | |||
380 | error = (*fp->f_ops->fo_write)(fp, uio, flags); | |||
381 | if (error) { | |||
382 | if (uio->uio_resid != cnt && (error == ERESTART-1 || | |||
383 | error == EINTR4 || error == EWOULDBLOCK35)) | |||
384 | error = 0; | |||
385 | if (error == EPIPE32) { | |||
386 | KERNEL_LOCK()_kernel_lock(); | |||
387 | ptsignal(p, SIGPIPE13, STHREAD); | |||
388 | KERNEL_UNLOCK()_kernel_unlock(); | |||
389 | } | |||
390 | } | |||
391 | cnt -= uio->uio_resid; | |||
392 | ||||
393 | mtx_enter(&fp->f_mtx); | |||
394 | fp->f_wxfer++; | |||
395 | fp->f_wbytes += cnt; | |||
396 | mtx_leave(&fp->f_mtx); | |||
397 | #ifdef KTRACE1 | |||
398 | if (ktriov != NULL((void *)0)) { | |||
399 | if (error == 0) | |||
400 | ktrgenio(p, fd, UIO_WRITE, ktriov, cnt); | |||
401 | free(ktriov, M_TEMP127, iovlen); | |||
402 | } | |||
403 | #endif | |||
404 | *retval = cnt; | |||
405 | done: | |||
406 | FRELE(fp, p)(_atomic_sub_int_nv((&fp->f_count), 1) == 0 ? fdrop(fp , p) : 0); | |||
407 | return (error); | |||
408 | } | |||
409 | ||||
410 | /* | |||
411 | * Ioctl system call | |||
412 | */ | |||
413 | int | |||
414 | sys_ioctl(struct proc *p, void *v, register_t *retval) | |||
415 | { | |||
416 | struct sys_ioctl_args /* { | |||
417 | syscallarg(int) fd; | |||
418 | syscallarg(u_long) com; | |||
419 | syscallarg(void *) data; | |||
420 | } */ *uap = v; | |||
421 | struct file *fp; | |||
422 | struct filedesc *fdp = p->p_fd; | |||
423 | u_long com = SCARG(uap, com)((uap)->com.le.datum); | |||
424 | int error = 0; | |||
425 | u_int size = 0; | |||
426 | caddr_t data, memp = NULL((void *)0); | |||
427 | int tmp; | |||
428 | #define STK_PARAMS128 128 | |||
429 | long long stkbuf[STK_PARAMS128 / sizeof(long long)]; | |||
430 | ||||
431 | if ((fp = fd_getfile_mode(fdp, SCARG(uap, fd)((uap)->fd.le.datum), FREAD0x0001|FWRITE0x0002)) == NULL((void *)0)) | |||
| ||||
432 | return (EBADF9); | |||
433 | ||||
434 | if (fp->f_type == DTYPE_SOCKET2) { | |||
435 | struct socket *so = fp->f_data; | |||
436 | ||||
437 | if (so->so_state & SS_DNS0x4000) { | |||
438 | error = EINVAL22; | |||
439 | goto out; | |||
440 | } | |||
441 | } | |||
442 | ||||
443 | error = pledge_ioctl(p, com, fp); | |||
444 | if (error) | |||
445 | goto out; | |||
446 | ||||
447 | switch (com) { | |||
448 | case FIONCLEX((unsigned long)0x20000000 | ((0 & 0x1fff) << 16) | ((('f')) << 8) | ((2))): | |||
449 | case FIOCLEX((unsigned long)0x20000000 | ((0 & 0x1fff) << 16) | ((('f')) << 8) | ((1))): | |||
450 | fdplock(fdp)do { do { int _s = rw_status(&netlock); if ((splassert_ctl > 0) && (_s == 0x0001UL)) splassert_fail(0, 0x0001UL , __func__); } while (0); rw_enter_write(&(fdp)->fd_lock ); } while (0); | |||
451 | if (com == FIONCLEX((unsigned long)0x20000000 | ((0 & 0x1fff) << 16) | ((('f')) << 8) | ((2)))) | |||
452 | fdp->fd_ofileflags[SCARG(uap, fd)((uap)->fd.le.datum)] &= ~UF_EXCLOSE0x01; | |||
453 | else | |||
454 | fdp->fd_ofileflags[SCARG(uap, fd)((uap)->fd.le.datum)] |= UF_EXCLOSE0x01; | |||
455 | fdpunlock(fdp)rw_exit_write(&(fdp)->fd_lock); | |||
456 | goto out; | |||
457 | } | |||
458 | ||||
459 | /* | |||
460 | * Interpret high order word to find amount of data to be | |||
461 | * copied to/from the user's address space. | |||
462 | */ | |||
463 | size = IOCPARM_LEN(com)(((com) >> 16) & 0x1fff); | |||
464 | if (size > IOCPARM_MAX(1 << 12)) { | |||
465 | error = ENOTTY25; | |||
466 | goto out; | |||
467 | } | |||
468 | if (size > sizeof (stkbuf)) { | |||
469 | memp = malloc(size, M_IOCTLOPS14, M_WAITOK0x0001); | |||
470 | data = memp; | |||
471 | } else | |||
472 | data = (caddr_t)stkbuf; | |||
473 | if (com&IOC_IN(unsigned long)0x80000000) { | |||
474 | if (size) { | |||
475 | error = copyin(SCARG(uap, data)((uap)->data.le.datum), data, size); | |||
476 | if (error) { | |||
477 | goto out; | |||
478 | } | |||
479 | } else | |||
480 | *(caddr_t *)data = SCARG(uap, data)((uap)->data.le.datum); | |||
481 | } else if ((com&IOC_OUT(unsigned long)0x40000000) && size) | |||
482 | /* | |||
483 | * Zero the buffer so the user always | |||
484 | * gets back something deterministic. | |||
485 | */ | |||
486 | memset(data, 0, size)__builtin_memset((data), (0), (size)); | |||
487 | else if (com&IOC_VOID(unsigned long)0x20000000) | |||
488 | *(caddr_t *)data = SCARG(uap, data)((uap)->data.le.datum); | |||
489 | ||||
490 | switch (com) { | |||
491 | ||||
492 | case FIONBIO((unsigned long)0x80000000 | ((sizeof(int) & 0x1fff) << 16) | ((('f')) << 8) | ((126))): | |||
493 | if ((tmp = *(int *)data) != 0) | |||
494 | atomic_setbits_intx86_atomic_setbits_u32(&fp->f_flag, FNONBLOCK0x0004); | |||
495 | else | |||
496 | atomic_clearbits_intx86_atomic_clearbits_u32(&fp->f_flag, FNONBLOCK0x0004); | |||
497 | error = (*fp->f_ops->fo_ioctl)(fp, FIONBIO((unsigned long)0x80000000 | ((sizeof(int) & 0x1fff) << 16) | ((('f')) << 8) | ((126))), (caddr_t)&tmp, p); | |||
498 | break; | |||
499 | ||||
500 | case FIOASYNC((unsigned long)0x80000000 | ((sizeof(int) & 0x1fff) << 16) | ((('f')) << 8) | ((125))): | |||
501 | if ((tmp = *(int *)data) != 0) | |||
| ||||
502 | atomic_setbits_intx86_atomic_setbits_u32(&fp->f_flag, FASYNC0x0040); | |||
503 | else | |||
504 | atomic_clearbits_intx86_atomic_clearbits_u32(&fp->f_flag, FASYNC0x0040); | |||
505 | error = (*fp->f_ops->fo_ioctl)(fp, FIOASYNC((unsigned long)0x80000000 | ((sizeof(int) & 0x1fff) << 16) | ((('f')) << 8) | ((125))), (caddr_t)&tmp, p); | |||
506 | break; | |||
507 | ||||
508 | default: | |||
509 | error = (*fp->f_ops->fo_ioctl)(fp, com, data, p); | |||
510 | break; | |||
511 | } | |||
512 | /* | |||
513 | * Copy any data to user, size was | |||
514 | * already set and checked above. | |||
515 | */ | |||
516 | if (error == 0 && (com&IOC_OUT(unsigned long)0x40000000) && size) | |||
517 | error = copyout(data, SCARG(uap, data)((uap)->data.le.datum), size); | |||
518 | out: | |||
519 | FRELE(fp, p)(_atomic_sub_int_nv((&fp->f_count), 1) == 0 ? fdrop(fp , p) : 0); | |||
520 | free(memp, M_IOCTLOPS14, size); | |||
521 | return (error); | |||
522 | } | |||
523 | ||||
524 | int selwait, nselcoll; | |||
525 | ||||
526 | /* | |||
527 | * Select system call. | |||
528 | */ | |||
529 | int | |||
530 | sys_select(struct proc *p, void *v, register_t *retval) | |||
531 | { | |||
532 | struct sys_select_args /* { | |||
533 | syscallarg(int) nd; | |||
534 | syscallarg(fd_set *) in; | |||
535 | syscallarg(fd_set *) ou; | |||
536 | syscallarg(fd_set *) ex; | |||
537 | syscallarg(struct timeval *) tv; | |||
538 | } */ *uap = v; | |||
539 | ||||
540 | struct timespec ts, *tsp = NULL((void *)0); | |||
541 | int error; | |||
542 | ||||
543 | if (SCARG(uap, tv)((uap)->tv.le.datum) != NULL((void *)0)) { | |||
544 | struct timeval tv; | |||
545 | if ((error = copyin(SCARG(uap, tv)((uap)->tv.le.datum), &tv, sizeof tv)) != 0) | |||
546 | return (error); | |||
547 | #ifdef KTRACE1 | |||
548 | if (KTRPOINT(p, KTR_STRUCT)((p)->p_p->ps_traceflag & (1<<(8)) && ((p)->p_flag & 0x00000001) == 0)) | |||
549 | ktrreltimeval(p, &tv)ktrstruct((p), "reltimeval", (&tv), sizeof(struct timeval )); | |||
550 | #endif | |||
551 | if (tv.tv_sec < 0 || !timerisvalid(&tv)((&tv)->tv_usec >= 0 && (&tv)->tv_usec < 1000000)) | |||
552 | return (EINVAL22); | |||
553 | TIMEVAL_TO_TIMESPEC(&tv, &ts)do { (&ts)->tv_sec = (&tv)->tv_sec; (&ts)-> tv_nsec = (&tv)->tv_usec * 1000; } while (0); | |||
554 | tsp = &ts; | |||
555 | } | |||
556 | ||||
557 | return (dopselect(p, SCARG(uap, nd)((uap)->nd.le.datum), SCARG(uap, in)((uap)->in.le.datum), SCARG(uap, ou)((uap)->ou.le.datum), | |||
558 | SCARG(uap, ex)((uap)->ex.le.datum), tsp, NULL((void *)0), retval)); | |||
559 | } | |||
560 | ||||
561 | int | |||
562 | sys_pselect(struct proc *p, void *v, register_t *retval) | |||
563 | { | |||
564 | struct sys_pselect_args /* { | |||
565 | syscallarg(int) nd; | |||
566 | syscallarg(fd_set *) in; | |||
567 | syscallarg(fd_set *) ou; | |||
568 | syscallarg(fd_set *) ex; | |||
569 | syscallarg(const struct timespec *) ts; | |||
570 | syscallarg(const sigset_t *) mask; | |||
571 | } */ *uap = v; | |||
572 | ||||
573 | struct timespec ts, *tsp = NULL((void *)0); | |||
574 | sigset_t ss, *ssp = NULL((void *)0); | |||
575 | int error; | |||
576 | ||||
577 | if (SCARG(uap, ts)((uap)->ts.le.datum) != NULL((void *)0)) { | |||
578 | if ((error = copyin(SCARG(uap, ts)((uap)->ts.le.datum), &ts, sizeof ts)) != 0) | |||
579 | return (error); | |||
580 | #ifdef KTRACE1 | |||
581 | if (KTRPOINT(p, KTR_STRUCT)((p)->p_p->ps_traceflag & (1<<(8)) && ((p)->p_flag & 0x00000001) == 0)) | |||
582 | ktrreltimespec(p, &ts)ktrstruct((p), "reltimespec", (&ts), sizeof(struct timespec )); | |||
583 | #endif | |||
584 | if (ts.tv_sec < 0 || !timespecisvalid(&ts)((&ts)->tv_nsec >= 0 && (&ts)->tv_nsec < 1000000000L)) | |||
585 | return (EINVAL22); | |||
586 | tsp = &ts; | |||
587 | } | |||
588 | if (SCARG(uap, mask)((uap)->mask.le.datum) != NULL((void *)0)) { | |||
589 | if ((error = copyin(SCARG(uap, mask)((uap)->mask.le.datum), &ss, sizeof ss)) != 0) | |||
590 | return (error); | |||
591 | ssp = &ss; | |||
592 | } | |||
593 | ||||
594 | return (dopselect(p, SCARG(uap, nd)((uap)->nd.le.datum), SCARG(uap, in)((uap)->in.le.datum), SCARG(uap, ou)((uap)->ou.le.datum), | |||
595 | SCARG(uap, ex)((uap)->ex.le.datum), tsp, ssp, retval)); | |||
596 | } | |||
597 | ||||
598 | int | |||
599 | dopselect(struct proc *p, int nd, fd_set *in, fd_set *ou, fd_set *ex, | |||
600 | struct timespec *timeout, const sigset_t *sigmask, register_t *retval) | |||
601 | { | |||
602 | struct kqueue_scan_state scan; | |||
603 | struct timespec zerots = {}; | |||
604 | fd_mask__fd_mask bits[6]; | |||
605 | fd_set *pibits[3], *pobits[3]; | |||
606 | int error, ncollected = 0, nevents = 0; | |||
607 | u_int ni; | |||
608 | ||||
609 | if (nd < 0) | |||
610 | return (EINVAL22); | |||
611 | if (nd > p->p_fd->fd_nfiles) { | |||
612 | /* forgiving; slightly wrong */ | |||
613 | nd = p->p_fd->fd_nfiles; | |||
614 | } | |||
615 | ni = howmany(nd, NFDBITS)(((nd) + ((((unsigned)(sizeof(__fd_mask) * 8))) - 1)) / (((unsigned )(sizeof(__fd_mask) * 8)))) * sizeof(fd_mask__fd_mask); | |||
616 | if (ni > sizeof(bits[0])) { | |||
617 | caddr_t mbits; | |||
618 | ||||
619 | mbits = mallocarray(6, ni, M_TEMP127, M_WAITOK0x0001|M_ZERO0x0008); | |||
620 | pibits[0] = (fd_set *)&mbits[ni * 0]; | |||
621 | pibits[1] = (fd_set *)&mbits[ni * 1]; | |||
622 | pibits[2] = (fd_set *)&mbits[ni * 2]; | |||
623 | pobits[0] = (fd_set *)&mbits[ni * 3]; | |||
624 | pobits[1] = (fd_set *)&mbits[ni * 4]; | |||
625 | pobits[2] = (fd_set *)&mbits[ni * 5]; | |||
626 | } else { | |||
627 | memset(bits, 0, sizeof(bits))__builtin_memset((bits), (0), (sizeof(bits))); | |||
628 | pibits[0] = (fd_set *)&bits[0]; | |||
629 | pibits[1] = (fd_set *)&bits[1]; | |||
630 | pibits[2] = (fd_set *)&bits[2]; | |||
631 | pobits[0] = (fd_set *)&bits[3]; | |||
632 | pobits[1] = (fd_set *)&bits[4]; | |||
633 | pobits[2] = (fd_set *)&bits[5]; | |||
634 | } | |||
635 | ||||
636 | kqpoll_init(nd); | |||
637 | ||||
638 | #define getbits(name, x) \ | |||
639 | if (name && (error = copyin(name, pibits[x], ni))) \ | |||
640 | goto done; | |||
641 | getbits(in, 0); | |||
642 | getbits(ou, 1); | |||
643 | getbits(ex, 2); | |||
644 | #undef getbits | |||
645 | #ifdef KTRACE1 | |||
646 | if (ni > 0 && KTRPOINT(p, KTR_STRUCT)((p)->p_p->ps_traceflag & (1<<(8)) && ((p)->p_flag & 0x00000001) == 0)) { | |||
647 | if (in) ktrfdset(p, pibits[0], ni)ktrstruct((p), "fdset", (pibits[0]), ni); | |||
648 | if (ou) ktrfdset(p, pibits[1], ni)ktrstruct((p), "fdset", (pibits[1]), ni); | |||
649 | if (ex) ktrfdset(p, pibits[2], ni)ktrstruct((p), "fdset", (pibits[2]), ni); | |||
650 | } | |||
651 | #endif | |||
652 | ||||
653 | if (sigmask) | |||
654 | dosigsuspend(p, *sigmask &~ sigcantmask((1U << ((9)-1)) | (1U << ((17)-1)))); | |||
655 | ||||
656 | /* Register kqueue events */ | |||
657 | error = pselregister(p, pibits, pobits, nd, &nevents, &ncollected); | |||
658 | if (error != 0) | |||
659 | goto done; | |||
660 | ||||
661 | /* | |||
662 | * The poll/select family of syscalls has been designed to | |||
663 | * block when file descriptors are not available, even if | |||
664 | * there's nothing to wait for. | |||
665 | */ | |||
666 | if (nevents == 0 && ncollected == 0) { | |||
667 | uint64_t nsecs = INFSLP0xffffffffffffffffULL; | |||
668 | ||||
669 | if (timeout != NULL((void *)0)) { | |||
670 | if (!timespecisset(timeout)((timeout)->tv_sec || (timeout)->tv_nsec)) | |||
671 | goto done; | |||
672 | nsecs = MAX(1, MIN(TIMESPEC_TO_NSEC(timeout), MAXTSLP))(((1)>((((TIMESPEC_TO_NSEC(timeout))<((0xffffffffffffffffULL - 1)))?(TIMESPEC_TO_NSEC(timeout)):((0xffffffffffffffffULL - 1)))))?(1):((((TIMESPEC_TO_NSEC(timeout))<((0xffffffffffffffffULL - 1)))?(TIMESPEC_TO_NSEC(timeout)):((0xffffffffffffffffULL - 1))))); | |||
673 | } | |||
674 | error = tsleep_nsec(&nowake, PSOCK24 | PCATCH0x100, "kqsel", nsecs); | |||
675 | /* select is not restarted after signals... */ | |||
676 | if (error == ERESTART-1) | |||
677 | error = EINTR4; | |||
678 | if (error == EWOULDBLOCK35) | |||
679 | error = 0; | |||
680 | goto done; | |||
681 | } | |||
682 | ||||
683 | /* Do not block if registering found pending events. */ | |||
684 | if (ncollected > 0) | |||
685 | timeout = &zerots; | |||
686 | ||||
687 | /* Collect at most `nevents' possibly waiting in kqueue_scan() */ | |||
688 | kqueue_scan_setup(&scan, p->p_kq); | |||
689 | while (nevents > 0) { | |||
690 | struct kevent kev[KQ_NEVENTS8]; | |||
691 | int i, ready, count; | |||
692 | ||||
693 | /* Maximum number of events per iteration */ | |||
694 | count = MIN(nitems(kev), nevents)((((sizeof((kev)) / sizeof((kev)[0])))<(nevents))?((sizeof ((kev)) / sizeof((kev)[0]))):(nevents)); | |||
695 | ready = kqueue_scan(&scan, count, kev, timeout, p, &error); | |||
696 | #ifdef KTRACE1 | |||
697 | if (KTRPOINT(p, KTR_STRUCT)((p)->p_p->ps_traceflag & (1<<(8)) && ((p)->p_flag & 0x00000001) == 0)) | |||
698 | ktrevent(p, kev, ready)ktrstruct(p, "kevent", kev, (ready) * sizeof(struct kevent)); | |||
699 | #endif | |||
700 | /* Convert back events that are ready. */ | |||
701 | for (i = 0; i < ready && error == 0; i++) | |||
702 | error = pselcollect(p, &kev[i], pobits, &ncollected); | |||
703 | /* | |||
704 | * Stop if there was an error or if we had enough | |||
705 | * space to collect all events that were ready. | |||
706 | */ | |||
707 | if (error || ready < count) | |||
708 | break; | |||
709 | ||||
710 | nevents -= ready; | |||
711 | } | |||
712 | kqueue_scan_finish(&scan); | |||
713 | *retval = ncollected; | |||
714 | done: | |||
715 | #define putbits(name, x) \ | |||
716 | if (name && (error2 = copyout(pobits[x], name, ni))) \ | |||
717 | error = error2; | |||
718 | if (error == 0) { | |||
719 | int error2; | |||
720 | ||||
721 | putbits(in, 0); | |||
722 | putbits(ou, 1); | |||
723 | putbits(ex, 2); | |||
724 | #undef putbits | |||
725 | #ifdef KTRACE1 | |||
726 | if (ni > 0 && KTRPOINT(p, KTR_STRUCT)((p)->p_p->ps_traceflag & (1<<(8)) && ((p)->p_flag & 0x00000001) == 0)) { | |||
727 | if (in) ktrfdset(p, pobits[0], ni)ktrstruct((p), "fdset", (pobits[0]), ni); | |||
728 | if (ou) ktrfdset(p, pobits[1], ni)ktrstruct((p), "fdset", (pobits[1]), ni); | |||
729 | if (ex) ktrfdset(p, pobits[2], ni)ktrstruct((p), "fdset", (pobits[2]), ni); | |||
730 | } | |||
731 | #endif | |||
732 | } | |||
733 | ||||
734 | if (pibits[0] != (fd_set *)&bits[0]) | |||
735 | free(pibits[0], M_TEMP127, 6 * ni); | |||
736 | ||||
737 | kqpoll_done(nd); | |||
738 | ||||
739 | return (error); | |||
740 | } | |||
741 | ||||
742 | /* | |||
743 | * Convert fd_set into kqueue events and register them on the | |||
744 | * per-thread queue. | |||
745 | */ | |||
746 | int | |||
747 | pselregister(struct proc *p, fd_set *pibits[3], fd_set *pobits[3], int nfd, | |||
748 | int *nregistered, int *ncollected) | |||
749 | { | |||
750 | static const int evf[] = { EVFILT_READ(-1), EVFILT_WRITE(-2), EVFILT_EXCEPT(-9) }; | |||
751 | static const int evff[] = { 0, 0, NOTE_OOB0x0004 }; | |||
752 | int msk, i, j, fd, nevents = 0, error = 0; | |||
753 | struct kevent kev; | |||
754 | fd_mask__fd_mask bits; | |||
755 | ||||
756 | for (msk = 0; msk < 3; msk++) { | |||
757 | for (i = 0; i < nfd; i += NFDBITS((unsigned)(sizeof(__fd_mask) * 8))) { | |||
758 | bits = pibits[msk]->fds_bits[i / NFDBITS((unsigned)(sizeof(__fd_mask) * 8))]; | |||
759 | while ((j = ffs(bits)) && (fd = i + --j) < nfd) { | |||
760 | bits &= ~(1 << j); | |||
761 | ||||
762 | DPRINTFN(2, "select fd %d mask %d serial %lu\n",if (kqpoll_debug > 2) { printf("%s(%d): ", ({struct cpu_info *__ci; asm volatile("movq %%gs:%P1,%0" : "=r" (__ci) :"n" (__builtin_offsetof (struct cpu_info, ci_self))); __ci;})->ci_curproc->p_p-> ps_comm, ({struct cpu_info *__ci; asm volatile("movq %%gs:%P1,%0" : "=r" (__ci) :"n" (__builtin_offsetof(struct cpu_info, ci_self ))); __ci;})->ci_curproc->p_tid); printf("select fd %d mask %d serial %lu\n" , fd, msk, p->p_kq_serial); } | |||
763 | fd, msk, p->p_kq_serial)if (kqpoll_debug > 2) { printf("%s(%d): ", ({struct cpu_info *__ci; asm volatile("movq %%gs:%P1,%0" : "=r" (__ci) :"n" (__builtin_offsetof (struct cpu_info, ci_self))); __ci;})->ci_curproc->p_p-> ps_comm, ({struct cpu_info *__ci; asm volatile("movq %%gs:%P1,%0" : "=r" (__ci) :"n" (__builtin_offsetof(struct cpu_info, ci_self ))); __ci;})->ci_curproc->p_tid); printf("select fd %d mask %d serial %lu\n" , fd, msk, p->p_kq_serial); }; | |||
764 | EV_SET(&kev, fd, evf[msk],do { struct kevent *__kevp = (&kev); (__kevp)->ident = (fd); (__kevp)->filter = (evf[msk]); (__kevp)->flags = (0x0001|0x0004|0x0800); (__kevp)->fflags = (evff[msk]); ( __kevp)->data = (0); (__kevp)->udata = ((void *)(p-> p_kq_serial)); } while(0) | |||
765 | EV_ADD|EV_ENABLE|__EV_SELECT,do { struct kevent *__kevp = (&kev); (__kevp)->ident = (fd); (__kevp)->filter = (evf[msk]); (__kevp)->flags = (0x0001|0x0004|0x0800); (__kevp)->fflags = (evff[msk]); ( __kevp)->data = (0); (__kevp)->udata = ((void *)(p-> p_kq_serial)); } while(0) | |||
766 | evff[msk], 0, (void *)(p->p_kq_serial))do { struct kevent *__kevp = (&kev); (__kevp)->ident = (fd); (__kevp)->filter = (evf[msk]); (__kevp)->flags = (0x0001|0x0004|0x0800); (__kevp)->fflags = (evff[msk]); ( __kevp)->data = (0); (__kevp)->udata = ((void *)(p-> p_kq_serial)); } while(0); | |||
767 | #ifdef KTRACE1 | |||
768 | if (KTRPOINT(p, KTR_STRUCT)((p)->p_p->ps_traceflag & (1<<(8)) && ((p)->p_flag & 0x00000001) == 0)) | |||
769 | ktrevent(p, &kev, 1)ktrstruct(p, "kevent", &kev, (1) * sizeof(struct kevent)); | |||
770 | #endif | |||
771 | error = kqueue_register(p->p_kq, &kev, p); | |||
772 | switch (error) { | |||
773 | case 0: | |||
774 | nevents++; | |||
775 | /* FALLTHROUGH */ | |||
776 | case EOPNOTSUPP45:/* No underlying kqfilter */ | |||
777 | case EINVAL22: /* Unimplemented filter */ | |||
778 | case EPERM1: /* Specific to FIFO and | |||
779 | * __EV_SELECT */ | |||
780 | error = 0; | |||
781 | break; | |||
782 | case EPIPE32: /* Specific to pipes */ | |||
783 | KASSERT(kev.filter == EVFILT_WRITE)((kev.filter == (-2)) ? (void)0 : __assert("diagnostic ", "/usr/src/sys/kern/sys_generic.c" , 783, "kev.filter == EVFILT_WRITE")); | |||
784 | FD_SET(kev.ident, pobits[1])__fd_set((kev.ident), (pobits[1])); | |||
785 | (*ncollected)++; | |||
786 | error = 0; | |||
787 | break; | |||
788 | case ENXIO6: /* Device has been detached */ | |||
789 | default: | |||
790 | goto bad; | |||
791 | } | |||
792 | } | |||
793 | } | |||
794 | } | |||
795 | ||||
796 | *nregistered = nevents; | |||
797 | return (0); | |||
798 | bad: | |||
799 | DPRINTFN(0, "select fd %u filt %d error %d\n", (int)kev.ident,if (kqpoll_debug > 0) { printf("%s(%d): ", ({struct cpu_info *__ci; asm volatile("movq %%gs:%P1,%0" : "=r" (__ci) :"n" (__builtin_offsetof (struct cpu_info, ci_self))); __ci;})->ci_curproc->p_p-> ps_comm, ({struct cpu_info *__ci; asm volatile("movq %%gs:%P1,%0" : "=r" (__ci) :"n" (__builtin_offsetof(struct cpu_info, ci_self ))); __ci;})->ci_curproc->p_tid); printf("select fd %u filt %d error %d\n" , (int)kev.ident, kev.filter, error); } | |||
800 | kev.filter, error)if (kqpoll_debug > 0) { printf("%s(%d): ", ({struct cpu_info *__ci; asm volatile("movq %%gs:%P1,%0" : "=r" (__ci) :"n" (__builtin_offsetof (struct cpu_info, ci_self))); __ci;})->ci_curproc->p_p-> ps_comm, ({struct cpu_info *__ci; asm volatile("movq %%gs:%P1,%0" : "=r" (__ci) :"n" (__builtin_offsetof(struct cpu_info, ci_self ))); __ci;})->ci_curproc->p_tid); printf("select fd %u filt %d error %d\n" , (int)kev.ident, kev.filter, error); }; | |||
801 | return (error); | |||
802 | } | |||
803 | ||||
804 | /* | |||
805 | * Convert given kqueue event into corresponding select(2) bit. | |||
806 | */ | |||
807 | int | |||
808 | pselcollect(struct proc *p, struct kevent *kevp, fd_set *pobits[3], | |||
809 | int *ncollected) | |||
810 | { | |||
811 | if ((unsigned long)kevp->udata != p->p_kq_serial) { | |||
812 | panic("%s: spurious kevp %p fd %d udata 0x%lx serial 0x%lx", | |||
813 | __func__, kevp, (int)kevp->ident, | |||
814 | (unsigned long)kevp->udata, p->p_kq_serial); | |||
815 | } | |||
816 | ||||
817 | if (kevp->flags & EV_ERROR0x4000) { | |||
818 | DPRINTFN(2, "select fd %d filt %d error %d\n",if (kqpoll_debug > 2) { printf("%s(%d): ", ({struct cpu_info *__ci; asm volatile("movq %%gs:%P1,%0" : "=r" (__ci) :"n" (__builtin_offsetof (struct cpu_info, ci_self))); __ci;})->ci_curproc->p_p-> ps_comm, ({struct cpu_info *__ci; asm volatile("movq %%gs:%P1,%0" : "=r" (__ci) :"n" (__builtin_offsetof(struct cpu_info, ci_self ))); __ci;})->ci_curproc->p_tid); printf("select fd %d filt %d error %d\n" , (int)kevp->ident, kevp->filter, (int)kevp->data); } | |||
819 | (int)kevp->ident, kevp->filter, (int)kevp->data)if (kqpoll_debug > 2) { printf("%s(%d): ", ({struct cpu_info *__ci; asm volatile("movq %%gs:%P1,%0" : "=r" (__ci) :"n" (__builtin_offsetof (struct cpu_info, ci_self))); __ci;})->ci_curproc->p_p-> ps_comm, ({struct cpu_info *__ci; asm volatile("movq %%gs:%P1,%0" : "=r" (__ci) :"n" (__builtin_offsetof(struct cpu_info, ci_self ))); __ci;})->ci_curproc->p_tid); printf("select fd %d filt %d error %d\n" , (int)kevp->ident, kevp->filter, (int)kevp->data); }; | |||
820 | return (kevp->data); | |||
821 | } | |||
822 | ||||
823 | switch (kevp->filter) { | |||
824 | case EVFILT_READ(-1): | |||
825 | FD_SET(kevp->ident, pobits[0])__fd_set((kevp->ident), (pobits[0])); | |||
826 | break; | |||
827 | case EVFILT_WRITE(-2): | |||
828 | FD_SET(kevp->ident, pobits[1])__fd_set((kevp->ident), (pobits[1])); | |||
829 | break; | |||
830 | case EVFILT_EXCEPT(-9): | |||
831 | FD_SET(kevp->ident, pobits[2])__fd_set((kevp->ident), (pobits[2])); | |||
832 | break; | |||
833 | default: | |||
834 | KASSERT(0)((0) ? (void)0 : __assert("diagnostic ", "/usr/src/sys/kern/sys_generic.c" , 834, "0")); | |||
835 | } | |||
836 | (*ncollected)++; | |||
837 | ||||
838 | DPRINTFN(2, "select fd %d filt %d\n", (int)kevp->ident, kevp->filter)if (kqpoll_debug > 2) { printf("%s(%d): ", ({struct cpu_info *__ci; asm volatile("movq %%gs:%P1,%0" : "=r" (__ci) :"n" (__builtin_offsetof (struct cpu_info, ci_self))); __ci;})->ci_curproc->p_p-> ps_comm, ({struct cpu_info *__ci; asm volatile("movq %%gs:%P1,%0" : "=r" (__ci) :"n" (__builtin_offsetof(struct cpu_info, ci_self ))); __ci;})->ci_curproc->p_tid); printf("select fd %d filt %d\n" , (int)kevp->ident, kevp->filter); }; | |||
839 | return (0); | |||
840 | } | |||
841 | ||||
842 | int | |||
843 | seltrue(dev_t dev, int events, struct proc *p) | |||
844 | { | |||
845 | ||||
846 | return (events & (POLLIN0x0001 | POLLOUT0x0004 | POLLRDNORM0x0040 | POLLWRNORM0x0004)); | |||
847 | } | |||
848 | ||||
849 | int | |||
850 | selfalse(dev_t dev, int events, struct proc *p) | |||
851 | { | |||
852 | ||||
853 | return (0); | |||
854 | } | |||
855 | ||||
856 | /* | |||
857 | * Record a select request. | |||
858 | */ | |||
859 | void | |||
860 | selrecord(struct proc *selector, struct selinfo *sip) | |||
861 | { | |||
862 | struct proc *p; | |||
863 | pid_t mytid; | |||
864 | ||||
865 | KERNEL_ASSERT_LOCKED()((_kernel_lock_held()) ? (void)0 : __assert("diagnostic ", "/usr/src/sys/kern/sys_generic.c" , 865, "_kernel_lock_held()")); | |||
866 | ||||
867 | mytid = selector->p_tid; | |||
868 | if (sip->si_seltid == mytid) | |||
869 | return; | |||
870 | if (sip->si_seltid && (p = tfind(sip->si_seltid)) && | |||
871 | p->p_wchan == (caddr_t)&selwait) | |||
872 | sip->si_flags |= SI_COLL0x0001; | |||
873 | else | |||
874 | sip->si_seltid = mytid; | |||
875 | } | |||
876 | ||||
877 | /* | |||
878 | * Do a wakeup when a selectable event occurs. | |||
879 | */ | |||
880 | void | |||
881 | selwakeup(struct selinfo *sip) | |||
882 | { | |||
883 | KERNEL_LOCK()_kernel_lock(); | |||
884 | KNOTE(&sip->si_note, NOTE_SUBMIT)do { struct klist *__list = (&sip->si_note); if (__list != ((void *)0)) knote(__list, 0x01000000); } while (0); | |||
885 | doselwakeup(sip); | |||
886 | KERNEL_UNLOCK()_kernel_unlock(); | |||
887 | } | |||
888 | ||||
889 | void | |||
890 | doselwakeup(struct selinfo *sip) | |||
891 | { | |||
892 | struct proc *p; | |||
893 | ||||
894 | KERNEL_ASSERT_LOCKED()((_kernel_lock_held()) ? (void)0 : __assert("diagnostic ", "/usr/src/sys/kern/sys_generic.c" , 894, "_kernel_lock_held()")); | |||
895 | ||||
896 | if (sip->si_seltid == 0) | |||
897 | return; | |||
898 | if (sip->si_flags & SI_COLL0x0001) { | |||
899 | nselcoll++; | |||
900 | sip->si_flags &= ~SI_COLL0x0001; | |||
901 | wakeup(&selwait); | |||
902 | } | |||
903 | p = tfind(sip->si_seltid); | |||
904 | sip->si_seltid = 0; | |||
905 | if (p != NULL((void *)0)) { | |||
906 | if (wakeup_proc(p, &selwait)) { | |||
907 | /* nothing else to do */ | |||
908 | } else if (p->p_flag & P_SELECT0x00000040) | |||
909 | atomic_clearbits_intx86_atomic_clearbits_u32(&p->p_flag, P_SELECT0x00000040); | |||
910 | } | |||
911 | } | |||
912 | ||||
913 | void | |||
914 | pollscan(struct proc *p, struct pollfd *pl, u_int nfd, register_t *retval) | |||
915 | { | |||
916 | struct filedesc *fdp = p->p_fd; | |||
917 | struct file *fp; | |||
918 | u_int i; | |||
919 | int n = 0; | |||
920 | ||||
921 | for (i = 0; i < nfd; i++, pl++) { | |||
922 | /* Check the file descriptor. */ | |||
923 | if (pl->fd < 0) { | |||
924 | pl->revents = 0; | |||
925 | continue; | |||
926 | } | |||
927 | if ((fp = fd_getfile(fdp, pl->fd)) == NULL((void *)0)) { | |||
928 | pl->revents = POLLNVAL0x0020; | |||
929 | n++; | |||
930 | continue; | |||
931 | } | |||
932 | pl->revents = (*fp->f_ops->fo_poll)(fp, pl->events, p); | |||
933 | FRELE(fp, p)(_atomic_sub_int_nv((&fp->f_count), 1) == 0 ? fdrop(fp , p) : 0); | |||
934 | if (pl->revents != 0) | |||
935 | n++; | |||
936 | } | |||
937 | *retval = n; | |||
938 | } | |||
939 | ||||
940 | /* | |||
941 | * Only copyout the revents field. | |||
942 | */ | |||
943 | int | |||
944 | pollout(struct pollfd *pl, struct pollfd *upl, u_int nfds) | |||
945 | { | |||
946 | int error = 0; | |||
947 | u_int i = 0; | |||
948 | ||||
949 | while (!error && i++ < nfds) { | |||
950 | error = copyout(&pl->revents, &upl->revents, | |||
951 | sizeof(upl->revents)); | |||
952 | pl++; | |||
953 | upl++; | |||
954 | } | |||
955 | ||||
956 | return (error); | |||
957 | } | |||
958 | ||||
959 | /* | |||
960 | * We are using the same mechanism as select only we encode/decode args | |||
961 | * differently. | |||
962 | */ | |||
963 | int | |||
964 | sys_poll(struct proc *p, void *v, register_t *retval) | |||
965 | { | |||
966 | struct sys_poll_args /* { | |||
967 | syscallarg(struct pollfd *) fds; | |||
968 | syscallarg(u_int) nfds; | |||
969 | syscallarg(int) timeout; | |||
970 | } */ *uap = v; | |||
971 | ||||
972 | struct timespec ts, *tsp = NULL((void *)0); | |||
973 | int msec = SCARG(uap, timeout)((uap)->timeout.le.datum); | |||
974 | ||||
975 | if (msec != INFTIM(-1)) { | |||
976 | if (msec < 0) | |||
977 | return (EINVAL22); | |||
978 | ts.tv_sec = msec / 1000; | |||
979 | ts.tv_nsec = (msec - (ts.tv_sec * 1000)) * 1000000; | |||
980 | tsp = &ts; | |||
981 | } | |||
982 | ||||
983 | return (doppoll(p, SCARG(uap, fds)((uap)->fds.le.datum), SCARG(uap, nfds)((uap)->nfds.le.datum), tsp, NULL((void *)0), | |||
984 | retval)); | |||
985 | } | |||
986 | ||||
987 | int | |||
988 | sys_ppoll(struct proc *p, void *v, register_t *retval) | |||
989 | { | |||
990 | struct sys_ppoll_args /* { | |||
991 | syscallarg(struct pollfd *) fds; | |||
992 | syscallarg(u_int) nfds; | |||
993 | syscallarg(const struct timespec *) ts; | |||
994 | syscallarg(const sigset_t *) mask; | |||
995 | } */ *uap = v; | |||
996 | ||||
997 | int error; | |||
998 | struct timespec ts, *tsp = NULL((void *)0); | |||
999 | sigset_t ss, *ssp = NULL((void *)0); | |||
1000 | ||||
1001 | if (SCARG(uap, ts)((uap)->ts.le.datum) != NULL((void *)0)) { | |||
1002 | if ((error = copyin(SCARG(uap, ts)((uap)->ts.le.datum), &ts, sizeof ts)) != 0) | |||
1003 | return (error); | |||
1004 | #ifdef KTRACE1 | |||
1005 | if (KTRPOINT(p, KTR_STRUCT)((p)->p_p->ps_traceflag & (1<<(8)) && ((p)->p_flag & 0x00000001) == 0)) | |||
1006 | ktrreltimespec(p, &ts)ktrstruct((p), "reltimespec", (&ts), sizeof(struct timespec )); | |||
1007 | #endif | |||
1008 | if (ts.tv_sec < 0 || !timespecisvalid(&ts)((&ts)->tv_nsec >= 0 && (&ts)->tv_nsec < 1000000000L)) | |||
1009 | return (EINVAL22); | |||
1010 | tsp = &ts; | |||
1011 | } | |||
1012 | ||||
1013 | if (SCARG(uap, mask)((uap)->mask.le.datum) != NULL((void *)0)) { | |||
1014 | if ((error = copyin(SCARG(uap, mask)((uap)->mask.le.datum), &ss, sizeof ss)) != 0) | |||
1015 | return (error); | |||
1016 | ssp = &ss; | |||
1017 | } | |||
1018 | ||||
1019 | return (doppoll(p, SCARG(uap, fds)((uap)->fds.le.datum), SCARG(uap, nfds)((uap)->nfds.le.datum), tsp, ssp, | |||
1020 | retval)); | |||
1021 | } | |||
1022 | ||||
1023 | int | |||
1024 | doppoll(struct proc *p, struct pollfd *fds, u_int nfds, | |||
1025 | struct timespec *timeout, const sigset_t *sigmask, register_t *retval) | |||
1026 | { | |||
1027 | size_t sz; | |||
1028 | struct pollfd pfds[4], *pl = pfds; | |||
1029 | struct timespec elapsed, start, stop; | |||
1030 | uint64_t nsecs; | |||
1031 | int ncoll, i, s, error; | |||
1032 | ||||
1033 | /* Standards say no more than MAX_OPEN; this is possibly better. */ | |||
1034 | if (nfds > min((int)lim_cur(RLIMIT_NOFILE8), maxfiles)) | |||
1035 | return (EINVAL22); | |||
1036 | ||||
1037 | /* optimize for the default case, of a small nfds value */ | |||
1038 | if (nfds > nitems(pfds)(sizeof((pfds)) / sizeof((pfds)[0]))) { | |||
1039 | pl = mallocarray(nfds, sizeof(*pl), M_TEMP127, | |||
1040 | M_WAITOK0x0001 | M_CANFAIL0x0004); | |||
1041 | if (pl == NULL((void *)0)) | |||
1042 | return (EINVAL22); | |||
1043 | } | |||
1044 | ||||
1045 | sz = nfds * sizeof(*pl); | |||
1046 | ||||
1047 | if ((error = copyin(fds, pl, sz)) != 0) | |||
1048 | goto bad; | |||
1049 | ||||
1050 | for (i = 0; i < nfds; i++) { | |||
1051 | pl[i].events &= ~POLL_NOHUP0x1000; | |||
1052 | pl[i].revents = 0; | |||
1053 | } | |||
1054 | ||||
1055 | if (sigmask) | |||
1056 | dosigsuspend(p, *sigmask &~ sigcantmask((1U << ((9)-1)) | (1U << ((17)-1)))); | |||
1057 | ||||
1058 | retry: | |||
1059 | ncoll = nselcoll; | |||
1060 | atomic_setbits_intx86_atomic_setbits_u32(&p->p_flag, P_SELECT0x00000040); | |||
1061 | pollscan(p, pl, nfds, retval); | |||
1062 | if (*retval) | |||
1063 | goto done; | |||
1064 | if (timeout == NULL((void *)0) || timespecisset(timeout)((timeout)->tv_sec || (timeout)->tv_nsec)) { | |||
1065 | if (timeout != NULL((void *)0)) { | |||
1066 | getnanouptime(&start); | |||
1067 | nsecs = MIN(TIMESPEC_TO_NSEC(timeout), MAXTSLP)(((TIMESPEC_TO_NSEC(timeout))<((0xffffffffffffffffULL - 1) ))?(TIMESPEC_TO_NSEC(timeout)):((0xffffffffffffffffULL - 1))); | |||
1068 | } else | |||
1069 | nsecs = INFSLP0xffffffffffffffffULL; | |||
1070 | s = splhigh()splraise(0xd); | |||
1071 | if ((p->p_flag & P_SELECT0x00000040) == 0 || nselcoll != ncoll) { | |||
1072 | splx(s)spllower(s); | |||
1073 | goto retry; | |||
1074 | } | |||
1075 | atomic_clearbits_intx86_atomic_clearbits_u32(&p->p_flag, P_SELECT0x00000040); | |||
1076 | error = tsleep_nsec(&selwait, PSOCK24 | PCATCH0x100, "poll", nsecs); | |||
1077 | splx(s)spllower(s); | |||
1078 | if (timeout != NULL((void *)0)) { | |||
1079 | getnanouptime(&stop); | |||
1080 | timespecsub(&stop, &start, &elapsed)do { (&elapsed)->tv_sec = (&stop)->tv_sec - (& start)->tv_sec; (&elapsed)->tv_nsec = (&stop)-> tv_nsec - (&start)->tv_nsec; if ((&elapsed)->tv_nsec < 0) { (&elapsed)->tv_sec--; (&elapsed)->tv_nsec += 1000000000L; } } while (0); | |||
1081 | timespecsub(timeout, &elapsed, timeout)do { (timeout)->tv_sec = (timeout)->tv_sec - (&elapsed )->tv_sec; (timeout)->tv_nsec = (timeout)->tv_nsec - (&elapsed)->tv_nsec; if ((timeout)->tv_nsec < 0 ) { (timeout)->tv_sec--; (timeout)->tv_nsec += 1000000000L ; } } while (0); | |||
1082 | if (timeout->tv_sec < 0) | |||
1083 | timespecclear(timeout)(timeout)->tv_sec = (timeout)->tv_nsec = 0; | |||
1084 | } | |||
1085 | if (error == 0 || error == EWOULDBLOCK35) | |||
1086 | goto retry; | |||
1087 | } | |||
1088 | ||||
1089 | done: | |||
1090 | atomic_clearbits_intx86_atomic_clearbits_u32(&p->p_flag, P_SELECT0x00000040); | |||
1091 | /* | |||
1092 | * NOTE: poll(2) is not restarted after a signal and EWOULDBLOCK is | |||
1093 | * ignored (since the whole point is to see what would block). | |||
1094 | */ | |||
1095 | switch (error) { | |||
1096 | case ERESTART-1: | |||
1097 | error = pollout(pl, fds, nfds); | |||
1098 | if (error == 0) | |||
1099 | error = EINTR4; | |||
1100 | break; | |||
1101 | case EWOULDBLOCK35: | |||
1102 | case 0: | |||
1103 | error = pollout(pl, fds, nfds); | |||
1104 | break; | |||
1105 | } | |||
1106 | #ifdef KTRACE1 | |||
1107 | if (KTRPOINT(p, KTR_STRUCT)((p)->p_p->ps_traceflag & (1<<(8)) && ((p)->p_flag & 0x00000001) == 0)) | |||
1108 | ktrpollfd(p, pl, nfds)ktrstruct(p, "pollfd", pl, (nfds) * sizeof(struct pollfd)); | |||
1109 | #endif /* KTRACE */ | |||
1110 | bad: | |||
1111 | if (pl != pfds) | |||
1112 | free(pl, M_TEMP127, sz); | |||
1113 | return (error); | |||
1114 | } | |||
1115 | ||||
1116 | /* | |||
1117 | * utrace system call | |||
1118 | */ | |||
1119 | int | |||
1120 | sys_utrace(struct proc *curp, void *v, register_t *retval) | |||
1121 | { | |||
1122 | #ifdef KTRACE1 | |||
1123 | struct sys_utrace_args /* { | |||
1124 | syscallarg(const char *) label; | |||
1125 | syscallarg(const void *) addr; | |||
1126 | syscallarg(size_t) len; | |||
1127 | } */ *uap = v; | |||
1128 | ||||
1129 | return (ktruser(curp, SCARG(uap, label)((uap)->label.le.datum), SCARG(uap, addr)((uap)->addr.le.datum), | |||
1130 | SCARG(uap, len)((uap)->len.le.datum))); | |||
1131 | #else | |||
1132 | return (0); | |||
1133 | #endif | |||
1134 | } |