![[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 [CSRG BSD Unix] / 43BSDReno / sys / kern|
Return to sys_generic.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / sys / kern |
1.1 ! root 1: /* ! 2: * Copyright (c) 1982, 1986, 1989 Regents of the University of California. ! 3: * All rights reserved. ! 4: * ! 5: * Redistribution is only permitted until one year after the first shipment ! 6: * of 4.4BSD by the Regents. Otherwise, redistribution and use in source and ! 7: * binary forms are permitted provided that: (1) source distributions retain ! 8: * this entire copyright notice and comment, and (2) distributions including ! 9: * binaries display the following acknowledgement: This product includes ! 10: * software developed by the University of California, Berkeley and its ! 11: * contributors'' in the documentation or other materials provided with the ! 12: * distribution and in all advertising materials mentioning features or use ! 13: * of this software. Neither the name of the University nor the names of ! 14: * its contributors may be used to endorse or promote products derived from ! 15: * this software without specific prior written permission. ! 16: * THIS SOFTWARE IS PROVIDED AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED ! 17: * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF ! 18: * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. ! 19: * ! 20: * @(#)sys_generic.c 7.23 (Berkeley) 7/22/90 ! 21: */ ! 22: ! 23: #include "param.h" ! 24: #include "systm.h" ! 25: #include "user.h" ! 26: #include "ioctl.h" ! 27: #include "file.h" ! 28: #include "proc.h" ! 29: #include "uio.h" ! 30: #include "kernel.h" ! 31: #include "stat.h" ! 32: #include "malloc.h" ! 33: #ifdef KTRACE ! 34: #include "ktrace.h" ! 35: #endif ! 36: ! 37: /* ! 38: * Read system call. ! 39: */ ! 40: read(p, uap, retval) ! 41: struct proc *p; ! 42: register struct args { ! 43: int fdes; ! 44: char *cbuf; ! 45: unsigned count; ! 46: } *uap; ! 47: int *retval; ! 48: { ! 49: register struct file *fp; ! 50: struct uio auio; ! 51: struct iovec aiov; ! 52: long cnt, error = 0; ! 53: #ifdef KTRACE ! 54: struct iovec ktriov; ! 55: #endif ! 56: ! 57: if (((unsigned)uap->fdes) >= NOFILE || ! 58: (fp = u.u_ofile[uap->fdes]) == NULL || ! 59: (fp->f_flag & FREAD) == 0) ! 60: return (EBADF); ! 61: aiov.iov_base = (caddr_t)uap->cbuf; ! 62: aiov.iov_len = uap->count; ! 63: auio.uio_iov = &aiov; ! 64: auio.uio_iovcnt = 1; ! 65: auio.uio_resid = uap->count; ! 66: auio.uio_rw = UIO_READ; ! 67: auio.uio_segflg = UIO_USERSPACE; ! 68: #ifdef KTRACE ! 69: /* ! 70: * if tracing, save a copy of iovec ! 71: */ ! 72: if (KTRPOINT(p, KTR_GENIO)) ! 73: ktriov = aiov; ! 74: #endif ! 75: cnt = uap->count; ! 76: if (error = (*fp->f_ops->fo_read)(fp, &auio, fp->f_cred)) ! 77: if (auio.uio_resid != cnt && (error == ERESTART || ! 78: error == EINTR || error == EWOULDBLOCK)) ! 79: error = 0; ! 80: cnt -= auio.uio_resid; ! 81: #ifdef KTRACE ! 82: if (KTRPOINT(p, KTR_GENIO) && error == 0) ! 83: ktrgenio(p->p_tracep, uap->fdes, UIO_READ, &ktriov, cnt, error); ! 84: #endif ! 85: *retval = cnt; ! 86: return (error); ! 87: } ! 88: ! 89: /* ! 90: * Scatter read system call. ! 91: */ ! 92: readv(p, uap, retval) ! 93: struct proc *p; ! 94: register struct args { ! 95: int fdes; ! 96: struct iovec *iovp; ! 97: unsigned iovcnt; ! 98: } *uap; ! 99: int *retval; ! 100: { ! 101: register struct file *fp; ! 102: struct uio auio; ! 103: register struct iovec *iov; ! 104: struct iovec *saveiov; ! 105: struct iovec aiov[UIO_SMALLIOV]; ! 106: long i, cnt, error = 0; ! 107: unsigned iovlen; ! 108: #ifdef KTRACE ! 109: struct iovec *ktriov = NULL; ! 110: #endif ! 111: ! 112: if (((unsigned)uap->fdes) >= NOFILE || ! 113: (fp = u.u_ofile[uap->fdes]) == NULL || ! 114: (fp->f_flag & FREAD) == 0) ! 115: return (EBADF); ! 116: /* note: can't use iovlen until iovcnt is validated */ ! 117: iovlen = uap->iovcnt * sizeof (struct iovec); ! 118: if (uap->iovcnt > UIO_SMALLIOV) { ! 119: if (uap->iovcnt > UIO_MAXIOV) ! 120: return (EINVAL); ! 121: MALLOC(iov, struct iovec *, iovlen, M_IOV, M_WAITOK); ! 122: saveiov = iov; ! 123: } else ! 124: iov = aiov; ! 125: auio.uio_iov = iov; ! 126: auio.uio_iovcnt = uap->iovcnt; ! 127: auio.uio_rw = UIO_READ; ! 128: auio.uio_segflg = UIO_USERSPACE; ! 129: if (error = copyin((caddr_t)uap->iovp, (caddr_t)iov, iovlen)) ! 130: goto done; ! 131: auio.uio_resid = 0; ! 132: for (i = 0; i < uap->iovcnt; i++) { ! 133: if (iov->iov_len < 0) { ! 134: error = EINVAL; ! 135: goto done; ! 136: } ! 137: auio.uio_resid += iov->iov_len; ! 138: if (auio.uio_resid < 0) { ! 139: error = EINVAL; ! 140: goto done; ! 141: } ! 142: iov++; ! 143: } ! 144: #ifdef KTRACE ! 145: /* ! 146: * if tracing, save a copy of iovec ! 147: */ ! 148: if (KTRPOINT(p, KTR_GENIO)) { ! 149: MALLOC(ktriov, struct iovec *, iovlen, M_TEMP, M_WAITOK); ! 150: bcopy((caddr_t)auio.uio_iov, (caddr_t)ktriov, iovlen); ! 151: } ! 152: #endif ! 153: cnt = auio.uio_resid; ! 154: if (error = (*fp->f_ops->fo_read)(fp, &auio, fp->f_cred)) ! 155: if (auio.uio_resid != cnt && (error == ERESTART || ! 156: error == EINTR || error == EWOULDBLOCK)) ! 157: error = 0; ! 158: cnt -= auio.uio_resid; ! 159: #ifdef KTRACE ! 160: if (ktriov != NULL) { ! 161: if (error == 0) ! 162: ktrgenio(p->p_tracep, uap->fdes, UIO_READ, ktriov, ! 163: cnt, error); ! 164: FREE(ktriov, M_TEMP); ! 165: } ! 166: #endif ! 167: *retval = cnt; ! 168: done: ! 169: if (uap->iovcnt > UIO_SMALLIOV) ! 170: FREE(saveiov, M_IOV); ! 171: return (error); ! 172: } ! 173: ! 174: /* ! 175: * Write system call ! 176: */ ! 177: write(p, uap, retval) ! 178: struct proc *p; ! 179: register struct args { ! 180: int fdes; ! 181: char *cbuf; ! 182: unsigned count; ! 183: } *uap; ! 184: int *retval; ! 185: { ! 186: register struct file *fp; ! 187: struct uio auio; ! 188: struct iovec aiov; ! 189: long cnt, error = 0; ! 190: #ifdef KTRACE ! 191: struct iovec ktriov; ! 192: #endif ! 193: ! 194: if (((unsigned)uap->fdes) >= NOFILE || ! 195: (fp = u.u_ofile[uap->fdes]) == NULL || ! 196: (fp->f_flag & FWRITE) == 0) ! 197: return (EBADF); ! 198: aiov.iov_base = (caddr_t)uap->cbuf; ! 199: aiov.iov_len = uap->count; ! 200: auio.uio_iov = &aiov; ! 201: auio.uio_iovcnt = 1; ! 202: auio.uio_resid = uap->count; ! 203: auio.uio_rw = UIO_WRITE; ! 204: auio.uio_segflg = UIO_USERSPACE; ! 205: #ifdef KTRACE ! 206: /* ! 207: * if tracing, save a copy of iovec ! 208: */ ! 209: if (KTRPOINT(p, KTR_GENIO)) ! 210: ktriov = aiov; ! 211: #endif ! 212: cnt = uap->count; ! 213: if (error = (*fp->f_ops->fo_write)(fp, &auio, fp->f_cred)) { ! 214: if (auio.uio_resid != cnt && (error == ERESTART || ! 215: error == EINTR || error == EWOULDBLOCK)) ! 216: error = 0; ! 217: if (error == EPIPE) ! 218: psignal(p, SIGPIPE); ! 219: } ! 220: cnt -= auio.uio_resid; ! 221: #ifdef KTRACE ! 222: if (KTRPOINT(p, KTR_GENIO) && error == 0) ! 223: ktrgenio(p->p_tracep, uap->fdes, UIO_WRITE, ! 224: &ktriov, cnt, error); ! 225: #endif ! 226: *retval = cnt; ! 227: return (error); ! 228: } ! 229: ! 230: /* ! 231: * Gather write system call ! 232: */ ! 233: writev(p, uap, retval) ! 234: struct proc *p; ! 235: register struct args { ! 236: int fdes; ! 237: struct iovec *iovp; ! 238: unsigned iovcnt; ! 239: } *uap; ! 240: int *retval; ! 241: { ! 242: register struct file *fp; ! 243: struct uio auio; ! 244: register struct iovec *iov; ! 245: struct iovec *saveiov; ! 246: struct iovec aiov[UIO_SMALLIOV]; ! 247: long i, cnt, error = 0; ! 248: unsigned iovlen; ! 249: #ifdef KTRACE ! 250: struct iovec *ktriov = NULL; ! 251: #endif ! 252: ! 253: if (((unsigned)uap->fdes) >= NOFILE || ! 254: (fp = u.u_ofile[uap->fdes]) == NULL || ! 255: (fp->f_flag & FWRITE) == 0) ! 256: return (EBADF); ! 257: /* note: can't use iovlen until iovcnt is validated */ ! 258: iovlen = uap->iovcnt * sizeof (struct iovec); ! 259: if (uap->iovcnt > UIO_SMALLIOV) { ! 260: if (uap->iovcnt > UIO_MAXIOV) ! 261: return (EINVAL); ! 262: MALLOC(iov, struct iovec *, iovlen, M_IOV, M_WAITOK); ! 263: saveiov = iov; ! 264: } else ! 265: iov = aiov; ! 266: auio.uio_iov = iov; ! 267: auio.uio_iovcnt = uap->iovcnt; ! 268: auio.uio_rw = UIO_WRITE; ! 269: auio.uio_segflg = UIO_USERSPACE; ! 270: if (error = copyin((caddr_t)uap->iovp, (caddr_t)iov, iovlen)) ! 271: goto done; ! 272: auio.uio_resid = 0; ! 273: for (i = 0; i < uap->iovcnt; i++) { ! 274: if (iov->iov_len < 0) { ! 275: error = EINVAL; ! 276: goto done; ! 277: } ! 278: auio.uio_resid += iov->iov_len; ! 279: if (auio.uio_resid < 0) { ! 280: error = EINVAL; ! 281: goto done; ! 282: } ! 283: iov++; ! 284: } ! 285: #ifdef KTRACE ! 286: /* ! 287: * if tracing, save a copy of iovec ! 288: */ ! 289: if (KTRPOINT(p, KTR_GENIO)) { ! 290: MALLOC(ktriov, struct iovec *, iovlen, M_TEMP, M_WAITOK); ! 291: bcopy((caddr_t)auio.uio_iov, (caddr_t)ktriov, iovlen); ! 292: } ! 293: #endif ! 294: cnt = auio.uio_resid; ! 295: if (error = (*fp->f_ops->fo_write)(fp, &auio, fp->f_cred)) { ! 296: if (auio.uio_resid != cnt && (error == ERESTART || ! 297: error == EINTR || error == EWOULDBLOCK)) ! 298: error = 0; ! 299: if (error == EPIPE) ! 300: psignal(p, SIGPIPE); ! 301: } ! 302: cnt -= auio.uio_resid; ! 303: #ifdef KTRACE ! 304: if (ktriov != NULL) { ! 305: if (error == 0) ! 306: ktrgenio(p->p_tracep, uap->fdes, UIO_WRITE, ! 307: ktriov, cnt, error); ! 308: FREE(ktriov, M_TEMP); ! 309: } ! 310: #endif ! 311: *retval = cnt; ! 312: done: ! 313: if (uap->iovcnt > UIO_SMALLIOV) ! 314: FREE(saveiov, M_IOV); ! 315: return (error); ! 316: } ! 317: ! 318: /* ! 319: * Ioctl system call ! 320: */ ! 321: /* ARGSUSED */ ! 322: ioctl(p, uap, retval) ! 323: struct proc *p; ! 324: register struct args { ! 325: int fdes; ! 326: int cmd; ! 327: caddr_t cmarg; ! 328: } *uap; ! 329: int *retval; ! 330: { ! 331: register struct file *fp; ! 332: register int com, error; ! 333: register u_int size; ! 334: caddr_t memp = 0; ! 335: #define STK_PARAMS 128 ! 336: char stkbuf[STK_PARAMS]; ! 337: caddr_t data = stkbuf; ! 338: ! 339: if ((unsigned)uap->fdes >= NOFILE || ! 340: (fp = u.u_ofile[uap->fdes]) == NULL) ! 341: return (EBADF); ! 342: if ((fp->f_flag & (FREAD|FWRITE)) == 0) ! 343: return (EBADF); ! 344: com = uap->cmd; ! 345: ! 346: if (com == FIOCLEX) { ! 347: u.u_pofile[uap->fdes] |= UF_EXCLOSE; ! 348: return (0); ! 349: } ! 350: if (com == FIONCLEX) { ! 351: u.u_pofile[uap->fdes] &= ~UF_EXCLOSE; ! 352: return (0); ! 353: } ! 354: ! 355: /* ! 356: * Interpret high order word to find ! 357: * amount of data to be copied to/from the ! 358: * user's address space. ! 359: */ ! 360: size = IOCPARM_LEN(com); ! 361: if (size > IOCPARM_MAX) ! 362: return (ENOTTY); ! 363: if (size > sizeof (stkbuf)) { ! 364: memp = (caddr_t)malloc((u_long)size, M_IOCTLOPS, M_WAITOK); ! 365: data = memp; ! 366: } ! 367: if (com&IOC_IN) { ! 368: if (size) { ! 369: error = copyin(uap->cmarg, data, (u_int)size); ! 370: if (error) { ! 371: if (memp) ! 372: free(memp, M_IOCTLOPS); ! 373: return (error); ! 374: } ! 375: } else ! 376: *(caddr_t *)data = uap->cmarg; ! 377: } else if ((com&IOC_OUT) && size) ! 378: /* ! 379: * Zero the buffer so the user always ! 380: * gets back something deterministic. ! 381: */ ! 382: bzero(data, size); ! 383: else if (com&IOC_VOID) ! 384: *(caddr_t *)data = uap->cmarg; ! 385: ! 386: switch (com) { ! 387: ! 388: case FIONBIO: ! 389: error = fset(fp, FNDELAY, *(int *)data); ! 390: break; ! 391: ! 392: case FIOASYNC: ! 393: error = fset(fp, FASYNC, *(int *)data); ! 394: break; ! 395: ! 396: case FIOSETOWN: ! 397: error = fsetown(fp, *(int *)data); ! 398: break; ! 399: ! 400: case FIOGETOWN: ! 401: error = fgetown(fp, (int *)data); ! 402: break; ! 403: default: ! 404: error = (*fp->f_ops->fo_ioctl)(fp, com, data); ! 405: /* ! 406: * Copy any data to user, size was ! 407: * already set and checked above. ! 408: */ ! 409: if (error == 0 && (com&IOC_OUT) && size) ! 410: error = copyout(data, uap->cmarg, (u_int)size); ! 411: break; ! 412: } ! 413: if (memp) ! 414: free(memp, M_IOCTLOPS); ! 415: return (error); ! 416: } ! 417: ! 418: int nselcoll; ! 419: ! 420: /* ! 421: * Select system call. ! 422: */ ! 423: select(p, uap, retval) ! 424: register struct proc *p; ! 425: register struct args { ! 426: int nd; ! 427: fd_set *in, *ou, *ex; ! 428: struct timeval *tv; ! 429: } *uap; ! 430: int *retval; ! 431: { ! 432: fd_set ibits[3], obits[3]; ! 433: struct timeval atv; ! 434: int s, ncoll, ni, error = 0, timo; ! 435: ! 436: bzero((caddr_t)ibits, sizeof(ibits)); ! 437: bzero((caddr_t)obits, sizeof(obits)); ! 438: if (uap->nd > NOFILE) ! 439: uap->nd = NOFILE; /* forgiving, if slightly wrong */ ! 440: ni = howmany(uap->nd, NFDBITS); ! 441: ! 442: #define getbits(name, x) \ ! 443: if (uap->name) { \ ! 444: error = copyin((caddr_t)uap->name, (caddr_t)&ibits[x], \ ! 445: (unsigned)(ni * sizeof(fd_mask))); \ ! 446: if (error) \ ! 447: goto done; \ ! 448: } ! 449: getbits(in, 0); ! 450: getbits(ou, 1); ! 451: getbits(ex, 2); ! 452: #undef getbits ! 453: ! 454: if (uap->tv) { ! 455: error = copyin((caddr_t)uap->tv, (caddr_t)&atv, ! 456: sizeof (atv)); ! 457: if (error) ! 458: goto done; ! 459: if (itimerfix(&atv)) { ! 460: error = EINVAL; ! 461: goto done; ! 462: } ! 463: s = splhigh(); timevaladd(&atv, &time); splx(s); ! 464: timo = hzto(&atv); ! 465: } else ! 466: timo = 0; ! 467: retry: ! 468: ncoll = nselcoll; ! 469: p->p_flag |= SSEL; ! 470: error = selscan(ibits, obits, uap->nd, retval); ! 471: if (error || *retval) ! 472: goto done; ! 473: s = splhigh(); ! 474: /* this should be timercmp(&time, &atv, >=) */ ! 475: if (uap->tv && (time.tv_sec > atv.tv_sec || ! 476: time.tv_sec == atv.tv_sec && time.tv_usec >= atv.tv_usec)) { ! 477: splx(s); ! 478: goto done; ! 479: } ! 480: if ((p->p_flag & SSEL) == 0 || nselcoll != ncoll) { ! 481: splx(s); ! 482: goto retry; ! 483: } ! 484: p->p_flag &= ~SSEL; ! 485: error = tsleep((caddr_t)&selwait, PSOCK | PCATCH, "select", timo); ! 486: splx(s); ! 487: if (error == 0) ! 488: goto retry; ! 489: done: ! 490: p->p_flag &= ~SSEL; ! 491: /* select is not restarted after signals... */ ! 492: if (error == ERESTART) ! 493: error = EINTR; ! 494: if (error == EWOULDBLOCK) ! 495: error = 0; ! 496: #define putbits(name, x) \ ! 497: if (uap->name) { \ ! 498: int error2 = copyout((caddr_t)&obits[x], (caddr_t)uap->name, \ ! 499: (unsigned)(ni * sizeof(fd_mask))); \ ! 500: if (error2) \ ! 501: error = error2; \ ! 502: } ! 503: if (error == 0) { ! 504: putbits(in, 0); ! 505: putbits(ou, 1); ! 506: putbits(ex, 2); ! 507: #undef putbits ! 508: } ! 509: return (error); ! 510: } ! 511: ! 512: selscan(ibits, obits, nfd, retval) ! 513: fd_set *ibits, *obits; ! 514: int nfd, *retval; ! 515: { ! 516: register int which, i, j; ! 517: register fd_mask bits; ! 518: int flag; ! 519: struct file *fp; ! 520: int error = 0, n = 0; ! 521: ! 522: for (which = 0; which < 3; which++) { ! 523: switch (which) { ! 524: ! 525: case 0: ! 526: flag = FREAD; break; ! 527: ! 528: case 1: ! 529: flag = FWRITE; break; ! 530: ! 531: case 2: ! 532: flag = 0; break; ! 533: } ! 534: for (i = 0; i < nfd; i += NFDBITS) { ! 535: bits = ibits[which].fds_bits[i/NFDBITS]; ! 536: while ((j = ffs(bits)) && i + --j < nfd) { ! 537: bits &= ~(1 << j); ! 538: fp = u.u_ofile[i + j]; ! 539: if (fp == NULL) { ! 540: error = EBADF; ! 541: break; ! 542: } ! 543: if ((*fp->f_ops->fo_select)(fp, flag)) { ! 544: FD_SET(i + j, &obits[which]); ! 545: n++; ! 546: } ! 547: } ! 548: } ! 549: } ! 550: *retval = n; ! 551: return (error); ! 552: } ! 553: ! 554: /*ARGSUSED*/ ! 555: seltrue(dev, flag) ! 556: dev_t dev; ! 557: int flag; ! 558: { ! 559: ! 560: return (1); ! 561: } ! 562: ! 563: selwakeup(p, coll) ! 564: register struct proc *p; ! 565: int coll; ! 566: { ! 567: ! 568: if (coll) { ! 569: nselcoll++; ! 570: wakeup((caddr_t)&selwait); ! 571: } ! 572: if (p) { ! 573: int s = splhigh(); ! 574: if (p->p_wchan == (caddr_t)&selwait) { ! 575: if (p->p_stat == SSLEEP) ! 576: setrun(p); ! 577: else ! 578: unsleep(p); ! 579: } else if (p->p_flag & SSEL) ! 580: p->p_flag &= ~SSEL; ! 581: splx(s); ! 582: } ! 583: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.