![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to streamio.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / sys / os|
Return to streamio.c CVS log | Up to [Research Unix] / researchv10no / sys / os |
1.1 ! root 1: #include "sys/param.h" ! 2: #include "sys/user.h" ! 3: #include "sys/buf.h" ! 4: #include "sys/stream.h" ! 5: #include "sys/inode.h" ! 6: #include "sys/filio.h" ! 7: #include "sys/ttyio.h" ! 8: #include "sys/conf.h" ! 9: #include "sys/proc.h" ! 10: #include "sys/file.h" ! 11: ! 12: extern struct queue queue[]; ! 13: ! 14: #define STIPRI 28 ! 15: #define STOPRI 29 ! 16: ! 17: extern struct stdata streams[]; ! 18: extern int streamcnt; ! 19: ! 20: struct stdata *stenter(); ! 21: int strput(), stwsrv(), nulldev(), nilput(); ! 22: long nilopen(); ! 23: ! 24: struct qinit strdata = { strput, NULL, nilopen, nulldev, 512, 256 }; ! 25: struct qinit stwdata = { nulldev, stwsrv, nilopen, nulldev, 0, 0}; ! 26: struct qinit nilw = { nilput, NULL, nilopen, nulldev, 1, 0 }; ! 27: struct streamtab nilinfo = { &nilw, &nilw }; ! 28: ! 29: /* ! 30: * open a stream device ! 31: * returns the inode, ! 32: * which may be different from ip, ! 33: * in which event ip has been put. ! 34: * return NULL on error, ! 35: * in which event ip has also been put. ! 36: */ ! 37: struct inode * ! 38: stopen(qinfo, dev, flag, ip) ! 39: struct streamtab *qinfo; ! 40: dev_t dev; ! 41: struct inode *ip; ! 42: { ! 43: register struct queue *qp; ! 44: register struct stdata *sp; ! 45: register struct inode *nip; ! 46: register s; ! 47: ! 48: if (sp = ip->i_sptr) { /* already streaming? */ ! 49: if (sp->flag & EXCL && u.u_uid!=0 ! 50: && (sp->pgrp==0 || sp->pgrp != u.u_procp->p_pgrp)) { ! 51: u.u_error = ENXIO; ! 52: iput(ip); ! 53: return(NULL); ! 54: } ! 55: if (stenter(ip)==NULL) { ! 56: iput(ip); ! 57: return(NULL); ! 58: } ! 59: while (sp->flag&STWOPEN) { ! 60: if (tsleep((caddr_t)sp, STOPRI, 0)!=TS_OK) { ! 61: stexit(ip); ! 62: u.u_error = ENXIO; ! 63: iput(ip); ! 64: return(NULL); ! 65: } ! 66: } ! 67: if (sp->flag&HUNGUP) { ! 68: flushq(RD(sp->wrq), 1); ! 69: stexit(ip); ! 70: u.u_error = ENXIO; ! 71: iput(ip); ! 72: return(NULL); ! 73: } ! 74: for (qp = sp->wrq; qp->next && (qp->next->flag&QREADR)==0; qp = qp->next) { ! 75: /* device-cloning; qopen s.b. struct inode * */ ! 76: nip = (struct inode *) ! 77: (*qp->next->qinfo->qopen)(RD(qp->next), dev); ! 78: if (nip == NULL) { /* open failed */ ! 79: stexit(ip); ! 80: u.u_error = ENXIO; ! 81: iput(ip); ! 82: return(NULL); ! 83: } ! 84: if ((long)nip != 1) { /* changed inode, so stop now */ ! 85: stexit(ip); ! 86: iput(ip); ! 87: return(nip); ! 88: } ! 89: } ! 90: stexit(ip); ! 91: return(ip); ! 92: } else { /* new stream */ ! 93: register struct stdata *esp = &streams[streamcnt]; ! 94: register struct queue *nq; ! 95: ! 96: for (sp = streams; sp < esp; sp++) ! 97: if (sp->wrq==NULL) ! 98: break; ! 99: if (sp >= esp) { ! 100: printf("out of streams\n"); ! 101: u.u_error = ENFILE; ! 102: iput(ip); ! 103: return(NULL); ! 104: } ! 105: if ((qp = allocq()) == NULL) { ! 106: printf("Out of queues in stopen\n"); ! 107: u.u_error = ENFILE; ! 108: iput(ip); ! 109: return(NULL); ! 110: } ! 111: sp->wrq = WR(qp); ! 112: sp->pgrp = 0; ! 113: sp->inode = ip; ! 114: sp->flag = 0; ! 115: sp->iocblk = NULL; ! 116: sp->count = 1; ! 117: qp->ptr = (caddr_t)sp; ! 118: WR(qp)->ptr = (caddr_t)sp; ! 119: qp->qinfo = &strdata; ! 120: WR(qp)->qinfo = &stwdata; ! 121: qp->flag |= QBIGB; ! 122: WR(qp)->flag |= QDELIM; ! 123: ip->i_sptr = sp; ! 124: s = spl6(); ! 125: if (qattach(qinfo, qp, dev) == 0) { ! 126: sp->flag |= HUNGUP; ! 127: splx(s); ! 128: stexit(ip); ! 129: u.u_error = ENXIO; ! 130: iput(ip); ! 131: return(NULL); ! 132: } ! 133: nq = RD(WR(qp)->next); ! 134: sp->flag |= STWOPEN; ! 135: nip = (struct inode *)(*nq->qinfo->qopen)(nq, dev); ! 136: sp->flag &= ~STWOPEN; ! 137: splx(s); ! 138: wakeup((caddr_t)sp); ! 139: if (nip == NULL) { ! 140: qdetach(nq, 0); ! 141: sp->flag |= HUNGUP; ! 142: stexit(ip); ! 143: u.u_error = ENXIO; ! 144: iput(ip); ! 145: return(NULL); ! 146: } ! 147: if ((long)nip != 1) { ! 148: stexit(ip); ! 149: iput(ip); ! 150: return(nip); ! 151: } ! 152: stexit(ip); ! 153: return(ip); ! 154: } ! 155: } ! 156: ! 157: /* ! 158: * Shut down a stream ! 159: * -- pop all line disciplines ! 160: * -- shut down the driver ! 161: */ ! 162: stclose(ip, sleepOK) ! 163: struct inode *ip; ! 164: { ! 165: register struct stdata *stp; ! 166: register struct queue *qp; ! 167: register s; ! 168: register struct block *bp; ! 169: ! 170: s = spl6(); ! 171: if ((stp = ip->i_sptr) == NULL) { ! 172: splx(s); ! 173: return; ! 174: } ! 175: forceclose(stp, FREAD|FWRITE); ! 176: if (stp->count != 0) { ! 177: printf("count is %d in stclose, stream %x\n", stp->count, stp); ! 178: splx(s); ! 179: return; ! 180: } ! 181: ip->i_sptr = NULL; ! 182: splx(s); ! 183: qp = stp->wrq; ! 184: while (qp->next) { ! 185: register i; ! 186: /* detect cross-connects, and seal off other end */ ! 187: if (qp->next->flag & QREADR) { ! 188: putctl(qp->next, M_HANGUP); ! 189: if (qattach(&nilinfo, qp->next, (dev_t)-1) == 0) ! 190: panic("close/qattach"); ! 191: WR(qp->next)->next = NULL; ! 192: break; ! 193: } ! 194: if (sleepOK && (stp->flag&HUNGUP)==0) ! 195: for (i=0; qp->next->count!=0 && i<60; i++) ! 196: tsleep((caddr_t)qp, STIPRI, 1); ! 197: qdetach(RD(qp->next), 1); ! 198: } ! 199: flushq(qp, 1); ! 200: while (bp = getq(RD(qp))) { ! 201: if (bp->type == M_PASS) ! 202: closef(((struct kpassfd *)bp->rptr)->f.fp); ! 203: freeb(bp); ! 204: } ! 205: stp->wrq = NULL; ! 206: RD(qp)->flag = 0; ! 207: qp->flag = 0; ! 208: } ! 209: ! 210: /* ! 211: * Read a stream ! 212: */ ! 213: stread(ip) ! 214: struct inode *ip; ! 215: { ! 216: register struct stdata *stq; ! 217: register struct block *bp; ! 218: register n; ! 219: register s, nc = 0; ! 220: ! 221: if ((stq = stenter(ip)) == NULL) { ! 222: u.u_error = 0; /* return EOF not error */ ! 223: return; ! 224: } ! 225: /* ! 226: * Read is complete when: ! 227: * Q is empty and some data has been read and next Q might not generate ! 228: * delimiters, or ! 229: * There is data on Q and count has been satisfied, or ! 230: * A delimiter is taken from the Q, or ! 231: * There was an error. ! 232: */ ! 233: for (;;) { ! 234: s = spl6(); ! 235: if ((bp = getq(RD(stq->wrq))) == NULL) { ! 236: if ((nc && (OTHERQ(stq->wrq->next)->flag&QDELIM)==0) ! 237: || stq->flag&HUNGUP) { ! 238: splx(s); ! 239: stexit(ip); ! 240: return; ! 241: } ! 242: stq->flag |= RSLEEP; ! 243: n = tsleep((caddr_t)RD(stq->wrq), STIPRI, 0); ! 244: splx(s); ! 245: if (n == TS_SIG) { ! 246: stexit(ip); ! 247: longjmp(u.u_qsav); ! 248: } ! 249: continue; ! 250: } ! 251: splx(s); ! 252: switch (bp->type) { ! 253: ! 254: case M_DATA: ! 255: n = min(u.u_count, bp->wptr - bp->rptr); ! 256: if (n) ! 257: iomove(bp->rptr, n, B_READ); ! 258: bp->rptr += n; ! 259: nc += n; ! 260: if (bp->rptr >= bp->wptr) { ! 261: n = bp->class; ! 262: freeb(bp); ! 263: if (n&S_DELIM) ! 264: goto out; ! 265: } else { ! 266: putbq(RD(stq->wrq), bp); ! 267: if (u.u_count == 0) ! 268: goto out; ! 269: } ! 270: if (u.u_error) ! 271: goto out; ! 272: continue; ! 273: ! 274: case M_PASS: ! 275: putbq(RD(stq->wrq), bp); ! 276: goto out; ! 277: ! 278: default: ! 279: printf("stread: msg %d\n", bp->type); ! 280: freeb(bp); ! 281: continue; ! 282: } ! 283: } ! 284: out: ! 285: stexit(ip); ! 286: } ! 287: ! 288: /* ! 289: * Internal version of stread: transfer to given address. ! 290: * Always returns; >= 0 is # bytes transferred, -1 is error. ! 291: * Always reads a whole record; excess discarded. ! 292: */ ! 293: istread(ip, addr, count, flag) /* flag is for timeout debugging */ ! 294: struct inode *ip; ! 295: caddr_t addr; ! 296: { ! 297: register struct stdata *stq; ! 298: register struct block *bp; ! 299: register n; ! 300: register s, nc = 0; ! 301: ! 302: if ((stq = stenter(ip)) == NULL) ! 303: return(-1); ! 304: for (;;) { ! 305: s = spl6(); ! 306: if ((bp = getq(RD(stq->wrq))) == NULL) { ! 307: if ((nc && (OTHERQ(stq->wrq->next)->flag&QDELIM)==0) ! 308: || stq->flag&HUNGUP) { ! 309: splx(s); ! 310: stexit(ip); ! 311: return(nc); ! 312: } ! 313: stq->flag |= RSLEEP; ! 314: n = tsleep((caddr_t)RD(stq->wrq), PRIBIO, 30); ! 315: splx(s); ! 316: if (n == TS_TIME) { ! 317: if(flag) ! 318: printf("nb timeout nc %d count %d addr #%x\n", ! 319: nc, count, addr); ! 320: stexit(ip); ! 321: return(-1); ! 322: } ! 323: continue; ! 324: } ! 325: splx(s); ! 326: switch (bp->type) { ! 327: ! 328: case M_DATA: ! 329: n = min(count, bp->wptr - bp->rptr); ! 330: if (n) ! 331: bcopy(bp->rptr, addr, n); ! 332: addr += n; ! 333: nc += n; ! 334: count -= n; ! 335: n = bp->class; ! 336: freeb(bp); ! 337: if (n&S_DELIM) { ! 338: stexit(ip); ! 339: return(nc); ! 340: } ! 341: continue; ! 342: ! 343: case M_PASS: ! 344: putbq(RD(stq->wrq), bp); ! 345: stexit(ip); ! 346: return(nc); ! 347: ! 348: default: ! 349: printf("istread: msg %d\n", bp->type); ! 350: freeb(bp); ! 351: continue; ! 352: } ! 353: } ! 354: } ! 355: ! 356: /* ! 357: * Stream input put proc ! 358: * -- collect signals and ioctl acks ! 359: -- put data and delims on data queue ! 360: -- see hangups and seal off channel ! 361: */ ! 362: strput(q, bp) ! 363: register struct queue *q; ! 364: register struct block *bp; ! 365: { ! 366: register struct stdata *stp = (struct stdata *)q->ptr; ! 367: ! 368: switch (bp->type) { ! 369: ! 370: case M_DATA: ! 371: default: ! 372: putq(q, bp); ! 373: if (stp->flag & RSLEEP) { ! 374: stp->flag &= ~RSLEEP; ! 375: wakeup((caddr_t)q); ! 376: } ! 377: break; ! 378: ! 379: case M_HANGUP: ! 380: stp->flag |= HUNGUP; ! 381: freeb(bp); ! 382: if (stp->pgrp) ! 383: gsignal(stp->pgrp, SIGHUP); ! 384: forceclose(stp, FWRITE); ! 385: wakeup((caddr_t)q); /* the readers */ ! 386: wakeup((caddr_t)WR(q)); /* the writers */ ! 387: wakeup((caddr_t)stp); /* the ioctllers */ ! 388: break; ! 389: ! 390: case M_SIGNAL: ! 391: gsignal(stp->pgrp, *bp->rptr); ! 392: case M_FLUSH: ! 393: flushq(q, 0); /* flush races with select */ ! 394: case M_BREAK: ! 395: case M_YDEL: ! 396: case M_NDEL: ! 397: case M_CTL: ! 398: freeb(bp); ! 399: return; ! 400: ! 401: case M_IOCACK: ! 402: case M_IOCNAK: ! 403: case M_IOCWAIT: ! 404: if(stp->iocblk && stp->iocblk->type==M_IOCWAIT) { ! 405: freeb(stp->iocblk); ! 406: stp->iocblk = NULL; ! 407: } ! 408: if ((stp->flag&IOCWAIT)==0 || stp->iocblk) { ! 409: freeb(bp); ! 410: return; ! 411: } ! 412: stp->iocblk = bp; ! 413: wakeup((caddr_t)stp); ! 414: return; ! 415: ! 416: case M_IOCTL: ! 417: bp->type = M_IOCNAK; ! 418: bp->wptr = bp->rptr; /* data means error */ ! 419: qreply(q, bp); ! 420: return; ! 421: } ! 422: if (stp->rsel) { ! 423: selwakeup(stp->rsel, stp->flag&RSEL); ! 424: stp->flag &= ~RSEL; ! 425: stp->rsel = NULL; ! 426: } ! 427: } ! 428: ! 429: ! 430: /* ! 431: * Write on a stream ! 432: */ ! 433: stwrite(ip) ! 434: struct inode *ip; ! 435: { ! 436: register struct stdata *stq; ! 437: register struct block *bp; ! 438: register n; ! 439: register s; ! 440: ! 441: if ((stq = stenter(ip)) == NULL) ! 442: return; ! 443: do { ! 444: s = spl6(); ! 445: while ((stq->flag&HUNGUP)==0 && stq->wrq->next->flag&QFULL) { ! 446: stq->flag |= WSLEEP; ! 447: if (tsleep((caddr_t)stq->wrq, STOPRI, 0)==TS_SIG) { ! 448: splx(s); ! 449: stexit(ip); ! 450: longjmp(u.u_qsav); ! 451: } ! 452: } ! 453: splx(s); ! 454: if (stq->flag & HUNGUP) { ! 455: psignal(u.u_procp, SIGPIPE); ! 456: u.u_error = ENXIO; ! 457: break; ! 458: } ! 459: n = QBSIZE; ! 460: if (u.u_count >= 512 && stq->wrq->next->flag&QBIGB) ! 461: n = 1024; ! 462: if ((bp = allocb(n)) == NULL) { ! 463: printf("stwrite can't alloc\n"); ! 464: continue; /* temp */ ! 465: } ! 466: bp->type = M_DATA; ! 467: n = min(bp->lim - bp->wptr, u.u_count); ! 468: iomove(bp->wptr, n, B_WRITE); ! 469: if (u.u_error) { ! 470: freeb(bp); ! 471: break; ! 472: } ! 473: bp->wptr += n; ! 474: if (u.u_count==0) ! 475: bp->class |= S_DELIM; ! 476: (*stq->wrq->next->qinfo->putp)(stq->wrq->next, bp); ! 477: } while (u.u_count); ! 478: stexit(ip); ! 479: } ! 480: ! 481: /* ! 482: * Stream output -- internal version ! 483: * return -1 on error, 0 OK ! 484: */ ! 485: istwrite(ip, addr, count) ! 486: register count; ! 487: struct inode *ip; ! 488: caddr_t addr; ! 489: { ! 490: register struct stdata *stq; ! 491: register struct block *bp; ! 492: register n; ! 493: register s; ! 494: ! 495: if ((stq = stenter(ip)) == NULL) ! 496: return(-1); ! 497: do { ! 498: s = spl6(); ! 499: while (stq->wrq->next->flag&QFULL && (stq->flag&HUNGUP)==0) { ! 500: stq->flag |= WSLEEP; ! 501: if (tsleep((caddr_t)stq->wrq, PRIBIO, 30)==TS_TIME) { ! 502: splx(s); ! 503: stexit(ip); ! 504: return(-1); ! 505: } ! 506: } ! 507: splx(s); ! 508: if (stq->flag & HUNGUP) { ! 509: stexit(ip); ! 510: return(-1); ! 511: } ! 512: n = QBSIZE; ! 513: if (count >= 512 && stq->wrq->next->flag&QBIGB) ! 514: n = 1024; ! 515: if ((bp = allocb(n)) == NULL) { ! 516: printf("istwrite can't alloc\n"); ! 517: continue; /* temp */ ! 518: } ! 519: bp->type = M_DATA; ! 520: n = min(bp->lim - bp->wptr, count); ! 521: bcopy(addr, bp->wptr, n); ! 522: bp->wptr += n; ! 523: addr += n; ! 524: count -= n; ! 525: if (count==0) ! 526: bp->class |= S_DELIM; ! 527: (*stq->wrq->next->qinfo->putp)(stq->wrq->next, bp); ! 528: } while (count); ! 529: stexit(ip); ! 530: return(0); ! 531: } ! 532: ! 533: /* ! 534: * Stream output server (when full queue empties) ! 535: */ ! 536: stwsrv(q) ! 537: register struct queue *q; ! 538: { ! 539: register struct stdata *stq = (struct stdata *)q->ptr; ! 540: ! 541: if (stq->flag & WSLEEP) { ! 542: stq->flag &= ~WSLEEP; ! 543: wakeup((caddr_t)q); ! 544: } ! 545: if (stq->wsel) { ! 546: selwakeup(stq->wsel, stq->flag&WSEL); ! 547: stq->flag &= ~WSEL; ! 548: stq->wsel = NULL; ! 549: } ! 550: } ! 551: ! 552: /* ! 553: * ioctl for streams ! 554: */ ! 555: stioctl(ip, cmd, arg) ! 556: struct inode *ip; ! 557: caddr_t arg; ! 558: { ! 559: register struct stdata *stq; ! 560: register struct block *bp; ! 561: register struct queue *q; ! 562: register s; ! 563: int fmt, nld, ioctime; ! 564: struct insld ld; ! 565: extern nstreamtab; ! 566: ! 567: if ((stq = stenter(ip)) == NULL) ! 568: return; ! 569: switch(cmd) { ! 570: ! 571: case FIONREAD: ! 572: nld = 0; ! 573: bp = RD(stq->wrq)->first; ! 574: if (bp && bp->type==M_DATA) ! 575: nld = bp->wptr - bp->rptr; ! 576: if (copyout((caddr_t)&nld, arg, sizeof(nld))) ! 577: u.u_error = EFAULT; ! 578: goto out; ! 579: ! 580: case TIOCGPGRP: ! 581: if (copyout ((caddr_t) &stq->pgrp, arg, sizeof (stq->pgrp))) ! 582: u.u_error = EFAULT; ! 583: goto out; ! 584: ! 585: case TIOCSPGRP: ! 586: if (arg==0) { ! 587: stq->pgrp = u.u_procp->p_pgrp = u.u_procp->p_pid; ! 588: u.u_ttydev = ip->i_dev; ! 589: u.u_ttyino = ip->i_number; ! 590: } else if (copyin(arg, (caddr_t)&stq->pgrp, sizeof(stq->pgrp))) ! 591: u.u_error = EFAULT; ! 592: goto out; ! 593: ! 594: case TIOCEXCL: ! 595: stq->flag |= EXCL; ! 596: goto out; ! 597: ! 598: case TIOCNXCL: ! 599: stq->flag &= ~EXCL; ! 600: goto out; ! 601: ! 602: case TIOCFLUSH: ! 603: if (stq->flag & HUNGUP) { ! 604: u.u_error = ENXIO; ! 605: goto out; ! 606: } ! 607: flushq(RD(stq->wrq), 0); ! 608: putctl(stq->wrq->next, M_FLUSH); ! 609: goto out; ! 610: ! 611: case TIOCSBRK: ! 612: if (stq->flag & HUNGUP) { ! 613: u.u_error = ENXIO; ! 614: goto out; ! 615: } ! 616: putctl(stq->wrq->next, M_BREAK); ! 617: goto out; ! 618: ! 619: case FIOSNDFD: ! 620: if (stq->flag & HUNGUP) { ! 621: u.u_error = ENXIO; ! 622: goto out; ! 623: } ! 624: usndfile(stq, arg); ! 625: goto out; ! 626: ! 627: case FIORCVFD: ! 628: urcvfile(stq, arg); ! 629: goto out; ! 630: ! 631: case FIOPUSHLD: /* add a line discipline */ ! 632: case FIOINSLD: ! 633: if (stq->flag & HUNGUP) { ! 634: u.u_error = ENXIO; ! 635: goto out; ! 636: } ! 637: if (copyin(arg, (caddr_t)&ld, sizeof(ld))) { ! 638: u.u_error = EFAULT; ! 639: goto out; ! 640: } ! 641: if(ld.ld<0 || ld.ld>=nstreamtab || streamtab[ld.ld]==NULL){ ! 642: u.u_error = EINVAL; ! 643: goto out; ! 644: } ! 645: if (cmd==FIOPUSHLD) ! 646: ld.level = 0; ! 647: q = stq->wrq; ! 648: while (ld.level > 0) { ! 649: if (q->next == NULL) { ! 650: u.u_error = EINVAL; ! 651: goto out; ! 652: } ! 653: q = q->next; ! 654: ld.level--; ! 655: } ! 656: s = spl6(); ! 657: if (qattach(streamtab[ld.ld], RD(q), ip->i_un.i_rdev)) { ! 658: long nip = ! 659: (*q->next->qinfo->qopen)(RD(q->next), ip->i_un.i_rdev); ! 660: if (nip==0) { ! 661: qdetach(RD(q->next), 0); ! 662: u.u_error = ENXIO; ! 663: } else if (nip!=1) ! 664: panic("pushld qopen returns inode"); ! 665: splx(s); ! 666: goto out; ! 667: } ! 668: splx(s); ! 669: u.u_error = ENOMEM; ! 670: goto out; ! 671: ! 672: case FIOPOPLD: ! 673: if (stq->flag & HUNGUP) { ! 674: u.u_error = ENXIO; ! 675: goto out; ! 676: } ! 677: nld = 0; ! 678: if (arg) { ! 679: if (copyin(arg, (caddr_t)&nld, sizeof(nld))) { ! 680: u.u_error = EFAULT; ! 681: goto out; ! 682: } ! 683: } ! 684: q = stq->wrq; ! 685: while (nld > 0) { ! 686: if (q == NULL || q->next==NULL ! 687: || q->next->flag&QREADR) { ! 688: u.u_error = EINVAL; ! 689: goto out; ! 690: } ! 691: q = q->next; ! 692: nld--; ! 693: } ! 694: if (q->next->next && (q->next->flag&QREADR) == 0) { /* LD exists? */ ! 695: qdetach(RD(q->next), 1); ! 696: goto out; ! 697: } ! 698: u.u_error = EINVAL; ! 699: goto out; ! 700: ! 701: case FIOLOOKLD: ! 702: nld = 0; ! 703: if (arg) { ! 704: if (copyin(arg, (caddr_t)&nld, sizeof(nld))) { ! 705: u.u_error = EFAULT; ! 706: goto out; ! 707: } ! 708: } ! 709: q = stq->wrq; ! 710: for (;;) { ! 711: if (q == NULL || q->next==NULL || q->next->next == NULL ! 712: || q->next->flag&QREADR) { ! 713: u.u_error = EINVAL; ! 714: goto out; ! 715: } ! 716: if (--nld < 0) ! 717: break; ! 718: q = q->next; ! 719: } ! 720: for (fmt=0; fmt<nstreamtab; fmt++) ! 721: if(streamtab[fmt] && streamtab[fmt]->wrinit==q->next->qinfo) ! 722: break; ! 723: if (fmt >= nstreamtab) { ! 724: u.u_error = ENXIO; ! 725: goto out; ! 726: } ! 727: if (arg) { ! 728: if (copyout((caddr_t)&fmt, arg, sizeof(arg))) { ! 729: u.u_error = EINVAL; ! 730: goto out; ! 731: } ! 732: } ! 733: u.u_r.r_val1 = fmt; ! 734: goto out; ! 735: ! 736: } ! 737: if (stq->flag & HUNGUP) { ! 738: u.u_error = ENXIO; ! 739: goto out; ! 740: } ! 741: if ((bp = allocb(STIOCHDR+(arg?STIOCSIZE:0))) == NULL) { ! 742: u.u_error = ENOSPC; ! 743: goto out; ! 744: } ! 745: ((struct stioctl *)bp->wptr)->com[0] = cmd; ! 746: ((struct stioctl *)bp->wptr)->com[1] = cmd>>8; ! 747: ((struct stioctl *)bp->wptr)->com[2] = cmd>>16; ! 748: ((struct stioctl *)bp->wptr)->com[3] = cmd>>24; ! 749: bp->wptr += STIOCHDR; ! 750: if (arg) { ! 751: if (copyin(arg, (caddr_t)stiodata(bp), STIOCSIZE)) { ! 752: u.u_error = EFAULT; ! 753: freeb(bp); ! 754: goto out; ! 755: } ! 756: bp->wptr += STIOCSIZE; ! 757: } ! 758: bp->type = M_IOCTL; ! 759: s = spl6(); ! 760: while (stq->flag & IOCWAIT) { ! 761: if (tsleep((caddr_t)stq,STIPRI,0)!=TS_OK || stq->flag&HUNGUP) { ! 762: splx(s); ! 763: u.u_error = EIO; ! 764: freeb(bp); ! 765: goto out; ! 766: } ! 767: } ! 768: stq->flag |= IOCWAIT; ! 769: splx(s); ! 770: (*stq->wrq->next->qinfo->putp)(stq->wrq->next, bp); ! 771: /* wait for acknowledgment */ ! 772: s = spl6(); ! 773: ioctime = 15; ! 774: while ((bp = stq->iocblk) == NULL || bp->type == M_IOCWAIT) { ! 775: if (bp) ! 776: ioctime = 0; ! 777: if (tsleep((caddr_t)stq, STIPRI, ioctime) != TS_OK ! 778: || stq->flag & HUNGUP) { ! 779: if (stq->iocblk) ! 780: freeb(stq->iocblk); ! 781: stq->iocblk = NULL; ! 782: u.u_error = EIO; ! 783: stq->flag &= ~IOCWAIT; ! 784: splx(s); ! 785: goto out; ! 786: } ! 787: } ! 788: stq->iocblk = NULL; ! 789: stq->flag &= ~IOCWAIT; ! 790: splx(s); ! 791: switch (bp->type) { ! 792: case M_IOCACK: ! 793: if (bp->wptr > bp->rptr) { ! 794: bp->rptr = (u_char *)((struct stioctl *)(bp->rptr))->data; ! 795: if (copyout((caddr_t)bp->rptr, arg, bp->wptr-bp->rptr)) ! 796: u.u_error = EFAULT; ! 797: } ! 798: freeb(bp); ! 799: break; ! 800: ! 801: case M_IOCNAK: ! 802: if (bp->rptr < bp->wptr) ! 803: u.u_error = *bp->rptr; ! 804: freeb(bp); ! 805: if (u.u_error==0) ! 806: u.u_error = ENOTTY; ! 807: break; ! 808: ! 809: default: ! 810: printf("strange stuff on ioctl ack cell %x\n", stq); ! 811: break; ! 812: } ! 813: wakeup((caddr_t)stq); ! 814: out: ! 815: stexit(ip); ! 816: } ! 817: ! 818: /* ! 819: * attach a stream device or line discipline ! 820: * qp is a read queue; the new queue goes in so its next ! 821: * read ptr is the argument, and the write queue corresponding ! 822: * to the argument points to this queue. ! 823: */ ! 824: qattach(qinfo, qp, dev) ! 825: register struct streamtab *qinfo; ! 826: register struct queue *qp; ! 827: dev_t dev; ! 828: { ! 829: register struct queue *nq; ! 830: register s; ! 831: extern putq(); ! 832: ! 833: if ((nq = allocq()) == NULL) { ! 834: printf("allocq NULL\n"); ! 835: return(0); ! 836: } ! 837: s = spl6(); ! 838: nq->next = qp; ! 839: WR(nq)->next = WR(qp)->next; ! 840: if (WR(qp)->next) ! 841: OTHERQ(WR(qp)->next)->next = nq; ! 842: WR(qp)->next = WR(nq); ! 843: nq->qinfo = qinfo->rdinit; ! 844: WR(nq)->qinfo = qinfo->wrinit; ! 845: nq->flag |= QREADR|QWANTR; ! 846: WR(nq)->flag |= QWANTR; ! 847: nq->ptr = NULL; ! 848: WR(nq)->ptr = NULL; ! 849: splx(s); ! 850: return(1); ! 851: } ! 852: ! 853: /* ! 854: * Detach a stream device or line discipline. ! 855: * Call its close routine, then evict it. ! 856: * The close routine is required to return. ! 857: * The flag (if 1) indicates that the close routine ! 858: * should be called (real shutdown) otherwise this ! 859: * is merely a failed open. ! 860: */ ! 861: qdetach(qp, flag) ! 862: register struct queue *qp; ! 863: { ! 864: register s = spl6(); ! 865: register i; ! 866: ! 867: if (flag) { ! 868: queuerun(); ! 869: (*qp->qinfo->qclose)(qp); ! 870: for (i=0; (qp->flag|WR(qp)->flag)&QENAB; i++) { ! 871: queuerun(); ! 872: if (i>10) ! 873: panic("queue won't give up"); ! 874: } ! 875: flushq(qp, 1); ! 876: flushq(WR(qp), 1); ! 877: } ! 878: if (WR(qp)->next) ! 879: backq(qp)->next = qp->next; ! 880: if (qp->next) ! 881: backq(WR(qp))->next = WR(qp)->next; ! 882: qp->flag = 0; ! 883: WR(qp)->flag = 0; ! 884: splx(s); ! 885: } ! 886: ! 887: /* ! 888: * Count entries/exits to the routines that process streams. ! 889: * If a stream receives a HANGUP, it should be shut down ! 890: * forcibly, and this makes sure that it does not happen while ! 891: * pointers are still floating about. ! 892: */ ! 893: struct stdata * ! 894: stenter(ip) ! 895: register struct inode *ip; ! 896: { ! 897: register struct stdata *stp; ! 898: register s = spl6(); ! 899: ! 900: if ((stp = ip->i_sptr) == NULL) { ! 901: u.u_error = ENXIO; ! 902: splx(s); ! 903: return(NULL); ! 904: } ! 905: stp->count++; ! 906: splx(s); ! 907: return(stp); ! 908: } ! 909: ! 910: stexit(ip) ! 911: register struct inode *ip; ! 912: { ! 913: register struct stdata *stp = ip->i_sptr; ! 914: ! 915: if(stp == 0) { ! 916: printf("null stp in stexit\n"); ! 917: return; ! 918: } /* can't happen, of course */ ! 919: if (--stp->count==0 && stp->flag&HUNGUP && RD(stp->wrq)->count==0) ! 920: stclose(ip, 1); ! 921: } ! 922: ! 923: /* ! 924: * create a message transferring a file to process on the other end of a stream ! 925: */ ! 926: usndfile(stq, arg) ! 927: register struct stdata *stq; ! 928: caddr_t arg; ! 929: { ! 930: int f; ! 931: register struct file *fp; ! 932: ! 933: if (copyin(arg, (caddr_t)&f, sizeof(f))) { ! 934: u.u_error = EFAULT; ! 935: return; ! 936: } ! 937: if ((fp = getf(f)) == NULL) { ! 938: u.u_error = EBADF; ! 939: return; ! 940: } ! 941: sndfile(stq->wrq, fp); ! 942: } ! 943: ! 944: sndfile(q, fp) ! 945: register struct queue *q; ! 946: register struct file *fp; ! 947: { ! 948: register struct block *bp; ! 949: ! 950: for (;;) { ! 951: if (q==NULL) { ! 952: u.u_error = ENXIO; ! 953: return(0); ! 954: } ! 955: if (q->qinfo == &strdata) ! 956: break; ! 957: /* follow pt's here */ ! 958: q = q->next; ! 959: } ! 960: if (q->flag&QFULL) { ! 961: u.u_error = ENOMEM; ! 962: return(0); ! 963: } ! 964: if ((bp = allocb(sizeof(struct kpassfd))) == NULL) { ! 965: u.u_error = ENOMEM; ! 966: return(0); ! 967: } ! 968: bp->type = M_PASS; ! 969: ((struct kpassfd *)bp->rptr)->uid = u.u_uid; ! 970: ((struct kpassfd *)bp->rptr)->gid = u.u_gid; ! 971: ((struct kpassfd *)bp->rptr)->nice = u.u_procp->p_nice-NZERO; ! 972: bcopy(u.u_logname,((struct kpassfd *)bp->rptr)->logname, ! 973: sizeof(u.u_logname)); ! 974: ((struct kpassfd *)bp->rptr)->f.fp = fp; ! 975: bp->wptr += sizeof(struct kpassfd); ! 976: fp->f_count++; ! 977: strput(q, bp); ! 978: return(1); ! 979: } ! 980: ! 981: urcvfile(stq, arg) ! 982: register struct stdata *stq; ! 983: caddr_t arg; ! 984: { ! 985: register struct block *bp; ! 986: register i; ! 987: register struct file *fp; ! 988: register struct kpassfd *kp; ! 989: struct passfd pfd; ! 990: ! 991: while ((bp = getq(RD(stq->wrq))) == NULL) { ! 992: if (stq->flag&HUNGUP) { ! 993: u.u_error = ENXIO; ! 994: return; ! 995: } ! 996: stq->flag |= RSLEEP; ! 997: if (tsleep((caddr_t)RD(stq->wrq), STIPRI, 0)==TS_SIG) { ! 998: stexit(stq->inode); ! 999: longjmp(u.u_qsav); ! 1000: } ! 1001: } ! 1002: if (bp->type != M_PASS) { ! 1003: putbq(RD(stq->wrq), bp); ! 1004: u.u_error = EIO; ! 1005: return; ! 1006: } ! 1007: kp = (struct kpassfd *)bp->rptr; ! 1008: fp = kp->f.fp; ! 1009: i = ufalloc(); ! 1010: if (i < 0) { ! 1011: closef(fp); ! 1012: freeb(bp); ! 1013: return; ! 1014: } ! 1015: u.u_ofile[i] = fp; ! 1016: pfd.fd = i; ! 1017: pfd.uid = kp->uid; ! 1018: pfd.gid = kp->gid; ! 1019: bcopy(kp->logname, pfd.logname, sizeof(kp->logname)); ! 1020: if (copyout((caddr_t)&pfd, arg, sizeof(struct passfd))) ! 1021: u.u_error = EFAULT; ! 1022: freeb(bp); ! 1023: } ! 1024: ! 1025: stselect(stp, rw, anyyet) ! 1026: register struct stdata *stp; ! 1027: { ! 1028: register ret = 0; ! 1029: register s = spl6(); ! 1030: extern int selwait; ! 1031: ! 1032: if (rw==FWRITE) { ! 1033: if ((stp->wrq->next->flag&QFULL) == 0) ! 1034: ret = 1; ! 1035: else if (!anyyet) { ! 1036: if (stp->wsel && stp->wsel->p_wchan==(caddr_t)&selwait) ! 1037: stp->flag |= WSEL; ! 1038: else ! 1039: stp->wsel = u.u_procp; ! 1040: } ! 1041: } else { ! 1042: if (streadable(RD(stp->wrq)) || stp->flag&HUNGUP) ! 1043: ret = 1; ! 1044: else if (!anyyet) { ! 1045: if (stp->rsel && stp->rsel->p_wchan==(caddr_t)&selwait) ! 1046: stp->flag |= RSEL; ! 1047: else ! 1048: stp->rsel = u.u_procp; ! 1049: } ! 1050: } ! 1051: splx(s); ! 1052: return(ret); ! 1053: } ! 1054: ! 1055: /* ! 1056: * poison the flags in the file table leading to this stream ! 1057: */ ! 1058: forceclose(sptr, whichflags) ! 1059: register struct stdata *sptr; ! 1060: { ! 1061: register struct file *fp; ! 1062: ! 1063: for (fp = &file[0]; fp < fileNFILE; fp++) { ! 1064: if (fp->f_count==0) ! 1065: continue; ! 1066: if (fp->f_inode==NULL || fp->f_inode->i_sptr != sptr) ! 1067: continue; ! 1068: fp->f_flag &= ~whichflags; ! 1069: fp->f_flag |= FHUNGUP; ! 1070: } ! 1071: } ! 1072: ! 1073: /* ! 1074: * check if a queue is likely to be readable ! 1075: */ ! 1076: streadable(q) ! 1077: register struct queue *q; ! 1078: { ! 1079: register struct block *bp; ! 1080: ! 1081: if (q->first == 0) ! 1082: return(0); ! 1083: if ((backq(q)->flag&QDELIM) == 0 || q->count >= q->qinfo->lolimit) ! 1084: return(1); ! 1085: for (bp = q->first; bp; bp = bp->next) ! 1086: if (bp->class&S_DELIM || bp->type==M_PASS) ! 1087: return(1); ! 1088: return(0); ! 1089: } ! 1090: ! 1091: ! 1092: /* ! 1093: * Black hole to seal off closed pipes, and serve as a stub device. ! 1094: */ ! 1095: long ! 1096: nilopen(q, dev) ! 1097: struct queue *q; ! 1098: dev_t dev; ! 1099: { ! 1100: return(1); ! 1101: } ! 1102: ! 1103: nilput(q, bp) ! 1104: struct queue *q; ! 1105: struct block *bp; ! 1106: { ! 1107: if (bp->type == M_IOCTL) { ! 1108: bp->type = M_IOCNAK; ! 1109: bp->wptr = bp->rptr; ! 1110: qreply(q, bp); ! 1111: return; ! 1112: } ! 1113: freeb(bp); ! 1114: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.