![[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 / PS2_KERNEL / io.386|
Return to tty.c CVS log | Up to [MW Coherent from dump] / coherent / d / PS2_KERNEL / io.386 |
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.2 92/08/04 12:54:52 bin
11: * upd for ker59
12: *
13: * Revision 1.12 92/06/06 12:39:28 hal
14: * Last before adding termio field to tty struct.
15: *
16: * Revision 1.11 92/04/30 08:58:50 hal
17: * Add asy. Remove silos from tty struct.
18: *
19: * Revision 1.10 92/04/13 10:14:01 hal
20: * Kernel #52.
21: *
22: * Revision 1.9 92/03/18 07:44:47 hal
23: * ttwrite0() needed to break pty deadlock.
24: *
25: * Revision 1.8 92/03/18 05:27:05 hal
26: * Add ttrtp(), ttinp(), ttoutp().
27: * Fix ctrl-s/ctrl-q transposition in termio routine.
28: * TIOCSET[PN] now sets RAW depending on RAWIN&RAWOUT & vice versa.
29: *
30: * Revision 1.7 92/02/20 20:25:36 hal
31: * Minor fixes
32: *
33: * Revision 1.6 92/02/20 19:43:30 piggy
34: * Add "mode" arg to ttsetgrp() for NOCTTY support.
35: *
36: * Revision 1.5 92/02/16 23:14:23 hal
37: * Initial termio support.
38: *
39: * Revision 1.4 92/02/16 18:27:33 hal
40: * Binary compatibility with Sys V sgtty
41: *
42: * Revision 1.3 92/02/15 15:43:46 root
43: * Merge with 286 kernel tty.c.
44: */
45:
46: /*
47: * About STOP flag bits:
48: * T_ISTOP is set when the tty module's input queue is in danger of
49: * overflow. It is up to the device driver to check this flag
50: * and do something about it. If ttin() is called with a
51: * character from the device while T_ISTOP is set, the character
52: * is discarded. T_ISTOP is cleared when the input queue is
53: * sufficiently empty. The device driver can monitor this bit for
54: * hardware flow control.
55: * T_TSTOP is the "Tandem" flow control flag for input. If TANDEM is set
56: * and the input queue is in danger of overflow, t_stopc is sent
57: * and T_TSTOP is set. When the input queue is empty enough,
58: * t_startc is sent and T_TSTOP is cleared.
59: * T_STOP is the flow control bit for output. No output will be
60: * written to the output queue while this bit is true.
61: * Except for initialization of flags in the TTY struct, by
62: * ttopen(), this bit is not written by tty.c.
63: * 91/09/15 - hal
64: */
65:
66: /*
67: * Includes.
68: */
69: #include <sys/clist.h>
70: #include <sys/coherent.h>
71: #include <sys/con.h>
72: #include <sys/deftty.h>
73: #include <sys/io.h>
74: #include <sys/proc.h>
75: #include <sys/sched.h>
76: #include <sys/stat.h>
77: #include <sys/tty.h>
78: #include <errno.h>
79: #ifdef _I386
80: #include <termio.h>
81: #include <sys/inode.h>
82: #else
83: #endif
84:
85: #ifdef TRACER
86: #define DUMPSGTTY(sp) dumpsgtty(sp)
87:
88: static void dumpsgtty(sp)
89: struct sgttyb * sp;
90: {
91: T_HAL(2, printf("S:%x:%x ", sp->sg_ispeed, sp->sg_flags));
92: }
93: #else
94: #define DUMPSGTTY(sp)
95: #endif
96:
97: /*
98: * Definitions.
99: * Constants.
100: * Macros with argument lists.
101: * Typedefs.
102: * Enums.
103: */
104:
105: #define SGTTY_CPY_LEN (sizeof (struct sgttyb))
106:
107: /* NEAR_OR_FAR_CALL is for invoking t_param and t_start */
108: #ifdef _I386
109: #define NEAR_OR_FAR_CALL(tp_fn) { (*tp->tp_fn)(tp); }
110: #define SET_HPCL { \
111: if (tp->t_termio.c_cflag & HUPCL) \
112: tp->t_flags |= T_HPCL; \
113: else \
114: tp->t_flags &= ~T_HPCL; }
115: #else
116: #define NEAR_OR_FAR_CALL(tp_fn) {\
117: if (tp->t_cs_sel) \
118: ld_call(tp->t_cs_sel, tp->tp_fn, tp); \
119: else \
120: (*tp->tp_fn)(tp); }
121: #define SET_HPCL
122: #endif
123:
124: /*
125: * Functions.
126: * Import Functions.
127: * Export Functions.
128: * Local Functions.
129: */
130: void ttclose();
131: void ttflush();
132: void tthup();
133: void ttin();
134: int ttinp();
135: void ttioctl();
136: void ttopen();
137: int ttout();
138: int ttoutp();
139: int ttpoll();
140: void ttread();
141: void ttread0();
142: void ttsetgrp();
143: void ttsignal();
144: void ttstart();
145: void ttwrite();
146: void ttwrite0();
147:
148: static void ttstash();
149: static void ttrtp();
150:
151: #ifdef _I386
152: static void make_termio();
153: static void make_sg();
154: #else
155: #define make_termio(a1,a2,a3)
156: #define make_sg(a1,a2,a3)
157: #endif
158:
159: /*
160: * Global Data.
161: * Import Variables.
162: * Export Variables.
163: * Local Variables.
164: */
165: extern int wakeup();
166: extern void pollwake();
167:
168: /*
169: * ttopen()
170: *
171: * Called by driver on first open.
172: * Set up defaults.
173: */
174: void
175: ttopen(tp)
176: register TTY *tp;
177: {
178: tp->t_escape = 0;
179: tp->t_sgttyb.sg_ispeed = tp->t_dispeed;
180: tp->t_sgttyb.sg_ospeed = tp->t_dospeed;
181: tp->t_sgttyb.sg_erase = DEF_SG_ERASE;
182: tp->t_sgttyb.sg_kill = DEF_SG_KILL;
183: tp->t_sgttyb.sg_flags = DEF_SG_FLAGS;
184: tp->t_tchars.t_intrc = DEF_T_INTRC;
185: tp->t_tchars.t_quitc = DEF_T_QUITC;
186: tp->t_tchars.t_startc = DEF_T_STARTC;
187: tp->t_tchars.t_stopc = DEF_T_STOPC;
188: tp->t_tchars.t_eofc = DEF_T_EOFC;
189: tp->t_tchars.t_brkc = DEF_T_BRKC;
190: #ifdef _I386
191: make_termio(&tp->t_sgttyb, &tp->t_tchars, &tp->t_termio);
192: if (tp->t_flags & T_HPCL)
193: tp->t_termio.c_cflag |= HUPCL;
194: else
195: tp->t_termio.c_cflag &= ~HUPCL;
196: tp->t_termio.c_cflag |= (CS8|CREAD);
197: #endif
198: if (tp->t_param)
199: NEAR_OR_FAR_CALL(t_param)
200: }
201:
202: /*
203: * ttsetgrp()
204: *
205: * If process is a group leader without a control terminal,
206: * make its control terminal this device.
207: *
208: * If process is a group leader and this device does not have
209: * a process group, give it the group of the current process.
210: */
211: void ttsetgrp(tp, ctdev, mode)
212: register TTY *tp;
213: dev_t ctdev;
214: int mode;
215: {
216: register PROC *pp;
217:
218: pp = SELF;
219: #ifdef _I386
220: if (pp->p_group == pp->p_pid && 0 == (mode & IPNOCTTY)) {
221: #else
222: if (pp->p_group == pp->p_pid) {
223: #endif
224: if (pp->p_ttdev == NODEV)
225: pp->p_ttdev = ctdev;
226: if (tp->t_group == 0)
227: tp->t_group = pp->p_pid;
228: }
229: }
230:
231: /*
232: * ttyclose()
233: *
234: * Called by driver on the last close.
235: * Wait for all pending output to go out.
236: * Kill input.
237: */
238: void ttclose(tp)
239: register TTY *tp;
240: {
241: register int s;
242:
243: while (tp->t_oq.cq_cc) {
244: s = sphi();
245: if (tp->t_oq.cq_cc) {
246: tp->t_flags |= T_DRAIN;
247: v_sleep((char *)&tp->t_oq, CVTTOUT, IVTTOUT, SVTTOUT,
248: "ttydrain");
249: /* The line discipline is waiting for the tty to drain. */
250: }
251: spl(s);
252: if (SELF->p_ssig && nondsig())
253: break;
254: }
255: ttflush(tp);
256: tp->t_flags = tp->t_group = 0;
257: }
258:
259: /*
260: * ttread()
261: *
262: * The read routine for a tty device driver will call this function.
263: *
264: * Move data from tp->t_iq to io segment iop.
265: * Number of characters to copy is in iop->ioc.
266: *
267: * In cooked mode, copy up to the first newline or break character, or
268: * until the count runs out.
269: * In CBREAK or RAW modes, return when count runs out or when input clist
270: * is empty and we're returning at least one byte.
271: */
272:
273: void ttread(tp, iop)
274: register TTY *tp;
275: register IO *iop;
276: {
277: ttread0(tp, iop, 0, 0, 0, 0);
278: }
279:
280: /*
281: * ttread0()
282: *
283: * Move data from user (in IO struct) to clists.
284: * Do wakeups on functions supplied when read is blocked or completed.
285: */
286: void ttread0(tp, iop, func1, arg1, func2, arg2)
287: register TTY *tp;
288: register IO *iop;
289: int (*func1)(), arg1, (*func2)(), arg2;
290: {
291: register int c;
292: int o;
293: int sioc = iop->io_ioc; /* number of bytes to read */
294:
295: while (iop->io_ioc) {
296: o = sphi();
297: while ((c = getq(&tp->t_iq)) < 0) {
298: if ((tp->t_flags & T_CARR) == 0) {
299: u.u_error = EIO; /* error since no carrier */
300: spl(o);
301: return;
302: }
303:
304: /* If we're in CBREAK or RAW mode, and we don't */
305: /* have the special "blocking read" bit set for */
306: /* these modes, and we read at least one byte */
307: /* of input, return immediately, since we have */
308: /* run out of characters from the clist. */
309:
310: if (ISBBYB && ((tp->t_flags & T_BRD) == 0)
311: && iop->io_ioc < sioc) {
312: spl(o);
313: return;
314: }
315:
316: /*
317: * Non-blocking reads.
318: * Tell user process to try again later.
319: */
320: if (iop->io_flag & IONDLY) {
321: u.u_error = EAGAIN;
322: spl(o);
323: return;
324: }
325:
326: tp->t_flags |= T_INPUT; /* wait for more data */
327: if (func1)
328: (*func1)(arg1);
329: if (func2)
330: (*func2)(arg2);
331: v_sleep((char *)&tp->t_iq, CVTTIN, IVTTIN, SVTTIN,
332: "ttywait");
333: /* The line discipline is waiting for more data. */
334:
335: if (SELF->p_ssig && nondsig()) {
336: if (iop->io_ioc == sioc)
337: u.u_error = EINTR;
338: spl(o);
339: return;
340: }
341: }
342: /*
343: * Flow control - can we turn on input from the driver yet?
344: */
345: if (tp->t_iq.cq_cc <= ILOLIM) {
346: if (tp->t_flags & T_ISTOP)
347: tp->t_flags &= ~T_ISTOP;
348: if (ISTAND && (tp->t_flags&T_TSTOP)) {
349: tp->t_flags &= ~T_TSTOP;
350: while (putq(&tp->t_oq, startc) < 0) {
351: ttstart(tp);
352: waitq();
353: }
354: ttstart(tp);
355: }
356: }
357: spl(o);
358: if (!ISBBYB && ISEOF)
359: goto read_done;
360: if (ioputc(c, iop) < 0)
361: goto read_done;
362: if (!ISBBYB && (c=='\n' || ISBRK))
363: goto read_done;
364: }
365: read_done:
366: if (func1)
367: (*func1)(arg1);
368: if (func2)
369: (*func2)(arg2);
370: }
371:
372: /*
373: * ttwrite()
374: *
375: * Write routine.
376: */
377: void ttwrite(tp, iop)
378: register TTY *tp;
379: register IO *iop;
380: {
381: ttwrite0(tp, iop, 0, 0, 0, 0);
382: }
383:
384: /*
385: * ttwrite0()
386: *
387: * Move data from user (in IO struct) to clists.
388: * Do wakeups on functions supplied when write is blocked or completed.
389: */
390: void ttwrite0(tp, iop, func1, arg1, func2, arg2)
391: register TTY *tp;
392: register IO *iop;
393: int (*func1)(), arg1, (*func2)(), arg2;
394: {
395: register int c;
396: int o;
397:
398: /*
399: * Non-blocking writes which can fit.
400: * NOTE: exhaustion of clists can still cause blocking writes.
401: */
402: if ((iop->io_flag & IONDLY) && (OHILIM >= iop->io_ioc)) {
403:
404: /*
405: * No room.
406: */
407: if (tp->t_oq.cq_cc >= OHILIM-iop->io_ioc) {
408: u.u_error = EAGAIN;
409: return;
410: }
411: }
412:
413: while ((c = iogetc(iop)) >= 0) {
414: if ((tp->t_flags & T_CARR) == 0) {
415: u.u_error = EIO; /* error since no carrier */
416: return;
417: }
418: o = sphi();
419: while (tp->t_oq.cq_cc >= OHILIM) {
420: ttstart(tp);
421: if (tp->t_oq.cq_cc < OHILIM)
422: break;
423: tp->t_flags |= T_HILIM;
424: if (func1)
425: (*func1)(arg1);
426: if (func2)
427: (*func2)(arg2);
428: v_sleep((char *)&tp->t_oq, CVTTOUT, IVTTOUT, SVTTOUT,
429: "ttyoq");
430: /*
431: * The line discipline is waiting for an output
432: * queue to drain.
433: */
434: if (SELF->p_ssig && nondsig()) {
435: u.u_error = EINTR;
436: spl(o);
437: return;
438: }
439: }
440: while (putq(&tp->t_oq, c) < 0) {
441: ttstart(tp);
442: waitq();
443: }
444: spl(o);
445: }
446: o = sphi();
447: ttstart(tp);
448: spl(o);
449: if (func1)
450: (*func1)(arg1);
451: if (func2)
452: (*func2)(arg2);
453: }
454:
455: /*
456: * ttioctl()
457: *
458: * This routine handles common typewriter ioctl functions.
459: * Note that flushing the stream now means drain the output
460: * and clear the input.
461: */
462: void ttioctl(tp, com, vec)
463: register TTY *tp;
464: int com;
465: register struct sgttyb *vec;
466: {
467: register int flush = 0;
468: register int drain = 0;
469: int s;
470: int rload = 0;
471: int was_bbyb;
472:
473: /*
474: * Keep sgttyb, t_chars, AND termio structs for each tty device.
475: *
476: * TCSET* writes a new termio and converts so as to update
477: * sgttyb and t_chars as well.
478: *
479: * TIOCSET[NP] writes new sgttyb and converts so as to update termio.
480: *
481: * TIOCSETC writes new t_chars and converts so as to update termio.
482: */
483: switch (com) {
484: #ifdef _I386
485: case TCGETA:
486: kucopy(&tp->t_termio, vec, sizeof(struct termio));
487: break;
488: case TCSETA:
489: ukcopy(vec, &tp->t_termio, sizeof(struct termio));
490: was_bbyb = ISBBYB; /* previous mode */
491: make_sg(vec, &tp->t_sgttyb, &tp->t_tchars);
492: SET_HPCL;
493: ++rload;
494: if (!was_bbyb && ISBBYB)
495: ttrtp(tp);
496: break;
497: case TCSETAW:
498: ukcopy(vec, &tp->t_termio, sizeof(struct termio));
499: make_sg(vec, &tp->t_sgttyb, &tp->t_tchars);
500: SET_HPCL;
501: ++drain; /* delay for output */
502: ++rload;
503: break;
504: case TCSETAF:
505: ukcopy(vec, &tp->t_termio, sizeof(struct termio));
506: make_sg(vec, &tp->t_sgttyb, &tp->t_tchars);
507: SET_HPCL;
508: ++flush; /* flush input */
509: ++drain; /* delay for output */
510: ++rload;
511: break;
512: #endif
513: case TIOCQUERY:
514: kucopy(&tp->t_iq.cq_cc, vec, sizeof(int));
515: break;
516: case TIOCGETP:
517: kucopy(&tp->t_sgttyb, vec, SGTTY_CPY_LEN);
518: break;
519: case TIOCSETP:
520: DUMPSGTTY(&tp->t_sgttyb);
521: ++flush; /* flush input */
522: ++drain; /* delay for output */
523: ++rload;
524: ukcopy(vec, &tp->t_sgttyb, SGTTY_CPY_LEN);
525: make_termio(&tp->t_sgttyb, &tp->t_tchars, &tp->t_termio);
526: break;
527: case TIOCSETN:
528: DUMPSGTTY(&tp->t_sgttyb);
529: was_bbyb = ISBBYB; /* previous mode */
530: ++rload;
531: ukcopy(vec, &tp->t_sgttyb, SGTTY_CPY_LEN);
532: make_termio(&tp->t_sgttyb, &tp->t_tchars, &tp->t_termio);
533: if (!was_bbyb && ISBBYB)
534: ttrtp(tp);
535: break;
536: case TIOCGETC:
537: kucopy(&tp->t_tchars, vec, sizeof (struct tchars));
538: break;
539: case TIOCSETC:
540: ++rload;
541: ++drain;
542: ukcopy(vec, &tp->t_tchars, sizeof (struct tchars));
543: make_termio(&tp->t_sgttyb, &tp->t_tchars, &tp->t_termio);
544: break;
545: case TIOCEXCL:
546: s = sphi();
547: tp->t_flags |= T_EXCL;
548: spl(s);
549: break;
550: case TIOCNXCL:
551: s = sphi();
552: tp->t_flags &= ~T_EXCL;
553: spl(s);
554: break;
555: case TIOCHPCL: /* set hangup on last close */
556: s = sphi();
557: tp->t_flags |= T_HPCL;
558: spl(s);
559: #ifdef _I386
560: tp->t_termio.c_cflag |= HUPCL;
561: #endif
562: break;
563: case TIOCCHPCL: /* don't hangup on last close */
564: if (!super()) /* only superuser may do this */
565: u.u_error = EPERM; /* not su */
566: else {
567: s = sphi();
568: tp->t_flags &= ~T_HPCL; /* turn off hangup bit */
569: spl(s);
570: #ifdef _I386
571: tp->t_termio.c_cflag &= ~HUPCL;
572: #endif
573: }
574: break;
575: case TIOCGETTF: /* get tty flag word */
576: kucopy(&tp->t_flags, (unsigned *) vec, sizeof(unsigned));
577: break;
578: #ifdef _I386
579: case TCFLSH: /* sleazy - should look at 2nd arg but don't yet */
580: #endif
581: case TIOCFLUSH:
582: ++flush; /* flush both input and output */
583: /* ++drain; Why? - hws - 91/11/22 */
584: break;
585: case TIOCBREAD: /* blocking read for CBREAK/RAW mode */
586: s = sphi();
587: tp->t_flags |= T_BRD;
588: spl(s);
589: break;
590: case TIOCCBREAD: /* turn off CBREAK/RAW blocking read mode */
591: s = sphi();
592: tp->t_flags &= ~T_BRD;
593: spl(s);
594: break;
595: /*
596: * The following is a hack so that the process group for /dev/console
597: * contains the current login shell running on it.
598: * Only expect /etc/init to use this ugliness.
599: */
600: case TIOCSETG:
601: if (super())
602: tp->t_group = SELF->p_group;
603: break;
604: default:
605: u.u_error = EINVAL;
606: }
607:
608: /*
609: * T_STOP is set under two conditions:
610: * - a modem control device is awaiting carrier
611: * - a stopc (usually Ctrl-S) character was received.
612: *
613: * If ioctl just put device into RAWIN mode, make sure device
614: * is not still waiting for startc.
615: */
616: if (ISRIN && (tp->t_flags & T_STOP) && !(tp->t_flags & T_HOPEN)) {
617: s = sphi();
618: tp->t_flags &= ~T_STOP;
619: ttstart(tp);
620: spl(s);
621: }
622:
623: /*
624: * Wait for output to drain, or signal to arrive.
625: */
626: if (drain) {
627: while (tp->t_oq.cq_cc) {
628: s = sphi();
629: tp->t_flags |= T_DRAIN;
630: spl(s);
631: v_sleep((char *)&tp->t_oq, CVTTOUT, IVTTOUT, SVTTOUT,
632: "ttyiodrn");
633: /* A TIOC has asked for tty output to drain. */
634: if (SELF->p_ssig && nondsig())
635: break;
636: }
637: }
638:
639: /*
640: * Flush input.
641: */
642: if (flush)
643: ttflush(tp);
644:
645: /*
646: * Re-initialize hardware.
647: */
648: if (rload) {
649: if ((tp->t_sgttyb.sg_flags & RAWIN)
650: && (tp->t_sgttyb.sg_flags & RAWOUT))
651: tp->t_sgttyb.sg_flags |= RAW;
652: if (tp->t_sgttyb.sg_flags & RAW)
653: tp->t_sgttyb.sg_flags |= (RAWIN|RAWOUT);
654: if (tp->t_param)
655: NEAR_OR_FAR_CALL(t_param)
656: }
657: }
658:
659: /*
660: * ttpoll()
661: *
662: * Polling routine.
663: * [System V.3 Compatible]
664: */
665: int ttpoll(tp, ev, msec)
666: register TTY * tp;
667: int ev;
668: int msec;
669: {
670: /*
671: * Priority polls not supported.
672: */
673: ev &= ~POLLPRI;
674:
675: /*
676: * Input poll with no data present.
677: */
678: if ((ev & POLLIN) && (tp->t_iq.cq_cc == 0)) {
679:
680: /*
681: * Blocking input poll.
682: */
683: if (msec)
684: pollopen(&tp->t_ipolls);
685:
686: /*
687: * Second look to avoid interrupt race.
688: */
689: if (tp->t_iq.cq_cc == 0)
690: ev &= ~POLLIN;
691: }
692:
693: /*
694: * Output poll with no space.
695: */
696: if ((ev & POLLOUT) && (tp->t_oq.cq_cc >= OLOLIM)) {
697:
698: /*
699: * Blocking output poll.
700: */
701: if (msec)
702: pollopen(&tp->t_opolls);
703:
704: /*
705: * Second look to avoid interrupt race.
706: */
707: if (tp->t_oq.cq_cc >= OLOLIM)
708: ev &= ~POLLIN;
709: }
710:
711: if (((ev & POLLIN) == 0) && ((tp->t_flags & T_CARR) == 0))
712: ev |= POLLHUP;
713:
714: return ev;
715: }
716:
717: /*
718: * ttout()
719: *
720: * Pull a character from the output queues of the typewriter.
721: * Doing fills, newline insert, tab expansion, etc.
722: *
723: * If the stream is empty return a -1.
724: * Called at high priority.
725: */
726: int ttout(tp)
727: register TTY *tp;
728: {
729: register int c;
730:
731: if (tp->t_nfill) {
732: --tp->t_nfill;
733: c = tp->t_fillb;
734: } else if (tp->t_flags & T_INL) {
735: tp->t_flags &= ~T_INL;
736: c = '\n';
737: } else {
738: if ((c=getq(&tp->t_oq)) < 0)
739: return -1;
740: if (!ISROUT) {
741: if (c=='\n' && ISCRMOD) {
742: tp->t_flags |= T_INL;
743: c = '\r';
744: } else if (c=='\t' && ISXTABS) {
745: tp->t_nfill = ~(tp->t_hpos|~07);
746: tp->t_fillb = ' ';
747: c = ' ';
748: }
749: }
750: }
751: if (!ISROUT) {
752: if (c == '\b') {
753: if (tp->t_hpos)
754: --tp->t_hpos;
755: } else if (c == '\r')
756: tp->t_hpos = 0;
757: else if (c == '\t')
758: tp->t_hpos = (tp->t_hpos|07) + 1;
759: #if NOT_8_BIT
760: else if (c >= ' ' && c <= '~')
761: #else
762: else if ((c >= ' ' && c <= '~') || (c >= 0200 && c <= 0376))
763: #endif
764: ++tp->t_hpos;
765: }
766: return c;
767: }
768:
769: /*
770: * ttin()
771: *
772: * Pass a character to the device independent typewriter routines.
773: * Handle erase and kill, tandem flow control, and other magic.
774: * Often called at high priority from the driver's interrupt routine.
775: */
776: void
777: ttin(tp, c)
778: register TTY *tp;
779: register int c;
780: {
781: int dc, i, n;
782: int s;
783:
784: if (!ISRIN) {
785: #if NOT_8_BIT
786: c &= 0177;
787: #endif
788: if (ISINTR) {
789: ttsignal(tp, SIGINT);
790: goto ttin_ret;
791: }
792: if (ISQUIT) {
793: ttsignal(tp, SIGQUIT);
794: goto ttin_ret;
795: }
796: }
797: if (tp->t_flags & T_ISTOP)
798: goto ttin_ret;
799: if (!ISRIN) {
800: if (c=='\r' && ISCRMOD)
801: c = '\n';
802: if (tp->t_escape) {
803: if (c == ESC)
804: ++tp->t_escape;
805: else {
806: if (ISERASE || ISKILL) {
807: c |= 0200;
808: --tp->t_escape;
809: }
810: while (tp->t_escape && tp->t_ibx<NCIB-1) {
811: tp->t_ib[tp->t_ibx++] = ESC;
812: --tp->t_escape;
813: }
814: ttstash(tp, c);
815: }
816: if (ISECHO) {
817: #if NOT_8_BIT
818: putq(&tp->t_oq, c&0177);
819: #else
820: putq(&tp->t_oq, c); /* no strip for 8-bit */
821: #endif
822: ttstart(tp);
823: }
824: goto ttin_ret;
825: }
826: if (ISERASE && !ISCBRK) {
827: while (tp->t_escape && tp->t_ibx<NCIB-1) {
828: tp->t_ib[tp->t_ibx++] = ESC;
829: --tp->t_escape;
830: }
831: if (tp->t_ibx == 0)
832: goto ttin_ret;
833: dc = tp->t_ib[--tp->t_ibx];
834: if (ISECHO) {
835: if (!ISCRT)
836: putq(&tp->t_oq, c);
837: /* don't erase for bell, null, or rubout */
838: #if NOT_8_BIT
839: else if (((c = dc&0177) == '\007')
840: || c == 0 || c == 0177)
841: #else
842: else if (((c = dc) == '\007')
843: || c == 0 || c == 0177 || c == 0377)
844: #endif
845: goto ttin_ret;
846: else if (c != '\b' && c != '\t') {
847: putq(&tp->t_oq, '\b');
848: putq(&tp->t_oq, ' ');
849: putq(&tp->t_oq, '\b');
850: } else if (c == '\t') {
851: n = tp->t_opos + tp->t_escape;
852: for (i=0; i<tp->t_ibx; ++i) {
853: c = tp->t_ib[i];
854: #if NOT_8_BIT
855: if (c & 0200) {
856: ++n;
857: c &= 0177;
858: }
859: #endif
860: if (c == '\b')
861: --n;
862: else {
863: if (c == '\t')
864: n |= 07;
865: ++n;
866: }
867: }
868: while (n++ < tp->t_hpos)
869: putq(&tp->t_oq, '\b');
870: }
871: #if NOT_8_BIT
872: if (dc & 0200) {
873: if ((dc&0177) != '\b')
874: putq(&tp->t_oq, '\b');
875: putq(&tp->t_oq, ' ');
876: putq(&tp->t_oq, '\b');
877: }
878: #endif
879: ttstart(tp);
880: }
881: goto ttin_ret;
882: }
883: if (ISKILL && !ISCBRK) {
884: tp->t_ibx = 0;
885: tp->t_escape = 0;
886: if (ISECHO) {
887: if (c < 0x20) {
888: putq(&tp->t_oq, '^');
889: c += 0x40;
890: }
891: putq(&tp->t_oq, c);
892: putq(&tp->t_oq, '\n');
893: ttstart(tp);
894: }
895: goto ttin_ret;
896: }
897: }
898: if (ISBBYB) {
899: putq(&tp->t_iq, c);
900: if (tp->t_flags & T_INPUT) {
901: s = sphi();
902: tp->t_flags &= ~T_INPUT;
903: spl(s);
904: defer(wakeup, (char *) &tp->t_iq);
905: }
906: if (tp->t_ipolls.e_procp) {
907: tp->t_ipolls.e_procp = 0;
908: defer(pollwake, (char *) &tp->t_ipolls);
909: }
910: } else {
911: if (tp->t_ibx == 0)
912: tp->t_opos = tp->t_hpos;
913: if (c == ESC)
914: ++tp->t_escape;
915: else
916: ttstash(tp, c);
917: }
918: if (ISECHO) {
919: if (ISRIN || !ISEOF) {
920: putq(&tp->t_oq, c);
921: ttstart(tp);
922: }
923: }
924: if ((n=tp->t_iq.cq_cc)>=IHILIM) {
925: s = sphi();
926: tp->t_flags |= T_ISTOP;
927: spl(s);
928: } else if (ISTAND && (tp->t_flags&T_TSTOP)==0 && n>=ITSLIM) {
929: s = sphi();
930: tp->t_flags |= T_TSTOP;
931: spl(s);
932: putq(&tp->t_oq, stopc);
933: ttstart(tp);
934: }
935:
936: ttin_ret:
937: return;
938: }
939:
940: /*
941: * ttstash()
942: *
943: * Cooked mode.
944: * Put character in the buffer and check for end of line.
945: * Only a legal end of line can take the last character position.
946: *
947: * Only called from ttin(), and ttin() is called at high priority.
948: */
949: static void ttstash(tp, c)
950: register TTY *tp;
951: {
952: register char *p1, *p2;
953:
954: if (c=='\n' || ISEOF || ISBRK) {
955: p1 = &tp->t_ib[0];
956: p2 = &tp->t_ib[tp->t_ibx];
957: *p2++ = c; /* Always room */
958: while (p1 < p2)
959: #if NOT_8_BIT
960: putq(&tp->t_iq, (*p1++)&0177);
961: #else
962: putq(&tp->t_iq, (*p1++));
963: #endif
964: tp->t_ibx = 0;
965: tp->t_escape = 0;
966:
967: if (tp->t_flags & T_INPUT) {
968: tp->t_flags &= ~T_INPUT;
969: defer(wakeup, (char *) &tp->t_iq);
970: }
971:
972: if (tp->t_ipolls.e_procp) {
973: tp->t_ipolls.e_procp = 0;
974: defer(pollwake, (char *) &tp->t_ipolls);
975: }
976:
977: } else if (tp->t_ibx < NCIB-1)
978: tp->t_ib[tp->t_ibx++] = c;
979: }
980:
981: /*
982: * ttstart()
983: *
984: * Start output on a tty.
985: * Duck out if stopped. Do wakeups.
986: */
987: void ttstart(tp)
988: register TTY *tp;
989: {
990: register int n;
991: int s;
992:
993: n = tp->t_flags;
994: if (n & T_STOP)
995: goto stdone;
996:
997: if ((n&T_DRAIN) && tp->t_oq.cq_cc==0
998: && (n&T_INL)==0 && tp->t_nfill==0) {
999: s = sphi();
1000: tp->t_flags &= ~T_DRAIN;
1001: spl(s);
1002: defer(wakeup, (char *) &tp->t_oq);
1003: goto stdone;
1004: }
1005:
1006: NEAR_OR_FAR_CALL(t_start)
1007:
1008: if (tp->t_oq.cq_cc > OLOLIM)
1009: goto stdone;
1010:
1011: if (n & T_HILIM) {
1012: s = sphi();
1013: tp->t_flags &= ~T_HILIM;
1014: spl(s);
1015: defer(wakeup, (char *) &tp->t_oq);
1016: }
1017:
1018: if (tp->t_opolls.e_procp) {
1019: tp->t_opolls.e_procp = 0;
1020: defer(pollwake, (char *) &tp->t_opolls);
1021: }
1022: stdone:
1023: return;
1024: }
1025:
1026: /*
1027: * ttflush()
1028: *
1029: * Flush a tty.
1030: * Called to clear out queues.
1031: */
1032: void ttflush(tp)
1033: register TTY *tp;
1034: {
1035: int s;
1036:
1037: clrq(&tp->t_iq);
1038: clrq(&tp->t_oq);
1039:
1040: if (tp->t_flags & T_INPUT) {
1041: defer(wakeup, (char *) &tp->t_iq);
1042: }
1043:
1044: if (tp->t_flags & (T_DRAIN|T_HILIM)) {
1045: defer(wakeup, (char *) &tp->t_oq);
1046: }
1047:
1048: if (tp->t_ipolls.e_procp) {
1049: tp->t_ipolls.e_procp = 0;
1050: defer(pollwake, (char *) &tp->t_ipolls);
1051: }
1052:
1053: if (tp->t_opolls.e_procp) {
1054: tp->t_opolls.e_procp = 0;
1055: defer(pollwake, (char *) &tp->t_opolls);
1056: }
1057:
1058: tp->t_ibx = 0;
1059: tp->t_escape = 0;
1060: s = sphi();
1061: tp->t_flags &= T_SAVE; /* reset most flag bits */
1062: spl(s);
1063: }
1064:
1065: /*
1066: * ttsignal()
1067: *
1068: * Send a signal to every process in the given process group.
1069: */
1070: void
1071: ttsignal(tp, sig)
1072: TTY *tp;
1073: int sig;
1074: {
1075: register int g;
1076: register PROC *pp;
1077:
1078: g = tp->t_group;
1079: if (g == 0)
1080: goto sigdone;
1081: ttflush(tp);
1082: pp = &procq;
1083: while ((pp=pp->p_nforw) != &procq)
1084: if (pp->p_group == g) {
1085: sendsig(sig, pp);
1086: }
1087: sigdone:
1088: return;
1089: }
1090:
1091: /*
1092: * tthup()
1093: *
1094: * Flag hangup internally to force errors on tty read/write, flush tty,
1095: * then send hangup signal.
1096: */
1097: void tthup(tp)
1098: register TTY *tp;
1099: {
1100: ttflush(tp);
1101: ttsignal(tp, SIGHUP);
1102: }
1103:
1104: #ifdef _I386
1105: /*
1106: * Convert from sgttyb and tchars structs to termio.
1107: */
1108: static void
1109: make_termio(sgp, tcp, trp)
1110: struct sgttyb * sgp;
1111: struct tchars * tcp;
1112: struct termio * trp;
1113: {
1114: trp->c_cc[VINTR] = tcp->t_intrc;
1115: trp->c_cc[VQUIT] = tcp->t_quitc;
1116: trp->c_cc[VEOF ] = tcp->t_eofc;
1117: trp->c_cc[VEOL ] = '\n';
1118: trp->c_cc[VERASE] = sgp->sg_erase;
1119: trp->c_cc[VKILL ] = sgp->sg_kill;
1120:
1121: trp->c_iflag = BRKINT | ISTRIP | IXON | IGNPAR | INPCK | ISTRIP;
1122: trp->c_oflag = OPOST;
1123: trp->c_cflag &= (CSIZE|HUPCL|CLOCAL|CREAD);
1124: trp->c_lflag = ICANON | ISIG | ECHONL | ECHOK;
1125:
1126: if (sgp->sg_flags & TANDEM)
1127: trp->c_iflag |= IXOFF;
1128:
1129: if (sgp->sg_flags & CRMOD)
1130: trp->c_iflag |= ICRNL;
1131:
1132: if (sgp->sg_flags & LCASE) {
1133: trp->c_lflag |= XCASE;
1134: trp->c_iflag |= IUCLC;
1135: trp->c_oflag |= OLCUC;
1136: }
1137:
1138: if (sgp->sg_flags & RAWIN)
1139: trp->c_iflag &= ~IXON;
1140:
1141: if (sgp->sg_flags & RAWOUT)
1142: trp->c_oflag &= ~OPOST;
1143:
1144: if (sgp->sg_flags & XTABS)
1145: trp->c_oflag |= XTABS;
1146:
1147: if (sgp->sg_flags & CRMOD)
1148: trp->c_oflag |= ONLCR;
1149:
1150: if (sgp->sg_flags & (EVENP|ODDP)) {
1151: trp->c_cflag |= PARENB;
1152: if (sgp->sg_flags & ODDP)
1153: trp->c_cflag |= PARODD;
1154: }
1155: trp->c_cflag |= sgp->sg_ispeed;
1156:
1157: if (sgp->sg_flags & CRT)
1158: trp->c_lflag |= ECHOE;
1159:
1160: if (sgp->sg_flags & RAWIN)
1161: trp->c_lflag &= ~(ISIG|ICANON);
1162:
1163: if (sgp->sg_flags & CBREAK)
1164: trp->c_lflag &= ~ICANON;
1165:
1166: if (sgp->sg_flags & ECHO)
1167: trp->c_lflag |= ECHO;
1168: }
1169:
1170: /*
1171: * Convert from termio struct to sgttyb and tchars.
1172: */
1173: static void
1174: make_sg(trp, sgp, tcp)
1175: struct termio * trp;
1176: struct sgttyb * sgp;
1177: struct tchars * tcp;
1178: {
1179: T_HAL(1, { printf("T:%x:%x:%x:%x ", trp->c_iflag, trp->c_oflag, \
1180: trp->c_cflag, trp->c_lflag);});
1181: tcp->t_intrc = trp->c_cc[VINTR];
1182: tcp->t_quitc = trp->c_cc[VQUIT];
1183: tcp->t_startc= '\021'; /* Ctrl-Q */
1184: tcp->t_stopc = '\023'; /* Ctrl-S */
1185: tcp->t_eofc = trp->c_cc[VEOF];
1186: tcp->t_brkc = -1;
1187:
1188: sgp->sg_erase = trp->c_cc[VERASE];
1189: sgp->sg_kill = trp->c_cc[VKILL ];
1190: sgp->sg_ispeed = trp->c_cflag & CBAUD;
1191: sgp->sg_ospeed = sgp->sg_ispeed;
1192: sgp->sg_flags = RAWIN | RAWOUT | CBREAK;
1193:
1194: if (trp->c_lflag & ECHO)
1195: sgp->sg_flags |= ECHO;
1196:
1197: if (trp->c_lflag & ECHOE)
1198: sgp->sg_flags |= CRT;
1199:
1200: if ( (trp->c_lflag & XCASE)
1201: || (trp->c_oflag & OLCUC)
1202: || (trp->c_iflag & IUCLC))
1203: sgp->sg_flags |= LCASE;
1204:
1205: if (trp->c_iflag & IXOFF)
1206: sgp->sg_flags |= TANDEM;
1207:
1208: if (trp->c_iflag & ICRNL)
1209: sgp->sg_flags |= CRMOD;
1210:
1211: if (trp->c_oflag & ONLCR)
1212: sgp->sg_flags |= CRMOD;
1213:
1214: if (trp->c_oflag & OPOST)
1215: sgp->sg_flags &= ~RAWOUT;
1216:
1217: if (trp->c_oflag & XTABS)
1218: sgp->sg_flags |= XTABS;
1219:
1220: if (trp->c_cflag & PARENB) {
1221: if (trp->c_cflag & PARODD)
1222: sgp->sg_flags |= ODDP;
1223: else
1224: sgp->sg_flags |= EVENP;
1225: }
1226:
1227: if (trp->c_lflag & ISIG)
1228: sgp->sg_flags &= ~RAWIN;
1229:
1230: if (trp->c_lflag & ICANON)
1231: sgp->sg_flags &= ~CBREAK;
1232: }
1233: #endif
1234:
1235: /*
1236: * ttrtp()
1237: *
1238: * Recover contents of typeahead when changing modes.
1239: * Called for ioctls of TIOCSETP and TCSETA,
1240: * when going from not byte-by-byte input to BBYB.
1241: */
1242: static void
1243: ttrtp(tp)
1244: TTY * tp;
1245: {
1246: register char *p1, *p2;
1247:
1248: if (tp->t_ibx) {
1249: p1 = &tp->t_ib[0];
1250: p2 = &tp->t_ib[tp->t_ibx];
1251: while (p1 < p2) {
1252: #if NOT_8_BIT
1253: putq(&tp->t_iq, (*p1++) & 0177);
1254: #else
1255: putq(&tp->t_iq, (*p1++));
1256: #endif
1257: }
1258: tp->t_ibx = 0;
1259: }
1260: }
1261:
1262: /*
1263: * ttinp()
1264: *
1265: * Return nonzero if ttin() may be called to send data for pickup by ttread(),
1266: * or 0 if not.
1267: */
1268: int
1269: ttinp(tp)
1270: TTY * tp;
1271: {
1272: return ((tp->t_flags&T_ISTOP) == 0);
1273: }
1274:
1275: /*
1276: * ttoutp()
1277: *
1278: * Return nonzero if ttout() may be called to fetch data stored by ttwrite(),
1279: * or 0 if not.
1280: */
1281: int
1282: ttoutp(tp)
1283: TTY * tp;
1284: {
1285: return (tp->t_nfill || (tp->t_flags&T_INL) || tp->t_oq.cq_cc);
1286: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.