![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sys_generic.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / bsd / kern|
Return to sys_generic.c CVS log | Up to [Apple XNU] / XNU / bsd / kern |
1.1 root 1: /*
2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * The contents of this file constitute Original Code as defined in and
7: * are subject to the Apple Public Source License Version 1.1 (the
8: * "License"). You may not use this file except in compliance with the
9: * License. Please obtain a copy of the License at
10: * http://www.apple.com/publicsource and read it before using this file.
11: *
12: * This Original Code and all software distributed under the License are
13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
17: * License for the specific language governing rights and limitations
18: * under the License.
19: *
20: * @APPLE_LICENSE_HEADER_END@
21: */
22: /* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
23: /*
24: * Copyright (c) 1982, 1986, 1989, 1993
25: * The Regents of the University of California. All rights reserved.
26: * (c) UNIX System Laboratories, Inc.
27: * All or some portions of this file are derived from material licensed
28: * to the University of California by American Telephone and Telegraph
29: * Co. or Unix System Laboratories, Inc. and are reproduced herein with
30: * the permission of UNIX System Laboratories, Inc.
31: *
32: * Redistribution and use in source and binary forms, with or without
33: * modification, are permitted provided that the following conditions
34: * are met:
35: * 1. Redistributions of source code must retain the above copyright
36: * notice, this list of conditions and the following disclaimer.
37: * 2. Redistributions in binary form must reproduce the above copyright
38: * notice, this list of conditions and the following disclaimer in the
39: * documentation and/or other materials provided with the distribution.
40: * 3. All advertising materials mentioning features or use of this software
41: * must display the following acknowledgement:
42: * This product includes software developed by the University of
43: * California, Berkeley and its contributors.
44: * 4. Neither the name of the University nor the names of its contributors
45: * may be used to endorse or promote products derived from this software
46: * without specific prior written permission.
47: *
48: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
49: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
50: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
51: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
52: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
53: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
54: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
55: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
56: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
57: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
58: * SUCH DAMAGE.
59: *
60: * @(#)sys_generic.c 8.9 (Berkeley) 2/14/95
61: */
62:
63: #include <sys/param.h>
64: #include <sys/systm.h>
65: #include <sys/filedesc.h>
66: #include <sys/ioctl.h>
67: #include <sys/file.h>
68: #include <sys/proc.h>
69: #include <sys/socketvar.h>
70: #include <sys/uio.h>
71: #include <sys/kernel.h>
72: #include <sys/stat.h>
73: #include <sys/malloc.h>
74:
75: #if KTRACE
76: #include <sys/ktrace.h>
77: #endif
78:
79: #include <sys/mount.h>
80: #include <sys/protosw.h>
81: #include <sys/ev.h>
82: #include <sys/user.h>
83: #include <sys/kdebug.h>
84: #include <kern/assert.h>
85: #include <kern/thread_act.h>
86:
87: #include <sys/mbuf.h>
88: #include <sys/socket.h>
89: #include <sys/socketvar.h>
90: #include <sys/errno.h>
91:
92: #include <net/if.h>
93: #include <net/route.h>
94:
95: #include <netinet/in.h>
96: #include <netinet/in_systm.h>
97: #include <netinet/ip.h>
98: #include <netinet/in_pcb.h>
99: #include <netinet/ip_var.h>
100: #include <netinet/tcp.h>
101: #include <netinet/tcp_fsm.h>
102: #include <netinet/tcp_seq.h>
103: #include <netinet/tcp_timer.h>
104: #include <netinet/tcp_var.h>
105: #include <netinet/tcpip.h>
106: #include <netinet/tcp_debug.h>
107:
108: /*
109: * Read system call.
110: */
111: struct read_args {
112: int fd;
113: char *cbuf;
114: u_int nbyte;
115: };
116: /* ARGSUSED */
117: read(p, uap, retval)
118: struct proc *p;
119: register struct read_args *uap;
120: register_t *retval;
121: {
122: struct uio auio;
123: struct iovec aiov;
124:
125: aiov.iov_base = (caddr_t)uap->cbuf;
126: aiov.iov_len = uap->nbyte;
127: auio.uio_iov = &aiov;
128: auio.uio_iovcnt = 1;
129: auio.uio_rw = UIO_READ;
130: return (rwuio(p, uap->fd, &auio, UIO_READ, retval));
131: }
132:
133: struct readv_args {
134: int fd;
135: struct iovec *iovp;
136: u_int iovcnt;
137: };
138: readv(p, uap, retval)
139: struct proc *p;
140: register struct readv_args *uap;
141: int *retval;
142: {
143: struct uio auio;
144: register struct iovec *iov;
145: int error;
146: struct iovec aiov[UIO_SMALLIOV];
147:
148: if (uap->iovcnt > UIO_SMALLIOV) {
149: if (uap->iovcnt > UIO_MAXIOV)
150: return (EINVAL);
151: if ((iov = (struct iovec *)
152: kalloc(sizeof(struct iovec) * (uap->iovcnt))) == 0)
153: return (ENOMEM);
154: } else
155: iov = aiov;
156: auio.uio_iov = iov;
157: auio.uio_iovcnt = uap->iovcnt;
158: auio.uio_rw = UIO_READ;
159: error = copyin((caddr_t)uap->iovp, (caddr_t)iov,
160: uap->iovcnt * sizeof (struct iovec));
161: if (!error)
162: error = rwuio(p, uap->fd, &auio, UIO_READ, retval);
163: if (uap->iovcnt > UIO_SMALLIOV)
164: kfree(iov, sizeof(struct iovec)*uap->iovcnt);
165: return (error);
166: }
167:
168: /*
169: * Write system call
170: */
171: struct write_args {
172: int fd;
173: char *cbuf;
174: u_int nbyte;
175: };
176: write(p, uap, retval)
177: struct proc *p;
178: register struct write_args *uap;
179: int *retval;
180: {
181: struct uio auio;
182: struct iovec aiov;
183:
184: aiov.iov_base = uap->cbuf;
185: aiov.iov_len = uap->nbyte;
186: auio.uio_iov = &aiov;
187: auio.uio_iovcnt = 1;
188: auio.uio_rw = UIO_WRITE;
189: return (rwuio(p, uap->fd, &auio, UIO_WRITE, retval));
190: }
191:
192: struct writev_args {
193: int fd;
194: struct iovec *iovp;
195: u_int iovcnt;
196: };
197: writev(p, uap, retval)
198: struct proc *p;
199: register struct writev_args *uap;
200: int *retval;
201: {
202: struct uio auio;
203: register struct iovec *iov;
204: int error;
205: struct iovec aiov[UIO_SMALLIOV];
206:
207: if (uap->iovcnt > UIO_SMALLIOV) {
208: if (uap->iovcnt > UIO_MAXIOV)
209: return (EINVAL);
210: if ((iov = (struct iovec *)
211: kalloc(sizeof(struct iovec) * (uap->iovcnt))) == 0)
212: return (ENOMEM);
213: } else
214: iov = aiov;
215: auio.uio_iov = iov;
216: auio.uio_iovcnt = uap->iovcnt;
217: auio.uio_rw = UIO_WRITE;
218: error = copyin((caddr_t)uap->iovp, (caddr_t)iov,
219: uap->iovcnt * sizeof (struct iovec));
220: if (!error)
221: error = rwuio(p, uap->fd, &auio, UIO_WRITE, retval);
222: if (uap->iovcnt > UIO_SMALLIOV)
223: kfree(iov, sizeof(struct iovec)*uap->iovcnt);
224: return (error);
225: }
226:
227: rwuio(p, fdes, uio, rw, retval)
228: struct proc *p;
229: int fdes;
230: register struct uio *uio;
231: enum uio_rw rw;
232: int *retval;
233: {
234: register struct file *fp;
235: register struct iovec *iov;
236: int i, count, flag, error;
237:
238: if (error = fdgetf(p, fdes, &fp))
239: return (error);
240:
241: if ((fp->f_flag&(rw==UIO_READ ? FREAD : FWRITE)) == 0) {
242: return(EBADF);
243: }
244: uio->uio_resid = 0;
245: uio->uio_segflg = UIO_USERSPACE;
246: uio->uio_procp = p;
247: iov = uio->uio_iov;
248: for (i = 0; i < uio->uio_iovcnt; i++) {
249: if (iov->iov_len < 0) {
250: return(EINVAL);
251: }
252: uio->uio_resid += iov->iov_len;
253: if (uio->uio_resid < 0) {
254: return(EINVAL);
255: }
256: iov++;
257: }
258: count = uio->uio_resid;
259: if (rw == UIO_READ) {
260: if (error = (*fp->f_ops->fo_read)(fp, uio, fp->f_cred))
261: if (uio->uio_resid != count && (error == ERESTART ||
262: error == EINTR || error == EWOULDBLOCK))
263: error = 0;
264: } else {
265: if (error = (*fp->f_ops->fo_write)(fp, uio, fp->f_cred)) {
266: if (uio->uio_resid != count && (error == ERESTART ||
267: error == EINTR || error == EWOULDBLOCK))
268: error = 0;
269: if (error == EPIPE)
270: psignal(p, SIGPIPE);
271: }
272: }
273: *retval = count - uio->uio_resid;
274: return(error);
275: }
276:
277: /*
278: * Ioctl system call
279: */
280: struct ioctl_args {
281: int fd;
282: u_long com;
283: caddr_t data;
284: };
285: /* ARGSUSED */
286: ioctl(p, uap, retval)
287: struct proc *p;
288: register struct ioctl_args *uap;
289: register_t *retval;
290: {
291: register struct file *fp;
292: register u_long com;
293: register int error;
294: register u_int size;
295: caddr_t data, memp;
296: int tmp;
297: #define STK_PARAMS 128
298: char stkbuf[STK_PARAMS];
299:
300: if (error = fdgetf(p, uap->fd, &fp))
301: return (error);
302:
303: if ((fp->f_flag & (FREAD | FWRITE)) == 0)
304: return (EBADF);
305:
306: /*### LD 6/11/97 Hack Alert: this is to get AppleTalk to work
307: * while implementing an ATioctl system call
308: */
309: #if NETAT
310: {
311: extern int appletalk_inited;
312:
313: if (appletalk_inited && ((uap->com & 0x0000FFFF) == 0xff99)) {
314: #ifdef APPLETALK_DEBUG
315: kprintf("ioctl: special AppleTalk \n");
316: #endif
317: error = (*fp->f_ops->fo_ioctl)(fp, uap->com, uap->data, p);
318: return(error);
319: }
320: }
321:
322: #endif /* NETAT */
323:
324:
325: switch (com = uap->com) {
326: case FIONCLEX:
327: *fdflags(p, uap->fd) &= ~UF_EXCLOSE;
328: return (0);
329: case FIOCLEX:
330: *fdflags(p, uap->fd) |= UF_EXCLOSE;
331: return (0);
332: }
333:
334: /*
335: * Interpret high order word to find amount of data to be
336: * copied to/from the user's address space.
337: */
338: size = IOCPARM_LEN(com);
339: if (size > IOCPARM_MAX)
340: return (ENOTTY);
341: memp = NULL;
342: if (size > sizeof (stkbuf)) {
343: if ((memp = (caddr_t)kalloc(size)) == 0)
344: return(ENOMEM);
345: data = memp;
346: } else
347: data = stkbuf;
348: if (com&IOC_IN) {
349: if (size) {
350: error = copyin(uap->data, data, (u_int)size);
351: if (error) {
352: if (memp)
353: kfree(memp, size);
354: return (error);
355: }
356: } else
357: *(caddr_t *)data = uap->data;
358: } else if ((com&IOC_OUT) && size)
359: /*
360: * Zero the buffer so the user always
361: * gets back something deterministic.
362: */
363: bzero(data, size);
364: else if (com&IOC_VOID)
365: *(caddr_t *)data = uap->data;
366:
367: switch (com) {
368:
369: case FIONBIO:
370: if (tmp = *(int *)data)
371: fp->f_flag |= FNONBLOCK;
372: else
373: fp->f_flag &= ~FNONBLOCK;
374: error = (*fp->f_ops->fo_ioctl)(fp, FIONBIO, (caddr_t)&tmp, p);
375: break;
376:
377: case FIOASYNC:
378: if (tmp = *(int *)data)
379: fp->f_flag |= FASYNC;
380: else
381: fp->f_flag &= ~FASYNC;
382: error = (*fp->f_ops->fo_ioctl)(fp, FIOASYNC, (caddr_t)&tmp, p);
383: break;
384:
385: case FIOSETOWN:
386: tmp = *(int *)data;
387: if (fp->f_type == DTYPE_SOCKET) {
388: ((struct socket *)fp->f_data)->so_pgid = tmp;
389: error = 0;
390: break;
391: }
392: if (tmp <= 0) {
393: tmp = -tmp;
394: } else {
395: struct proc *p1 = pfind(tmp);
396: if (p1 == 0) {
397: error = ESRCH;
398: break;
399: }
400: tmp = p1->p_pgrp->pg_id;
401: }
402: error = (*fp->f_ops->fo_ioctl)
403: (fp, (int)TIOCSPGRP, (caddr_t)&tmp, p);
404: break;
405:
406: case FIOGETOWN:
407: if (fp->f_type == DTYPE_SOCKET) {
408: error = 0;
409: *(int *)data = ((struct socket *)fp->f_data)->so_pgid;
410: break;
411: }
412: error = (*fp->f_ops->fo_ioctl)(fp, TIOCGPGRP, data, p);
413: *(int *)data = -*(int *)data;
414: break;
415:
416: default:
417: error = (*fp->f_ops->fo_ioctl)(fp, com, data, p);
418: /*
419: * Copy any data to user, size was
420: * already set and checked above.
421: */
422: if (error == 0 && (com&IOC_OUT) && size)
423: error = copyout(data, uap->data, (u_int)size);
424: break;
425: }
426: if (memp)
427: kfree(memp, size);
428: return (error);
429: }
430:
431:
432: int selwait, nselcoll;
433:
434: /*
435: * Select system call.
436: */
437: struct select_args {
438: u_int nd;
439: fd_set *in;
440: fd_set *ou;
441: fd_set *ex;
442: struct timeval *tv;
443: };
444:
445: int selcontinue(int error);
446:
447: select(p, uap, retval)
448: register struct proc *p;
449: register struct select_args *uap;
450: register_t *retval;
451: {
452: int s, ncoll, error = 0, timo;
453: u_int ni;
454: struct thread *th;
455: thread_act_t th_act;
456: struct uthread *uth;
457: struct _select *sel;
458:
459: th = current_thread();
460: th_act = current_act();
461: uth = get_bsdthread_info(th_act);
462: sel = &uth->uu_state.ss_select;
463:
464: bzero((caddr_t)&sel->ibits[0], sizeof(sel->ibits));
465: bzero((caddr_t)&sel->obits[0], sizeof(sel->obits));
466:
467: if (uap->nd > FD_SETSIZE)
468: return (EINVAL);
469: if (uap->nd > p->p_fd->fd_nfiles) {
470: /* forgiving; slightly wrong */
471: uap->nd = p->p_fd->fd_nfiles;
472: }
473: ni = howmany(uap->nd, NFDBITS) * sizeof(fd_mask);
474:
475: #define getbits(name, x) \
476: if (uap->name && (error = copyin((caddr_t)uap->name, \
477: (caddr_t)&sel->ibits[x], ni))) \
478: goto contin;
479: getbits(in, 0);
480: getbits(ou, 1);
481: getbits(ex, 2);
482: #undef getbits
483:
484: if (uap->tv) {
485: error = copyin((caddr_t)uap->tv, (caddr_t)&sel->atv,
486: sizeof (sel->atv));
487: if (error)
488: goto contin;
489: if (itimerfix(&sel->atv)) {
490: error = EINVAL;
491: goto contin;
492: }
493: s = splhigh();
494: timeradd(&sel->atv, &time, &sel->atv);
495: timo = hzto(&sel->atv);
496: splx(s);
497: } else
498: timo = 0;
499: sel->poll = timo;
500: contin:
501: selcontinue(error);
502: }
503:
504: int
505: selcontinue(error)
506: {
507: int s, ncoll, timo;
508: u_int ni;
509: struct thread *th;
510: thread_act_t th_act;
511: struct uthread *uth;
512: struct proc *p;
513: struct select_args *uap;
514: int *retval;
515: struct _select *sel;
516:
517: th = (struct thread *)current_thread();
518: th_act = current_act();
519: uth = get_bsdthread_info(th_act);
520: p = (struct proc *)get_bsdtask_info(current_task());
521: uap = (struct select_args *)get_bsduthreadarg(th_act);
522: retval = (int *)get_bsduthreadrval(th_act);
523: sel = &uth->uu_state.ss_select;
524:
525: retry:
526: if (error != 0)
527: goto done;
528: ncoll = nselcoll;
529: p->p_flag |= P_SELECT;
530: error = selscan(p, &sel->ibits[0], &sel->obits[0], uap->nd, retval);
531: if (error || *retval)
532: goto done;
533: s = splhigh();
534: /* this should be timercmp(&time, &atv, >=) */
535: if (uap->tv && (time.tv_sec > sel->atv.tv_sec ||
536: time.tv_sec == sel->atv.tv_sec && time.tv_usec >= sel->atv.tv_usec)) {
537: splx(s);
538: goto done;
539: }
540: /*
541: * To effect a poll, the timeout argument should be
542: * non-nil, pointing to a zero-valued timeval structure.
543: */
544: timo = sel->poll;
545:
546: if (uap->tv && (timo == 0)) {
547: splx(s);
548: goto done;
549: }
550: if ((p->p_flag & P_SELECT) == 0 || nselcoll != ncoll) {
551: splx(s);
552: goto retry;
553: }
554: p->p_flag &= ~P_SELECT;
555:
556: #if 1
557: error = tsleep0((caddr_t)&selwait, PSOCK | PCATCH, "select", timo, selcontinue);
558: /* NOTREACHED */
559: #else
560: error = tsleep((caddr_t)&selwait, PSOCK | PCATCH, "select", timo);
561: #endif
562: splx(s);
563: if (error == 0)
564: goto retry;
565: done:
566: p->p_flag &= ~P_SELECT;
567: /* select is not restarted after signals... */
568: if (error == ERESTART)
569: error = EINTR;
570: if (error == EWOULDBLOCK)
571: error = 0;
572: ni = howmany(uap->nd, NFDBITS) * sizeof(fd_mask);
573: #define putbits(name, x) \
574: if (uap->name && (error2 = copyout((caddr_t)&sel->obits[x], \
575: (caddr_t)uap->name, ni))) \
576: error = error2;
577: if (error == 0) {
578: int error2;
579:
580: putbits(in, 0);
581: putbits(ou, 1);
582: putbits(ex, 2);
583: #undef putbits
584: }
585:
586: unix_syscall_return(error);
587: }
588:
589: selscan(p, ibits, obits, nfd, retval)
590: struct proc *p;
591: fd_set *ibits, *obits;
592: int nfd;
593: register_t *retval;
594: {
595: register struct filedesc *fdp = p->p_fd;
596: register int msk, i, j, fd;
597: register fd_mask bits;
598: struct file *fp;
599: int n = 0;
600: static int flag[3] = { FREAD, FWRITE, 0 };
601:
602: /* Problems when reboot; due to MacOSX signal probs
603: * in Beaker1C ; verify that the p->p_fd is valid
604: */
605: if (fdp == NULL) {
606: *retval=0;
607: return(EIO);
608: }
609:
610: for (msk = 0; msk < 3; msk++) {
611: for (i = 0; i < nfd; i += NFDBITS) {
612: bits = ibits[msk].fds_bits[i/NFDBITS];
613: while ((j = ffs(bits)) && (fd = i + --j) < nfd) {
614: bits &= ~(1 << j);
615: fp = fdp->fd_ofiles[fd];
616: if (fp == NULL || (fdp->fd_ofileflags[fd] &
617: UF_RESERVED))
618: return (EBADF);
619: if (fp->f_ops && (*fp->f_ops->fo_select)(fp, flag[msk], p)) {
620: FD_SET(fd, &obits[msk]);
621: n++;
622: }
623: }
624: }
625: }
626: *retval = n;
627: return (0);
628: }
629:
630: /*ARGSUSED*/
631: seltrue(dev, flag, p)
632: dev_t dev;
633: int flag;
634: struct proc *p;
635: {
636:
637: return (1);
638: }
639:
640: /*
641: * Record a select request.
642: */
643: void
644: selrecord(selector, sip)
645: struct proc *selector;
646: struct selinfo *sip;
647: {
648: int oldpri = splhigh();
649: thread_t my_thread = current_thread();
650: thread_t selthread;
651:
652: selthread = sip->si_thread;
653:
654: if (selthread == my_thread) {
655: splx(oldpri);
656: return;
657: }
658:
659: if (selthread && is_thread_active(selthread) &&
660: get_thread_waitevent(selthread) == (caddr_t)&selwait) {
661: sip->si_flags |= SI_COLL;
662: splx(oldpri);
663: }
664: else {
665: sip->si_thread = my_thread;
666: splx(oldpri);
667: if (selthread) {
668: /* thread_deallocate(selthread); */
669: act_deallocate(getact_thread(selthread));
670: }
671: /* do I need act reference ??? */
672: /* thread_reference(sip->si_thread); */
673: act_reference(getact_thread(sip->si_thread));
674: }
675:
676: return;
677: }
678:
679: void
680: selwakeup(sip)
681: register struct selinfo *sip;
682: {
683: register thread_t the_thread = (thread_t)sip->si_thread;
684: int oldpri;
685: struct proc *p;
686: thread_act_t th_act;
687:
688: if (the_thread == 0)
689: return;
690:
691: if (sip->si_flags & SI_COLL) {
692: nselcoll++;
693: sip->si_flags &= ~SI_COLL;
694: wakeup((caddr_t)&selwait);
695: }
696:
697: oldpri = splhigh();
698:
699: th_act = getact_thread(the_thread);
700:
701: if (is_thread_active(the_thread)) {
702: /* protect p_flag minimally at splsched() */
703: if (get_thread_waitevent(the_thread) == &selwait)
704: clear_wait(the_thread, THREAD_AWAKENED, TRUE);
705: if (p=(struct proc *)(get_bsdtask_info(get_threadtask(th_act))))
706: p->p_flag &= ~P_SELECT;
707: }
708:
709: th_act = getact_thread(the_thread);
710:
711: act_deallocate(th_act);
712:
713: sip->si_thread = 0;
714:
715: splx(oldpri);
716:
717: }
718:
719: void selthreadclear(sip)
720: register struct selinfo *sip;
721: {
722: thread_act_t th_act;
723:
724: if (sip->si_thread) {
725: th_act = getact_thread(sip->si_thread);
726: act_deallocate(th_act);
727: }
728:
729: }
730: /*
731: * called upon socket close. deque and free all events for
732: * the socket
733: */
734: evsofree(struct socket *sp)
735: {
736: struct eventqelt *eqp, *next;
737:
738: if (sp == NULL) return;
739:
740: for (eqp = sp->so_evlist.tqh_first; eqp != NULL; eqp = next) {
741: next = eqp->ee_slist.tqe_next;
742: evprocdeque(eqp->ee_proc, eqp); // remove from proc q if there
743: TAILQ_REMOVE(&sp->so_evlist, eqp, ee_slist); // remove from socket q
744: FREE(eqp, M_TEMP);
745: }
746: }
747:
748:
749: #define DBG_EVENT 0x10
750:
751: #define DBG_POST 0x10
752: #define DBG_WATCH 0x11
753: #define DBG_WAIT 0x12
754: #define DBG_MOD 0x13
755: #define DBG_EWAKEUP 0x14
756:
757: #define DBG_MISC_POST MISCDBG_CODE(DBG_EVENT,DBG_POST)
758: #define DBG_MISC_WATCH MISCDBG_CODE(DBG_EVENT,DBG_WATCH)
759: #define DBG_MISC_WAIT MISCDBG_CODE(DBG_EVENT,DBG_WAIT)
760: #define DBG_MISC_MOD MISCDBG_CODE(DBG_EVENT,DBG_MOD)
761: #define DBG_MISC_EWAKEUP MISCDBG_CODE(DBG_EVENT,DBG_EWAKEUP)
762:
763:
764:
765: /*
766: * enque this event if it's not already queued. wakeup
767: the proc if we do queue this event to it.
768: */
769: evprocenque(struct eventqelt *eqp)
770: {
771: struct proc *p;
772:
773: assert(eqp);
774: if (eqp->ee_flags & EV_QUEUED) {
775: return;
776: }
777: eqp->ee_flags |= EV_QUEUED;
778: eqp->ee_eventmask = 0; // disarm
779: p = eqp->ee_proc;
780: TAILQ_INSERT_TAIL(&p->p_evlist, eqp, ee_plist);
781: KERNEL_DEBUG(DBG_MISC_EWAKEUP,0,0,0,eqp,0);
782: wakeup(&p->p_evlist);
783: }
784:
785: /*
786: * given either a sockbuf or a socket run down the
787: * event list and queue ready events found
788: */
789: postevent(struct socket *sp, struct sockbuf *sb, int event)
790: {
791: int mask;
792: struct eventqelt *evq;
793: register struct tcpcb *tp;
794:
795: if (sb) sp = sb->sb_so;
796: if (!sp || sp->so_evlist.tqh_first == NULL) return;
797:
798: KERNEL_DEBUG(DBG_MISC_POST|DBG_FUNC_START, 0,0,0,0,0);
799:
800: for (evq = sp->so_evlist.tqh_first;
801: evq != NULL; evq = evq->ee_slist.tqe_next) {
802:
803: mask = 0;
804:
805: /* ready for reading:
806: - byte cnt >= receive low water mark
807: - read-half of conn closed
808: - conn pending for listening sock
809: - socket error pending
810:
811: ready for writing
812: - byte cnt avail >= send low water mark
813: - write half of conn closed
814: - socket error pending
815: - non-blocking conn completed successfully
816:
817: exception pending
818: - out of band data
819: - sock at out of band mark
820:
821: */
822: switch (event & EV_DMASK) {
823:
824: case EV_RWBYTES:
825: case EV_OOB:
826: case EV_RWBYTES|EV_OOB:
827: if (event & EV_OOB) {
828: if ((evq->ee_eventmask & EV_EX)) {
829: if (sp->so_oobmark || ((sp->so_state & SS_RCVATMARK))) {
830: mask |= EV_EX|EV_OOB;
831: }
832: }
833: }
834: if (event & EV_RWBYTES) {
835: if ((evq->ee_eventmask & EV_RE) && soreadable(sp)) {
836: if ((sp->so_type == SOCK_STREAM) && (sp->so_error == ECONNREFUSED) ||
837: (sp->so_error == ECONNRESET)) {
838: if ((sp->so_pcb == 0) ||
839: !(tp = sototcpcb(sp)) ||
840: (tp->t_state == TCPS_CLOSED)) {
841: mask |= EV_RE|EV_RESET;
842: break;
843: }
844: }
845: if (sp->so_state & SS_CANTRCVMORE) {
846: mask |= EV_RE|EV_FIN;
847: evq->ee_req.er_rcnt = sp->so_rcv.sb_cc;
848: break;
849: }
850: mask |= EV_RE;
851: evq->ee_req.er_rcnt = sp->so_rcv.sb_cc;
852: }
853:
854: if ((evq->ee_eventmask & EV_WR) && sowriteable(sp)) {
855: if ((sp->so_type == SOCK_STREAM) &&(sp->so_error == ECONNREFUSED) ||
856: (sp->so_error == ECONNRESET)) {
857: if ((sp->so_pcb == 0) ||
858: !(tp = sototcpcb(sp)) ||
859: (tp->t_state == TCPS_CLOSED)) {
860: mask |= EV_WR|EV_RESET;
861: break;
862: }
863: }
864: mask |= EV_WR;
865: evq->ee_req.er_wcnt = sbspace(&sp->so_snd);
866: }
867: }
868: break;
869:
870: case EV_RCONN:
871: if ((evq->ee_eventmask & EV_RE)) {
872: evq->ee_req.er_rcnt = sp->so_qlen + 1; // incl this one
873: mask |= EV_RE|EV_RCONN;
874: }
875: break;
876:
877: case EV_WCONN:
878: if ((evq->ee_eventmask & EV_WR)) {
879: mask |= EV_WR|EV_WCONN;
880: }
881: break;
882:
883: case EV_RCLOSED:
884: if ((evq->ee_eventmask & EV_RE)) {
885: mask |= EV_RE|EV_RCLOSED;
886: }
887: break;
888:
889: case EV_WCLOSED:
890: if ((evq->ee_eventmask & EV_WR)) {
891: mask |= EV_WR|EV_WCLOSED;
892: }
893: break;
894:
895: case EV_FIN:
896: if (evq->ee_eventmask & EV_RE) {
897: mask |= EV_RE|EV_FIN;
898: }
899: break;
900:
901: case EV_RESET:
902: case EV_TIMEOUT:
903: if (evq->ee_eventmask & EV_RE) {
904: mask |= EV_RE | event;
905: }
906: if (evq->ee_eventmask & EV_WR) {
907: mask |= EV_WR | event;
908: }
909: break;
910:
911: default:
912: return;
913: } /* switch */
914:
915: if (mask) {
916: evq->ee_req.er_eventbits |= mask;
917: evprocenque(evq);
918: }
919: }
920: KERNEL_DEBUG(DBG_MISC_POST|DBG_FUNC_END, 0,0,0,0,0);
921: }
922:
923: /*
924: * remove and return the first event (eqp=NULL) or a specific
925: * event, or return NULL if no events found
926: */
927: struct eventqelt *
928: evprocdeque(struct proc *p, struct eventqelt *eqp)
929: {
930:
931:
932: if (eqp && ((eqp->ee_flags & EV_QUEUED) == NULL))
933: return(NULL);
934: if (p->p_evlist.tqh_first == NULL)
935: return(NULL);
936: if (eqp == NULL) { // remove first
937: eqp = p->p_evlist.tqh_first;
938: }
939: TAILQ_REMOVE(&p->p_evlist, eqp, ee_plist);
940: eqp->ee_flags &= ~EV_QUEUED;
941: return(eqp);
942: }
943:
944: struct evwatch_args {
945: struct eventreq *u_req;
946: int u_eventmask;
947: };
948:
949:
950: /*
951: * watchevent system call. user passes us an event to watch
952: * for. we malloc an event object, initialize it, and queue
953: * it to the open socket. when the event occurs, postevent()
954: * will enque it back to our proc where we can retrieve it
955: * via waitevent().
956: *
957: * should this prevent duplicate events on same socket?
958: */
959: int
960: watchevent(p, uap, retval)
961: struct proc *p;
962: struct evwatch_args *uap;
963: register_t *retval;
964: {
965: struct eventqelt *eqp = (struct eventqelt *)0;
966: struct eventqelt *np;
967: struct eventreq *erp;
968: struct file *fp;
969: struct socket *sp;
970: int error;
971:
972: // get a qelt and fill with users req
973: MALLOC(eqp, struct eventqelt *, sizeof(struct eventqelt), M_TEMP, M_WAITOK);
974: if (!eqp) panic("can't MALLOC eqp");
975: erp = &eqp->ee_req;
976: // get users request pkt
977: if (error = copyin((caddr_t)uap->u_req, (caddr_t)erp,
978: sizeof(struct eventreq))) {
979: FREE(eqp, M_TEMP);
980: KERNEL_DEBUG(DBG_MISC_WATCH|DBG_FUNC_END, 0,0,0,0,0);
981: return(error);
982: }
983: KERNEL_DEBUG(DBG_MISC_WATCH|DBG_FUNC_START, 0,
984: erp->er_handle,uap->u_eventmask,eqp,0);
985: // validate, freeing qelt if errors
986: error = 0;
987: if (erp->er_type != EV_FD) {
988: error = EINVAL;
989: } else if (erp->er_handle < 0) {
990: error = EBADF;
991: } else if (erp->er_handle > p->p_fd->fd_nfiles) {
992: error = EBADF;
993: } else if ((fp = *fdfile(p, erp->er_handle)) == NULL) {
994: error = EBADF;
995: } else if (fp->f_type != DTYPE_SOCKET) {
996: error = EINVAL;
997: }
998: if (error) {
999: FREE(eqp,M_TEMP);
1000: KERNEL_DEBUG(DBG_MISC_WATCH|DBG_FUNC_END, 0,0,0,0,0);
1001: return(error);
1002: }
1003:
1004: erp->er_rcnt = erp->er_wcnt = erp->er_eventbits = 0;
1005: eqp->ee_proc = p;
1006: eqp->ee_eventmask = uap->u_eventmask & EV_MASK;
1007: eqp->ee_flags = 0;
1008:
1009: sp = (struct socket *)fp->f_data;
1010: assert(sp != NULL);
1011:
1012: // only allow one watch per file per proc
1013: for (np = sp->so_evlist.tqh_first; np != NULL; np = np->ee_slist.tqe_next) {
1014: if (np->ee_proc == p) {
1015: FREE(eqp,M_TEMP);
1016: KERNEL_DEBUG(DBG_MISC_WATCH|DBG_FUNC_END, 0,0,0,0,0);
1017: return(EINVAL);
1018: }
1019: }
1020:
1021: TAILQ_INSERT_TAIL(&sp->so_evlist, eqp, ee_slist);
1022: postevent(sp, 0, EV_RWBYTES); // catch existing events
1023: KERNEL_DEBUG(DBG_MISC_WATCH|DBG_FUNC_END, 0,0,0,0,0);
1024: return(0);
1025: }
1026:
1027: struct evwait_args {
1028: struct eventreq *u_req;
1029: struct timeval *tv;
1030: };
1031:
1032: /*
1033: * waitevent system call.
1034: * grabs the next waiting event for this proc and returns
1035: * it. if no events, user can request to sleep with timeout
1036: * or poll mode (tv=NULL);
1037: */
1038: int
1039: waitevent(p, uap, retval)
1040: struct proc *p;
1041: struct evwait_args *uap;
1042: register_t *retval;
1043: {
1044: int error = 0;
1045: struct eventqelt *eqp;
1046: int timo;
1047: struct timeval atv;
1048: int s;
1049:
1050: if (uap->tv) {
1051: error = copyin((caddr_t)uap->tv, (caddr_t)&atv,
1052: sizeof (atv));
1053: if (error)
1054: return(error);
1055: if (itimerfix(&atv)) {
1056: error = EINVAL;
1057: return(error);
1058: }
1059: s = splhigh();
1060: timeradd(&atv, &time, &atv);
1061: timo = hzto(&atv);
1062: splx(s);
1063: } else
1064: timo = 0;
1065:
1066: KERNEL_DEBUG(DBG_MISC_WAIT|DBG_FUNC_START, 0,0,0,0,0);
1067:
1068: retry:
1069: s = splhigh();
1070: if ((eqp = evprocdeque(p,NULL)) != NULL) {
1071: splx(s);
1072: error = copyout((caddr_t)&eqp->ee_req, (caddr_t)uap->u_req,
1073: sizeof(struct eventreq));
1074: KERNEL_DEBUG(DBG_MISC_WAIT|DBG_FUNC_END, 0,
1075: eqp->ee_req.er_handle,eqp->ee_req.er_eventbits,eqp,0);
1076: return(error);
1077: } else {
1078: if (uap->tv && (timo == 0)) {
1079: splx(s);
1080: *retval = 1; // poll failed
1081: return(error);
1082: }
1083:
1084: KERNEL_DEBUG(DBG_MISC_WAIT, 1,0,0,0,0);
1085: error = tsleep(&p->p_evlist, PSOCK | PCATCH, "waitevent", timo);
1086: KERNEL_DEBUG(DBG_MISC_WAIT, 0,0,2,p->p_evlist.tqh_first,0);
1087: splx(s);
1088: if (error == 0)
1089: goto retry;
1090: if (error == ERESTART)
1091: error = EINTR;
1092: if (error == EWOULDBLOCK) {
1093: *retval = 1;
1094: error = 0;
1095: }
1096: }
1097: KERNEL_DEBUG(DBG_MISC_WAIT|DBG_FUNC_END, 0,0,0,0,0);
1098: return(error);
1099: }
1100:
1101: struct modwatch_args {
1102: struct eventreq *u_req;
1103: int u_eventmask;
1104: };
1105:
1106: /*
1107: * modwatch system call. user passes in event to modify.
1108: * if we find it we reset the event bits and que/deque event
1109: * it needed.
1110: */
1111: int
1112: modwatch(p, uap, retval)
1113: struct proc *p;
1114: struct modwatch_args *uap;
1115: register_t *retval;
1116: {
1117: struct eventreq er;
1118: struct eventreq *erp = &er;
1119: struct eventqelt *evq;
1120: int error;
1121: struct file *fp;
1122: struct socket *sp;
1123: int flag;
1124:
1125:
1126: // get users request pkt
1127: if (error = copyin((caddr_t)uap->u_req, (caddr_t)erp,
1128: sizeof(struct eventreq))) return(error);
1129:
1130: if (erp->er_type != EV_FD) return(EINVAL);
1131: if (erp->er_handle < 0) return(EBADF);
1132: if (erp->er_handle > p->p_fd->fd_nfiles) return(EBADF);
1133: if ((fp = *fdfile(p, erp->er_handle)) == NULL)
1134: return(EBADF);
1135: if (fp->f_type != DTYPE_SOCKET) return(EINVAL); // for now must be sock
1136: sp = (struct socket *)fp->f_data;
1137: assert(sp != NULL);
1138:
1139: // locate event if possible
1140: for (evq = sp->so_evlist.tqh_first;
1141: evq != NULL; evq = evq->ee_slist.tqe_next) {
1142: if (evq->ee_proc == p) break;
1143: }
1144: if (evq == NULL) {
1145: return(EINVAL);
1146: }
1147:
1148:
1149: if (uap->u_eventmask == EV_RM) {
1150: evprocdeque(p, evq);
1151: TAILQ_REMOVE(&sp->so_evlist, evq, ee_slist);
1152: FREE(evq, M_TEMP);
1153: return(0);
1154: }
1155:
1156: switch (uap->u_eventmask & EV_MASK) {
1157:
1158: case 0:
1159: flag = 0;
1160: break;
1161:
1162: case EV_RE:
1163: case EV_WR:
1164: case EV_RE|EV_WR:
1165: flag = EV_RWBYTES;
1166: break;
1167:
1168: case EV_EX:
1169: flag = EV_OOB;
1170: break;
1171:
1172: case EV_EX|EV_RE:
1173: case EV_EX|EV_WR:
1174: case EV_EX|EV_RE|EV_WR:
1175: flag = EV_OOB|EV_RWBYTES;
1176: break;
1177:
1178: default:
1179: return(EINVAL);
1180: }
1181:
1182: evq->ee_eventmask = uap->u_eventmask & EV_MASK;
1183: evprocdeque(p, evq);
1184: evq->ee_req.er_eventbits = 0;
1185: postevent(sp, 0, flag);
1186: return(0);
1187: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.