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