![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tty.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / d / 286_KERNEL / USRSRC / io|
Return to tty.c CVS log | Up to [MW Coherent from dump] / coherent / d / 286_KERNEL / USRSRC / io |
1.1 ! root 1: /* ! 2: * File: $USRSRC/ttydrv/tty.c ! 3: * ! 4: * Purpose: COHERENT line discipline module. ! 5: * This is the common part of typewriter service. It handles all device- ! 6: * independent aspects of a typewriter, including tandem flow control, ! 7: * erase and kill, stop and start, and common ioctl functions. ! 8: * ! 9: * $Log: tty.c,v $ ! 10: * Revision 1.15 92/01/13 08:58:40 bin ! 11: * update by hal for 321 kernel (looks like just additions of debug stuff) ! 12: * ! 13: * Revision 1.15 92/01/13 08:36:53 hal ! 14: * Add a few DEBUG lines. ! 15: * ! 16: * Revision 1.14 92/01/09 09:42:31 hal ! 17: * Add debug conditionals for sleeps. ! 18: * Fix process group logic, including TIOCSETG hack. ! 19: * ! 20: * Revision 1.13 91/12/10 17:01:56 hal ! 21: * Don't wait for drain on TIOCFLUSH. ! 22: * ! 23: * Revision 1.12 91/11/14 14:28:51 hal ! 24: * Move flow control out of tty.c. ! 25: * Make ttin() run at hi priority. ! 26: * ! 27: * Revision 1.11 91/09/16 18:11:08 hal ! 28: * Update t_flags in ttstart() at high priority. ! 29: * Document that ttstash() is local. ! 30: * ! 31: * Revision 1.10 91/09/16 15:58:26 hal ! 32: * Mask interrrupts when modifying tp->t_flags as some IRQ handlers change this. ! 33: * ! 34: * Revision 1.9 91/09/16 10:27:47 hal ! 35: * Explain T_ISTOP/T_TSTOP/T_STOP. ! 36: * Add check for TANDEM before sending t_startc. ! 37: * ! 38: * Revision 1.8 91/09/13 18:01:39 piggy ! 39: * Only do XON/XOFF flow control if TANDEM is set. ! 40: * ! 41: * Revision 1.7 91/09/13 17:58:00 hal ! 42: * Drop 3rd arg (was writing PSW directly from it!) for ttread/ttwrite. ! 43: * General face lift. ! 44: * ! 45: * Bug: no support for 8-bit characters. ! 46: * Fix: don't strip keyboard input. 01/22/91. (norm) ! 47: * ! 48: * Bug: Switching modes between cooked and CBREAK/RAW left buffered input ! 49: * in the input buffer until returning to cooked mode. 05/13/91 norm ! 50: * ! 51: * Bug: setting speed to default in ttopen() was conditioned to ! 52: * use hard constants. 90/08/28. hws ! 53: * ! 54: * Revision 1.5 91/06/06 18:28:53 norm ! 55: * Restore 8-bit fix. ! 56: * ! 57: * Revision 1.2 89/07/17 11:51:20 src ! 58: * Bug: Terminal could lock up when setting it to RAWIN mode, if ! 59: * output was suspended due to X-OFF, and output data was present. ! 60: * Fix: Setting terminal to RAWIN mode now clears X-OFF, starts output ! 61: * BEFORE waiting for output to drain. Received signals now cause ! 62: * operation to complete without waiting for drain. (ABC) ! 63: * ! 64: * Revision 1.1 88/03/24 16:18:12 src ! 65: * Initial revision ! 66: * ! 67: * 86/12/12 Allan Cornish /usr/src/sys/drv/tty.c ! 68: * Added 3rd argument to ttpoll() to support non-blocking polls. ! 69: * ! 70: * 86/11/19 Allan Cornish /usr/src/sys/drv/tty.c ! 71: * Made ttread() and ttwrite() recognize the IONDLY flag in iop->io_flag. ! 72: * wakeup() and pollwake() now have delayed invocation by defer(). ! 73: * Added poll [System V.3] capability. ! 74: * ! 75: * 85/06/28 Allan Cornish ! 76: * made ttioctl() clear T_STOP flag if ISRIN. ! 77: * ! 78: * 85/03/04 Allan Cornish ! 79: * made ttread() interruptible. ! 80: * ! 81: * 85/03/01 Allan Cornish ! 82: * made ttclose() interruptible. ! 83: */ ! 84: ! 85: /* ! 86: * About STOP flag bits: ! 87: * T_ISTOP is set when the tty module's input queue is in danger of ! 88: * overflow. It is up to the device driver to check this flag ! 89: * and do something about it. If ttin() is called with a ! 90: * character from the device while T_ISTOP is set, the character ! 91: * is discarded. T_ISTOP is cleared when the input queue is ! 92: * sufficiently empty. The device driver can monitor this bit for ! 93: * hardware flow control. ! 94: * T_TSTOP is the "Tandem" flow control flag for input. If TANDEM is set ! 95: * and the input queue is in danger of overflow, t_stopc is sent ! 96: * and T_TSTOP is set. When the input queue is empty enough, ! 97: * t_startc is sent and T_TSTOP is cleared. ! 98: * T_STOP is the flow control bit for output. No output will be ! 99: * written to the output queue while this bit is true. ! 100: * Except for initialization of flags in the TTY struct, by ! 101: * ttopen(), this bit is not written by tty.c. ! 102: * 91/09/15 - hal ! 103: */ ! 104: ! 105: /* ! 106: * Includes. ! 107: */ ! 108: #include <sys/clist.h> ! 109: #include <sys/coherent.h> ! 110: #include <sys/con.h> ! 111: #include <sys/deftty.h> ! 112: #include <sys/io.h> ! 113: #include <sys/proc.h> ! 114: #include <sys/sched.h> ! 115: #include <sys/stat.h> ! 116: #include <sys/tty.h> ! 117: #include <sys/uproc.h> ! 118: #include <errno.h> ! 119: ! 120: /* ! 121: * Definitions. ! 122: * Constants. ! 123: * Macros with argument lists. ! 124: * Typedefs. ! 125: * Enums. ! 126: */ ! 127: ! 128: /* NEAR_OR_FAR_CALL is for invoking t_param and t_start */ ! 129: #define NEAR_OR_FAR_CALL(tp_fn) {\ ! 130: if (tp->t_cs_sel) \ ! 131: ld_call(tp->t_cs_sel, tp->tp_fn, tp); \ ! 132: else \ ! 133: (*tp->tp_fn)(tp); } ! 134: ! 135: /* ! 136: * Functions. ! 137: * Import Functions. ! 138: * Export Functions. ! 139: * Local Functions. ! 140: */ ! 141: void ttclose(); ! 142: void ttflush(); ! 143: void tthup(); ! 144: void ttin(); ! 145: void ttioctl(); ! 146: void ttopen(); ! 147: int ttout(); ! 148: int ttpoll(); ! 149: void ttread(); ! 150: void ttsetgrp(); ! 151: void ttsignal(); ! 152: void ttstart(); ! 153: void ttwrite(); ! 154: ! 155: static void ttstash(); ! 156: ! 157: /* ! 158: * Global Data. ! 159: * Import Variables. ! 160: * Export Variables. ! 161: * Local Variables. ! 162: */ ! 163: extern int wakeup(); ! 164: extern void pollwake(); ! 165: ! 166: /* ! 167: * ttopen() ! 168: * ! 169: * Called by driver on first open. ! 170: * Set up defaults. ! 171: */ ! 172: void ttopen(tp) ! 173: register TTY *tp; ! 174: { ! 175: tp->t_escape = 0; ! 176: tp->t_sgttyb.sg_ispeed = tp->t_dispeed; ! 177: tp->t_sgttyb.sg_ospeed = tp->t_dospeed; ! 178: tp->t_sgttyb.sg_erase = DEF_SG_ERASE; ! 179: tp->t_sgttyb.sg_kill = DEF_SG_KILL; ! 180: tp->t_sgttyb.sg_flags = DEF_SG_FLAGS; ! 181: tp->t_tchars.t_intrc = DEF_T_INTRC; ! 182: tp->t_tchars.t_quitc = DEF_T_QUITC; ! 183: tp->t_tchars.t_startc = DEF_T_STARTC; ! 184: tp->t_tchars.t_stopc = DEF_T_STOPC; ! 185: tp->t_tchars.t_eofc = DEF_T_EOFC; ! 186: tp->t_tchars.t_brkc = DEF_T_BRKC; ! 187: if (tp->t_param != NULL) { ! 188: NEAR_OR_FAR_CALL(t_param) ! 189: } ! 190: } ! 191: ! 192: /* ! 193: * ttsetgrp() ! 194: * ! 195: * If process is a group leader without a control terminal, ! 196: * make its control terminal this device. ! 197: * ! 198: * If process is a group leader and this device does not have ! 199: * a process group, give it the group of the current process. ! 200: */ ! 201: void ttsetgrp(tp, ctdev) ! 202: register TTY *tp; ! 203: dev_t ctdev; ! 204: { ! 205: register PROC *pp; ! 206: ! 207: pp = SELF; ! 208: #if DEBUG ! 209: printf("ttsetgrp dev=%x pid=%d pg=%d ", ctdev, pp->p_pid, pp->p_group); ! 210: printf("old_ct=%x old_tg=%d ", pp->p_ttdev, tp->t_group); ! 211: #endif ! 212: if (pp->p_group == pp->p_pid) { ! 213: if (pp->p_ttdev == NODEV) ! 214: pp->p_ttdev = ctdev; ! 215: if (tp->t_group == 0) ! 216: tp->t_group = pp->p_pid; ! 217: } ! 218: #if DEBUG ! 219: printf("new_ct=%x new_tg=%d\n", pp->p_ttdev, tp->t_group); ! 220: #endif ! 221: } ! 222: ! 223: /* ! 224: * ttyclose() ! 225: * ! 226: * Called by driver on the last close. ! 227: * Wait for all pending output to go out. ! 228: * Kill input. ! 229: */ ! 230: void ttclose(tp) ! 231: register TTY *tp; ! 232: { ! 233: register int s; ! 234: ! 235: while (tp->t_oq.cq_cc != 0) { ! 236: s = sphi(); ! 237: if (tp->t_oq.cq_cc != 0) { ! 238: tp->t_flags |= T_DRAIN; ! 239: #if DEBUG ! 240: printf("T1 "); ! 241: #endif ! 242: sleep((char *)&tp->t_oq, CVTTOUT, IVTTOUT, SVTTOUT); ! 243: #if DEBUG ! 244: printf("z "); ! 245: #endif ! 246: } ! 247: spl(s); ! 248: if (SELF->p_ssig && nondsig()) ! 249: break; ! 250: } ! 251: ttflush(tp); ! 252: tp->t_flags = tp->t_group = 0; ! 253: } ! 254: ! 255: /* ! 256: * ttread() ! 257: * ! 258: * The read routine for a tty device driver will call this function. ! 259: * ! 260: * Move data from tp->t_iq to io segment iop. ! 261: * Number of characters to copy is in iop->ioc. ! 262: * ! 263: * In cooked mode, copy up to the first newline or break character, or ! 264: * until the count runs out. ! 265: * In CBREAK or RAW modes, return when count runs out or when input clist ! 266: * is empty and we're returning at least one byte. ! 267: */ ! 268: void ttread(tp, iop) ! 269: register TTY *tp; ! 270: register IO *iop; ! 271: { ! 272: register c; ! 273: int o; ! 274: int sioc = iop->io_ioc; /* number of bytes to read */ ! 275: ! 276: while (iop->io_ioc) { ! 277: o = sphi(); ! 278: while ((c = getq(&tp->t_iq)) < 0) { ! 279: if ((tp->t_flags & T_CARR) == 0) { ! 280: u.u_error = EIO; /* error since no carrier */ ! 281: spl(o); ! 282: return; ! 283: } ! 284: ! 285: /* If we're in CBREAK or RAW mode, and we don't */ ! 286: /* have the special "blocking read" bit set for */ ! 287: /* these modes, and we read at least one byte */ ! 288: /* of input, return immediately, since we have */ ! 289: /* run out of characters from the clist. */ ! 290: ! 291: if (ISBBYB && ((tp->t_flags & T_BRD) == 0) ! 292: && iop->io_ioc < sioc) { ! 293: spl(o); ! 294: return; ! 295: } ! 296: ! 297: /* ! 298: * Non-blocking reads. ! 299: * Tell user process to try again later. ! 300: */ ! 301: if (iop->io_flag & IONDLY) { ! 302: u.u_error = EAGAIN; ! 303: spl(o); ! 304: return; ! 305: } ! 306: ! 307: tp->t_flags |= T_INPUT; /* wait for more data */ ! 308: #if DEBUG ! 309: printf("T2 "); ! 310: #endif ! 311: sleep((char *)&tp->t_iq, CVTTIN, IVTTIN, SVTTIN); ! 312: #if DEBUG ! 313: printf("z "); ! 314: #endif ! 315: ! 316: if (SELF->p_ssig && nondsig()) { ! 317: if (iop->io_ioc == sioc) ! 318: u.u_error = EINTR; ! 319: spl(o); ! 320: return; ! 321: } ! 322: } ! 323: /* ! 324: * Flow control - can we turn on input from the driver yet? ! 325: */ ! 326: if (tp->t_iq.cq_cc <= ILOLIM) { ! 327: if ((tp->t_flags&T_ISTOP) != 0) ! 328: tp->t_flags &= ~T_ISTOP; ! 329: if (ISTAND && (tp->t_flags&T_TSTOP) != 0) { ! 330: tp->t_flags &= ~T_TSTOP; ! 331: while (putq(&tp->t_oq, startc) < 0) { ! 332: ttstart(tp); ! 333: waitq(); ! 334: } ! 335: ttstart(tp); ! 336: } ! 337: } ! 338: spl(o); ! 339: if (!ISBBYB && ISEOF) ! 340: return; ! 341: if (ioputc(c, iop) < 0) ! 342: return; ! 343: if (!ISBBYB && (c=='\n' || ISBRK)) ! 344: return; ! 345: } ! 346: } ! 347: ! 348: /* ! 349: * ttwrite() ! 350: * ! 351: * Write routine. ! 352: * Transfer stuff to the character list. ! 353: */ ! 354: void ttwrite(tp, iop) ! 355: register TTY *tp; ! 356: register IO *iop; ! 357: { ! 358: register c; ! 359: int o; ! 360: ! 361: /* ! 362: * Non-blocking writes which can fit. ! 363: * NOTE: exhaustion of clists can still cause blocking writes. ! 364: */ ! 365: if ((iop->io_flag & IONDLY) && (OHILIM >= iop->io_ioc)) { ! 366: ! 367: /* ! 368: * No room. ! 369: */ ! 370: if (tp->t_oq.cq_cc >= OHILIM-iop->io_ioc) { ! 371: u.u_error = EAGAIN; ! 372: return; ! 373: } ! 374: } ! 375: ! 376: while ((c = iogetc(iop)) >= 0) { ! 377: if ((tp->t_flags & T_CARR) == 0) { ! 378: u.u_error = EIO; /* error since no carrier */ ! 379: return; ! 380: } ! 381: o = sphi(); ! 382: while (tp->t_oq.cq_cc >= OHILIM) { ! 383: ttstart(tp); ! 384: if (tp->t_oq.cq_cc < OHILIM) ! 385: break; ! 386: tp->t_flags |= T_HILIM; ! 387: #if DEBUG ! 388: printf("T3 "); ! 389: #endif ! 390: sleep((char *)&tp->t_oq, CVTTOUT, IVTTOUT, SVTTOUT); ! 391: #if DEBUG ! 392: printf("z "); ! 393: #endif ! 394: if (SELF->p_ssig && nondsig()) { ! 395: u.u_error = EINTR; ! 396: spl(o); ! 397: return; ! 398: } ! 399: } ! 400: while (putq(&tp->t_oq, c) < 0) { ! 401: ttstart(tp); ! 402: waitq(); ! 403: } ! 404: spl(o); ! 405: } ! 406: o = sphi(); ! 407: ttstart(tp); ! 408: spl(o); ! 409: } ! 410: ! 411: /* ! 412: * ttioctl() ! 413: * ! 414: * This routine handles common typewriter ioctl functions. ! 415: * Note that flushing the stream now means drain the output ! 416: * and clear the input. ! 417: */ ! 418: void ttioctl(tp, com, vec) ! 419: register TTY *tp; ! 420: register struct sgttyb *vec; ! 421: { ! 422: register int flush = 0; ! 423: register int drain = 0; ! 424: register char *p1, *p2; ! 425: int s; ! 426: int rload = 0; ! 427: int was_bbyb = 0; ! 428: ! 429: switch (com) { ! 430: case TIOCQUERY: ! 431: kucopy(&tp->t_iq.cq_cc, vec, sizeof(int)); ! 432: break; ! 433: case TIOCGETP: ! 434: kucopy(&tp->t_sgttyb, vec, sizeof (struct sgttyb)); ! 435: break; ! 436: case TIOCSETP: ! 437: ++flush; /* flush input */ ! 438: ++drain; /* delay for output */ ! 439: ++rload; ! 440: ukcopy(vec, &tp->t_sgttyb, sizeof (struct sgttyb)); ! 441: break; ! 442: case TIOCSETN: ! 443: was_bbyb = ISBBYB; /* previous mode */ ! 444: ++rload; ! 445: ukcopy(vec, &tp->t_sgttyb, sizeof (struct sgttyb)); ! 446: if (!was_bbyb && ISBBYB && tp->t_ibx != 0) { ! 447: p1 = &tp->t_ib[0]; ! 448: p2 = &tp->t_ib[tp->t_ibx]; ! 449: while (p1 < p2) ! 450: #if NOT_8_BIT ! 451: putq(&tp->t_iq, (*p1++) & 0177); ! 452: #else ! 453: putq(&tp->t_iq, (*p1++)); ! 454: #endif ! 455: tp->t_ibx = 0; ! 456: } ! 457: break; ! 458: case TIOCGETC: ! 459: kucopy(&tp->t_tchars, vec, sizeof (struct tchars)); ! 460: break; ! 461: case TIOCSETC: ! 462: ++rload; ! 463: ++drain; ! 464: ukcopy(vec, &tp->t_tchars, sizeof (struct tchars)); ! 465: break; ! 466: case TIOCEXCL: ! 467: s = sphi(); ! 468: tp->t_flags |= T_EXCL; ! 469: spl(s); ! 470: break; ! 471: case TIOCNXCL: ! 472: s = sphi(); ! 473: tp->t_flags &= ~T_EXCL; ! 474: spl(s); ! 475: break; ! 476: case TIOCHPCL: /* set hangup on last close */ ! 477: s = sphi(); ! 478: tp->t_flags |= T_HPCL; ! 479: spl(s); ! 480: break; ! 481: case TIOCCHPCL: /* don't hangup on last close */ ! 482: if (!super()) /* only superuser may do this */ ! 483: u.u_error = EPERM; /* not su */ ! 484: else { ! 485: s = sphi(); ! 486: tp->t_flags &= ~T_HPCL; /* turn off hangup bit */ ! 487: spl(s); ! 488: } ! 489: break; ! 490: case TIOCGETTF: /* get tty flag word */ ! 491: kucopy(&tp->t_flags, (unsigned *) vec, sizeof(unsigned)); ! 492: break; ! 493: case TIOCFLUSH: ! 494: ++flush; /* flush both input and output */ ! 495: /* ++drain; Why? - hws - 91/11/22 */ ! 496: break; ! 497: case TIOCBREAD: /* blocking read for CBREAK/RAW mode */ ! 498: s = sphi(); ! 499: tp->t_flags |= T_BRD; ! 500: spl(s); ! 501: break; ! 502: case TIOCCBREAD: /* turn off CBREAK/RAW blocking read mode */ ! 503: s = sphi(); ! 504: tp->t_flags &= ~T_BRD; ! 505: spl(s); ! 506: break; ! 507: /* ! 508: * The following is a hack so that the process group for /dev/console ! 509: * contains the current login shell running on it. ! 510: * Only expect /etc/init to use this ugliness. ! 511: */ ! 512: case TIOCSETG: ! 513: if (super()) ! 514: tp->t_group = SELF->p_group; ! 515: break; ! 516: default: ! 517: u.u_error = EINVAL; ! 518: } ! 519: ! 520: /* ! 521: * Wait for output to drain, or signal to arrive. ! 522: */ ! 523: if (drain != 0) { ! 524: ! 525: /* ! 526: * Ensure output is enabled BEFORE waiting for output to drain. ! 527: */ ! 528: if (ISRIN && (tp->t_flags & T_STOP)) { ! 529: s = sphi(); ! 530: tp->t_flags &= ~T_STOP; ! 531: ttstart(tp); ! 532: spl(s); ! 533: } ! 534: ! 535: while (tp->t_oq.cq_cc != 0) { ! 536: s = sphi(); ! 537: tp->t_flags |= T_DRAIN; ! 538: spl(s); ! 539: #if DEBUG ! 540: printf("T4 "); ! 541: #endif ! 542: sleep((char *)&tp->t_oq, CVTTOUT, IVTTOUT, SVTTOUT); ! 543: #if DEBUG ! 544: printf("z "); ! 545: #endif ! 546: if (SELF->p_ssig && nondsig()) ! 547: break; ! 548: } ! 549: } ! 550: ! 551: /* ! 552: * Flush input. ! 553: */ ! 554: if (flush != 0) ! 555: ttflush(tp); ! 556: ! 557: /* ! 558: * Re-initialize hardware. ! 559: */ ! 560: if ((rload != 0) && (tp->t_param != NULL)) ! 561: NEAR_OR_FAR_CALL(t_param) ! 562: } ! 563: ! 564: /* ! 565: * ttpoll() ! 566: * ! 567: * Polling routine. ! 568: * [System V.3 Compatible] ! 569: */ ! 570: int ttpoll(tp, ev, msec) ! 571: register TTY * tp; ! 572: int ev; ! 573: int msec; ! 574: { ! 575: /* ! 576: * Priority polls not supported. ! 577: */ ! 578: ev &= ~POLLPRI; ! 579: ! 580: /* ! 581: * Input poll with no data present. ! 582: */ ! 583: if ((ev & POLLIN) && (tp->t_iq.cq_cc == 0)) { ! 584: ! 585: /* ! 586: * Blocking input poll. ! 587: */ ! 588: if (msec != 0) ! 589: pollopen(&tp->t_ipolls); ! 590: ! 591: /* ! 592: * Second look to avoid interrupt race. ! 593: */ ! 594: if (tp->t_iq.cq_cc == 0) ! 595: ev &= ~POLLIN; ! 596: } ! 597: ! 598: /* ! 599: * Output poll with no space. ! 600: */ ! 601: if ((ev & POLLOUT) && (tp->t_oq.cq_cc >= OLOLIM)) { ! 602: ! 603: /* ! 604: * Blocking output poll. ! 605: */ ! 606: if (msec != 0) ! 607: pollopen(&tp->t_opolls); ! 608: ! 609: /* ! 610: * Second look to avoid interrupt race. ! 611: */ ! 612: if (tp->t_oq.cq_cc >= OLOLIM) ! 613: ev &= ~POLLIN; ! 614: } ! 615: ! 616: if (((ev & POLLIN) == 0) && ((tp->t_flags & T_CARR) == 0)) ! 617: ev |= POLLHUP; ! 618: ! 619: return ev; ! 620: } ! 621: ! 622: /* ! 623: * ttout() ! 624: * ! 625: * Pull a character from the output queues of the typewriter. ! 626: * Doing fills, newline insert, tab expansion, etc. ! 627: * ! 628: * If the stream is empty return a -1. ! 629: * Called at high priority. ! 630: */ ! 631: int ttout(tp) ! 632: register TTY *tp; ! 633: { ! 634: register c; ! 635: ! 636: if (tp->t_nfill) { ! 637: --tp->t_nfill; ! 638: c = tp->t_fillb; ! 639: } else if ((tp->t_flags&T_INL) != 0) { ! 640: tp->t_flags &= ~T_INL; ! 641: c = '\n'; ! 642: } else { ! 643: if ((c=getq(&tp->t_oq)) < 0) ! 644: return -1; ! 645: if (!ISROUT) { ! 646: if (c=='\n' && ISCRMOD) { ! 647: tp->t_flags |= T_INL; ! 648: c = '\r'; ! 649: } else if (c=='\t' && ISXTABS) { ! 650: tp->t_nfill = ~(tp->t_hpos|~07); ! 651: tp->t_fillb = ' '; ! 652: c = ' '; ! 653: } ! 654: } ! 655: } ! 656: if (!ISROUT) { ! 657: if (c == '\b') { ! 658: if (tp->t_hpos) ! 659: --tp->t_hpos; ! 660: } else if (c == '\r') ! 661: tp->t_hpos = 0; ! 662: else if (c == '\t') ! 663: tp->t_hpos = (tp->t_hpos|07) + 1; ! 664: #if NOT_8_BIT ! 665: else if (c >= ' ' && c <= '~') ! 666: #else ! 667: else if ((c >= ' ' && c <= '~') || (c >= 0200 && c <= 0376)) ! 668: #endif ! 669: ++tp->t_hpos; ! 670: } ! 671: return c; ! 672: } ! 673: ! 674: /* ! 675: * ttin() ! 676: * ! 677: * Pass a character to the device independent typewriter routines. ! 678: * Handle erase and kill, tandem flow control, and other magic. ! 679: * Often called at high priority from the driver's interrupt routine. ! 680: */ ! 681: void ttin(tp, c) ! 682: register TTY *tp; ! 683: register c; ! 684: { ! 685: int dc, i, n; ! 686: int s; ! 687: ! 688: if (!ISRIN) { ! 689: #if NOT_8_BIT ! 690: c &= 0177; ! 691: #endif ! 692: if (ISINTR) { ! 693: ttsignal(tp, SIGINT); ! 694: goto ttin_ret; ! 695: } ! 696: if (ISQUIT) { ! 697: ttsignal(tp, SIGQUIT); ! 698: goto ttin_ret; ! 699: } ! 700: } ! 701: if ((tp->t_flags&T_ISTOP) != 0) ! 702: goto ttin_ret; ! 703: if (!ISRIN) { ! 704: if (c=='\r' && ISCRMOD) ! 705: c = '\n'; ! 706: if (tp->t_escape != 0) { ! 707: if (c == ESC) ! 708: ++tp->t_escape; ! 709: else { ! 710: if (ISERASE || ISKILL) { ! 711: c |= 0200; ! 712: --tp->t_escape; ! 713: } ! 714: while (tp->t_escape!=0 && tp->t_ibx<NCIB-1) { ! 715: tp->t_ib[tp->t_ibx++] = ESC; ! 716: --tp->t_escape; ! 717: } ! 718: ttstash(tp, c); ! 719: } ! 720: if (ISECHO) { ! 721: #if NOT_8_BIT ! 722: putq(&tp->t_oq, c&0177); ! 723: #else ! 724: putq(&tp->t_oq, c); /* no strip for 8-bit */ ! 725: #endif ! 726: ttstart(tp); ! 727: } ! 728: goto ttin_ret; ! 729: } ! 730: if (ISERASE && !ISCBRK) { ! 731: while (tp->t_escape!=0 && tp->t_ibx<NCIB-1) { ! 732: tp->t_ib[tp->t_ibx++] = ESC; ! 733: --tp->t_escape; ! 734: } ! 735: if (tp->t_ibx == 0) ! 736: goto ttin_ret; ! 737: dc = tp->t_ib[--tp->t_ibx]; ! 738: if (ISECHO) { ! 739: if (!ISCRT) ! 740: putq(&tp->t_oq, c); ! 741: /* don't erase for bell, null, or rubout */ ! 742: #if NOT_8_BIT ! 743: else if (((c = dc&0177) == '\007') ! 744: || c == 0 || c == 0177) ! 745: #else ! 746: else if (((c = dc) == '\007') ! 747: || c == 0 || c == 0177 || c == 0377) ! 748: #endif ! 749: goto ttin_ret; ! 750: else if (c != '\b' && c != '\t') { ! 751: putq(&tp->t_oq, '\b'); ! 752: putq(&tp->t_oq, ' '); ! 753: putq(&tp->t_oq, '\b'); ! 754: } else if (c == '\t') { ! 755: n = tp->t_opos + tp->t_escape; ! 756: for (i=0; i<tp->t_ibx; ++i) { ! 757: c = tp->t_ib[i]; ! 758: #if NOT_8_BIT ! 759: if ((c&0200) != 0) { ! 760: ++n; ! 761: c &= 0177; ! 762: } ! 763: #endif ! 764: if (c == '\b') ! 765: --n; ! 766: else { ! 767: if (c == '\t') ! 768: n |= 07; ! 769: ++n; ! 770: } ! 771: } ! 772: while (n++ < tp->t_hpos) ! 773: putq(&tp->t_oq, '\b'); ! 774: } ! 775: #if NOT_8_BIT ! 776: if ((dc&0200) != 0) { ! 777: if ((dc&0177) != '\b') ! 778: putq(&tp->t_oq, '\b'); ! 779: putq(&tp->t_oq, ' '); ! 780: putq(&tp->t_oq, '\b'); ! 781: } ! 782: #endif ! 783: ttstart(tp); ! 784: } ! 785: goto ttin_ret; ! 786: } ! 787: if (ISKILL && !ISCBRK) { ! 788: tp->t_ibx = 0; ! 789: tp->t_escape = 0; ! 790: if (ISECHO) { ! 791: if (c < 0x20) { ! 792: putq(&tp->t_oq, '^'); ! 793: c += 0x40; ! 794: } ! 795: putq(&tp->t_oq, c); ! 796: putq(&tp->t_oq, '\n'); ! 797: ttstart(tp); ! 798: } ! 799: goto ttin_ret; ! 800: } ! 801: } ! 802: if (ISBBYB) { ! 803: putq(&tp->t_iq, c); ! 804: if ((tp->t_flags&T_INPUT) != 0) { ! 805: s = sphi(); ! 806: tp->t_flags &= ~T_INPUT; ! 807: spl(s); ! 808: defer(wakeup, (char *) &tp->t_iq); ! 809: } ! 810: if (tp->t_ipolls.e_procp) { ! 811: tp->t_ipolls.e_procp = 0; ! 812: defer(pollwake, (char *) &tp->t_ipolls); ! 813: } ! 814: } else { ! 815: if (tp->t_ibx == 0) ! 816: tp->t_opos = tp->t_hpos; ! 817: if (c == ESC) ! 818: ++tp->t_escape; ! 819: else ! 820: ttstash(tp, c); ! 821: } ! 822: if (ISECHO) { ! 823: if (ISRIN || !ISEOF) { ! 824: putq(&tp->t_oq, c); ! 825: ttstart(tp); ! 826: } ! 827: } ! 828: if ((n=tp->t_iq.cq_cc)>=IHILIM) { ! 829: s = sphi(); ! 830: tp->t_flags |= T_ISTOP; ! 831: spl(s); ! 832: } else if (ISTAND && (tp->t_flags&T_TSTOP)==0 && n>=ITSLIM) { ! 833: s = sphi(); ! 834: tp->t_flags |= T_TSTOP; ! 835: spl(s); ! 836: putq(&tp->t_oq, stopc); ! 837: ttstart(tp); ! 838: } ! 839: ! 840: ttin_ret: ! 841: return; ! 842: } ! 843: ! 844: /* ! 845: * ttstash() ! 846: * ! 847: * Cooked mode. ! 848: * Put character in the buffer and check for end of line. ! 849: * Only a legal end of line can take the last character position. ! 850: * ! 851: * Only called from ttin(), and ttin() is called at high priority. ! 852: */ ! 853: static void ttstash(tp, c) ! 854: register TTY *tp; ! 855: { ! 856: register char *p1, *p2; ! 857: ! 858: if (c=='\n' || ISEOF || ISBRK) { ! 859: p1 = &tp->t_ib[0]; ! 860: p2 = &tp->t_ib[tp->t_ibx]; ! 861: *p2++ = c; /* Always room */ ! 862: while (p1 < p2) ! 863: #if NOT_8_BIT ! 864: putq(&tp->t_iq, (*p1++)&0177); ! 865: #else ! 866: putq(&tp->t_iq, (*p1++)); ! 867: #endif ! 868: tp->t_ibx = 0; ! 869: tp->t_escape = 0; ! 870: ! 871: if (tp->t_flags & T_INPUT) { ! 872: tp->t_flags &= ~T_INPUT; ! 873: defer(wakeup, (char *) &tp->t_iq); ! 874: } ! 875: ! 876: if (tp->t_ipolls.e_procp) { ! 877: tp->t_ipolls.e_procp = 0; ! 878: defer(pollwake, (char *) &tp->t_ipolls); ! 879: } ! 880: ! 881: } else if (tp->t_ibx < NCIB-1) ! 882: tp->t_ib[tp->t_ibx++] = c; ! 883: } ! 884: ! 885: /* ! 886: * ttstart() ! 887: * ! 888: * Start output on a tty. ! 889: * Duck out if stopped. Do wakeups. ! 890: */ ! 891: void ttstart(tp) ! 892: register TTY *tp; ! 893: { ! 894: register int n; ! 895: int s; ! 896: ! 897: n = tp->t_flags; ! 898: if (n & T_STOP) ! 899: goto stdone; ! 900: ! 901: if ((n&T_DRAIN)!=0 && tp->t_oq.cq_cc==0 ! 902: && (n&T_INL)==0 && tp->t_nfill==0) { ! 903: s = sphi(); ! 904: tp->t_flags &= ~T_DRAIN; ! 905: spl(s); ! 906: defer(wakeup, (char *) &tp->t_oq); ! 907: goto stdone; ! 908: } ! 909: ! 910: NEAR_OR_FAR_CALL(t_start) ! 911: ! 912: if (tp->t_oq.cq_cc > OLOLIM) ! 913: goto stdone; ! 914: ! 915: if (n & T_HILIM) { ! 916: s = sphi(); ! 917: tp->t_flags &= ~T_HILIM; ! 918: spl(s); ! 919: defer(wakeup, (char *) &tp->t_oq); ! 920: } ! 921: ! 922: if (tp->t_opolls.e_procp) { ! 923: tp->t_opolls.e_procp = 0; ! 924: defer(pollwake, (char *) &tp->t_opolls); ! 925: } ! 926: stdone: ! 927: return; ! 928: } ! 929: ! 930: /* ! 931: * ttflush() ! 932: * ! 933: * Flush a tty. ! 934: * Called to clear out queues. ! 935: */ ! 936: void ttflush(tp) ! 937: register TTY *tp; ! 938: { ! 939: int s; ! 940: ! 941: clrq(&tp->t_iq); ! 942: clrq(&tp->t_oq); ! 943: ! 944: if (tp->t_flags & T_INPUT) ! 945: defer(wakeup, (char *) &tp->t_iq); ! 946: ! 947: if (tp->t_flags & (T_DRAIN|T_HILIM)) ! 948: defer(wakeup, (char *) &tp->t_oq); ! 949: ! 950: if (tp->t_ipolls.e_procp != 0) { ! 951: tp->t_ipolls.e_procp = 0; ! 952: defer(pollwake, (char *) &tp->t_ipolls); ! 953: } ! 954: ! 955: if (tp->t_opolls.e_procp != 0) { ! 956: tp->t_opolls.e_procp = 0; ! 957: defer(pollwake, (char *) &tp->t_opolls); ! 958: } ! 959: ! 960: tp->t_ibx = 0; ! 961: tp->t_escape = 0; ! 962: s = sphi(); ! 963: tp->t_flags &= T_SAVE; /* reset most flag bits */ ! 964: spl(s); ! 965: } ! 966: ! 967: /* ! 968: * ttsignal() ! 969: * ! 970: * Send a signal to every process in the given process group. ! 971: */ ! 972: void ttsignal(tp, sig) ! 973: TTY *tp; ! 974: int sig; ! 975: { ! 976: register int g; ! 977: register PROC *pp; ! 978: ! 979: g = tp->t_group; ! 980: #if DEBUG ! 981: printf("ttsignal sig=%d gp=%d\n", sig, g); ! 982: #endif ! 983: if (g == 0) ! 984: goto sigdone; ! 985: ttflush(tp); ! 986: pp = &procq; ! 987: while ((pp=pp->p_nforw) != &procq) ! 988: if (pp->p_group == g) { ! 989: sendsig(sig, pp); ! 990: } ! 991: sigdone: ! 992: return; ! 993: } ! 994: ! 995: /* ! 996: * tthup() ! 997: * ! 998: * Flag hangup internally to force errors on tty read/write, flush tty, ! 999: * then send hangup signal. ! 1000: */ ! 1001: void tthup(tp) ! 1002: register TTY *tp; ! 1003: { ! 1004: ttflush(tp); ! 1005: ttsignal(tp, SIGHUP); ! 1006: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.