![[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 [CSRG BSD Unix] / 43BSDReno / sys / kern|
Return to tty.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / sys / kern |
1.1 root 1: /*
2: * Copyright (c) 1982, 1986, 1990 Regents of the University of California.
3: * All rights reserved. The Berkeley software License Agreement
4: * specifies the terms and conditions for redistribution.
5: *
6: * @(#)tty.c 7.35 (Berkeley) 7/27/90
7: */
8:
9: #include "param.h"
10: #include "systm.h"
11: #include "user.h"
12: #include "ioctl.h"
13: #define TTYDEFCHARS
14: #include "tty.h"
15: #undef TTYDEFCHARS
16: #include "proc.h"
17: #include "file.h"
18: #include "conf.h"
19: #include "dkstat.h"
20: #include "uio.h"
21: #include "kernel.h"
22: #include "vnode.h"
23: #include "syslog.h"
24:
25: #include "machine/reg.h"
26:
27: /* symbolic sleep message strings */
28: char ttyin[] = "ttyin";
29: char ttyout[] = "ttyout";
30: char ttopen[] = "ttyopn";
31: char ttclos[] = "ttycls";
32: char ttybg[] = "ttybg";
33: char ttybuf[] = "ttybuf";
34:
35: /*
36: * Table giving parity for characters and indicating
37: * character classes to tty driver. The 8th bit
38: * indicates parity, the 7th bit indicates the character
39: * is an alphameric or underscore (for ALTWERASE), and the
40: * low 6 bits indicate delay type. If the low 6 bits are 0
41: * then the character needs no special processing on output.
42: */
43:
44: char partab[] = {
45: 0001,0201,0201,0001,0201,0001,0001,0201, /* nul - bel */
46: 0202,0004,0003,0201,0005,0206,0201,0001, /* bs - si */
47: 0201,0001,0001,0201,0001,0201,0201,0001, /* dle - etb */
48: 0001,0201,0201,0001,0201,0001,0001,0201, /* can - us */
49: 0200,0000,0000,0200,0000,0200,0200,0000, /* sp - ' */
50: 0000,0200,0200,0000,0200,0000,0000,0200, /* ( - / */
51: 0100,0300,0300,0100,0300,0100,0100,0300, /* 0 - 7 */
52: 0300,0100,0000,0200,0000,0200,0200,0000, /* 8 - ? */
53: 0200,0100,0100,0300,0100,0300,0300,0100, /* @ - G */
54: 0100,0300,0300,0100,0300,0100,0100,0300, /* H - O */
55: 0100,0300,0300,0100,0300,0100,0100,0300, /* P - W */
56: 0300,0100,0100,0200,0000,0200,0200,0300, /* X - _ */
57: 0000,0300,0300,0100,0300,0100,0100,0300, /* ` - g */
58: 0300,0100,0100,0300,0100,0300,0300,0100, /* h - o */
59: 0300,0100,0100,0300,0100,0300,0300,0100, /* p - w */
60: 0100,0300,0300,0000,0200,0000,0000,0201, /* x - del */
61: /*
62: * meta chars
63: */
64: 0001,0201,0201,0001,0201,0001,0001,0201, /* nul - bel */
65: 0202,0004,0003,0201,0005,0206,0201,0001, /* bs - si */
66: 0201,0001,0001,0201,0001,0201,0201,0001, /* dle - etb */
67: 0001,0201,0201,0001,0201,0001,0001,0201, /* can - us */
68: 0200,0000,0000,0200,0000,0200,0200,0000, /* sp - ' */
69: 0000,0200,0200,0000,0200,0000,0000,0200, /* ( - / */
70: 0100,0300,0300,0100,0300,0100,0100,0300, /* 0 - 7 */
71: 0300,0100,0000,0200,0000,0200,0200,0000, /* 8 - ? */
72: 0200,0100,0100,0300,0100,0300,0300,0100, /* @ - G */
73: 0100,0300,0300,0100,0300,0100,0100,0300, /* H - O */
74: 0100,0300,0300,0100,0300,0100,0100,0300, /* P - W */
75: 0300,0100,0100,0200,0000,0200,0200,0300, /* X - _ */
76: 0000,0300,0300,0100,0300,0100,0100,0300, /* ` - g */
77: 0300,0100,0100,0300,0100,0300,0300,0100, /* h - o */
78: 0300,0100,0100,0300,0100,0300,0300,0100, /* p - w */
79: 0100,0300,0300,0000,0200,0000,0000,0201, /* x - del */
80: };
81:
82: extern struct tty *constty; /* temporary virtual console */
83: extern char partab[], maptab[];
84:
85: /*
86: * Is 'c' a line delimiter ("break" character)?
87: */
88: #define ttbreakc(c) ((c) == '\n' || ((c) == cc[VEOF] || \
89: (c) == cc[VEOL] || (c) == cc[VEOL2]) && (c) != _POSIX_VDISABLE)
90:
91: ttychars(tp)
92: struct tty *tp;
93: {
94: bcopy(ttydefchars, tp->t_cc, sizeof(ttydefchars));
95: }
96:
97: /*
98: * Wait for output to drain, then flush input waiting.
99: */
100: ttywflush(tp)
101: struct tty *tp;
102: {
103: int error;
104:
105: if ((error = ttywait(tp)) == 0)
106: ttyflush(tp, FREAD);
107: return (error);
108: }
109:
110: /*
111: * Wait for output to drain.
112: */
113: ttywait(tp)
114: register struct tty *tp;
115: {
116: int error = 0, s = spltty();
117:
118: while ((tp->t_outq.c_cc || tp->t_state&TS_BUSY) &&
119: (tp->t_state&TS_CARR_ON || tp->t_cflag&CLOCAL) &&
120: tp->t_oproc) {
121: (*tp->t_oproc)(tp);
122: tp->t_state |= TS_ASLEEP;
123: if (error = ttysleep(tp, (caddr_t)&tp->t_outq,
124: TTOPRI | PCATCH, ttyout, 0))
125: break;
126: }
127: splx(s);
128: return (error);
129: }
130:
131: /*
132: * Flush all TTY queues
133: */
134: ttyflush(tp, rw)
135: register struct tty *tp;
136: {
137: register s;
138:
139: s = spltty();
140: if (rw & FREAD) {
141: while (getc(&tp->t_canq) >= 0)
142: ;
143: ttwakeup(tp);
144: }
145: if (rw & FWRITE) {
146: wakeup((caddr_t)&tp->t_outq); /* XXX? what about selwakeup? */
147: tp->t_state &= ~TS_TTSTOP;
148: (*cdevsw[major(tp->t_dev)].d_stop)(tp, rw);
149: while (getc(&tp->t_outq) >= 0)
150: ;
151: }
152: if (rw & FREAD) {
153: while (getc(&tp->t_rawq) >= 0)
154: ;
155: tp->t_rocount = 0;
156: tp->t_rocol = 0;
157: tp->t_state &= ~TS_LOCAL;
158: }
159: splx(s);
160: }
161:
162: /*
163: * Send stop character on input overflow.
164: */
165: ttyblock(tp)
166: register struct tty *tp;
167: {
168: register x;
169:
170: x = tp->t_rawq.c_cc + tp->t_canq.c_cc;
171: if (tp->t_rawq.c_cc > TTYHOG) {
172: ttyflush(tp, FREAD|FWRITE);
173: tp->t_state &= ~TS_TBLOCK;
174: }
175: /*
176: * Block further input iff:
177: * Current input > threshold AND input is available to user program
178: */
179: if (x >= TTYHOG/2 && (tp->t_state & TS_TBLOCK) == 0 &&
180: ((tp->t_lflag&ICANON) == 0) || (tp->t_canq.c_cc > 0) &&
181: tp->t_cc[VSTOP] != _POSIX_VDISABLE) {
182: if (putc(tp->t_cc[VSTOP], &tp->t_outq) == 0) {
183: tp->t_state |= TS_TBLOCK;
184: ttstart(tp);
185: }
186: }
187: }
188:
189: /*
190: * Restart typewriter output following a delay
191: * timeout.
192: * The name of the routine is passed to the timeout
193: * subroutine and it is called during a clock interrupt.
194: */
195: ttrstrt(tp)
196: struct tty *tp;
197: {
198:
199: #ifdef DIAGNOSTIC
200: if (tp == 0)
201: panic("ttrstrt");
202: #endif
203: tp->t_state &= ~TS_TIMEOUT;
204: ttstart(tp);
205: }
206:
207: /*
208: * Start output on the typewriter. It is used from the top half
209: * after some characters have been put on the output queue,
210: * from the interrupt routine to transmit the next
211: * character, and after a timeout has finished.
212: */
213: ttstart(tp)
214: struct tty *tp;
215: {
216:
217: if (tp->t_oproc) /* kludge for pty */
218: (*tp->t_oproc)(tp);
219: }
220:
221: /*
222: * Common code for tty ioctls.
223: */
224: /*ARGSUSED*/
225: ttioctl(tp, com, data, flag)
226: register struct tty *tp;
227: caddr_t data;
228: {
229: extern int nldisp;
230: int s, error;
231:
232: /*
233: * If the ioctl involves modification,
234: * hang if in the background.
235: */
236: switch (com) {
237:
238: case TIOCSETD:
239: case TIOCFLUSH:
240: /*case TIOCSPGRP:*/
241: case TIOCSTI:
242: case TIOCSWINSZ:
243: case TIOCSETA:
244: case TIOCSETAW:
245: case TIOCSETAF:
246: #ifdef COMPAT_43
247: case TIOCSETP:
248: case TIOCSETN:
249: case TIOCSETC:
250: case TIOCSLTC:
251: case TIOCLBIS:
252: case TIOCLBIC:
253: case TIOCLSET:
254: case OTIOCSETD:
255: #endif
256: while (isbackground(u.u_procp, tp) &&
257: u.u_procp->p_pgrp->pg_jobc &&
258: (u.u_procp->p_flag&SVFORK) == 0 &&
259: (u.u_procp->p_sigignore & sigmask(SIGTTOU)) == 0 &&
260: (u.u_procp->p_sigmask & sigmask(SIGTTOU)) == 0) {
261: pgsignal(u.u_procp->p_pgrp, SIGTTOU, 1);
262: if (error = ttysleep(tp, (caddr_t)&lbolt,
263: TTOPRI | PCATCH, ttybg, 0))
264: return (error);
265: }
266: break;
267: }
268:
269: /*
270: * Process the ioctl.
271: */
272: switch (com) {
273:
274: /* get discipline number */
275: case TIOCGETD:
276: *(int *)data = tp->t_line;
277: break;
278:
279: /* set line discipline */
280: case TIOCSETD: {
281: register int t = *(int *)data;
282: dev_t dev = tp->t_dev;
283:
284: if ((unsigned)t >= nldisp)
285: return (ENXIO);
286: if (t != tp->t_line) {
287: s = spltty();
288: (*linesw[tp->t_line].l_close)(tp);
289: error = (*linesw[t].l_open)(dev, tp);
290: if (error) {
291: (void)(*linesw[tp->t_line].l_open)(dev, tp);
292: splx(s);
293: return (error);
294: }
295: tp->t_line = t;
296: splx(s);
297: }
298: break;
299: }
300:
301: /* prevent more opens on channel */
302: case TIOCEXCL:
303: tp->t_state |= TS_XCLUDE;
304: break;
305:
306: case TIOCNXCL:
307: tp->t_state &= ~TS_XCLUDE;
308: break;
309:
310: case TIOCHPCL:
311: tp->t_cflag |= HUPCL;
312: break;
313:
314: case TIOCFLUSH: {
315: register int flags = *(int *)data;
316:
317: if (flags == 0)
318: flags = FREAD|FWRITE;
319: else
320: flags &= FREAD|FWRITE;
321: ttyflush(tp, flags);
322: break;
323: }
324:
325: case FIOASYNC:
326: if (*(int *)data)
327: tp->t_state |= TS_ASYNC;
328: else
329: tp->t_state &= ~TS_ASYNC;
330: break;
331:
332: case FIONBIO:
333: break; /* XXX remove */
334:
335: /* return number of characters immediately available */
336: case FIONREAD:
337: *(off_t *)data = ttnread(tp);
338: break;
339:
340: case TIOCOUTQ:
341: *(int *)data = tp->t_outq.c_cc;
342: break;
343:
344: case TIOCSTOP:
345: s = spltty();
346: if ((tp->t_state&TS_TTSTOP) == 0) {
347: tp->t_state |= TS_TTSTOP;
348: (*cdevsw[major(tp->t_dev)].d_stop)(tp, 0);
349: }
350: splx(s);
351: break;
352:
353: case TIOCSTART:
354: s = spltty();
355: if ((tp->t_state&TS_TTSTOP) || (tp->t_lflag&FLUSHO)) {
356: tp->t_state &= ~TS_TTSTOP;
357: tp->t_lflag &= ~FLUSHO;
358: ttstart(tp);
359: }
360: splx(s);
361: break;
362:
363: /*
364: * Simulate typing of a character at the terminal.
365: */
366: case TIOCSTI:
367: if (u.u_uid && (flag & FREAD) == 0)
368: return (EPERM);
369: if (u.u_uid && !isctty(u.u_procp, tp))
370: return (EACCES);
371: (*linesw[tp->t_line].l_rint)(*(char *)data, tp);
372: break;
373:
374: case TIOCGETA: {
375: struct termios *t = (struct termios *)data;
376:
377: bcopy(&tp->t_termios, t, sizeof(struct termios));
378: break;
379: }
380:
381: case TIOCSETA:
382: case TIOCSETAW:
383: case TIOCSETAF: {
384: register struct termios *t = (struct termios *)data;
385:
386: s = spltty();
387: if (com == TIOCSETAW || com == TIOCSETAF) {
388: if (error = ttywait(tp)) {
389: splx(s);
390: return (error);
391: }
392: if (com == TIOCSETAF)
393: ttyflush(tp, FREAD);
394: }
395: if ((t->c_cflag&CIGNORE) == 0) {
396: /*
397: * set device hardware
398: */
399: if (tp->t_param && (error = (*tp->t_param)(tp, t))) {
400: splx(s);
401: return (error);
402: } else {
403: if ((tp->t_state&TS_CARR_ON) == 0 &&
404: (tp->t_cflag&CLOCAL) &&
405: (t->c_cflag&CLOCAL) == 0) {
406: tp->t_state &= ~TS_ISOPEN;
407: tp->t_state |= TS_WOPEN;
408: ttwakeup(tp);
409: }
410: tp->t_cflag = t->c_cflag;
411: tp->t_ispeed = t->c_ispeed;
412: tp->t_ospeed = t->c_ospeed;
413: }
414: ttsetwater(tp);
415: }
416: if (com != TIOCSETAF) {
417: if ((t->c_lflag&ICANON) != (tp->t_lflag&ICANON))
418: if (t->c_lflag&ICANON) {
419: tp->t_lflag |= PENDIN;
420: ttwakeup(tp);
421: }
422: else {
423: struct clist tq;
424:
425: catq(&tp->t_rawq, &tp->t_canq);
426: tq = tp->t_rawq;
427: tp->t_rawq = tp->t_canq;
428: tp->t_canq = tq;
429: }
430: }
431: tp->t_iflag = t->c_iflag;
432: tp->t_oflag = t->c_oflag;
433: /*
434: * Make the EXTPROC bit read only.
435: */
436: if (tp->t_lflag&EXTPROC)
437: t->c_lflag |= EXTPROC;
438: else
439: t->c_lflag &= ~EXTPROC;
440: tp->t_lflag = t->c_lflag;
441: bcopy(t->c_cc, tp->t_cc, sizeof(t->c_cc));
442: splx(s);
443: break;
444: }
445:
446: /*
447: * Set controlling terminal.
448: * Session ctty vnode pointer set in vnode layer.
449: */
450: case TIOCSCTTY: {
451: register struct proc *p = u.u_procp;
452:
453: if (!SESS_LEADER(p) ||
454: (p->p_session->s_ttyvp || tp->t_session) &&
455: (tp->t_session != p->p_session))
456: return (EPERM);
457: tp->t_session = p->p_session;
458: tp->t_pgrp = p->p_pgrp;
459: p->p_session->s_ttyp = tp;
460: p->p_flag |= SCTTY;
461: break;
462: }
463:
464: /*
465: * Set terminal process group.
466: */
467: case TIOCSPGRP: {
468: register struct proc *p = u.u_procp;
469: register struct pgrp *pgrp = pgfind(*(int *)data);
470:
471: if (!isctty(p, tp))
472: return (ENOTTY);
473: else if (pgrp == NULL || pgrp->pg_session != p->p_session)
474: return (EPERM);
475: tp->t_pgrp = pgrp;
476: break;
477: }
478:
479: case TIOCGPGRP:
480: if (!isctty(u.u_procp, tp))
481: return (ENOTTY);
482: *(int *)data = tp->t_pgrp ? tp->t_pgrp->pg_id : NO_PID;
483: break;
484:
485: case TIOCSWINSZ:
486: if (bcmp((caddr_t)&tp->t_winsize, data,
487: sizeof (struct winsize))) {
488: tp->t_winsize = *(struct winsize *)data;
489: pgsignal(tp->t_pgrp, SIGWINCH, 1);
490: }
491: break;
492:
493: case TIOCGWINSZ:
494: *(struct winsize *)data = tp->t_winsize;
495: break;
496:
497: case TIOCCONS:
498: if (*(int *)data) {
499: if (constty && constty != tp &&
500: (constty->t_state & (TS_CARR_ON|TS_ISOPEN)) ==
501: (TS_CARR_ON|TS_ISOPEN))
502: return (EBUSY);
503: #ifndef UCONSOLE
504: if (error = suser(u.u_cred, &u.u_acflag))
505: return (error);
506: #endif
507: constty = tp;
508: } else if (tp == constty)
509: constty = NULL;
510: break;
511:
512: #ifdef COMPAT_43
513: case TIOCGETP:
514: case TIOCSETP:
515: case TIOCSETN:
516: case TIOCGETC:
517: case TIOCSETC:
518: case TIOCSLTC:
519: case TIOCGLTC:
520: case TIOCLBIS:
521: case TIOCLBIC:
522: case TIOCLSET:
523: case TIOCLGET:
524: case OTIOCGETD:
525: case OTIOCSETD:
526: case OTIOCCONS:
527: return(ttcompat(tp, com, data, flag));
528: #endif
529:
530: default:
531: return (-1);
532: }
533: return (0);
534: }
535:
536: ttnread(tp)
537: struct tty *tp;
538: {
539: int nread = 0;
540:
541: if (tp->t_lflag & PENDIN)
542: ttypend(tp);
543: nread = tp->t_canq.c_cc;
544: if ((tp->t_lflag & ICANON) == 0)
545: nread += tp->t_rawq.c_cc;
546: return (nread);
547: }
548:
549: ttselect(dev, rw)
550: dev_t dev;
551: int rw;
552: {
553: register struct tty *tp = &cdevsw[major(dev)].d_ttys[minor(dev)];
554: int nread;
555: int s = spltty();
556:
557: switch (rw) {
558:
559: case FREAD:
560: nread = ttnread(tp);
561: if (nread > 0 ||
562: ((tp->t_cflag&CLOCAL) == 0 && (tp->t_state&TS_CARR_ON) == 0))
563: goto win;
564: if (tp->t_rsel && tp->t_rsel->p_wchan == (caddr_t)&selwait)
565: tp->t_state |= TS_RCOLL;
566: else
567: tp->t_rsel = u.u_procp;
568: break;
569:
570: case FWRITE:
571: if (tp->t_outq.c_cc <= tp->t_lowat)
572: goto win;
573: if (tp->t_wsel && tp->t_wsel->p_wchan == (caddr_t)&selwait)
574: tp->t_state |= TS_WCOLL;
575: else
576: tp->t_wsel = u.u_procp;
577: break;
578: }
579: splx(s);
580: return (0);
581: win:
582: splx(s);
583: return (1);
584: }
585:
586: /*
587: * Initial open of tty, or (re)entry to line discipline.
588: */
589: ttyopen(dev, tp)
590: dev_t dev;
591: register struct tty *tp;
592: {
593:
594: tp->t_dev = dev;
595:
596: tp->t_state &= ~TS_WOPEN;
597: if ((tp->t_state & TS_ISOPEN) == 0) {
598: tp->t_state |= TS_ISOPEN;
599: bzero((caddr_t)&tp->t_winsize, sizeof(tp->t_winsize));
600: }
601: return (0);
602: }
603:
604: /*
605: * "close" a line discipline
606: */
607: ttylclose(tp)
608: register struct tty *tp;
609: {
610:
611: ttywflush(tp);
612: }
613:
614: /*
615: * clean tp on last close
616: */
617: ttyclose(tp)
618: register struct tty *tp;
619: {
620: if (constty == tp)
621: constty = NULL;
622: ttyflush(tp, FREAD|FWRITE);
623: tp->t_session = NULL;
624: tp->t_pgrp = NULL;
625: tp->t_state = 0;
626: tp->t_gen++;
627: return (0);
628: }
629:
630: /*
631: * Handle modem control transition on a tty.
632: * Flag indicates new state of carrier.
633: * Returns 0 if the line should be turned off, otherwise 1.
634: */
635: ttymodem(tp, flag)
636: register struct tty *tp;
637: {
638:
639: if ((tp->t_state&TS_WOPEN) == 0 && (tp->t_lflag&MDMBUF)) {
640: /*
641: * MDMBUF: do flow control according to carrier flag
642: */
643: if (flag) {
644: tp->t_state &= ~TS_TTSTOP;
645: ttstart(tp);
646: } else if ((tp->t_state&TS_TTSTOP) == 0) {
647: tp->t_state |= TS_TTSTOP;
648: (*cdevsw[major(tp->t_dev)].d_stop)(tp, 0);
649: }
650: } else if (flag == 0) {
651: /*
652: * Lost carrier.
653: */
654: tp->t_state &= ~TS_CARR_ON;
655: if (tp->t_state&TS_ISOPEN && (tp->t_cflag&CLOCAL) == 0) {
656: if (tp->t_session && tp->t_session->s_leader)
657: psignal(tp->t_session->s_leader, SIGHUP);
658: ttyflush(tp, FREAD|FWRITE);
659: return (0);
660: }
661: } else {
662: /*
663: * Carrier now on.
664: */
665: tp->t_state |= TS_CARR_ON;
666: ttwakeup(tp);
667: }
668: return (1);
669: }
670:
671: /*
672: * Default modem control routine (for other line disciplines).
673: * Return argument flag, to turn off device on carrier drop.
674: */
675: nullmodem(tp, flag)
676: register struct tty *tp;
677: int flag;
678: {
679:
680: if (flag)
681: tp->t_state |= TS_CARR_ON;
682: else {
683: tp->t_state &= ~TS_CARR_ON;
684: if ((tp->t_cflag&CLOCAL) == 0) {
685: if (tp->t_session && tp->t_session->s_leader)
686: psignal(tp->t_session->s_leader, SIGHUP);
687: return (0);
688: }
689: }
690: return (1);
691: }
692:
693: /*
694: * reinput pending characters after state switch
695: * call at spltty().
696: */
697: ttypend(tp)
698: register struct tty *tp;
699: {
700: struct clist tq;
701: register c;
702:
703: tp->t_lflag &= ~PENDIN;
704: tp->t_state |= TS_TYPEN;
705: tq = tp->t_rawq;
706: tp->t_rawq.c_cc = 0;
707: tp->t_rawq.c_cf = tp->t_rawq.c_cl = 0;
708: while ((c = getc(&tq)) >= 0)
709: ttyinput(c, tp);
710: tp->t_state &= ~TS_TYPEN;
711: }
712:
713: /*
714: *
715: * Place a character on raw TTY input queue,
716: * putting in delimiters and waking up top
717: * half as needed. Also echo if required.
718: * The arguments are the character and the
719: * appropriate tty structure.
720: */
721: ttyinput(c, tp)
722: register c;
723: register struct tty *tp;
724: {
725: register int iflag = tp->t_iflag;
726: register int lflag = tp->t_lflag;
727: register u_char *cc = tp->t_cc;
728: int i, err;
729:
730: /*
731: * If input is pending take it first.
732: */
733: if (lflag&PENDIN)
734: ttypend(tp);
735: /*
736: * Gather stats.
737: */
738: tk_nin++;
739: if (lflag&ICANON) {
740: tk_cancc++;
741: tp->t_cancc++;
742: } else {
743: tk_rawcc++;
744: tp->t_rawcc++;
745: }
746: /*
747: * Handle exceptional conditions (break, parity, framing).
748: */
749: if (err = (c&TTY_ERRORMASK)) {
750: c &= ~TTY_ERRORMASK;
751: if (err&TTY_FE && !c) { /* break */
752: if (iflag&IGNBRK)
753: goto endcase;
754: else if (iflag&BRKINT && lflag&ISIG &&
755: (cc[VINTR] != _POSIX_VDISABLE))
756: c = cc[VINTR];
757: else {
758: c = 0;
759: if (iflag&PARMRK)
760: goto parmrk;
761: }
762: } else if ((err&TTY_PE && iflag&INPCK) || err&TTY_FE) {
763: if (iflag&IGNPAR)
764: goto endcase;
765: else if (iflag&PARMRK) {
766: parmrk:
767: putc(0377|TTY_QUOTE, &tp->t_rawq);
768: putc(0|TTY_QUOTE, &tp->t_rawq);
769: putc(c|TTY_QUOTE, &tp->t_rawq);
770: goto endcase;
771: } else
772: c = 0;
773: }
774: }
775: /*
776: * In tandem mode, check high water mark.
777: */
778: if (iflag&IXOFF)
779: ttyblock(tp);
780: if ((tp->t_state&TS_TYPEN) == 0 && (iflag&ISTRIP))
781: c &= 0177;
782: if ((tp->t_lflag&EXTPROC) == 0) {
783: /*
784: * Check for literal nexting very first
785: */
786: if (tp->t_state&TS_LNCH) {
787: c |= TTY_QUOTE;
788: tp->t_state &= ~TS_LNCH;
789: }
790: /*
791: * Scan for special characters. This code
792: * is really just a big case statement with
793: * non-constant cases. The bottom of the
794: * case statement is labeled ``endcase'', so goto
795: * it after a case match, or similar.
796: */
797:
798: /*
799: * Control chars which aren't controlled
800: * by ICANON, ISIG, or IXON.
801: */
802: if (lflag&IEXTEN) {
803: if (CCEQ(cc[VLNEXT], c)) {
804: if (lflag&ECHO) {
805: if (lflag&ECHOE)
806: ttyoutstr("^\b", tp);
807: else
808: ttyecho(c, tp);
809: }
810: tp->t_state |= TS_LNCH;
811: goto endcase;
812: }
813: if (CCEQ(cc[VDISCARD], c)) {
814: if (lflag&FLUSHO)
815: tp->t_lflag &= ~FLUSHO;
816: else {
817: ttyflush(tp, FWRITE);
818: ttyecho(c, tp);
819: if (tp->t_rawq.c_cc + tp->t_canq.c_cc)
820: ttyretype(tp);
821: tp->t_lflag |= FLUSHO;
822: }
823: goto startoutput;
824: }
825: }
826: /*
827: * Signals.
828: */
829: if (lflag&ISIG) {
830: if (CCEQ(cc[VINTR], c) || CCEQ(cc[VQUIT], c)) {
831: if ((lflag&NOFLSH) == 0)
832: ttyflush(tp, FREAD|FWRITE);
833: ttyecho(c, tp);
834: pgsignal(tp->t_pgrp,
835: CCEQ(cc[VINTR], c) ? SIGINT : SIGQUIT, 1);
836: goto endcase;
837: }
838: if (CCEQ(cc[VSUSP], c)) {
839: if ((lflag&NOFLSH) == 0)
840: ttyflush(tp, FREAD);
841: ttyecho(c, tp);
842: pgsignal(tp->t_pgrp, SIGTSTP, 1);
843: goto endcase;
844: }
845: }
846: /*
847: * Handle start/stop characters.
848: */
849: if (iflag&IXON) {
850: if (CCEQ(cc[VSTOP], c)) {
851: if ((tp->t_state&TS_TTSTOP) == 0) {
852: tp->t_state |= TS_TTSTOP;
853: (*cdevsw[major(tp->t_dev)].d_stop)(tp,
854: 0);
855: return;
856: }
857: if (!CCEQ(cc[VSTART], c))
858: return;
859: /*
860: * if VSTART == VSTOP then toggle
861: */
862: goto endcase;
863: }
864: if (CCEQ(cc[VSTART], c))
865: goto restartoutput;
866: }
867: /*
868: * IGNCR, ICRNL, & INLCR
869: */
870: if (c == '\r') {
871: if (iflag&IGNCR)
872: goto endcase;
873: else if (iflag&ICRNL)
874: c = '\n';
875: } else if (c == '\n' && iflag&INLCR)
876: c = '\r';
877: }
878: /*
879: * Non canonical mode; don't process line editing
880: * characters; check high water mark for wakeup.
881: *
882: */
883: if ((lflag&ICANON) == 0) {
884: if (tp->t_rawq.c_cc > TTYHOG) {
885: if (iflag&IMAXBEL) {
886: if (tp->t_outq.c_cc < tp->t_hiwat)
887: (void) ttyoutput(CTRL('g'), tp);
888: } else
889: ttyflush(tp, FREAD | FWRITE);
890: } else {
891: if (putc(c, &tp->t_rawq) >= 0) {
892: ttwakeup(tp);
893: ttyecho(c, tp);
894: }
895: }
896: goto endcase;
897: }
898: if ((tp->t_lflag&EXTPROC) == 0) {
899: /*
900: * From here on down canonical mode character
901: * processing takes place.
902: */
903: /*
904: * erase (^H / ^?)
905: */
906: if (CCEQ(cc[VERASE], c)) {
907: if (tp->t_rawq.c_cc)
908: ttyrub(unputc(&tp->t_rawq), tp);
909: goto endcase;
910: }
911: /*
912: * kill (^U)
913: */
914: if (CCEQ(cc[VKILL], c)) {
915: if (lflag&ECHOKE && tp->t_rawq.c_cc == tp->t_rocount &&
916: (lflag&ECHOPRT) == 0) {
917: while (tp->t_rawq.c_cc)
918: ttyrub(unputc(&tp->t_rawq), tp);
919: } else {
920: ttyecho(c, tp);
921: if (lflag&ECHOK || lflag&ECHOKE)
922: ttyecho('\n', tp);
923: while (getc(&tp->t_rawq) > 0)
924: ;
925: tp->t_rocount = 0;
926: }
927: tp->t_state &= ~TS_LOCAL;
928: goto endcase;
929: }
930: /*
931: * word erase (^W)
932: */
933: if (CCEQ(cc[VWERASE], c)) {
934: int ctype;
935:
936: #define CTYPE(c) ((lflag&ALTWERASE) ? (partab[(c)&TTY_CHARMASK]&0100) : 0)
937: /*
938: * erase whitespace
939: */
940: while ((c = unputc(&tp->t_rawq)) == ' ' || c == '\t')
941: ttyrub(c, tp);
942: if (c == -1)
943: goto endcase;
944: /*
945: * special case last char of token
946: */
947: ttyrub(c, tp);
948: c = unputc(&tp->t_rawq);
949: if (c == -1 || c == ' ' || c == '\t') {
950: if (c != -1)
951: (void) putc(c, &tp->t_rawq);
952: goto endcase;
953: }
954: /*
955: * erase rest of token
956: */
957: ctype = CTYPE(c);
958: do {
959: ttyrub(c, tp);
960: c = unputc(&tp->t_rawq);
961: if (c == -1)
962: goto endcase;
963: } while (c != ' ' && c != '\t' && CTYPE(c) == ctype);
964: (void) putc(c, &tp->t_rawq);
965: goto endcase;
966: #undef CTYPE
967: }
968: /*
969: * reprint line (^R)
970: */
971: if (CCEQ(cc[VREPRINT], c)) {
972: ttyretype(tp);
973: goto endcase;
974: }
975: /*
976: * ^T - kernel info and generate SIGINFO
977: */
978: if (CCEQ(cc[VSTATUS], c)) {
979: pgsignal(tp->t_pgrp, SIGINFO, 1);
980: if ((lflag&NOKERNINFO) == 0)
981: ttyinfo(tp);
982: goto endcase;
983: }
984: }
985: /*
986: * Check for input buffer overflow
987: */
988: if (tp->t_rawq.c_cc+tp->t_canq.c_cc >= TTYHOG) {
989: if (iflag&IMAXBEL) {
990: if (tp->t_outq.c_cc < tp->t_hiwat)
991: (void) ttyoutput(CTRL('g'), tp);
992: } else
993: ttyflush(tp, FREAD | FWRITE);
994: goto endcase;
995: }
996: /*
997: * Put data char in q for user and
998: * wakeup on seeing a line delimiter.
999: */
1000: if (putc(c, &tp->t_rawq) >= 0) {
1001: if (ttbreakc(c)) {
1002: tp->t_rocount = 0;
1003: catq(&tp->t_rawq, &tp->t_canq);
1004: ttwakeup(tp);
1005: } else if (tp->t_rocount++ == 0)
1006: tp->t_rocol = tp->t_col;
1007: if (tp->t_state&TS_ERASE) {
1008: /*
1009: * end of prterase \.../
1010: */
1011: tp->t_state &= ~TS_ERASE;
1012: (void) ttyoutput('/', tp);
1013: }
1014: i = tp->t_col;
1015: ttyecho(c, tp);
1016: if (CCEQ(cc[VEOF], c) && lflag&ECHO) {
1017: /*
1018: * Place the cursor over the '^' of the ^D.
1019: */
1020: i = MIN(2, tp->t_col - i);
1021: while (i > 0) {
1022: (void) ttyoutput('\b', tp);
1023: i--;
1024: }
1025: }
1026: }
1027: endcase:
1028: /*
1029: * IXANY means allow any character to restart output.
1030: */
1031: if ((tp->t_state&TS_TTSTOP) && (iflag&IXANY) == 0 &&
1032: cc[VSTART] != cc[VSTOP])
1033: return;
1034: restartoutput:
1035: tp->t_state &= ~TS_TTSTOP;
1036: tp->t_lflag &= ~FLUSHO;
1037: startoutput:
1038: ttstart(tp);
1039: }
1040:
1041: /*
1042: * Put character on TTY output queue, adding delays,
1043: * expanding tabs, and handling the CR/NL bit.
1044: * This is called both from the top half for output,
1045: * and from interrupt level for echoing.
1046: * The arguments are the character and the tty structure.
1047: * Returns < 0 if putc succeeds, otherwise returns char to resend
1048: * Must be recursive.
1049: */
1050: ttyoutput(c, tp)
1051: register c;
1052: register struct tty *tp;
1053: {
1054: register short *colp;
1055: register ctype;
1056: register long oflag = tp->t_oflag;
1057:
1058: if ((oflag&OPOST) == 0) {
1059: if (tp->t_lflag&FLUSHO)
1060: return (-1);
1061: if (putc(c, &tp->t_outq))
1062: return (c);
1063: tk_nout++;
1064: tp->t_outcc++;
1065: return (-1);
1066: }
1067: c &= TTY_CHARMASK;
1068: /*
1069: * Turn tabs to spaces as required
1070: *
1071: * Special case if we have external processing, we don't
1072: * do the tab expansion because we'll probably get it
1073: * wrong. If tab expansion needs to be done, let it
1074: * happen externally.
1075: */
1076: if ((tp->t_lflag&EXTPROC) == 0 &&
1077: c == '\t' && oflag&OXTABS ) {
1078: register int s;
1079:
1080: c = 8 - (tp->t_col&7);
1081: if ((tp->t_lflag&FLUSHO) == 0) {
1082: s = spltty(); /* don't interrupt tabs */
1083: c -= b_to_q(" ", c, &tp->t_outq);
1084: tk_nout += c;
1085: tp->t_outcc += c;
1086: splx(s);
1087: }
1088: tp->t_col += c;
1089: return (c ? -1 : '\t');
1090: }
1091: if (c == CEOT && oflag&ONOEOT)
1092: return(-1);
1093: tk_nout++;
1094: tp->t_outcc++;
1095: /*
1096: * turn <nl> to <cr><lf> if desired.
1097: */
1098: if (c == '\n' && (tp->t_oflag&ONLCR) && ttyoutput('\r', tp) >= 0)
1099: return (c);
1100: if ((tp->t_lflag&FLUSHO) == 0 && putc(c, &tp->t_outq))
1101: return (c);
1102: /*
1103: * Calculate delays.
1104: * The numbers here represent clock ticks
1105: * and are not necessarily optimal for all terminals.
1106: *
1107: * SHOULD JUST ALLOW USER TO SPECIFY DELAYS
1108: *
1109: * (actually, should THROW AWAY terminals which need delays)
1110: */
1111: colp = &tp->t_col;
1112: ctype = partab[c];
1113: c = 0;
1114: switch (ctype&077) {
1115:
1116: case ORDINARY:
1117: (*colp)++;
1118:
1119: case CONTROL:
1120: break;
1121:
1122: case BACKSPACE:
1123: if (*colp)
1124: (*colp)--;
1125: break;
1126:
1127: /*
1128: * This macro is close enough to the correct thing;
1129: * it should be replaced by real user settable delays
1130: * in any event...
1131: */
1132: #define mstohz(ms) (((ms) * hz) >> 10)
1133: case NEWLINE:
1134: ctype = (tp->t_flags >> 8) & 03;
1135: if (ctype == 1) { /* tty 37 */
1136: if (*colp > 0) {
1137: c = (((unsigned)*colp) >> 4) + 3;
1138: if ((unsigned)c > 6)
1139: c = 6;
1140: }
1141: } else if (ctype == 2) /* vt05 */
1142: c = mstohz(100);
1143: *colp = 0;
1144: break;
1145:
1146: case TAB:
1147: ctype = (tp->t_flags >> 10) & 03;
1148: if (ctype == 1) { /* tty 37 */
1149: c = 1 - (*colp | ~07);
1150: if (c < 5)
1151: c = 0;
1152: }
1153: *colp |= 07;
1154: (*colp)++;
1155: break;
1156:
1157: case VTAB:
1158: if (tp->t_flags&VTDELAY) /* tty 37 */
1159: c = 0177;
1160: break;
1161:
1162: case RETURN:
1163: ctype = (tp->t_flags >> 12) & 03;
1164: if (ctype == 1) /* tn 300 */
1165: c = mstohz(83);
1166: else if (ctype == 2) /* ti 700 */
1167: c = mstohz(166);
1168: else if (ctype == 3) { /* concept 100 */
1169: int i;
1170:
1171: if ((i = *colp) >= 0)
1172: for (; i < 9; i++)
1173: (void) putc(0177, &tp->t_outq);
1174: }
1175: *colp = 0;
1176: }
1177: if (c && (tp->t_lflag&FLUSHO) == 0)
1178: (void) putc(c|TTY_QUOTE, &tp->t_outq);
1179: return (-1);
1180: }
1181: #undef mstohz
1182:
1183: /*
1184: * Called from device's read routine after it has
1185: * calculated the tty-structure given as argument.
1186: */
1187: ttread(tp, uio, flag)
1188: register struct tty *tp;
1189: struct uio *uio;
1190: {
1191: register struct clist *qp;
1192: register int c;
1193: register long lflag;
1194: register u_char *cc = tp->t_cc;
1195: int s, first, error = 0;
1196:
1197: loop:
1198: lflag = tp->t_lflag;
1199: s = spltty();
1200: /*
1201: * take pending input first
1202: */
1203: if (lflag&PENDIN)
1204: ttypend(tp);
1205: splx(s);
1206:
1207: /*
1208: * Hang process if it's in the background.
1209: */
1210: if (isbackground(u.u_procp, tp)) {
1211: if ((u.u_procp->p_sigignore & sigmask(SIGTTIN)) ||
1212: (u.u_procp->p_sigmask & sigmask(SIGTTIN)) ||
1213: u.u_procp->p_flag&SVFORK || u.u_procp->p_pgrp->pg_jobc == 0)
1214: return (EIO);
1215: pgsignal(u.u_procp->p_pgrp, SIGTTIN, 1);
1216: if (error = ttysleep(tp, (caddr_t)&lbolt, TTIPRI | PCATCH,
1217: ttybg, 0))
1218: return (error);
1219: goto loop;
1220: }
1221:
1222: /*
1223: * If canonical, use the canonical queue,
1224: * else use the raw queue.
1225: *
1226: * XXX - should get rid of canonical queue.
1227: * (actually, should get rid of clists...)
1228: */
1229: qp = lflag&ICANON ? &tp->t_canq : &tp->t_rawq;
1230:
1231: /*
1232: * If there is no input, sleep on rawq
1233: * awaiting hardware receipt and notification.
1234: * If we have data, we don't need to check for carrier.
1235: */
1236: s = spltty();
1237: if (qp->c_cc <= 0) {
1238: int carrier;
1239:
1240: carrier = (tp->t_state&TS_CARR_ON) || (tp->t_cflag&CLOCAL);
1241: if (!carrier && tp->t_state&TS_ISOPEN) {
1242: splx(s);
1243: return (0); /* EOF */
1244: }
1245: if (flag & IO_NDELAY) {
1246: splx(s);
1247: return (EWOULDBLOCK);
1248: }
1249: error = ttysleep(tp, (caddr_t)&tp->t_rawq, TTIPRI | PCATCH,
1250: carrier ? ttyin : ttopen, 0);
1251: splx(s);
1252: if (error)
1253: return (error);
1254: goto loop;
1255: }
1256: splx(s);
1257:
1258: /*
1259: * Input present, check for input mapping and processing.
1260: */
1261: first = 1;
1262: while ((c = getc(qp)) >= 0) {
1263: /*
1264: * delayed suspend (^Y)
1265: */
1266: if (CCEQ(cc[VDSUSP], c) && lflag&ISIG) {
1267: pgsignal(tp->t_pgrp, SIGTSTP, 1);
1268: if (first) {
1269: if (error = ttysleep(tp, (caddr_t)&lbolt,
1270: TTIPRI | PCATCH, ttybg, 0))
1271: break;
1272: goto loop;
1273: }
1274: break;
1275: }
1276: /*
1277: * Interpret EOF only in canonical mode.
1278: */
1279: if (CCEQ(cc[VEOF], c) && lflag&ICANON)
1280: break;
1281: /*
1282: * Give user character.
1283: */
1284: error = ureadc(c, uio);
1285: if (error)
1286: break;
1287: if (uio->uio_resid == 0)
1288: break;
1289: /*
1290: * In canonical mode check for a "break character"
1291: * marking the end of a "line of input".
1292: */
1293: if (lflag&ICANON && ttbreakc(c))
1294: break;
1295: first = 0;
1296: }
1297: /*
1298: * Look to unblock output now that (presumably)
1299: * the input queue has gone down.
1300: */
1301: if (tp->t_state&TS_TBLOCK && tp->t_rawq.c_cc < TTYHOG/5) {
1302: if (cc[VSTART] != _POSIX_VDISABLE
1303: && putc(cc[VSTART], &tp->t_outq) == 0) {
1304: tp->t_state &= ~TS_TBLOCK;
1305: ttstart(tp);
1306: }
1307: }
1308: return (error);
1309: }
1310:
1311: /*
1312: * Check the output queue on tp for space for a kernel message
1313: * (from uprintf/tprintf). Allow some space over the normal
1314: * hiwater mark so we don't lose messages due to normal flow
1315: * control, but don't let the tty run amok.
1316: * Sleeps here are not interruptible, but we return prematurely
1317: * if new signals come in.
1318: */
1319: ttycheckoutq(tp, wait)
1320: register struct tty *tp;
1321: int wait;
1322: {
1323: int hiwat, s, oldsig;
1324:
1325: hiwat = tp->t_hiwat;
1326: s = spltty();
1327: oldsig = u.u_procp->p_sig;
1328: if (tp->t_outq.c_cc > hiwat + 200)
1329: while (tp->t_outq.c_cc > hiwat) {
1330: ttstart(tp);
1331: if (wait == 0 || u.u_procp->p_sig != oldsig) {
1332: splx(s);
1333: return (0);
1334: }
1335: timeout(wakeup, (caddr_t)&tp->t_outq, hz);
1336: tp->t_state |= TS_ASLEEP;
1337: sleep((caddr_t)&tp->t_outq, PZERO - 1);
1338: }
1339: splx(s);
1340: return (1);
1341: }
1342:
1343: /*
1344: * Called from the device's write routine after it has
1345: * calculated the tty-structure given as argument.
1346: */
1347: ttwrite(tp, uio, flag)
1348: register struct tty *tp;
1349: register struct uio *uio;
1350: {
1351: register char *cp;
1352: register int cc = 0, ce;
1353: int i, hiwat, cnt, error, s;
1354: char obuf[OBUFSIZ];
1355:
1356: hiwat = tp->t_hiwat;
1357: cnt = uio->uio_resid;
1358: error = 0;
1359: loop:
1360: s = spltty();
1361: if ((tp->t_state&TS_CARR_ON) == 0 && (tp->t_cflag&CLOCAL) == 0) {
1362: if (tp->t_state&TS_ISOPEN) {
1363: splx(s);
1364: return (EIO);
1365: } else if (flag & IO_NDELAY) {
1366: splx(s);
1367: error = EWOULDBLOCK;
1368: goto out;
1369: } else {
1370: /*
1371: * sleep awaiting carrier
1372: */
1373: error = ttysleep(tp, (caddr_t)&tp->t_rawq,
1374: TTIPRI | PCATCH,ttopen, 0);
1375: splx(s);
1376: if (error)
1377: goto out;
1378: goto loop;
1379: }
1380: }
1381: splx(s);
1382: /*
1383: * Hang the process if it's in the background.
1384: */
1385: if (isbackground(u.u_procp, tp) &&
1386: (tp->t_lflag&TOSTOP) && (u.u_procp->p_flag&SVFORK)==0 &&
1387: (u.u_procp->p_sigignore & sigmask(SIGTTOU)) == 0 &&
1388: (u.u_procp->p_sigmask & sigmask(SIGTTOU)) == 0 &&
1389: u.u_procp->p_pgrp->pg_jobc) {
1390: pgsignal(u.u_procp->p_pgrp, SIGTTOU, 1);
1391: if (error = ttysleep(tp, (caddr_t)&lbolt, TTIPRI | PCATCH,
1392: ttybg, 0))
1393: goto out;
1394: goto loop;
1395: }
1396: /*
1397: * Process the user's data in at most OBUFSIZ
1398: * chunks. Perform any output translation.
1399: * Keep track of high water mark, sleep on overflow
1400: * awaiting device aid in acquiring new space.
1401: */
1402: while (uio->uio_resid > 0 || cc > 0) {
1403: if (tp->t_lflag&FLUSHO) {
1404: uio->uio_resid = 0;
1405: return (0);
1406: }
1407: if (tp->t_outq.c_cc > hiwat)
1408: goto ovhiwat;
1409: /*
1410: * Grab a hunk of data from the user,
1411: * unless we have some leftover from last time.
1412: */
1413: if (cc == 0) {
1414: cc = min(uio->uio_resid, OBUFSIZ);
1415: cp = obuf;
1416: error = uiomove(cp, cc, uio);
1417: if (error) {
1418: cc = 0;
1419: break;
1420: }
1421: }
1422: /*
1423: * If nothing fancy need be done, grab those characters we
1424: * can handle without any of ttyoutput's processing and
1425: * just transfer them to the output q. For those chars
1426: * which require special processing (as indicated by the
1427: * bits in partab), call ttyoutput. After processing
1428: * a hunk of data, look for FLUSHO so ^O's will take effect
1429: * immediately.
1430: */
1431: while (cc > 0) {
1432: if ((tp->t_oflag&OPOST) == 0)
1433: ce = cc;
1434: else {
1435: ce = cc - scanc((unsigned)cc, (u_char *)cp,
1436: (u_char *)partab, 077);
1437: /*
1438: * If ce is zero, then we're processing
1439: * a special character through ttyoutput.
1440: */
1441: if (ce == 0) {
1442: tp->t_rocount = 0;
1443: if (ttyoutput(*cp, tp) >= 0) {
1444: /* no c-lists, wait a bit */
1445: ttstart(tp);
1446: if (error = ttysleep(tp,
1447: (caddr_t)&lbolt,
1448: TTOPRI | PCATCH, ttybuf, 0))
1449: break;
1450: goto loop;
1451: }
1452: cp++, cc--;
1453: if ((tp->t_lflag&FLUSHO) ||
1454: tp->t_outq.c_cc > hiwat)
1455: goto ovhiwat;
1456: continue;
1457: }
1458: }
1459: /*
1460: * A bunch of normal characters have been found,
1461: * transfer them en masse to the output queue and
1462: * continue processing at the top of the loop.
1463: * If there are any further characters in this
1464: * <= OBUFSIZ chunk, the first should be a character
1465: * requiring special handling by ttyoutput.
1466: */
1467: tp->t_rocount = 0;
1468: i = b_to_q(cp, ce, &tp->t_outq);
1469: ce -= i;
1470: tp->t_col += ce;
1471: cp += ce, cc -= ce, tk_nout += ce;
1472: tp->t_outcc += ce;
1473: if (i > 0) {
1474: /* out of c-lists, wait a bit */
1475: ttstart(tp);
1476: if (error = ttysleep(tp, (caddr_t)&lbolt,
1477: TTOPRI | PCATCH, ttybuf, 0))
1478: break;
1479: goto loop;
1480: }
1481: if (tp->t_lflag&FLUSHO || tp->t_outq.c_cc > hiwat)
1482: break;
1483: }
1484: ttstart(tp);
1485: }
1486: out:
1487: /*
1488: * If cc is nonzero, we leave the uio structure inconsistent,
1489: * as the offset and iov pointers have moved forward,
1490: * but it doesn't matter (the call will either return short
1491: * or restart with a new uio).
1492: */
1493: uio->uio_resid += cc;
1494: return (error);
1495:
1496: ovhiwat:
1497: ttstart(tp);
1498: s = spltty();
1499: /*
1500: * This can only occur if FLUSHO is set in t_lflag,
1501: * or if ttstart/oproc is synchronous (or very fast).
1502: */
1503: if (tp->t_outq.c_cc <= hiwat) {
1504: splx(s);
1505: goto loop;
1506: }
1507: if (flag & IO_NDELAY) {
1508: splx(s);
1509: uio->uio_resid += cc;
1510: if (uio->uio_resid == cnt)
1511: return (EWOULDBLOCK);
1512: return (0);
1513: }
1514: tp->t_state |= TS_ASLEEP;
1515: error = ttysleep(tp, (caddr_t)&tp->t_outq, TTOPRI | PCATCH, ttyout, 0);
1516: splx(s);
1517: if (error)
1518: goto out;
1519: goto loop;
1520: }
1521:
1522: /*
1523: * Rubout one character from the rawq of tp
1524: * as cleanly as possible.
1525: */
1526: ttyrub(c, tp)
1527: register c;
1528: register struct tty *tp;
1529: {
1530: register char *cp;
1531: register int savecol;
1532: int s;
1533: char *nextc();
1534:
1535: if ((tp->t_lflag&ECHO) == 0 || (tp->t_lflag&EXTPROC))
1536: return;
1537: tp->t_lflag &= ~FLUSHO;
1538: if (tp->t_lflag&ECHOE) {
1539: if (tp->t_rocount == 0) {
1540: /*
1541: * Screwed by ttwrite; retype
1542: */
1543: ttyretype(tp);
1544: return;
1545: }
1546: if (c == ('\t'|TTY_QUOTE) || c == ('\n'|TTY_QUOTE))
1547: ttyrubo(tp, 2);
1548: else switch (partab[c&=0377]&077) {
1549:
1550: case ORDINARY:
1551: ttyrubo(tp, 1);
1552: break;
1553:
1554: case VTAB:
1555: case BACKSPACE:
1556: case CONTROL:
1557: case RETURN:
1558: case NEWLINE: /* XXX can't happen ? */
1559: if (tp->t_lflag&ECHOCTL)
1560: ttyrubo(tp, 2);
1561: break;
1562:
1563: case TAB: {
1564: int c;
1565:
1566: if (tp->t_rocount < tp->t_rawq.c_cc) {
1567: ttyretype(tp);
1568: return;
1569: }
1570: s = spltty();
1571: savecol = tp->t_col;
1572: tp->t_state |= TS_CNTTB;
1573: tp->t_lflag |= FLUSHO;
1574: tp->t_col = tp->t_rocol;
1575: cp = tp->t_rawq.c_cf;
1576: if (cp)
1577: c = *cp; /* XXX FIX NEXTC */
1578: for (; cp; cp = nextc(&tp->t_rawq, cp, &c))
1579: ttyecho(c, tp);
1580: tp->t_lflag &= ~FLUSHO;
1581: tp->t_state &= ~TS_CNTTB;
1582: splx(s);
1583: /*
1584: * savecol will now be length of the tab
1585: */
1586: savecol -= tp->t_col;
1587: tp->t_col += savecol;
1588: if (savecol > 8)
1589: savecol = 8; /* overflow screw */
1590: while (--savecol >= 0)
1591: (void) ttyoutput('\b', tp);
1592: break;
1593: }
1594:
1595: default:
1596: /* XXX */
1597: printf("ttyrub: would panic c = %d, val = %d\n",
1598: c, partab[c&=0377]&077);
1599: /*panic("ttyrub");*/
1600: }
1601: } else if (tp->t_lflag&ECHOPRT) {
1602: if ((tp->t_state&TS_ERASE) == 0) {
1603: (void) ttyoutput('\\', tp);
1604: tp->t_state |= TS_ERASE;
1605: }
1606: ttyecho(c, tp);
1607: } else
1608: ttyecho(tp->t_cc[VERASE], tp);
1609: tp->t_rocount--;
1610: }
1611:
1612: /*
1613: * Crt back over cnt chars perhaps
1614: * erasing them.
1615: */
1616: ttyrubo(tp, cnt)
1617: register struct tty *tp;
1618: int cnt;
1619: {
1620:
1621: while (--cnt >= 0)
1622: ttyoutstr("\b \b", tp);
1623: }
1624:
1625: /*
1626: * Reprint the rawq line.
1627: * We assume c_cc has already been checked.
1628: */
1629: ttyretype(tp)
1630: register struct tty *tp;
1631: {
1632: register char *cp;
1633: char *nextc();
1634: int s, c;
1635:
1636: if (tp->t_cc[VREPRINT] != _POSIX_VDISABLE)
1637: ttyecho(tp->t_cc[VREPRINT], tp);
1638: (void) ttyoutput('\n', tp);
1639: s = spltty();
1640: /*** XXX *** FIX *** NEXTC IS BROKEN - DOESN'T CHECK QUOTE
1641: BIT OF FIRST CHAR ****/
1642: for (cp = tp->t_canq.c_cf, c=(cp?*cp:0); cp; cp = nextc(&tp->t_canq, cp, &c)) {
1643: ttyecho(c, tp);
1644: }
1645: for (cp = tp->t_rawq.c_cf, c=(cp?*cp:0); cp; cp = nextc(&tp->t_rawq, cp, &c)) {
1646: ttyecho(c, tp);
1647: }
1648: tp->t_state &= ~TS_ERASE;
1649: splx(s);
1650: tp->t_rocount = tp->t_rawq.c_cc;
1651: tp->t_rocol = 0;
1652: }
1653:
1654: /*
1655: * Echo a typed character to the terminal.
1656: */
1657: ttyecho(c, tp)
1658: register c;
1659: register struct tty *tp;
1660: {
1661: if ((tp->t_state&TS_CNTTB) == 0)
1662: tp->t_lflag &= ~FLUSHO;
1663: if (((tp->t_lflag&ECHO) == 0 && ((tp->t_lflag&ECHONL) == 0 ||
1664: c == '\n')) || (tp->t_lflag&EXTPROC))
1665: return;
1666: if (tp->t_lflag&ECHOCTL) {
1667: if ((c&TTY_CHARMASK) <= 037 && c != '\t' && c != '\n' ||
1668: c == 0177) {
1669: (void) ttyoutput('^', tp);
1670: c &= TTY_CHARMASK;
1671: if (c == 0177)
1672: c = '?';
1673: else
1674: c += 'A' - 1;
1675: }
1676: }
1677: (void) ttyoutput(c, tp);
1678: }
1679:
1680: /*
1681: * send string cp to tp
1682: */
1683: ttyoutstr(cp, tp)
1684: register char *cp;
1685: register struct tty *tp;
1686: {
1687: register char c;
1688:
1689: while (c = *cp++)
1690: (void) ttyoutput(c, tp);
1691: }
1692:
1693: ttwakeup(tp)
1694: struct tty *tp;
1695: {
1696:
1697: if (tp->t_rsel) {
1698: selwakeup(tp->t_rsel, tp->t_state&TS_RCOLL);
1699: tp->t_state &= ~TS_RCOLL;
1700: tp->t_rsel = 0;
1701: }
1702: if (tp->t_state & TS_ASYNC)
1703: pgsignal(tp->t_pgrp, SIGIO, 1);
1704: wakeup((caddr_t)&tp->t_rawq);
1705: }
1706:
1707: /*
1708: * set tty hi and low water marks
1709: *
1710: * Try to arrange the dynamics so there's about one second
1711: * from hi to low water.
1712: *
1713: */
1714: ttsetwater(tp)
1715: struct tty *tp;
1716: {
1717: register cps = tp->t_ospeed / 10;
1718: register x;
1719:
1720: #define clamp(x, h, l) ((x)>h ? h : ((x)<l) ? l : (x))
1721: tp->t_lowat = x = clamp(cps/2, TTMAXLOWAT, TTMINLOWAT);
1722: x += cps;
1723: x = clamp(x, TTMAXHIWAT, TTMINHIWAT);
1724: tp->t_hiwat = roundup(x, CBSIZE);
1725: #undef clamp
1726: }
1727:
1728: ttspeedtab(speed, table)
1729: struct speedtab table[];
1730: {
1731: register int i;
1732:
1733: for (i = 0; table[i].sp_speed != -1; i++)
1734: if (table[i].sp_speed == speed)
1735: return(table[i].sp_code);
1736: return(-1);
1737: }
1738:
1739: int ttyhostname = 0;
1740: /*
1741: * (^T)
1742: * Report on state of foreground process group.
1743: */
1744: ttyinfo(tp)
1745: struct tty *tp;
1746: {
1747: register struct proc *p, *pick = NULL;
1748: register char *cp = hostname;
1749: int x, s;
1750: struct timeval utime, stime;
1751: #define pgtok(a) (((a)*NBPG)/1024)
1752:
1753: if (ttycheckoutq(tp,0) == 0)
1754: return;
1755: /*
1756: * hostname
1757: */
1758: if (ttyhostname) {
1759: if (*cp == '\0')
1760: ttyprintf(tp, "amnesia");
1761: else
1762: while (*cp && *cp != '.')
1763: tputchar(*cp++, tp);
1764: tputchar(' ');
1765: }
1766: /*
1767: * load average
1768: */
1769: x = (averunnable[0] * 100 + FSCALE/2) >> FSHIFT;
1770: ttyprintf(tp, "load: %d.", x/100);
1771: ttyoutint(x%100, 10, 2, tp);
1772: if (tp->t_session == NULL)
1773: ttyprintf(tp, " not a controlling terminal\n");
1774: else if (tp->t_pgrp == NULL)
1775: ttyprintf(tp, " no foreground process group\n");
1776: else if ((p = tp->t_pgrp->pg_mem) == NULL)
1777: ttyprintf(tp, " empty foreground process group\n");
1778: else {
1779: /* pick interesting process */
1780: for (; p != NULL; p = p->p_pgrpnxt) {
1781: if (proc_compare(pick, p))
1782: pick = p;
1783: }
1784: ttyprintf(tp, " cmd: %s %d [%s] ",
1785: pick->p_comm, pick->p_pid,
1786: pick->p_wmesg ? pick->p_wmesg : "running");
1787: /*
1788: * cpu time
1789: */
1790: if (u.u_procp == pick)
1791: s = splclock();
1792: utime = pick->p_utime;
1793: stime = pick->p_stime;
1794: if (u.u_procp == pick)
1795: splx(s);
1796: /* user time */
1797: x = (utime.tv_usec + 5000) / 10000; /* scale to 100's */
1798: ttyoutint(utime.tv_sec, 10, 1, tp);
1799: tputchar('.', tp);
1800: ttyoutint(x, 10, 2, tp);
1801: tputchar('u', tp);
1802: tputchar(' ', tp);
1803: /* system time */
1804: x = (stime.tv_usec + 5000) / 10000; /* scale to 100's */
1805: ttyoutint(stime.tv_sec, 10, 1, tp);
1806: tputchar('.', tp);
1807: ttyoutint(x, 10, 2, tp);
1808: tputchar('s', tp);
1809: tputchar(' ', tp);
1810: /*
1811: * pctcpu
1812: */
1813: x = pick->p_pctcpu * 10000 + FSCALE/2 >> FSHIFT;
1814: ttyoutint(x/100, 10, 1, tp);
1815: #ifdef notdef /* do we really want this ??? */
1816: tputchar('.', tp);
1817: ttyoutint(x%100, 10, 2, tp);
1818: #endif
1819: ttyprintf(tp, "%% %dk\n", pgtok(pick->p_ssize + pick->p_dsize));
1820: }
1821: tp->t_rocount = 0; /* so pending input will be retyped if BS */
1822: }
1823:
1824: ttyoutint(n, base, min, tp)
1825: register int n, base, min;
1826: register struct tty *tp;
1827: {
1828: char info[16];
1829: register char *p = info;
1830:
1831: while (--min >= 0 || n) {
1832: *p++ = "0123456789abcdef"[n%base];
1833: n /= base;
1834: }
1835: while (p > info)
1836: ttyoutput(*--p, tp);
1837: }
1838:
1839: /*
1840: * Returns 1 if p2 is "better" than p1
1841: *
1842: * The algorithm for picking the "interesting" process is thus:
1843: *
1844: * 1) (Only foreground processes are eligable - implied)
1845: * 2) Runnable processes are favored over anything
1846: * else. The runner with the highest cpu
1847: * utilization is picked (p_cpu). Ties are
1848: * broken by picking the highest pid.
1849: * 3 Next, the sleeper with the shortest sleep
1850: * time is favored. With ties, we pick out
1851: * just "short-term" sleepers (SSINTR == 0).
1852: * Further ties are broken by picking the highest
1853: * pid.
1854: *
1855: */
1856: #define isrun(p) (((p)->p_stat == SRUN) || ((p)->p_stat == SIDL))
1857: proc_compare(p1, p2)
1858: register struct proc *p1, *p2;
1859: {
1860:
1861: if (p1 == NULL)
1862: return (1);
1863: /*
1864: * see if at least one of them is runnable
1865: */
1866: switch (isrun(p1)<<1 | isrun(p2)) {
1867: case 0x01:
1868: return (1);
1869: case 0x10:
1870: return (0);
1871: case 0x11:
1872: /*
1873: * tie - favor one with highest recent cpu utilization
1874: */
1875: if (p2->p_cpu > p1->p_cpu)
1876: return (1);
1877: if (p1->p_cpu > p2->p_cpu)
1878: return (0);
1879: return (p2->p_pid > p1->p_pid); /* tie - return highest pid */
1880: }
1881: /*
1882: * pick the one with the smallest sleep time
1883: */
1884: if (p2->p_slptime > p1->p_slptime)
1885: return (0);
1886: if (p1->p_slptime > p2->p_slptime)
1887: return (1);
1888: /*
1889: * favor one sleeping in a non-interruptible sleep
1890: */
1891: if (p1->p_flag&SSINTR && (p2->p_flag&SSINTR) == 0)
1892: return (1);
1893: if (p2->p_flag&SSINTR && (p1->p_flag&SSINTR) == 0)
1894: return (0);
1895: return(p2->p_pid > p1->p_pid); /* tie - return highest pid */
1896: }
1897: #define TOTTY 0x2 /* XXX should be in header */
1898: /*VARARGS2*/
1899: ttyprintf(tp, fmt, x1)
1900: struct tty *tp;
1901: char *fmt;
1902: unsigned x1;
1903: {
1904: prf(fmt, &x1, TOTTY, (caddr_t)tp);
1905: }
1906:
1907: /*
1908: * Output char to tty; console putchar style.
1909: */
1910: tputchar(c, tp)
1911: int c;
1912: struct tty *tp;
1913: {
1914: register s = spltty();
1915:
1916: if ((tp->t_state & (TS_CARR_ON | TS_ISOPEN))
1917: == (TS_CARR_ON | TS_ISOPEN)) {
1918: if (c == '\n')
1919: (void) ttyoutput('\r', tp);
1920: (void) ttyoutput(c, tp);
1921: ttstart(tp);
1922: splx(s);
1923: return (0);
1924: }
1925: splx(s);
1926: return (-1);
1927: }
1928:
1929: /*
1930: * Sleep on chan.
1931: *
1932: * Return ERESTART if tty changed while we napped.
1933: */
1934: ttysleep(tp, chan, pri, wmesg, timo)
1935: struct tty *tp;
1936: caddr_t chan;
1937: int pri;
1938: char *wmesg;
1939: int timo;
1940: {
1941: int error;
1942: short gen = tp->t_gen;
1943:
1944: if (error = tsleep(chan, pri, wmesg, timo))
1945: return (error);
1946: if (tp->t_gen != gen)
1947: return (ERESTART);
1948: return (0);
1949: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.