Annotation of src/sys/kern/tty.c, Revision 1.119
1.119 ! thorpej 1: /* $NetBSD: tty.c,v 1.118 2000/03/30 09:27:13 augustss Exp $ */
1.49 cgd 2:
3: /*-
4: * Copyright (c) 1982, 1986, 1990, 1991, 1993
5: * The Regents of the University of California. All rights reserved.
6: * (c) UNIX System Laboratories, Inc.
7: * All or some portions of this file are derived from material licensed
8: * to the University of California by American Telephone and Telegraph
9: * Co. or Unix System Laboratories, Inc. and are reproduced herein with
10: * the permission of UNIX System Laboratories, Inc.
11: *
12: * Redistribution and use in source and binary forms, with or without
13: * modification, are permitted provided that the following conditions
14: * are met:
15: * 1. Redistributions of source code must retain the above copyright
16: * notice, this list of conditions and the following disclaimer.
17: * 2. Redistributions in binary form must reproduce the above copyright
18: * notice, this list of conditions and the following disclaimer in the
19: * documentation and/or other materials provided with the distribution.
20: * 3. All advertising materials mentioning features or use of this software
21: * must display the following acknowledgement:
22: * This product includes software developed by the University of
23: * California, Berkeley and its contributors.
24: * 4. Neither the name of the University nor the names of its contributors
25: * may be used to endorse or promote products derived from this software
26: * without specific prior written permission.
27: *
28: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
29: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
30: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
31: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
32: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
33: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
34: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
35: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
36: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
37: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
38: * SUCH DAMAGE.
39: *
1.105 fvdl 40: * @(#)tty.c 8.13 (Berkeley) 1/9/95
1.49 cgd 41: */
1.100 thorpej 42:
43: #include "opt_uconsole.h"
1.49 cgd 44:
45: #include <sys/param.h>
46: #include <sys/systm.h>
47: #include <sys/ioctl.h>
48: #include <sys/proc.h>
49: #define TTYDEFCHARS
50: #include <sys/tty.h>
51: #undef TTYDEFCHARS
52: #include <sys/file.h>
53: #include <sys/conf.h>
54: #include <sys/dkstat.h>
55: #include <sys/uio.h>
56: #include <sys/kernel.h>
57: #include <sys/vnode.h>
58: #include <sys/syslog.h>
59: #include <sys/malloc.h>
1.111 thorpej 60: #include <sys/pool.h>
1.65 christos 61: #include <sys/signalvar.h>
62: #include <sys/resourcevar.h>
1.74 mycroft 63: #include <sys/poll.h>
1.49 cgd 64:
65: #include <vm/vm.h>
66:
1.65 christos 67: static int ttnread __P((struct tty *));
68: static void ttyblock __P((struct tty *));
69: static void ttyecho __P((int, struct tty *));
70: static void ttyrubo __P((struct tty *, int));
71: static int proc_compare __P((struct proc *, struct proc *));
1.49 cgd 72:
73: /* Symbolic sleep message strings. */
1.98 mycroft 74: const char ttclos[] = "ttycls";
75: const char ttopen[] = "ttyopn";
76: const char ttybg[] = "ttybg";
77: const char ttyin[] = "ttyin";
78: const char ttyout[] = "ttyout";
1.49 cgd 79:
80: /*
1.83 mycroft 81: * Used to determine whether we still have a connection. This is true in
82: * one of 3 cases:
83: * 1) We have carrier.
84: * 2) It's a locally attached terminal, and we are therefore ignoring carrier.
85: * 3) We're using a flow control mechanism that overloads the carrier signal.
86: */
87: #define CONNECTED(tp) (ISSET(tp->t_state, TS_CARR_ON) || \
88: ISSET(tp->t_cflag, CLOCAL | MDMBUF))
89:
90: /*
1.49 cgd 91: * Table with character classes and parity. The 8th bit indicates parity,
92: * the 7th bit indicates the character is an alphameric or underscore (for
93: * ALTWERASE), and the low 6 bits indicate delay type. If the low 6 bits
94: * are 0 then the character needs no special processing on output; classes
95: * other than 0 might be translated or (not currently) require delays.
96: */
97: #define E 0x00 /* Even parity. */
98: #define O 0x80 /* Odd parity. */
99: #define PARITY(c) (char_type[c] & O)
100:
101: #define ALPHA 0x40 /* Alpha or underscore. */
102: #define ISALPHA(c) (char_type[(c) & TTY_CHARMASK] & ALPHA)
103:
104: #define CCLASSMASK 0x3f
105: #define CCLASS(c) (char_type[c] & CCLASSMASK)
106:
107: #define BS BACKSPACE
108: #define CC CONTROL
109: #define CR RETURN
110: #define NA ORDINARY | ALPHA
111: #define NL NEWLINE
112: #define NO ORDINARY
113: #define TB TAB
114: #define VT VTAB
115:
116: char const char_type[] = {
117: E|CC, O|CC, O|CC, E|CC, O|CC, E|CC, E|CC, O|CC, /* nul - bel */
118: O|BS, E|TB, E|NL, O|CC, E|VT, O|CR, O|CC, E|CC, /* bs - si */
119: O|CC, E|CC, E|CC, O|CC, E|CC, O|CC, O|CC, E|CC, /* dle - etb */
120: E|CC, O|CC, O|CC, E|CC, O|CC, E|CC, E|CC, O|CC, /* can - us */
121: O|NO, E|NO, E|NO, O|NO, E|NO, O|NO, O|NO, E|NO, /* sp - ' */
122: E|NO, O|NO, O|NO, E|NO, O|NO, E|NO, E|NO, O|NO, /* ( - / */
123: E|NA, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* 0 - 7 */
124: O|NA, E|NA, E|NO, O|NO, E|NO, O|NO, O|NO, E|NO, /* 8 - ? */
125: O|NO, E|NA, E|NA, O|NA, E|NA, O|NA, O|NA, E|NA, /* @ - G */
126: E|NA, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* H - O */
127: E|NA, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* P - W */
128: O|NA, E|NA, E|NA, O|NO, E|NO, O|NO, O|NO, O|NA, /* X - _ */
129: E|NO, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* ` - g */
130: O|NA, E|NA, E|NA, O|NA, E|NA, O|NA, O|NA, E|NA, /* h - o */
131: O|NA, E|NA, E|NA, O|NA, E|NA, O|NA, O|NA, E|NA, /* p - w */
132: E|NA, O|NA, O|NA, E|NO, O|NO, E|NO, E|NO, O|CC, /* x - del */
133: /*
134: * Meta chars; should be settable per character set;
135: * for now, treat them all as normal characters.
136: */
137: NA, NA, NA, NA, NA, NA, NA, NA,
138: NA, NA, NA, NA, NA, NA, NA, NA,
139: NA, NA, NA, NA, NA, NA, NA, NA,
140: NA, NA, NA, NA, NA, NA, NA, NA,
141: NA, NA, NA, NA, NA, NA, NA, NA,
142: NA, NA, NA, NA, NA, NA, NA, NA,
143: NA, NA, NA, NA, NA, NA, NA, NA,
144: NA, NA, NA, NA, NA, NA, NA, NA,
145: NA, NA, NA, NA, NA, NA, NA, NA,
146: NA, NA, NA, NA, NA, NA, NA, NA,
147: NA, NA, NA, NA, NA, NA, NA, NA,
148: NA, NA, NA, NA, NA, NA, NA, NA,
149: NA, NA, NA, NA, NA, NA, NA, NA,
150: NA, NA, NA, NA, NA, NA, NA, NA,
151: NA, NA, NA, NA, NA, NA, NA, NA,
152: NA, NA, NA, NA, NA, NA, NA, NA,
153: };
154: #undef BS
155: #undef CC
156: #undef CR
157: #undef NA
158: #undef NL
159: #undef NO
160: #undef TB
161: #undef VT
162:
163: /* Macros to clear/set/test flags. */
164: #define SET(t, f) (t) |= (f)
1.65 christos 165: #define CLR(t, f) (t) &= ~((unsigned)(f))
1.49 cgd 166: #define ISSET(t, f) ((t) & (f))
167:
1.69 mrg 168: struct ttylist_head ttylist; /* TAILQ_HEAD */
169: int tty_count;
170:
1.111 thorpej 171: struct pool tty_pool;
172:
1.107 mycroft 173: int
174: ttyopen(tp, dialout, nonblock)
175: struct tty *tp;
176: int dialout, nonblock;
177: {
178: int s;
179: int error;
180:
181: s = spltty();
182:
183: if (dialout) {
184: /*
185: * If the device is already open for non-dialout, fail.
186: * Otherwise, set TS_DIALOUT to block any pending non-dialout
187: * opens.
188: */
189: if (ISSET(tp->t_state, TS_ISOPEN) &&
190: !ISSET(tp->t_state, TS_DIALOUT)) {
191: splx(s);
192: return (EBUSY);
193: }
194: SET(tp->t_state, TS_DIALOUT);
195: } else {
196: if (!nonblock) {
197: /*
198: * Wait for carrier. Also wait for any dialout
199: * processes to close the tty first.
200: */
201: while (ISSET(tp->t_state, TS_DIALOUT) ||
202: (!ISSET(tp->t_state, TS_CARR_ON) &&
203: !ISSET(tp->t_cflag, CLOCAL | MDMBUF))) {
204: tp->t_wopen++;
205: error = ttysleep(tp, &tp->t_rawq,
206: TTIPRI | PCATCH, ttopen, 0);
207: tp->t_wopen--;
208: if (error) {
209: splx(s);
210: return (error);
211: }
212: }
213: } else {
214: /*
215: * Don't allow a non-blocking non-dialout open if the
216: * device is already open for dialout.
217: */
218: if (ISSET(tp->t_state, TS_DIALOUT)) {
219: splx(s);
220: return (EBUSY);
221: }
222: }
223: }
224:
225: splx(s);
226: return (0);
227: }
228:
1.49 cgd 229: /*
230: * Initial open of tty, or (re)entry to standard tty line discipline.
231: */
232: int
1.107 mycroft 233: ttylopen(device, tp)
1.49 cgd 234: dev_t device;
1.118 augustss 235: struct tty *tp;
1.49 cgd 236: {
237: int s;
238:
239: s = spltty();
240: tp->t_dev = device;
241: if (!ISSET(tp->t_state, TS_ISOPEN)) {
242: SET(tp->t_state, TS_ISOPEN);
1.109 perry 243: memset(&tp->t_winsize, 0, sizeof(tp->t_winsize));
1.66 christos 244: #ifdef COMPAT_OLDTTY
1.50 mycroft 245: tp->t_flags = 0;
246: #endif
1.49 cgd 247: }
248: splx(s);
249: return (0);
250: }
251:
252: /*
253: * Handle close() on a tty line: flush and set to initial state,
254: * bumping generation number so that pending read/write calls
255: * can detect recycling of the tty.
256: */
257: int
258: ttyclose(tp)
1.118 augustss 259: struct tty *tp;
1.49 cgd 260: {
261: extern struct tty *constty; /* Temporary virtual console. */
262:
263: if (constty == tp)
264: constty = NULL;
265:
266: ttyflush(tp, FREAD | FWRITE);
267:
268: tp->t_gen++;
269: tp->t_pgrp = NULL;
270: tp->t_session = NULL;
271: tp->t_state = 0;
272: return (0);
273: }
274:
275: #define FLUSHQ(q) { \
276: if ((q)->c_cc) \
277: ndflush(q, (q)->c_cc); \
278: }
279:
1.88 kleink 280: /*
281: * This macro is used in canonical mode input processing, where a read
282: * request shall not return unless a 'line delimiter' ('\n') or 'break'
283: * (EOF, EOL, EOL2) character (or a signal) has been received. As EOL2
284: * is an extension to the POSIX.1 defined set of special characters,
285: * recognize it only if IEXTEN is set in the set of local flags.
286: */
1.85 kleink 287: #define TTBREAKC(c, lflg) \
1.87 cgd 288: ((c) == '\n' || (((c) == cc[VEOF] || (c) == cc[VEOL] || \
1.85 kleink 289: ((c) == cc[VEOL2] && ISSET(lflg, IEXTEN))) && (c) != _POSIX_VDISABLE))
1.49 cgd 290:
291:
292: /*
293: * Process input of a single character received on a tty.
294: */
295: int
296: ttyinput(c, tp)
1.118 augustss 297: int c;
298: struct tty *tp;
1.49 cgd 299: {
1.118 augustss 300: int iflag, lflag;
301: u_char *cc;
1.65 christos 302: int i, error;
1.78 christos 303:
304: /*
305: * Unless the receiver is enabled, drop incoming data.
306: */
307: if (!ISSET(tp->t_cflag, CREAD))
308: return (0);
1.49 cgd 309:
310: /*
311: * If input is pending take it first.
312: */
313: lflag = tp->t_lflag;
314: if (ISSET(lflag, PENDIN))
315: ttypend(tp);
316: /*
317: * Gather stats.
318: */
319: if (ISSET(lflag, ICANON)) {
320: ++tk_cancc;
321: ++tp->t_cancc;
322: } else {
323: ++tk_rawcc;
324: ++tp->t_rawcc;
325: }
326: ++tk_nin;
327:
328: cc = tp->t_cc;
1.94 kleink 329:
330: /*
331: * Handle exceptional conditions (break, parity, framing).
332: */
1.49 cgd 333: iflag = tp->t_iflag;
1.65 christos 334: if ((error = (ISSET(c, TTY_ERRORMASK))) != 0) {
1.49 cgd 335: CLR(c, TTY_ERRORMASK);
1.94 kleink 336: if (ISSET(error, TTY_FE) && c == 0) { /* Break. */
1.49 cgd 337: if (ISSET(iflag, IGNBRK))
1.94 kleink 338: return (0);
339: else if (ISSET(iflag, BRKINT)) {
340: ttyflush(tp, FREAD | FWRITE);
341: pgsignal(tp->t_pgrp, SIGINT, 1);
342: return (0);
343: }
1.49 cgd 344: else if (ISSET(iflag, PARMRK))
345: goto parmrk;
1.94 kleink 346: }
347: else if ((ISSET(error, TTY_PE) && ISSET(iflag, INPCK)) ||
348: ISSET(error, TTY_FE)) {
1.49 cgd 349: if (ISSET(iflag, IGNPAR))
1.94 kleink 350: return (0);
1.49 cgd 351: else if (ISSET(iflag, PARMRK)) {
352: parmrk: (void)putc(0377 | TTY_QUOTE, &tp->t_rawq);
1.94 kleink 353: (void)putc(0 | TTY_QUOTE, &tp->t_rawq);
354: (void)putc(c | TTY_QUOTE, &tp->t_rawq);
355: return (0);
356: }
357: else
1.49 cgd 358: c = 0;
359: }
360: }
1.94 kleink 361: else if (c == 0377 &&
362: ISSET(iflag, ISTRIP|IGNPAR|INPCK|PARMRK) == (INPCK|PARMRK)) {
363: /* "Escape" a valid character of '\377'. */
364: (void)putc(0377 | TTY_QUOTE, &tp->t_rawq);
365: (void)putc(0377 | TTY_QUOTE, &tp->t_rawq);
366: goto endcase;
367: }
368:
1.49 cgd 369: /*
370: * In tandem mode, check high water mark.
371: */
372: if (ISSET(iflag, IXOFF) || ISSET(tp->t_cflag, CHWFLOW))
373: ttyblock(tp);
374: if (!ISSET(tp->t_state, TS_TYPEN) && ISSET(iflag, ISTRIP))
375: CLR(c, 0x80);
376: if (!ISSET(lflag, EXTPROC)) {
377: /*
378: * Check for literal nexting very first
379: */
380: if (ISSET(tp->t_state, TS_LNCH)) {
381: SET(c, TTY_QUOTE);
382: CLR(tp->t_state, TS_LNCH);
383: }
384: /*
385: * Scan for special characters. This code
386: * is really just a big case statement with
387: * non-constant cases. The bottom of the
388: * case statement is labeled ``endcase'', so goto
389: * it after a case match, or similar.
390: */
391:
392: /*
393: * Control chars which aren't controlled
394: * by ICANON, ISIG, or IXON.
395: */
396: if (ISSET(lflag, IEXTEN)) {
397: if (CCEQ(cc[VLNEXT], c)) {
398: if (ISSET(lflag, ECHO)) {
399: if (ISSET(lflag, ECHOE)) {
400: (void)ttyoutput('^', tp);
401: (void)ttyoutput('\b', tp);
402: } else
403: ttyecho(c, tp);
404: }
405: SET(tp->t_state, TS_LNCH);
406: goto endcase;
407: }
408: if (CCEQ(cc[VDISCARD], c)) {
409: if (ISSET(lflag, FLUSHO))
410: CLR(tp->t_lflag, FLUSHO);
411: else {
412: ttyflush(tp, FWRITE);
413: ttyecho(c, tp);
414: if (tp->t_rawq.c_cc + tp->t_canq.c_cc)
415: ttyretype(tp);
416: SET(tp->t_lflag, FLUSHO);
417: }
418: goto startoutput;
419: }
420: }
421: /*
422: * Signals.
423: */
424: if (ISSET(lflag, ISIG)) {
425: if (CCEQ(cc[VINTR], c) || CCEQ(cc[VQUIT], c)) {
426: if (!ISSET(lflag, NOFLSH))
427: ttyflush(tp, FREAD | FWRITE);
428: ttyecho(c, tp);
429: pgsignal(tp->t_pgrp,
430: CCEQ(cc[VINTR], c) ? SIGINT : SIGQUIT, 1);
431: goto endcase;
432: }
433: if (CCEQ(cc[VSUSP], c)) {
434: if (!ISSET(lflag, NOFLSH))
435: ttyflush(tp, FREAD);
436: ttyecho(c, tp);
437: pgsignal(tp->t_pgrp, SIGTSTP, 1);
438: goto endcase;
439: }
440: }
441: /*
442: * Handle start/stop characters.
443: */
444: if (ISSET(iflag, IXON)) {
445: if (CCEQ(cc[VSTOP], c)) {
446: if (!ISSET(tp->t_state, TS_TTSTOP)) {
447: SET(tp->t_state, TS_TTSTOP);
448: (*cdevsw[major(tp->t_dev)].d_stop)(tp,
449: 0);
450: return (0);
451: }
452: if (!CCEQ(cc[VSTART], c))
453: return (0);
454: /*
455: * if VSTART == VSTOP then toggle
456: */
457: goto endcase;
458: }
459: if (CCEQ(cc[VSTART], c))
460: goto restartoutput;
461: }
462: /*
463: * IGNCR, ICRNL, & INLCR
464: */
465: if (c == '\r') {
466: if (ISSET(iflag, IGNCR))
467: goto endcase;
468: else if (ISSET(iflag, ICRNL))
469: c = '\n';
470: } else if (c == '\n' && ISSET(iflag, INLCR))
471: c = '\r';
472: }
473: if (!ISSET(tp->t_lflag, EXTPROC) && ISSET(lflag, ICANON)) {
474: /*
475: * From here on down canonical mode character
476: * processing takes place.
477: */
478: /*
479: * erase (^H / ^?)
480: */
481: if (CCEQ(cc[VERASE], c)) {
482: if (tp->t_rawq.c_cc)
483: ttyrub(unputc(&tp->t_rawq), tp);
484: goto endcase;
485: }
486: /*
487: * kill (^U)
488: */
489: if (CCEQ(cc[VKILL], c)) {
490: if (ISSET(lflag, ECHOKE) &&
491: tp->t_rawq.c_cc == tp->t_rocount &&
492: !ISSET(lflag, ECHOPRT))
493: while (tp->t_rawq.c_cc)
494: ttyrub(unputc(&tp->t_rawq), tp);
495: else {
496: ttyecho(c, tp);
497: if (ISSET(lflag, ECHOK) ||
498: ISSET(lflag, ECHOKE))
499: ttyecho('\n', tp);
500: FLUSHQ(&tp->t_rawq);
501: tp->t_rocount = 0;
502: }
503: CLR(tp->t_state, TS_LOCAL);
504: goto endcase;
505: }
506: /*
1.81 kleink 507: * Extensions to the POSIX.1 GTI set of functions.
1.49 cgd 508: */
1.81 kleink 509: if (ISSET(lflag, IEXTEN)) {
1.49 cgd 510: /*
1.81 kleink 511: * word erase (^W)
1.49 cgd 512: */
1.81 kleink 513: if (CCEQ(cc[VWERASE], c)) {
514: int alt = ISSET(lflag, ALTWERASE);
515: int ctype;
516:
517: /*
518: * erase whitespace
519: */
520: while ((c = unputc(&tp->t_rawq)) == ' ' ||
521: c == '\t')
522: ttyrub(c, tp);
523: if (c == -1)
524: goto endcase;
525: /*
526: * erase last char of word and remember the
527: * next chars type (for ALTWERASE)
528: */
1.49 cgd 529: ttyrub(c, tp);
1.81 kleink 530: c = unputc(&tp->t_rawq);
531: if (c == -1)
532: goto endcase;
533: if (c == ' ' || c == '\t') {
534: (void)putc(c, &tp->t_rawq);
535: goto endcase;
536: }
537: ctype = ISALPHA(c);
538: /*
539: * erase rest of word
540: */
541: do {
542: ttyrub(c, tp);
543: c = unputc(&tp->t_rawq);
544: if (c == -1)
545: goto endcase;
546: } while (c != ' ' && c != '\t' &&
547: (alt == 0 || ISALPHA(c) == ctype));
548: (void)putc(c, &tp->t_rawq);
1.49 cgd 549: goto endcase;
1.81 kleink 550: }
1.49 cgd 551: /*
1.81 kleink 552: * reprint line (^R)
1.49 cgd 553: */
1.81 kleink 554: if (CCEQ(cc[VREPRINT], c)) {
555: ttyretype(tp);
1.49 cgd 556: goto endcase;
557: }
558: /*
1.81 kleink 559: * ^T - kernel info and generate SIGINFO
1.49 cgd 560: */
1.81 kleink 561: if (CCEQ(cc[VSTATUS], c)) {
562: if (ISSET(lflag, ISIG))
563: pgsignal(tp->t_pgrp, SIGINFO, 1);
564: if (!ISSET(lflag, NOKERNINFO))
565: ttyinfo(tp);
566: goto endcase;
567: }
1.49 cgd 568: }
569: }
570: /*
571: * Check for input buffer overflow
572: */
573: if (tp->t_rawq.c_cc + tp->t_canq.c_cc >= TTYHOG) {
574: if (ISSET(iflag, IMAXBEL)) {
575: if (tp->t_outq.c_cc < tp->t_hiwat)
576: (void)ttyoutput(CTRL('g'), tp);
577: } else
578: ttyflush(tp, FREAD | FWRITE);
579: goto endcase;
580: }
581: /*
582: * Put data char in q for user and
583: * wakeup on seeing a line delimiter.
584: */
585: if (putc(c, &tp->t_rawq) >= 0) {
586: if (!ISSET(lflag, ICANON)) {
587: ttwakeup(tp);
588: ttyecho(c, tp);
589: goto endcase;
590: }
1.85 kleink 591: if (TTBREAKC(c, lflag)) {
1.49 cgd 592: tp->t_rocount = 0;
593: catq(&tp->t_rawq, &tp->t_canq);
594: ttwakeup(tp);
595: } else if (tp->t_rocount++ == 0)
596: tp->t_rocol = tp->t_column;
597: if (ISSET(tp->t_state, TS_ERASE)) {
598: /*
599: * end of prterase \.../
600: */
601: CLR(tp->t_state, TS_ERASE);
602: (void)ttyoutput('/', tp);
603: }
604: i = tp->t_column;
605: ttyecho(c, tp);
606: if (CCEQ(cc[VEOF], c) && ISSET(lflag, ECHO)) {
607: /*
608: * Place the cursor over the '^' of the ^D.
609: */
610: i = min(2, tp->t_column - i);
611: while (i > 0) {
612: (void)ttyoutput('\b', tp);
613: i--;
614: }
615: }
616: }
617: endcase:
618: /*
619: * IXANY means allow any character to restart output.
620: */
621: if (ISSET(tp->t_state, TS_TTSTOP) &&
622: !ISSET(iflag, IXANY) && cc[VSTART] != cc[VSTOP])
623: return (0);
624: restartoutput:
625: CLR(tp->t_lflag, FLUSHO);
626: CLR(tp->t_state, TS_TTSTOP);
627: startoutput:
628: return (ttstart(tp));
629: }
630:
631: /*
632: * Output a single character on a tty, doing output processing
633: * as needed (expanding tabs, newline processing, etc.).
634: * Returns < 0 if succeeds, otherwise returns char to resend.
635: * Must be recursive.
636: */
637: int
638: ttyoutput(c, tp)
1.118 augustss 639: int c;
640: struct tty *tp;
1.49 cgd 641: {
1.118 augustss 642: long oflag;
643: int col, notout, s;
1.49 cgd 644:
645: oflag = tp->t_oflag;
646: if (!ISSET(oflag, OPOST)) {
647: tk_nout++;
648: tp->t_outcc++;
1.99 mycroft 649: if (!ISSET(tp->t_lflag, FLUSHO) && putc(c, &tp->t_outq))
650: return (c);
1.49 cgd 651: return (-1);
652: }
653: /*
1.103 kleink 654: * Do tab expansion if OXTABS is set. Special case if we do external
1.49 cgd 655: * processing, we don't do the tab expansion because we'll probably
656: * get it wrong. If tab expansion needs to be done, let it happen
657: * externally.
658: */
659: CLR(c, ~TTY_CHARMASK);
660: if (c == '\t' &&
661: ISSET(oflag, OXTABS) && !ISSET(tp->t_lflag, EXTPROC)) {
662: c = 8 - (tp->t_column & 7);
663: if (ISSET(tp->t_lflag, FLUSHO)) {
664: notout = 0;
665: } else {
666: s = spltty(); /* Don't interrupt tabs. */
667: notout = b_to_q(" ", c, &tp->t_outq);
668: c -= notout;
669: tk_nout += c;
670: tp->t_outcc += c;
671: splx(s);
672: }
673: tp->t_column += c;
674: return (notout ? '\t' : -1);
675: }
676: if (c == CEOT && ISSET(oflag, ONOEOT))
677: return (-1);
678:
679: /*
680: * Newline translation: if ONLCR is set,
681: * translate newline into "\r\n".
682: */
683: if (c == '\n' && ISSET(tp->t_oflag, ONLCR)) {
684: tk_nout++;
685: tp->t_outcc++;
1.99 mycroft 686: if (!ISSET(tp->t_lflag, FLUSHO) && putc('\r', &tp->t_outq))
1.49 cgd 687: return (c);
688: }
1.103 kleink 689: /* If OCRNL is set, translate "\r" into "\n". */
1.79 kleink 690: else if (c == '\r' && ISSET(tp->t_oflag, OCRNL))
691: c = '\n';
1.103 kleink 692: /* If ONOCR is set, don't transmit CRs when on column 0. */
693: else if (c == '\r' && ISSET(tp->t_oflag, ONOCR) && tp->t_column == 0)
694: return (-1);
1.79 kleink 695:
1.49 cgd 696: tk_nout++;
697: tp->t_outcc++;
698: if (!ISSET(tp->t_lflag, FLUSHO) && putc(c, &tp->t_outq))
699: return (c);
700:
701: col = tp->t_column;
702: switch (CCLASS(c)) {
703: case BACKSPACE:
704: if (col > 0)
705: --col;
706: break;
707: case CONTROL:
708: break;
709: case NEWLINE:
1.103 kleink 710: if (ISSET(tp->t_oflag, ONLCR | ONLRET))
1.79 kleink 711: col = 0;
712: break;
1.49 cgd 713: case RETURN:
714: col = 0;
715: break;
716: case ORDINARY:
717: ++col;
718: break;
719: case TAB:
720: col = (col + 8) & ~7;
721: break;
722: }
723: tp->t_column = col;
724: return (-1);
725: }
726:
727: /*
728: * Ioctls for all tty devices. Called after line-discipline specific ioctl
729: * has been called to do discipline-specific functions and/or reject any
730: * of these ioctl commands.
731: */
732: /* ARGSUSED */
733: int
734: ttioctl(tp, cmd, data, flag, p)
1.118 augustss 735: struct tty *tp;
1.55 cgd 736: u_long cmd;
1.56 mycroft 737: caddr_t data;
1.55 cgd 738: int flag;
1.49 cgd 739: struct proc *p;
740: {
741: extern struct tty *constty; /* Temporary virtual console. */
742: extern int nlinesw;
743: int s, error;
744:
745: /* If the ioctl involves modification, hang if in the background. */
746: switch (cmd) {
747: case TIOCFLUSH:
1.92 kleink 748: case TIOCDRAIN:
1.95 kleink 749: case TIOCSBRK:
750: case TIOCCBRK:
751: case TIOCSTART:
1.49 cgd 752: case TIOCSETA:
753: case TIOCSETD:
754: case TIOCSETAF:
755: case TIOCSETAW:
756: #ifdef notdef
757: case TIOCSPGRP:
758: #endif
759: case TIOCSTAT:
760: case TIOCSTI:
761: case TIOCSWINSZ:
1.66 christos 762: #ifdef COMPAT_OLDTTY
1.49 cgd 763: case TIOCLBIC:
764: case TIOCLBIS:
765: case TIOCLSET:
766: case TIOCSETC:
767: case OTIOCSETD:
768: case TIOCSETN:
769: case TIOCSETP:
770: case TIOCSLTC:
771: #endif
772: while (isbackground(curproc, tp) &&
773: p->p_pgrp->pg_jobc && (p->p_flag & P_PPWAIT) == 0 &&
1.112 mycroft 774: !sigismember(&p->p_sigignore, SIGTTOU) &&
775: !sigismember(&p->p_sigmask, SIGTTOU)) {
1.49 cgd 776: pgsignal(p->p_pgrp, SIGTTOU, 1);
1.112 mycroft 777: error = ttysleep(tp, &lbolt, TTOPRI | PCATCH, ttybg, 0);
1.65 christos 778: if (error)
1.49 cgd 779: return (error);
780: }
781: break;
782: }
783:
784: switch (cmd) { /* Process the ioctl. */
785: case FIOASYNC: /* set/clear async i/o */
786: s = spltty();
787: if (*(int *)data)
788: SET(tp->t_state, TS_ASYNC);
789: else
790: CLR(tp->t_state, TS_ASYNC);
791: splx(s);
792: break;
793: case FIONBIO: /* set/clear non-blocking i/o */
794: break; /* XXX: delete. */
795: case FIONREAD: /* get # bytes to read */
796: *(int *)data = ttnread(tp);
797: break;
798: case TIOCEXCL: /* set exclusive use of tty */
799: s = spltty();
800: SET(tp->t_state, TS_XCLUDE);
801: splx(s);
802: break;
803: case TIOCFLUSH: { /* flush buffers */
1.118 augustss 804: int flags = *(int *)data;
1.49 cgd 805:
806: if (flags == 0)
807: flags = FREAD | FWRITE;
808: else
809: flags &= FREAD | FWRITE;
810: ttyflush(tp, flags);
811: break;
812: }
813: case TIOCCONS: /* become virtual console */
814: if (*(int *)data) {
815: if (constty && constty != tp &&
816: ISSET(constty->t_state, TS_CARR_ON | TS_ISOPEN) ==
817: (TS_CARR_ON | TS_ISOPEN))
818: return (EBUSY);
819: #ifndef UCONSOLE
1.65 christos 820: if ((error = suser(p->p_ucred, &p->p_acflag)) != 0)
1.49 cgd 821: return (error);
822: #endif
823: constty = tp;
824: } else if (tp == constty)
825: constty = NULL;
826: break;
827: case TIOCDRAIN: /* wait till output drained */
1.65 christos 828: if ((error = ttywait(tp)) != 0)
1.49 cgd 829: return (error);
830: break;
831: case TIOCGETA: { /* get termios struct */
832: struct termios *t = (struct termios *)data;
833:
1.109 perry 834: memcpy(t, &tp->t_termios, sizeof(struct termios));
1.49 cgd 835: break;
836: }
837: case TIOCGETD: /* get line discipline */
838: *(int *)data = tp->t_line;
839: break;
840: case TIOCGWINSZ: /* get window size */
841: *(struct winsize *)data = tp->t_winsize;
842: break;
843: case TIOCGPGRP: /* get pgrp of tty */
844: if (!isctty(p, tp))
845: return (ENOTTY);
846: *(int *)data = tp->t_pgrp ? tp->t_pgrp->pg_id : NO_PID;
1.104 thorpej 847: break;
848: case TIOCGSID: /* get sid of tty */
849: if (!isctty(p, tp))
850: return (ENOTTY);
851: *(int *)data = tp->t_session->s_sid;
1.49 cgd 852: break;
853: #ifdef TIOCHPCL
854: case TIOCHPCL: /* hang up on last close */
855: s = spltty();
856: SET(tp->t_cflag, HUPCL);
857: splx(s);
858: break;
859: #endif
860: case TIOCNXCL: /* reset exclusive use of tty */
861: s = spltty();
862: CLR(tp->t_state, TS_XCLUDE);
863: splx(s);
864: break;
865: case TIOCOUTQ: /* output queue size */
866: *(int *)data = tp->t_outq.c_cc;
867: break;
868: case TIOCSETA: /* set termios struct */
869: case TIOCSETAW: /* drain output, set */
870: case TIOCSETAF: { /* drn out, fls in, set */
1.118 augustss 871: struct termios *t = (struct termios *)data;
1.49 cgd 872:
873: s = spltty();
874: if (cmd == TIOCSETAW || cmd == TIOCSETAF) {
1.65 christos 875: if ((error = ttywait(tp)) != 0) {
1.49 cgd 876: splx(s);
877: return (error);
878: }
879: if (cmd == TIOCSETAF)
880: ttyflush(tp, FREAD);
881: }
882: if (!ISSET(t->c_cflag, CIGNORE)) {
883: /*
884: * Set device hardware.
885: */
886: if (tp->t_param && (error = (*tp->t_param)(tp, t))) {
887: splx(s);
888: return (error);
889: } else {
890: tp->t_cflag = t->c_cflag;
891: tp->t_ispeed = t->c_ispeed;
892: tp->t_ospeed = t->c_ospeed;
893: if (t->c_ospeed == 0 && tp->t_session &&
894: tp->t_session->s_leader)
895: psignal(tp->t_session->s_leader,
896: SIGHUP);
897: }
898: ttsetwater(tp);
899: }
900: if (cmd != TIOCSETAF) {
901: if (ISSET(t->c_lflag, ICANON) !=
1.110 thorpej 902: ISSET(tp->t_lflag, ICANON)) {
1.49 cgd 903: if (ISSET(t->c_lflag, ICANON)) {
904: SET(tp->t_lflag, PENDIN);
905: ttwakeup(tp);
906: } else {
907: struct clist tq;
908:
909: catq(&tp->t_rawq, &tp->t_canq);
910: tq = tp->t_rawq;
911: tp->t_rawq = tp->t_canq;
912: tp->t_canq = tq;
913: CLR(tp->t_lflag, PENDIN);
914: }
1.110 thorpej 915: }
1.49 cgd 916: }
917: tp->t_iflag = t->c_iflag;
918: tp->t_oflag = t->c_oflag;
919: /*
920: * Make the EXTPROC bit read only.
921: */
922: if (ISSET(tp->t_lflag, EXTPROC))
923: SET(t->c_lflag, EXTPROC);
924: else
925: CLR(t->c_lflag, EXTPROC);
926: tp->t_lflag = t->c_lflag | ISSET(tp->t_lflag, PENDIN);
1.109 perry 927: memcpy(tp->t_cc, t->c_cc, sizeof(t->c_cc));
1.49 cgd 928: splx(s);
929: break;
930: }
931: case TIOCSETD: { /* set line discipline */
1.118 augustss 932: int t = *(int *)data;
1.49 cgd 933: dev_t device = tp->t_dev;
934:
935: if ((u_int)t >= nlinesw)
936: return (ENXIO);
937: if (t != tp->t_line) {
938: s = spltty();
939: (*linesw[tp->t_line].l_close)(tp, flag);
940: error = (*linesw[t].l_open)(device, tp);
941: if (error) {
942: (void)(*linesw[tp->t_line].l_open)(device, tp);
943: splx(s);
944: return (error);
945: }
946: tp->t_line = t;
947: splx(s);
948: }
949: break;
950: }
951: case TIOCSTART: /* start output, like ^Q */
952: s = spltty();
953: if (ISSET(tp->t_state, TS_TTSTOP) ||
954: ISSET(tp->t_lflag, FLUSHO)) {
955: CLR(tp->t_lflag, FLUSHO);
956: CLR(tp->t_state, TS_TTSTOP);
957: ttstart(tp);
958: }
959: splx(s);
960: break;
961: case TIOCSTI: /* simulate terminal input */
962: if (p->p_ucred->cr_uid && (flag & FREAD) == 0)
963: return (EPERM);
964: if (p->p_ucred->cr_uid && !isctty(p, tp))
965: return (EACCES);
966: (*linesw[tp->t_line].l_rint)(*(u_char *)data, tp);
967: break;
968: case TIOCSTOP: /* stop output, like ^S */
969: s = spltty();
970: if (!ISSET(tp->t_state, TS_TTSTOP)) {
971: SET(tp->t_state, TS_TTSTOP);
972: (*cdevsw[major(tp->t_dev)].d_stop)(tp, 0);
973: }
974: splx(s);
975: break;
976: case TIOCSCTTY: /* become controlling tty */
977: /* Session ctty vnode pointer set in vnode layer. */
978: if (!SESS_LEADER(p) ||
1.65 christos 979: ((p->p_session->s_ttyvp || tp->t_session) &&
980: (tp->t_session != p->p_session)))
1.49 cgd 981: return (EPERM);
982: tp->t_session = p->p_session;
983: tp->t_pgrp = p->p_pgrp;
984: p->p_session->s_ttyp = tp;
985: p->p_flag |= P_CONTROLT;
986: break;
987: case TIOCSPGRP: { /* set pgrp of tty */
1.118 augustss 988: struct pgrp *pgrp = pgfind(*(int *)data);
1.49 cgd 989:
990: if (!isctty(p, tp))
991: return (ENOTTY);
1.93 kleink 992: else if (pgrp == NULL)
993: return (EINVAL);
994: else if (pgrp->pg_session != p->p_session)
1.49 cgd 995: return (EPERM);
996: tp->t_pgrp = pgrp;
997: break;
998: }
999: case TIOCSTAT: /* get load avg stats */
1000: ttyinfo(tp);
1001: break;
1002: case TIOCSWINSZ: /* set window size */
1.109 perry 1003: if (memcmp((caddr_t)&tp->t_winsize, data,
1.108 perry 1004: sizeof(struct winsize))) {
1.49 cgd 1005: tp->t_winsize = *(struct winsize *)data;
1006: pgsignal(tp->t_pgrp, SIGWINCH, 1);
1007: }
1008: break;
1009: default:
1.66 christos 1010: #ifdef COMPAT_OLDTTY
1.49 cgd 1011: return (ttcompat(tp, cmd, data, flag, p));
1012: #else
1013: return (-1);
1014: #endif
1015: }
1016: return (0);
1017: }
1018:
1019: int
1.74 mycroft 1020: ttpoll(dev, events, p)
1021: dev_t dev;
1022: int events;
1.49 cgd 1023: struct proc *p;
1024: {
1.118 augustss 1025: struct tty *tp = (*cdevsw[major(dev)].d_tty)(dev);
1.74 mycroft 1026: int revents = 0;
1027: int s = spltty();
1028:
1029: if (events & (POLLIN | POLLRDNORM))
1030: if (ttnread(tp) > 0)
1031: revents |= events & (POLLIN | POLLRDNORM);
1032:
1033: if (events & (POLLOUT | POLLWRNORM))
1034: if (tp->t_outq.c_cc <= tp->t_lowat)
1035: revents |= events & (POLLOUT | POLLWRNORM);
1036:
1037: if (events & POLLHUP)
1.83 mycroft 1038: if (!CONNECTED(tp))
1.74 mycroft 1039: revents |= POLLHUP;
1040:
1041: if (revents == 0) {
1042: if (events & (POLLIN | POLLHUP | POLLRDNORM))
1043: selrecord(p, &tp->t_rsel);
1.49 cgd 1044:
1.74 mycroft 1045: if (events & (POLLOUT | POLLWRNORM))
1046: selrecord(p, &tp->t_wsel);
1047: }
1.49 cgd 1048:
1049: splx(s);
1.74 mycroft 1050: return (revents);
1.49 cgd 1051: }
1052:
1053: static int
1054: ttnread(tp)
1055: struct tty *tp;
1056: {
1057: int nread;
1058:
1059: if (ISSET(tp->t_lflag, PENDIN))
1060: ttypend(tp);
1061: nread = tp->t_canq.c_cc;
1062: if (!ISSET(tp->t_lflag, ICANON)) {
1063: nread += tp->t_rawq.c_cc;
1064: if (nread < tp->t_cc[VMIN] && !tp->t_cc[VTIME])
1065: nread = 0;
1066: }
1067: return (nread);
1068: }
1069:
1070: /*
1071: * Wait for output to drain.
1072: */
1073: int
1074: ttywait(tp)
1.118 augustss 1075: struct tty *tp;
1.49 cgd 1076: {
1077: int error, s;
1078:
1079: error = 0;
1080: s = spltty();
1081: while ((tp->t_outq.c_cc || ISSET(tp->t_state, TS_BUSY)) &&
1.83 mycroft 1082: CONNECTED(tp) && tp->t_oproc) {
1.49 cgd 1083: (*tp->t_oproc)(tp);
1084: SET(tp->t_state, TS_ASLEEP);
1.65 christos 1085: error = ttysleep(tp, &tp->t_outq, TTOPRI | PCATCH, ttyout, 0);
1086: if (error)
1.49 cgd 1087: break;
1088: }
1089: splx(s);
1090: return (error);
1091: }
1092:
1093: /*
1094: * Flush if successfully wait.
1095: */
1096: int
1097: ttywflush(tp)
1098: struct tty *tp;
1099: {
1100: int error;
1101:
1102: if ((error = ttywait(tp)) == 0)
1103: ttyflush(tp, FREAD);
1104: return (error);
1105: }
1106:
1107: /*
1108: * Flush tty read and/or write queues, notifying anyone waiting.
1109: */
1110: void
1111: ttyflush(tp, rw)
1.118 augustss 1112: struct tty *tp;
1.49 cgd 1113: int rw;
1114: {
1.118 augustss 1115: int s;
1.49 cgd 1116:
1117: s = spltty();
1118: if (rw & FREAD) {
1119: FLUSHQ(&tp->t_canq);
1120: FLUSHQ(&tp->t_rawq);
1121: tp->t_rocount = 0;
1122: tp->t_rocol = 0;
1123: CLR(tp->t_state, TS_LOCAL);
1124: ttwakeup(tp);
1125: }
1126: if (rw & FWRITE) {
1127: CLR(tp->t_state, TS_TTSTOP);
1128: (*cdevsw[major(tp->t_dev)].d_stop)(tp, rw);
1129: FLUSHQ(&tp->t_outq);
1130: wakeup((caddr_t)&tp->t_outq);
1131: selwakeup(&tp->t_wsel);
1132: }
1133: splx(s);
1134: }
1135:
1136: /*
1137: * Copy in the default termios characters.
1138: */
1139: void
1140: ttychars(tp)
1141: struct tty *tp;
1142: {
1143:
1.109 perry 1144: memcpy(tp->t_cc, ttydefchars, sizeof(ttydefchars));
1.49 cgd 1145: }
1146:
1147: /*
1148: * Send stop character on input overflow.
1149: */
1150: static void
1151: ttyblock(tp)
1.118 augustss 1152: struct tty *tp;
1.49 cgd 1153: {
1.118 augustss 1154: int total;
1.49 cgd 1155:
1156: total = tp->t_rawq.c_cc + tp->t_canq.c_cc;
1157: if (tp->t_rawq.c_cc > TTYHOG) {
1158: ttyflush(tp, FREAD | FWRITE);
1159: CLR(tp->t_state, TS_TBLOCK);
1160: }
1161: /*
1162: * Block further input iff: current input > threshold
1163: * AND input is available to user program.
1164: */
1.101 drochner 1165: if (total >= TTYHOG / 2 &&
1166: !ISSET(tp->t_state, TS_TBLOCK) &&
1167: (!ISSET(tp->t_lflag, ICANON) || tp->t_canq.c_cc > 0)) {
1.60 mycroft 1168: if (ISSET(tp->t_iflag, IXOFF) &&
1169: tp->t_cc[VSTOP] != _POSIX_VDISABLE &&
1170: putc(tp->t_cc[VSTOP], &tp->t_outq) == 0) {
1.49 cgd 1171: SET(tp->t_state, TS_TBLOCK);
1172: ttstart(tp);
1173: }
1.59 mycroft 1174: /* Try to block remote output via hardware flow control. */
1.49 cgd 1175: if (ISSET(tp->t_cflag, CHWFLOW) && tp->t_hwiflow &&
1176: (*tp->t_hwiflow)(tp, 1) != 0)
1177: SET(tp->t_state, TS_TBLOCK);
1178: }
1179: }
1180:
1181: void
1182: ttrstrt(tp_arg)
1183: void *tp_arg;
1184: {
1185: struct tty *tp;
1186: int s;
1187:
1188: #ifdef DIAGNOSTIC
1189: if (tp_arg == NULL)
1190: panic("ttrstrt");
1191: #endif
1192: tp = tp_arg;
1193: s = spltty();
1194:
1195: CLR(tp->t_state, TS_TIMEOUT);
1196: ttstart(tp);
1197:
1198: splx(s);
1199: }
1200:
1201: int
1202: ttstart(tp)
1203: struct tty *tp;
1204: {
1205:
1206: if (tp->t_oproc != NULL) /* XXX: Kludge for pty. */
1207: (*tp->t_oproc)(tp);
1208: return (0);
1209: }
1210:
1211: /*
1212: * "close" a line discipline
1213: */
1214: int
1215: ttylclose(tp, flag)
1216: struct tty *tp;
1217: int flag;
1218: {
1219:
1.61 mycroft 1220: if (flag & FNONBLOCK)
1.49 cgd 1221: ttyflush(tp, FREAD | FWRITE);
1222: else
1223: ttywflush(tp);
1224: return (0);
1225: }
1226:
1227: /*
1228: * Handle modem control transition on a tty.
1229: * Flag indicates new state of carrier.
1230: * Returns 0 if the line should be turned off, otherwise 1.
1231: */
1232: int
1233: ttymodem(tp, flag)
1.118 augustss 1234: struct tty *tp;
1.49 cgd 1235: int flag;
1236: {
1237:
1.83 mycroft 1238: if (flag == 0) {
1.96 kleink 1239: if (ISSET(tp->t_state, TS_CARR_ON)) {
1240: /*
1241: * Lost carrier.
1242: */
1243: CLR(tp->t_state, TS_CARR_ON);
1244: if (ISSET(tp->t_state, TS_ISOPEN) && !CONNECTED(tp)) {
1245: if (tp->t_session && tp->t_session->s_leader)
1246: psignal(tp->t_session->s_leader, SIGHUP);
1247: ttyflush(tp, FREAD | FWRITE);
1248: return (0);
1249: }
1.49 cgd 1250: }
1251: } else {
1.96 kleink 1252: if (!ISSET(tp->t_state, TS_CARR_ON)) {
1253: /*
1254: * Carrier now on.
1255: */
1256: SET(tp->t_state, TS_CARR_ON);
1257: ttwakeup(tp);
1258: }
1.49 cgd 1259: }
1260: return (1);
1261: }
1262:
1263: /*
1264: * Default modem control routine (for other line disciplines).
1265: * Return argument flag, to turn off device on carrier drop.
1266: */
1267: int
1268: nullmodem(tp, flag)
1.118 augustss 1269: struct tty *tp;
1.49 cgd 1270: int flag;
1271: {
1272:
1273: if (flag)
1274: SET(tp->t_state, TS_CARR_ON);
1275: else {
1276: CLR(tp->t_state, TS_CARR_ON);
1.83 mycroft 1277: if (!CONNECTED(tp)) {
1.49 cgd 1278: if (tp->t_session && tp->t_session->s_leader)
1279: psignal(tp->t_session->s_leader, SIGHUP);
1280: return (0);
1281: }
1282: }
1283: return (1);
1284: }
1285:
1286: /*
1287: * Reinput pending characters after state switch
1288: * call at spltty().
1289: */
1290: void
1291: ttypend(tp)
1.118 augustss 1292: struct tty *tp;
1.49 cgd 1293: {
1294: struct clist tq;
1.118 augustss 1295: int c;
1.49 cgd 1296:
1297: CLR(tp->t_lflag, PENDIN);
1298: SET(tp->t_state, TS_TYPEN);
1299: tq = tp->t_rawq;
1300: tp->t_rawq.c_cc = 0;
1301: tp->t_rawq.c_cf = tp->t_rawq.c_cl = 0;
1302: while ((c = getc(&tq)) >= 0)
1303: ttyinput(c, tp);
1304: CLR(tp->t_state, TS_TYPEN);
1305: }
1306:
1307: /*
1308: * Process a read call on a tty device.
1309: */
1310: int
1311: ttread(tp, uio, flag)
1.118 augustss 1312: struct tty *tp;
1.49 cgd 1313: struct uio *uio;
1314: int flag;
1315: {
1.118 augustss 1316: struct clist *qp;
1317: int c;
1318: long lflag;
1319: u_char *cc = tp->t_cc;
1320: struct proc *p = curproc;
1.49 cgd 1321: int s, first, error = 0;
1322: struct timeval stime;
1.65 christos 1323: int has_stime = 0, last_cc = 0;
1.49 cgd 1324: long slp = 0;
1325:
1326: loop: lflag = tp->t_lflag;
1327: s = spltty();
1328: /*
1329: * take pending input first
1330: */
1331: if (ISSET(lflag, PENDIN))
1332: ttypend(tp);
1333: splx(s);
1334:
1335: /*
1336: * Hang process if it's in the background.
1337: */
1338: if (isbackground(p, tp)) {
1.112 mycroft 1339: if (sigismember(&p->p_sigignore, SIGTTIN) ||
1340: sigismember(&p->p_sigmask, SIGTTIN) ||
1.49 cgd 1341: p->p_flag & P_PPWAIT || p->p_pgrp->pg_jobc == 0)
1342: return (EIO);
1343: pgsignal(p->p_pgrp, SIGTTIN, 1);
1.65 christos 1344: error = ttysleep(tp, &lbolt, TTIPRI | PCATCH, ttybg, 0);
1345: if (error)
1.49 cgd 1346: return (error);
1347: goto loop;
1348: }
1349:
1350: s = spltty();
1351: if (!ISSET(lflag, ICANON)) {
1352: int m = cc[VMIN];
1353: long t = cc[VTIME];
1354:
1355: qp = &tp->t_rawq;
1356: /*
1357: * Check each of the four combinations.
1358: * (m > 0 && t == 0) is the normal read case.
1359: * It should be fairly efficient, so we check that and its
1360: * companion case (m == 0 && t == 0) first.
1361: * For the other two cases, we compute the target sleep time
1362: * into slp.
1363: */
1364: if (t == 0) {
1365: if (qp->c_cc < m)
1366: goto sleep;
1367: goto read;
1368: }
1369: t *= 100000; /* time in us */
1370: #define diff(t1, t2) (((t1).tv_sec - (t2).tv_sec) * 1000000 + \
1371: ((t1).tv_usec - (t2).tv_usec))
1372: if (m > 0) {
1373: if (qp->c_cc <= 0)
1374: goto sleep;
1375: if (qp->c_cc >= m)
1376: goto read;
1377: if (!has_stime) {
1378: /* first character, start timer */
1379: has_stime = 1;
1380: stime = time;
1381: slp = t;
1382: } else if (qp->c_cc > last_cc) {
1383: /* got a character, restart timer */
1384: stime = time;
1385: slp = t;
1386: } else {
1387: /* nothing, check expiration */
1388: slp = t - diff(time, stime);
1389: }
1390: } else { /* m == 0 */
1391: if (qp->c_cc > 0)
1392: goto read;
1393: if (!has_stime) {
1394: has_stime = 1;
1395: stime = time;
1396: slp = t;
1397: } else
1398: slp = t - diff(time, stime);
1399: }
1.54 mycroft 1400: last_cc = qp->c_cc;
1.49 cgd 1401: #undef diff
1402: if (slp > 0) {
1403: /*
1404: * Rounding down may make us wake up just short
1405: * of the target, so we round up.
1406: * The formula is ceiling(slp * hz/1000000).
1407: * 32-bit arithmetic is enough for hz < 169.
1408: *
1409: * Also, use plain wakeup() not ttwakeup().
1410: */
1411: slp = (long) (((u_long)slp * hz) + 999999) / 1000000;
1412: goto sleep;
1413: }
1414: } else if ((qp = &tp->t_canq)->c_cc <= 0) {
1415: int carrier;
1416:
1417: sleep:
1418: /*
1419: * If there is no input, sleep on rawq
1420: * awaiting hardware receipt and notification.
1421: * If we have data, we don't need to check for carrier.
1422: */
1.83 mycroft 1423: carrier = CONNECTED(tp);
1.49 cgd 1424: if (!carrier && ISSET(tp->t_state, TS_ISOPEN)) {
1425: splx(s);
1426: return (0); /* EOF */
1427: }
1428: if (flag & IO_NDELAY) {
1429: splx(s);
1430: return (EWOULDBLOCK);
1431: }
1432: error = ttysleep(tp, &tp->t_rawq, TTIPRI | PCATCH,
1.53 mycroft 1433: carrier ? ttyin : ttopen, slp);
1.49 cgd 1434: splx(s);
1.82 kleink 1435: /* VMIN == 0: any quantity read satisfies */
1436: if (cc[VMIN] == 0 && error == EWOULDBLOCK)
1437: return (0);
1.54 mycroft 1438: if (error && error != EWOULDBLOCK)
1.49 cgd 1439: return (error);
1440: goto loop;
1441: }
1442: read:
1443: splx(s);
1444:
1445: /*
1446: * Input present, check for input mapping and processing.
1447: */
1448: first = 1;
1449: while ((c = getc(qp)) >= 0) {
1450: /*
1451: * delayed suspend (^Y)
1452: */
1.81 kleink 1453: if (CCEQ(cc[VDSUSP], c) &&
1454: ISSET(lflag, IEXTEN|ISIG) == (IEXTEN|ISIG)) {
1.49 cgd 1455: pgsignal(tp->t_pgrp, SIGTSTP, 1);
1456: if (first) {
1.65 christos 1457: error = ttysleep(tp, &lbolt,
1458: TTIPRI | PCATCH, ttybg, 0);
1459: if (error)
1.49 cgd 1460: break;
1461: goto loop;
1462: }
1463: break;
1464: }
1465: /*
1466: * Interpret EOF only in canonical mode.
1467: */
1468: if (CCEQ(cc[VEOF], c) && ISSET(lflag, ICANON))
1469: break;
1470: /*
1471: * Give user character.
1472: */
1473: error = ureadc(c, uio);
1474: if (error)
1475: break;
1476: if (uio->uio_resid == 0)
1477: break;
1478: /*
1479: * In canonical mode check for a "break character"
1480: * marking the end of a "line of input".
1481: */
1.85 kleink 1482: if (ISSET(lflag, ICANON) && TTBREAKC(c, lflag))
1.49 cgd 1483: break;
1484: first = 0;
1485: }
1486: /*
1487: * Look to unblock output now that (presumably)
1488: * the input queue has gone down.
1489: */
1490: s = spltty();
1491: if (ISSET(tp->t_state, TS_TBLOCK) && tp->t_rawq.c_cc < TTYHOG/5) {
1.60 mycroft 1492: if (ISSET(tp->t_iflag, IXOFF) &&
1493: cc[VSTART] != _POSIX_VDISABLE &&
1.49 cgd 1494: putc(cc[VSTART], &tp->t_outq) == 0) {
1495: CLR(tp->t_state, TS_TBLOCK);
1496: ttstart(tp);
1497: }
1.59 mycroft 1498: /* Try to unblock remote output via hardware flow control. */
1499: if (ISSET(tp->t_cflag, CHWFLOW) && tp->t_hwiflow &&
1.49 cgd 1500: (*tp->t_hwiflow)(tp, 0) != 0)
1.59 mycroft 1501: CLR(tp->t_state, TS_TBLOCK);
1.49 cgd 1502: }
1503: splx(s);
1504: return (error);
1505: }
1506:
1507: /*
1508: * Check the output queue on tp for space for a kernel message (from uprintf
1509: * or tprintf). Allow some space over the normal hiwater mark so we don't
1510: * lose messages due to normal flow control, but don't let the tty run amok.
1511: * Sleeps here are not interruptible, but we return prematurely if new signals
1512: * arrive.
1513: */
1514: int
1515: ttycheckoutq(tp, wait)
1.118 augustss 1516: struct tty *tp;
1.49 cgd 1517: int wait;
1518: {
1.112 mycroft 1519: int hiwat, s;
1520: int error;
1.49 cgd 1521:
1522: hiwat = tp->t_hiwat;
1523: s = spltty();
1524: if (tp->t_outq.c_cc > hiwat + 200)
1525: while (tp->t_outq.c_cc > hiwat) {
1526: ttstart(tp);
1.112 mycroft 1527: if (wait == 0) {
1.49 cgd 1528: splx(s);
1529: return (0);
1530: }
1.116 thorpej 1531: callout_reset(&tp->t_outq_ch, hz,
1532: (void (*)__P((void *)))wakeup, &tp->t_outq);
1.49 cgd 1533: SET(tp->t_state, TS_ASLEEP);
1.112 mycroft 1534: error = tsleep(&tp->t_outq, (PZERO - 1) | PCATCH,
1535: "ttckoutq", 0);
1536: if (error == EINTR)
1537: wait = 0;
1.49 cgd 1538: }
1539: splx(s);
1540: return (1);
1541: }
1542:
1543: /*
1544: * Process a write call on a tty device.
1545: */
1546: int
1547: ttwrite(tp, uio, flag)
1.118 augustss 1548: struct tty *tp;
1549: struct uio *uio;
1.49 cgd 1550: int flag;
1551: {
1.118 augustss 1552: u_char *cp = NULL;
1553: int cc, ce;
1554: struct proc *p;
1.49 cgd 1555: int i, hiwat, cnt, error, s;
1556: u_char obuf[OBUFSIZ];
1557:
1558: hiwat = tp->t_hiwat;
1559: cnt = uio->uio_resid;
1560: error = 0;
1561: cc = 0;
1562: loop:
1563: s = spltty();
1.83 mycroft 1564: if (!CONNECTED(tp)) {
1.49 cgd 1565: if (ISSET(tp->t_state, TS_ISOPEN)) {
1566: splx(s);
1567: return (EIO);
1568: } else if (flag & IO_NDELAY) {
1569: splx(s);
1570: error = EWOULDBLOCK;
1571: goto out;
1572: } else {
1573: /* Sleep awaiting carrier. */
1574: error = ttysleep(tp,
1575: &tp->t_rawq, TTIPRI | PCATCH, ttopen, 0);
1576: splx(s);
1577: if (error)
1578: goto out;
1579: goto loop;
1580: }
1581: }
1582: splx(s);
1583: /*
1584: * Hang the process if it's in the background.
1585: */
1586: p = curproc;
1587: if (isbackground(p, tp) &&
1588: ISSET(tp->t_lflag, TOSTOP) && (p->p_flag & P_PPWAIT) == 0 &&
1.112 mycroft 1589: !sigismember(&p->p_sigignore, SIGTTOU) &&
1590: !sigismember(&p->p_sigmask, SIGTTOU)) {
1.86 kleink 1591: if (p->p_pgrp->pg_jobc == 0) {
1592: error = EIO;
1593: goto out;
1594: }
1.49 cgd 1595: pgsignal(p->p_pgrp, SIGTTOU, 1);
1.65 christos 1596: error = ttysleep(tp, &lbolt, TTIPRI | PCATCH, ttybg, 0);
1597: if (error)
1.49 cgd 1598: goto out;
1599: goto loop;
1600: }
1601: /*
1602: * Process the user's data in at most OBUFSIZ chunks. Perform any
1603: * output translation. Keep track of high water mark, sleep on
1604: * overflow awaiting device aid in acquiring new space.
1605: */
1606: while (uio->uio_resid > 0 || cc > 0) {
1607: if (ISSET(tp->t_lflag, FLUSHO)) {
1608: uio->uio_resid = 0;
1609: return (0);
1610: }
1611: if (tp->t_outq.c_cc > hiwat)
1612: goto ovhiwat;
1613: /*
1614: * Grab a hunk of data from the user, unless we have some
1615: * leftover from last time.
1616: */
1617: if (cc == 0) {
1618: cc = min(uio->uio_resid, OBUFSIZ);
1619: cp = obuf;
1620: error = uiomove(cp, cc, uio);
1621: if (error) {
1622: cc = 0;
1623: break;
1624: }
1625: }
1626: /*
1627: * If nothing fancy need be done, grab those characters we
1628: * can handle without any of ttyoutput's processing and
1629: * just transfer them to the output q. For those chars
1630: * which require special processing (as indicated by the
1631: * bits in char_type), call ttyoutput. After processing
1632: * a hunk of data, look for FLUSHO so ^O's will take effect
1633: * immediately.
1634: */
1635: while (cc > 0) {
1636: if (!ISSET(tp->t_oflag, OPOST))
1637: ce = cc;
1638: else {
1.77 cgd 1639: ce = cc - scanc((u_int)cc, cp, char_type,
1640: CCLASSMASK);
1.49 cgd 1641: /*
1642: * If ce is zero, then we're processing
1643: * a special character through ttyoutput.
1644: */
1645: if (ce == 0) {
1646: tp->t_rocount = 0;
1647: if (ttyoutput(*cp, tp) >= 0) {
1648: /* out of space */
1649: goto overfull;
1650: }
1651: cp++;
1652: cc--;
1653: if (ISSET(tp->t_lflag, FLUSHO) ||
1654: tp->t_outq.c_cc > hiwat)
1655: goto ovhiwat;
1656: continue;
1657: }
1658: }
1659: /*
1660: * A bunch of normal characters have been found.
1661: * Transfer them en masse to the output queue and
1662: * continue processing at the top of the loop.
1663: * If there are any further characters in this
1664: * <= OBUFSIZ chunk, the first should be a character
1665: * requiring special handling by ttyoutput.
1666: */
1667: tp->t_rocount = 0;
1668: i = b_to_q(cp, ce, &tp->t_outq);
1669: ce -= i;
1670: tp->t_column += ce;
1671: cp += ce, cc -= ce, tk_nout += ce;
1672: tp->t_outcc += ce;
1673: if (i > 0) {
1674: /* out of space */
1675: goto overfull;
1676: }
1677: if (ISSET(tp->t_lflag, FLUSHO) ||
1678: tp->t_outq.c_cc > hiwat)
1679: break;
1680: }
1681: ttstart(tp);
1682: }
1683: out:
1684: /*
1685: * If cc is nonzero, we leave the uio structure inconsistent, as the
1686: * offset and iov pointers have moved forward, but it doesn't matter
1687: * (the call will either return short or restart with a new uio).
1688: */
1689: uio->uio_resid += cc;
1690: return (error);
1691:
1692: overfull:
1693: /*
1694: * Since we are using ring buffers, if we can't insert any more into
1695: * the output queue, we can assume the ring is full and that someone
1696: * forgot to set the high water mark correctly. We set it and then
1697: * proceed as normal.
1698: */
1699: hiwat = tp->t_outq.c_cc - 1;
1700:
1701: ovhiwat:
1702: ttstart(tp);
1703: s = spltty();
1704: /*
1705: * This can only occur if FLUSHO is set in t_lflag,
1706: * or if ttstart/oproc is synchronous (or very fast).
1707: */
1708: if (tp->t_outq.c_cc <= hiwat) {
1709: splx(s);
1710: goto loop;
1711: }
1712: if (flag & IO_NDELAY) {
1713: splx(s);
1714: uio->uio_resid += cc;
1715: return (uio->uio_resid == cnt ? EWOULDBLOCK : 0);
1716: }
1717: SET(tp->t_state, TS_ASLEEP);
1718: error = ttysleep(tp, &tp->t_outq, TTOPRI | PCATCH, ttyout, 0);
1719: splx(s);
1720: if (error)
1721: goto out;
1722: goto loop;
1723: }
1724:
1725: /*
1726: * Rubout one character from the rawq of tp
1727: * as cleanly as possible.
1728: */
1729: void
1730: ttyrub(c, tp)
1731: int c;
1.118 augustss 1732: struct tty *tp;
1.49 cgd 1733: {
1.118 augustss 1734: u_char *cp;
1735: int savecol;
1.49 cgd 1736: int tabc, s;
1737:
1738: if (!ISSET(tp->t_lflag, ECHO) || ISSET(tp->t_lflag, EXTPROC))
1739: return;
1740: CLR(tp->t_lflag, FLUSHO);
1741: if (ISSET(tp->t_lflag, ECHOE)) {
1742: if (tp->t_rocount == 0) {
1743: /*
1744: * Screwed by ttwrite; retype
1745: */
1746: ttyretype(tp);
1747: return;
1748: }
1749: if (c == ('\t' | TTY_QUOTE) || c == ('\n' | TTY_QUOTE))
1750: ttyrubo(tp, 2);
1751: else {
1752: CLR(c, ~TTY_CHARMASK);
1753: switch (CCLASS(c)) {
1754: case ORDINARY:
1755: ttyrubo(tp, 1);
1756: break;
1757: case BACKSPACE:
1758: case CONTROL:
1759: case NEWLINE:
1760: case RETURN:
1761: case VTAB:
1762: if (ISSET(tp->t_lflag, ECHOCTL))
1763: ttyrubo(tp, 2);
1764: break;
1765: case TAB:
1766: if (tp->t_rocount < tp->t_rawq.c_cc) {
1767: ttyretype(tp);
1768: return;
1769: }
1770: s = spltty();
1771: savecol = tp->t_column;
1772: SET(tp->t_state, TS_CNTTB);
1773: SET(tp->t_lflag, FLUSHO);
1774: tp->t_column = tp->t_rocol;
1.52 deraadt 1775: for (cp = firstc(&tp->t_rawq, &tabc); cp;
1.49 cgd 1776: cp = nextc(&tp->t_rawq, cp, &tabc))
1777: ttyecho(tabc, tp);
1778: CLR(tp->t_lflag, FLUSHO);
1779: CLR(tp->t_state, TS_CNTTB);
1780: splx(s);
1781:
1782: /* savecol will now be length of the tab. */
1783: savecol -= tp->t_column;
1784: tp->t_column += savecol;
1785: if (savecol > 8)
1786: savecol = 8; /* overflow screw */
1787: while (--savecol >= 0)
1788: (void)ttyoutput('\b', tp);
1789: break;
1790: default: /* XXX */
1791: #define PANICSTR "ttyrub: would panic c = %d, val = %d\n"
1.76 christos 1792: (void)printf(PANICSTR, c, CCLASS(c));
1.49 cgd 1793: #ifdef notdef
1794: panic(PANICSTR, c, CCLASS(c));
1795: #endif
1796: }
1797: }
1798: } else if (ISSET(tp->t_lflag, ECHOPRT)) {
1799: if (!ISSET(tp->t_state, TS_ERASE)) {
1800: SET(tp->t_state, TS_ERASE);
1801: (void)ttyoutput('\\', tp);
1802: }
1803: ttyecho(c, tp);
1804: } else
1805: ttyecho(tp->t_cc[VERASE], tp);
1806: --tp->t_rocount;
1807: }
1808:
1809: /*
1810: * Back over cnt characters, erasing them.
1811: */
1812: static void
1813: ttyrubo(tp, cnt)
1.118 augustss 1814: struct tty *tp;
1.49 cgd 1815: int cnt;
1816: {
1817:
1818: while (cnt-- > 0) {
1819: (void)ttyoutput('\b', tp);
1820: (void)ttyoutput(' ', tp);
1821: (void)ttyoutput('\b', tp);
1822: }
1823: }
1824:
1825: /*
1826: * ttyretype --
1827: * Reprint the rawq line. Note, it is assumed that c_cc has already
1828: * been checked.
1829: */
1830: void
1831: ttyretype(tp)
1.118 augustss 1832: struct tty *tp;
1.49 cgd 1833: {
1.118 augustss 1834: u_char *cp;
1.49 cgd 1835: int s, c;
1836:
1837: /* Echo the reprint character. */
1838: if (tp->t_cc[VREPRINT] != _POSIX_VDISABLE)
1839: ttyecho(tp->t_cc[VREPRINT], tp);
1840:
1841: (void)ttyoutput('\n', tp);
1842:
1843: s = spltty();
1844: for (cp = firstc(&tp->t_canq, &c); cp; cp = nextc(&tp->t_canq, cp, &c))
1845: ttyecho(c, tp);
1846: for (cp = firstc(&tp->t_rawq, &c); cp; cp = nextc(&tp->t_rawq, cp, &c))
1847: ttyecho(c, tp);
1848: CLR(tp->t_state, TS_ERASE);
1849: splx(s);
1850:
1851: tp->t_rocount = tp->t_rawq.c_cc;
1852: tp->t_rocol = 0;
1853: }
1854:
1855: /*
1856: * Echo a typed character to the terminal.
1857: */
1858: static void
1859: ttyecho(c, tp)
1.118 augustss 1860: int c;
1861: struct tty *tp;
1.49 cgd 1862: {
1863:
1864: if (!ISSET(tp->t_state, TS_CNTTB))
1865: CLR(tp->t_lflag, FLUSHO);
1866: if ((!ISSET(tp->t_lflag, ECHO) &&
1.64 pk 1867: (!ISSET(tp->t_lflag, ECHONL) || c != '\n')) ||
1.49 cgd 1868: ISSET(tp->t_lflag, EXTPROC))
1869: return;
1.65 christos 1870: if (((ISSET(tp->t_lflag, ECHOCTL) &&
1871: (ISSET(c, TTY_CHARMASK) <= 037 && c != '\t' && c != '\n')) ||
1.49 cgd 1872: ISSET(c, TTY_CHARMASK) == 0177)) {
1873: (void)ttyoutput('^', tp);
1874: CLR(c, ~TTY_CHARMASK);
1875: if (c == 0177)
1876: c = '?';
1877: else
1878: c += 'A' - 1;
1879: }
1880: (void)ttyoutput(c, tp);
1881: }
1882:
1883: /*
1884: * Wake up any readers on a tty.
1885: */
1886: void
1887: ttwakeup(tp)
1.118 augustss 1888: struct tty *tp;
1.49 cgd 1889: {
1890:
1891: selwakeup(&tp->t_rsel);
1892: if (ISSET(tp->t_state, TS_ASYNC))
1893: pgsignal(tp->t_pgrp, SIGIO, 1);
1894: wakeup((caddr_t)&tp->t_rawq);
1895: }
1896:
1897: /*
1898: * Look up a code for a specified speed in a conversion table;
1899: * used by drivers to map software speed values to hardware parameters.
1900: */
1901: int
1902: ttspeedtab(speed, table)
1903: int speed;
1.118 augustss 1904: struct speedtab *table;
1.49 cgd 1905: {
1906:
1907: for ( ; table->sp_speed != -1; table++)
1908: if (table->sp_speed == speed)
1909: return (table->sp_code);
1910: return (-1);
1911: }
1912:
1913: /*
1914: * Set tty hi and low water marks.
1915: *
1916: * Try to arrange the dynamics so there's about one second
1917: * from hi to low water.
1918: */
1919: void
1920: ttsetwater(tp)
1921: struct tty *tp;
1922: {
1.118 augustss 1923: int cps, x;
1.49 cgd 1924:
1925: #define CLAMP(x, h, l) ((x) > h ? h : ((x) < l) ? l : (x))
1926:
1927: cps = tp->t_ospeed / 10;
1928: tp->t_lowat = x = CLAMP(cps / 2, TTMAXLOWAT, TTMINLOWAT);
1929: x += cps;
1930: x = CLAMP(x, TTMAXHIWAT, TTMINHIWAT);
1931: tp->t_hiwat = roundup(x, CBSIZE);
1932: #undef CLAMP
1933: }
1934:
1935: /*
1936: * Report on state of foreground process group.
1937: */
1938: void
1939: ttyinfo(tp)
1.118 augustss 1940: struct tty *tp;
1.49 cgd 1941: {
1.118 augustss 1942: struct proc *p, *pick;
1.49 cgd 1943: struct timeval utime, stime;
1944: int tmp;
1945:
1946: if (ttycheckoutq(tp,0) == 0)
1947: return;
1948:
1949: /* Print load average. */
1950: tmp = (averunnable.ldavg[0] * 100 + FSCALE / 2) >> FSHIFT;
1951: ttyprintf(tp, "load: %d.%02d ", tmp / 100, tmp % 100);
1952:
1953: if (tp->t_session == NULL)
1954: ttyprintf(tp, "not a controlling terminal\n");
1955: else if (tp->t_pgrp == NULL)
1956: ttyprintf(tp, "no foreground process group\n");
1.51 mycroft 1957: else if ((p = tp->t_pgrp->pg_members.lh_first) == 0)
1.49 cgd 1958: ttyprintf(tp, "empty foreground process group\n");
1959: else {
1960: /* Pick interesting process. */
1.115 tron 1961: for (pick = NULL; p != NULL; p = p->p_pglist.le_next)
1.49 cgd 1962: if (proc_compare(pick, p))
1963: pick = p;
1964:
1965: ttyprintf(tp, " cmd: %s %d [%s] ", pick->p_comm, pick->p_pid,
1.119 ! thorpej 1966: pick->p_stat == SONPROC ? "running" :
! 1967: pick->p_stat == SRUN ? "runnable" :
1.49 cgd 1968: pick->p_wmesg ? pick->p_wmesg : "iowait");
1969:
1970: calcru(pick, &utime, &stime, NULL);
1971:
1.62 cgd 1972: /* Round up and print user time. */
1973: utime.tv_usec += 5000;
1974: if (utime.tv_usec >= 1000000) {
1975: utime.tv_sec += 1;
1976: utime.tv_usec -= 1000000;
1977: }
1.117 kleink 1978: ttyprintf(tp, "%ld.%02ldu ", (long int)utime.tv_sec,
1979: (long int)utime.tv_usec / 10000);
1.62 cgd 1980:
1981: /* Round up and print system time. */
1982: stime.tv_usec += 5000;
1983: if (stime.tv_usec >= 1000000) {
1984: stime.tv_sec += 1;
1985: stime.tv_usec -= 1000000;
1986: }
1.117 kleink 1987: ttyprintf(tp, "%ld.%02lds ", (long int)stime.tv_sec,
1988: (long int)stime.tv_usec / 10000);
1.49 cgd 1989:
1.68 christos 1990: #define pgtok(a) (((u_long) ((a) * NBPG) / 1024))
1.90 gwr 1991: /* Print percentage cpu. */
1.66 christos 1992: tmp = (pick->p_pctcpu * 10000 + FSCALE / 2) >> FSHIFT;
1.90 gwr 1993: ttyprintf(tp, "%d%% ", tmp / 100);
1994:
1995: /* Print resident set size. */
1.115 tron 1996: if (pick->p_stat == SIDL || P_ZOMBIE(pick))
1.90 gwr 1997: tmp = 0;
1998: else {
1.118 augustss 1999: struct vmspace *vm = pick->p_vmspace;
1.90 gwr 2000: tmp = pgtok(vm_resident_count(vm));
2001: }
1.91 thorpej 2002: ttyprintf(tp, "%dk\n", tmp);
1.49 cgd 2003: }
2004: tp->t_rocount = 0; /* so pending input will be retyped if BS */
2005: }
2006:
2007: /*
2008: * Returns 1 if p2 is "better" than p1
2009: *
2010: * The algorithm for picking the "interesting" process is thus:
2011: *
2012: * 1) Only foreground processes are eligible - implied.
2013: * 2) Runnable processes are favored over anything else. The runner
2014: * with the highest cpu utilization is picked (p_estcpu). Ties are
2015: * broken by picking the highest pid.
2016: * 3) The sleeper with the shortest sleep time is next. With ties,
2017: * we pick out just "short-term" sleepers (P_SINTR == 0).
2018: * 4) Further ties are broken by picking the highest pid.
2019: */
1.119 ! thorpej 2020: #define ISRUN(p) (((p)->p_stat == SRUN) || ((p)->p_stat == SIDL) || \
! 2021: ((p)->p_stat == SONPROC))
1.49 cgd 2022: #define TESTAB(a, b) ((a)<<1 | (b))
2023: #define ONLYA 2
2024: #define ONLYB 1
2025: #define BOTH 3
2026:
2027: static int
2028: proc_compare(p1, p2)
1.118 augustss 2029: struct proc *p1, *p2;
1.49 cgd 2030: {
2031:
2032: if (p1 == NULL)
2033: return (1);
2034: /*
2035: * see if at least one of them is runnable
2036: */
2037: switch (TESTAB(ISRUN(p1), ISRUN(p2))) {
2038: case ONLYA:
2039: return (0);
2040: case ONLYB:
2041: return (1);
2042: case BOTH:
2043: /*
2044: * tie - favor one with highest recent cpu utilization
2045: */
2046: if (p2->p_estcpu > p1->p_estcpu)
2047: return (1);
2048: if (p1->p_estcpu > p2->p_estcpu)
2049: return (0);
2050: return (p2->p_pid > p1->p_pid); /* tie - return highest pid */
2051: }
2052: /*
2053: * weed out zombies
2054: */
1.114 thorpej 2055: switch (TESTAB(P_ZOMBIE(p1), P_ZOMBIE(p2))) {
1.49 cgd 2056: case ONLYA:
2057: return (1);
2058: case ONLYB:
2059: return (0);
2060: case BOTH:
2061: return (p2->p_pid > p1->p_pid); /* tie - return highest pid */
2062: }
2063: /*
2064: * pick the one with the smallest sleep time
2065: */
2066: if (p2->p_slptime > p1->p_slptime)
2067: return (0);
2068: if (p1->p_slptime > p2->p_slptime)
2069: return (1);
2070: /*
2071: * favor one sleeping in a non-interruptible sleep
2072: */
2073: if (p1->p_flag & P_SINTR && (p2->p_flag & P_SINTR) == 0)
2074: return (1);
2075: if (p2->p_flag & P_SINTR && (p1->p_flag & P_SINTR) == 0)
2076: return (0);
2077: return (p2->p_pid > p1->p_pid); /* tie - return highest pid */
2078: }
2079:
2080: /*
2081: * Output char to tty; console putchar style.
2082: */
2083: int
2084: tputchar(c, tp)
2085: int c;
2086: struct tty *tp;
2087: {
1.118 augustss 2088: int s;
1.49 cgd 2089:
2090: s = spltty();
2091: if (ISSET(tp->t_state,
2092: TS_CARR_ON | TS_ISOPEN) != (TS_CARR_ON | TS_ISOPEN)) {
2093: splx(s);
2094: return (-1);
2095: }
2096: if (c == '\n')
2097: (void)ttyoutput('\r', tp);
2098: (void)ttyoutput(c, tp);
2099: ttstart(tp);
2100: splx(s);
2101: return (0);
2102: }
2103:
2104: /*
2105: * Sleep on chan, returning ERESTART if tty changed while we napped and
2106: * returning any errors (e.g. EINTR/ETIMEDOUT) reported by tsleep. If
2107: * the tty is revoked, restarting a pending call will redo validation done
2108: * at the start of the call.
2109: */
2110: int
2111: ttysleep(tp, chan, pri, wmesg, timo)
2112: struct tty *tp;
2113: void *chan;
2114: int pri, timo;
1.97 mycroft 2115: const char *wmesg;
1.49 cgd 2116: {
2117: int error;
2118: short gen;
2119:
2120: gen = tp->t_gen;
1.65 christos 2121: if ((error = tsleep(chan, pri, wmesg, timo)) != 0)
1.49 cgd 2122: return (error);
2123: return (tp->t_gen == gen ? 0 : ERESTART);
2124: }
2125:
2126: /*
1.69 mrg 2127: * Initialise the global tty list.
2128: */
2129: void
2130: tty_init()
2131: {
1.71 cgd 2132:
1.69 mrg 2133: TAILQ_INIT(&ttylist);
2134: tty_count = 0;
1.111 thorpej 2135:
2136: pool_init(&tty_pool, sizeof(struct tty), 0, 0, 0, "ttypl",
2137: 0, pool_page_alloc_nointr, pool_page_free_nointr, M_TTYS);
1.69 mrg 2138: }
2139:
2140: /*
2141: * Attach a tty to the tty list.
1.72 mrg 2142: *
2143: * This should be called ONLY once per real tty (including pty's).
2144: * eg, on the sparc, the keyboard and mouse have struct tty's that are
2145: * distinctly NOT usable as tty's, and thus should not be attached to
2146: * the ttylist. This is why this call is not done from ttymalloc().
2147: *
2148: * Device drivers should attach tty's at a similar time that they are
2149: * ttymalloc()'ed, or, for the case of statically allocated struct tty's
2150: * either in the attach or (first) open routine.
1.69 mrg 2151: */
2152: void
2153: tty_attach(tp)
2154: struct tty *tp;
2155: {
1.71 cgd 2156:
1.69 mrg 2157: TAILQ_INSERT_TAIL(&ttylist, tp, tty_link);
2158: ++tty_count;
2159: }
2160:
2161: /*
2162: * Remove a tty from the tty list.
2163: */
2164: void
2165: tty_detach(tp)
2166: struct tty *tp;
2167: {
1.71 cgd 2168:
1.69 mrg 2169: --tty_count;
2170: #ifdef DIAGNOSTIC
2171: if (tty_count < 0)
2172: panic("tty_detach: tty_count < 0");
2173: #endif
1.70 mrg 2174: TAILQ_REMOVE(&ttylist, tp, tty_link);
1.69 mrg 2175: }
2176:
2177: /*
1.49 cgd 2178: * Allocate a tty structure and its associated buffers.
2179: */
2180: struct tty *
2181: ttymalloc()
2182: {
2183: struct tty *tp;
2184:
1.111 thorpej 2185: tp = pool_get(&tty_pool, PR_WAITOK);
1.109 perry 2186: memset(tp, 0, sizeof(*tp));
1.116 thorpej 2187: callout_init(&tp->t_outq_ch);
2188: callout_init(&tp->t_rstrt_ch);
1.84 mycroft 2189: /* XXX: default to 1024 chars for now */
2190: clalloc(&tp->t_rawq, 1024, 1);
2191: clalloc(&tp->t_canq, 1024, 1);
1.49 cgd 2192: /* output queue doesn't need quoting */
1.84 mycroft 2193: clalloc(&tp->t_outq, 1024, 0);
1.49 cgd 2194: return(tp);
2195: }
2196:
2197: /*
2198: * Free a tty structure and its buffers.
1.73 mrg 2199: *
2200: * Be sure to call tty_detach() for any tty that has been
2201: * tty_attach()ed.
1.49 cgd 2202: */
2203: void
2204: ttyfree(tp)
1.71 cgd 2205: struct tty *tp;
1.49 cgd 2206: {
1.71 cgd 2207:
1.116 thorpej 2208: callout_stop(&tp->t_outq_ch);
2209: callout_stop(&tp->t_rstrt_ch);
1.49 cgd 2210: clfree(&tp->t_rawq);
2211: clfree(&tp->t_canq);
2212: clfree(&tp->t_outq);
1.111 thorpej 2213: pool_put(&tty_pool, tp);
1.49 cgd 2214: }
CVSweb <webmaster@jp.NetBSD.org>