![[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 [Apple XNU] / XNU / bsd / kern|
Return to tty.c CVS log | Up to [Apple XNU] / XNU / bsd / kern |
1.1 root 1: /*
2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * The contents of this file constitute Original Code as defined in and
7: * are subject to the Apple Public Source License Version 1.1 (the
8: * "License"). You may not use this file except in compliance with the
9: * License. Please obtain a copy of the License at
10: * http://www.apple.com/publicsource and read it before using this file.
11: *
12: * This Original Code and all software distributed under the License are
13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
17: * License for the specific language governing rights and limitations
18: * under the License.
19: *
20: * @APPLE_LICENSE_HEADER_END@
21: */
22: /* Copyright (c) 1997 Apple Computer, Inc. All Rights Reserved */
23: /*-
24: * Copyright (c) 1982, 1986, 1990, 1991, 1993
25: * The Regents of the University of California. All rights reserved.
26: * (c) UNIX System Laboratories, Inc.
27: * All or some portions of this file are derived from material licensed
28: * to the University of California by American Telephone and Telegraph
29: * Co. or Unix System Laboratories, Inc. and are reproduced herein with
30: * the permission of UNIX System Laboratories, Inc.
31: *
32: * Redistribution and use in source and binary forms, with or without
33: * modification, are permitted provided that the following conditions
34: * are met:
35: * 1. Redistributions of source code must retain the above copyright
36: * notice, this list of conditions and the following disclaimer.
37: * 2. Redistributions in binary form must reproduce the above copyright
38: * notice, this list of conditions and the following disclaimer in the
39: * documentation and/or other materials provided with the distribution.
40: * 3. All advertising materials mentioning features or use of this software
41: * must display the following acknowledgement:
42: * This product includes software developed by the University of
43: * California, Berkeley and its contributors.
44: * 4. Neither the name of the University nor the names of its contributors
45: * may be used to endorse or promote products derived from this software
46: * without specific prior written permission.
47: *
48: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
49: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
50: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
51: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
52: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
53: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
54: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
55: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
56: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
57: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
58: * SUCH DAMAGE.
59: *
60: * @(#)tty.c 8.8 (Berkeley) 1/21/94
61: */
62: /*-
63: * TODO:
64: * o Fix races for sending the start char in ttyflush().
65: * o Handle inter-byte timeout for "MIN > 0, TIME > 0" in ttyselect().
66: * With luck, there will be MIN chars before select() returns().
67: * o Handle CLOCAL consistently for ptys. Perhaps disallow setting it.
68: * o Don't allow input in TS_ZOMBIE case. It would be visible through
69: * FIONREAD.
70: * o Do the new sio locking stuff here and use it to avoid special
71: * case for EXTPROC?
72: * o Lock PENDIN too?
73: * o Move EXTPROC and/or PENDIN to t_state?
74: * o Wrap most of ttioctl in spltty/splx.
75: * o Implement TIOCNOTTY or remove it from <sys/ioctl.h>.
76: * o Send STOP if IXOFF is toggled off while TS_TBLOCK is set.
77: * o Don't allow certain termios flags to affect disciplines other
78: * than TTYDISC. Cancel their effects before switch disciplines
79: * and ignore them if they are set while we are in another
80: * discipline.
81: * o Handle c_ispeed = 0 to c_ispeed = c_ospeed conversion here instead
82: * of in drivers and fix drivers that write to tp->t_termios.
83: * o Check for TS_CARR_ON being set while everything is closed and not
84: * waiting for carrier. TS_CARR_ON isn't cleared if nothing is open,
85: * so it would live until the next open even if carrier drops.
86: * o Restore TS_WOPEN since it is useful in pstat. It must be cleared
87: * only when _all_ openers leave open().
88: */
89: #ifdef NeXT
90: #define NSNP 0
91: #else
92: #include "snp.h"
93: #include "opt_uconsole.h"
94: #endif
95:
96: #include <sys/param.h>
97: #define TTYDEFCHARS 1
98: #include <sys/systm.h>
99: #undef TTYDEFCHARS
100: #include <sys/ioctl.h>
101: #include <sys/proc.h>
102: #include <sys/file.h>
103: #include <sys/conf.h>
104: #include <sys/dkstat.h>
105: #include <sys/uio.h>
106: #include <sys/kernel.h>
107: #include <sys/vnode.h>
108: #include <sys/syslog.h>
109: #include <sys/signalvar.h>
110: #ifndef NeXT
111: #include <sys/resourcevar.h>
112: #endif
113: #include <sys/malloc.h>
114: #if NSNP > 0
115: #include <sys/snoop.h>
116: #endif
117:
118: #ifndef NeXT
119: #include <vm/vm.h>
120: #include <vm/vm_param.h>
121: #include <vm/vm_prot.h>
122: #include <vm/lock.h>
123: #include <vm/pmap.h>
124: #include <vm/vm_map.h>
125: #else
126: #include <dev/kmreg_com.h>
127: #include <machine/cons.h>
128: #include <machine/spl.h>
129: #if 0 /* [ */
130: #include <machdep/machine/pmap.h>
131: #endif /* 0 ] */
132: #endif /* !NeXT */
133:
134: #ifndef NeXT
135: static int proc_compare __P((struct proc *p1, struct proc *p2));
136: #endif /* NeXT */
137: static int ttnread __P((struct tty *tp));
138: static void ttyecho __P((int c, struct tty *tp));
139: static int ttyoutput __P((int c, register struct tty *tp));
140: static void ttypend __P((struct tty *tp));
141: static void ttyretype __P((struct tty *tp));
142: static void ttyrub __P((int c, struct tty *tp));
143: static void ttyrubo __P((struct tty *tp, int cnt));
144: static void ttystop __P((struct tty *tp, int rw));
145: static void ttyunblock __P((struct tty *tp));
146: static int ttywflush __P((struct tty *tp));
147:
148: /*
149: * Table with character classes and parity. The 8th bit indicates parity,
150: * the 7th bit indicates the character is an alphameric or underscore (for
151: * ALTWERASE), and the low 6 bits indicate delay type. If the low 6 bits
152: * are 0 then the character needs no special processing on output; classes
153: * other than 0 might be translated or (not currently) require delays.
154: */
155: #define E 0x00 /* Even parity. */
156: #define O 0x80 /* Odd parity. */
157: #define PARITY(c) (char_type[c] & O)
158:
159: #define ALPHA 0x40 /* Alpha or underscore. */
160: #define ISALPHA(c) (char_type[(c) & TTY_CHARMASK] & ALPHA)
161:
162: #define CCLASSMASK 0x3f
163: #define CCLASS(c) (char_type[c] & CCLASSMASK)
164:
165: #define BS BACKSPACE
166: #define CC CONTROL
167: #define CR RETURN
168: #define NA ORDINARY | ALPHA
169: #define NL NEWLINE
170: #define NO ORDINARY
171: #define TB TAB
172: #define VT VTAB
173:
174: static u_char const char_type[] = {
175: E|CC, O|CC, O|CC, E|CC, O|CC, E|CC, E|CC, O|CC, /* nul - bel */
176: O|BS, E|TB, E|NL, O|CC, E|VT, O|CR, O|CC, E|CC, /* bs - si */
177: O|CC, E|CC, E|CC, O|CC, E|CC, O|CC, O|CC, E|CC, /* dle - etb */
178: E|CC, O|CC, O|CC, E|CC, O|CC, E|CC, E|CC, O|CC, /* can - us */
179: O|NO, E|NO, E|NO, O|NO, E|NO, O|NO, O|NO, E|NO, /* sp - ' */
180: E|NO, O|NO, O|NO, E|NO, O|NO, E|NO, E|NO, O|NO, /* ( - / */
181: E|NA, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* 0 - 7 */
182: O|NA, E|NA, E|NO, O|NO, E|NO, O|NO, O|NO, E|NO, /* 8 - ? */
183: O|NO, E|NA, E|NA, O|NA, E|NA, O|NA, O|NA, E|NA, /* @ - G */
184: E|NA, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* H - O */
185: E|NA, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* P - W */
186: O|NA, E|NA, E|NA, O|NO, E|NO, O|NO, O|NO, O|NA, /* X - _ */
187: E|NO, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* ` - g */
188: O|NA, E|NA, E|NA, O|NA, E|NA, O|NA, O|NA, E|NA, /* h - o */
189: O|NA, E|NA, E|NA, O|NA, E|NA, O|NA, O|NA, E|NA, /* p - w */
190: E|NA, O|NA, O|NA, E|NO, O|NO, E|NO, E|NO, O|CC, /* x - del */
191: /*
192: * Meta chars; should be settable per character set;
193: * for now, treat them all as normal characters.
194: */
195: NA, NA, NA, NA, NA, NA, NA, NA,
196: NA, NA, NA, NA, NA, NA, NA, NA,
197: NA, NA, NA, NA, NA, NA, NA, NA,
198: NA, NA, NA, NA, NA, NA, NA, NA,
199: NA, NA, NA, NA, NA, NA, NA, NA,
200: NA, NA, NA, NA, NA, NA, NA, NA,
201: NA, NA, NA, NA, NA, NA, NA, NA,
202: NA, NA, NA, NA, NA, NA, NA, NA,
203: NA, NA, NA, NA, NA, NA, NA, NA,
204: NA, NA, NA, NA, NA, NA, NA, NA,
205: NA, NA, NA, NA, NA, NA, NA, NA,
206: NA, NA, NA, NA, NA, NA, NA, NA,
207: NA, NA, NA, NA, NA, NA, NA, NA,
208: NA, NA, NA, NA, NA, NA, NA, NA,
209: NA, NA, NA, NA, NA, NA, NA, NA,
210: NA, NA, NA, NA, NA, NA, NA, NA,
211: };
212: #undef BS
213: #undef CC
214: #undef CR
215: #undef NA
216: #undef NL
217: #undef NO
218: #undef TB
219: #undef VT
220:
221: /* Macros to clear/set/test flags. */
222: #define SET(t, f) (t) |= (f)
223: #define CLR(t, f) (t) &= ~(f)
224: #define ISSET(t, f) ((t) & (f))
225:
226: /*
227: * Input control starts when we would not be able to fit the maximum
228: * contents of the ping-pong buffers and finishes when we would be able
229: * to fit that much plus 1/8 more.
230: */
231: #define I_HIGH_WATER (TTYHOG - 2 * 256) /* XXX */
232: #define I_LOW_WATER ((TTYHOG - 2 * 256) * 7 / 8) /* XXX */
233:
234: #undef MAX_INPUT /* XXX wrong in <sys/syslimits.h> */
235: #define MAX_INPUT TTYHOG
236:
237: /*
238: * Initial open of tty, or (re)entry to standard tty line discipline.
239: */
240: int
241: ttyopen(device, tp)
242: dev_t device;
243: register struct tty *tp;
244: {
245: int s;
246:
247: s = spltty();
248: tp->t_dev = device;
249: if (!ISSET(tp->t_state, TS_ISOPEN)) {
250: SET(tp->t_state, TS_ISOPEN);
251: if (ISSET(tp->t_cflag, CLOCAL)) {
252: SET(tp->t_state, TS_CONNECTED); }
253: bzero(&tp->t_winsize, sizeof(tp->t_winsize));
254: }
255:
256: #ifndef NeXT
257: /*
258: * Initialize or restore a cblock allocation policy suitable for
259: * the standard line discipline.
260: */
261: clist_alloc_cblocks(&tp->t_canq, TTYHOG, 512);
262: clist_alloc_cblocks(&tp->t_outq, TTMAXHIWAT + OBUFSIZ + 100,
263: TTMAXHIWAT + OBUFSIZ + 100);
264: clist_alloc_cblocks(&tp->t_rawq, TTYHOG, TTYHOG);
265: #endif /* !NeXT */
266:
267: splx(s);
268: return (0);
269: }
270:
271: /*
272: * Handle close() on a tty line: flush and set to initial state,
273: * bumping generation number so that pending read/write calls
274: * can detect recycling of the tty.
275: * XXX our caller should have done `spltty(); l_close(); ttyclose();'
276: * and l_close() should have flushed, but we repeat the spltty() and
277: * the flush in case there are buggy callers.
278: */
279: int
280: ttyclose(tp)
281: register struct tty *tp;
282: {
283: int s;
284:
285: s = spltty();
286: if (constty == tp) {
287: constty = NULL;
288:
289: splx(s);
290: spltty();
291:
292: #ifdef NeXT
293: /*
294: * Closing current console tty; disable printing of console
295: * messages at bottom-level driver.
296: */
297: (*cdevsw[major(tp->t_dev)].d_ioctl)
298: (tp->t_dev, KMIOCDISABLCONS, NULL, 0, current_proc());
299: #endif /* NeXT */
300: }
301:
302: ttyflush(tp, FREAD | FWRITE);
303: #ifndef NeXT
304: clist_free_cblocks(&tp->t_canq);
305: clist_free_cblocks(&tp->t_outq);
306: clist_free_cblocks(&tp->t_rawq);
307: #endif
308:
309: #if NSNP > 0
310: if (ISSET(tp->t_state, TS_SNOOP) && tp->t_sc != NULL)
311: snpdown((struct snoop *)tp->t_sc);
312: #endif
313:
314: tp->t_gen++;
315: tp->t_line = TTYDISC;
316: tp->t_pgrp = NULL;
317: tp->t_session = NULL;
318: tp->t_state = 0;
319: #if NeXT
320: selthreadclear(&tp->t_wsel);
321: selthreadclear(&tp->t_rsel);
322: #endif
323: splx(s);
324: return (0);
325: }
326:
327: #define FLUSHQ(q) { \
328: if ((q)->c_cc) \
329: ndflush(q, (q)->c_cc); \
330: }
331:
332: /* Is 'c' a line delimiter ("break" character)? */
333: #define TTBREAKC(c, lflag) \
334: ((c) == '\n' || (((c) == cc[VEOF] || \
335: (c) == cc[VEOL] || ((c) == cc[VEOL2] && lflag & IEXTEN)) && \
336: (c) != _POSIX_VDISABLE))
337:
338: /*
339: * Process input of a single character received on a tty.
340: */
341: int
342: ttyinput(c, tp)
343: register int c;
344: register struct tty *tp;
345: {
346: register tcflag_t iflag, lflag;
347: register cc_t *cc;
348: int i, err;
349:
350: /*
351: * If input is pending take it first.
352: */
353: lflag = tp->t_lflag;
354: if (ISSET(lflag, PENDIN))
355: ttypend(tp);
356: /*
357: * Gather stats.
358: */
359: if (ISSET(lflag, ICANON)) {
360: ++tk_cancc;
361: ++tp->t_cancc;
362: } else {
363: ++tk_rawcc;
364: ++tp->t_rawcc;
365: }
366: ++tk_nin;
367:
368: /*
369: * Block further input iff:
370: * current input > threshold AND input is available to user program
371: * AND input flow control is enabled and not yet invoked.
372: * The 3 is slop for PARMRK.
373: */
374: iflag = tp->t_iflag;
375: if (tp->t_rawq.c_cc + tp->t_canq.c_cc > I_HIGH_WATER - 3 &&
376: (!ISSET(lflag, ICANON) || tp->t_canq.c_cc != 0) &&
377: (ISSET(tp->t_cflag, CRTS_IFLOW) || ISSET(iflag, IXOFF)) &&
378: !ISSET(tp->t_state, TS_TBLOCK))
379: ttyblock(tp);
380:
381: /* Handle exceptional conditions (break, parity, framing). */
382: cc = tp->t_cc;
383: err = (ISSET(c, TTY_ERRORMASK));
384: if (err) {
385: CLR(c, TTY_ERRORMASK);
386: if (ISSET(err, TTY_BI)) {
387: if (ISSET(iflag, IGNBRK))
388: return (0);
389: if (ISSET(iflag, BRKINT)) {
390: ttyflush(tp, FREAD | FWRITE);
391: pgsignal(tp->t_pgrp, SIGINT, 1);
392: goto endcase;
393: }
394: if (ISSET(iflag, PARMRK))
395: goto parmrk;
396: } else if ((ISSET(err, TTY_PE) && ISSET(iflag, INPCK))
397: || ISSET(err, TTY_FE)) {
398: if (ISSET(iflag, IGNPAR))
399: return (0);
400: else if (ISSET(iflag, PARMRK)) {
401: parmrk:
402: if (tp->t_rawq.c_cc + tp->t_canq.c_cc >
403: MAX_INPUT - 3)
404: goto input_overflow;
405: (void)putc(0377 | TTY_QUOTE, &tp->t_rawq);
406: (void)putc(0 | TTY_QUOTE, &tp->t_rawq);
407: (void)putc(c | TTY_QUOTE, &tp->t_rawq);
408: goto endcase;
409: } else
410: c = 0;
411: }
412: }
413:
414: if (!ISSET(tp->t_state, TS_TYPEN) && ISSET(iflag, ISTRIP))
415: CLR(c, 0x80);
416: if (!ISSET(lflag, EXTPROC)) {
417: /*
418: * Check for literal nexting very first
419: */
420: if (ISSET(tp->t_state, TS_LNCH)) {
421: SET(c, TTY_QUOTE);
422: CLR(tp->t_state, TS_LNCH);
423: }
424: /*
425: * Scan for special characters. This code
426: * is really just a big case statement with
427: * non-constant cases. The bottom of the
428: * case statement is labeled ``endcase'', so goto
429: * it after a case match, or similar.
430: */
431:
432: /*
433: * Control chars which aren't controlled
434: * by ICANON, ISIG, or IXON.
435: */
436: if (ISSET(lflag, IEXTEN)) {
437: if (CCEQ(cc[VLNEXT], c)) {
438: if (ISSET(lflag, ECHO)) {
439: if (ISSET(lflag, ECHOE)) {
440: (void)ttyoutput('^', tp);
441: (void)ttyoutput('\b', tp);
442: } else
443: ttyecho(c, tp);
444: }
445: SET(tp->t_state, TS_LNCH);
446: goto endcase;
447: }
448: if (CCEQ(cc[VDISCARD], c)) {
449: if (ISSET(lflag, FLUSHO))
450: CLR(tp->t_lflag, FLUSHO);
451: else {
452: ttyflush(tp, FWRITE);
453: ttyecho(c, tp);
454: if (tp->t_rawq.c_cc + tp->t_canq.c_cc)
455: ttyretype(tp);
456: SET(tp->t_lflag, FLUSHO);
457: }
458: goto startoutput;
459: }
460: }
461: /*
462: * Signals.
463: */
464: if (ISSET(lflag, ISIG)) {
465: if (CCEQ(cc[VINTR], c) || CCEQ(cc[VQUIT], c)) {
466: if (!ISSET(lflag, NOFLSH))
467: ttyflush(tp, FREAD | FWRITE);
468: ttyecho(c, tp);
469: pgsignal(tp->t_pgrp,
470: CCEQ(cc[VINTR], c) ? SIGINT : SIGQUIT, 1);
471: goto endcase;
472: }
473: if (CCEQ(cc[VSUSP], c)) {
474: if (!ISSET(lflag, NOFLSH))
475: ttyflush(tp, FREAD);
476: ttyecho(c, tp);
477: pgsignal(tp->t_pgrp, SIGTSTP, 1);
478: goto endcase;
479: }
480: }
481: /*
482: * Handle start/stop characters.
483: */
484: if (ISSET(iflag, IXON)) {
485: if (CCEQ(cc[VSTOP], c)) {
486: if (!ISSET(tp->t_state, TS_TTSTOP)) {
487: SET(tp->t_state, TS_TTSTOP);
488: ttystop(tp, 0);
489: return (0);
490: }
491: if (!CCEQ(cc[VSTART], c))
492: return (0);
493: /*
494: * if VSTART == VSTOP then toggle
495: */
496: goto endcase;
497: }
498: if (CCEQ(cc[VSTART], c))
499: goto restartoutput;
500: }
501: /*
502: * IGNCR, ICRNL, & INLCR
503: */
504: if (c == '\r') {
505: if (ISSET(iflag, IGNCR))
506: return (0);
507: else if (ISSET(iflag, ICRNL))
508: c = '\n';
509: } else if (c == '\n' && ISSET(iflag, INLCR))
510: c = '\r';
511: }
512: if (!ISSET(tp->t_lflag, EXTPROC) && ISSET(lflag, ICANON)) {
513: /*
514: * From here on down canonical mode character
515: * processing takes place.
516: */
517: /*
518: * erase (^H / ^?)
519: */
520: if (CCEQ(cc[VERASE], c)) {
521: if (tp->t_rawq.c_cc)
522: ttyrub(unputc(&tp->t_rawq), tp);
523: goto endcase;
524: }
525: /*
526: * kill (^U)
527: */
528: if (CCEQ(cc[VKILL], c)) {
529: if (ISSET(lflag, ECHOKE) &&
530: tp->t_rawq.c_cc == tp->t_rocount &&
531: !ISSET(lflag, ECHOPRT))
532: while (tp->t_rawq.c_cc)
533: ttyrub(unputc(&tp->t_rawq), tp);
534: else {
535: ttyecho(c, tp);
536: if (ISSET(lflag, ECHOK) ||
537: ISSET(lflag, ECHOKE))
538: ttyecho('\n', tp);
539: FLUSHQ(&tp->t_rawq);
540: tp->t_rocount = 0;
541: }
542: CLR(tp->t_state, TS_LOCAL);
543: goto endcase;
544: }
545: /*
546: * word erase (^W)
547: */
548: if (CCEQ(cc[VWERASE], c) && ISSET(lflag, IEXTEN)) {
549: int ctype;
550:
551: /*
552: * erase whitespace
553: */
554: while ((c = unputc(&tp->t_rawq)) == ' ' || c == '\t')
555: ttyrub(c, tp);
556: if (c == -1)
557: goto endcase;
558: /*
559: * erase last char of word and remember the
560: * next chars type (for ALTWERASE)
561: */
562: ttyrub(c, tp);
563: c = unputc(&tp->t_rawq);
564: if (c == -1)
565: goto endcase;
566: if (c == ' ' || c == '\t') {
567: (void)putc(c, &tp->t_rawq);
568: goto endcase;
569: }
570: ctype = ISALPHA(c);
571: /*
572: * erase rest of word
573: */
574: do {
575: ttyrub(c, tp);
576: c = unputc(&tp->t_rawq);
577: if (c == -1)
578: goto endcase;
579: } while (c != ' ' && c != '\t' &&
580: (!ISSET(lflag, ALTWERASE) || ISALPHA(c) == ctype));
581: (void)putc(c, &tp->t_rawq);
582: goto endcase;
583: }
584: /*
585: * reprint line (^R)
586: */
587: if (CCEQ(cc[VREPRINT], c) && ISSET(lflag, IEXTEN)) {
588: ttyretype(tp);
589: goto endcase;
590: }
591: /*
592: * ^T - kernel info and generate SIGINFO
593: */
594: if (CCEQ(cc[VSTATUS], c) && ISSET(lflag, IEXTEN)) {
595: if (ISSET(lflag, ISIG))
596: pgsignal(tp->t_pgrp, SIGINFO, 1);
597: if (!ISSET(lflag, NOKERNINFO))
598: ttyinfo(tp);
599: goto endcase;
600: }
601: }
602: /*
603: * Check for input buffer overflow
604: */
605: if (tp->t_rawq.c_cc + tp->t_canq.c_cc >= MAX_INPUT) {
606: input_overflow:
607: if (ISSET(iflag, IMAXBEL)) {
608: if (tp->t_outq.c_cc < tp->t_hiwat)
609: (void)ttyoutput(CTRL('g'), tp);
610: }
611: goto endcase;
612: }
613:
614: if ( c == 0377 && ISSET(iflag, PARMRK) && !ISSET(iflag, ISTRIP)
615: && ISSET(iflag, IGNBRK|IGNPAR) != (IGNBRK|IGNPAR))
616: (void)putc(0377 | TTY_QUOTE, &tp->t_rawq);
617:
618: /*
619: * Put data char in q for user and
620: * wakeup on seeing a line delimiter.
621: */
622: if (putc(c, &tp->t_rawq) >= 0) {
623: if (!ISSET(lflag, ICANON)) {
624: ttwakeup(tp);
625: ttyecho(c, tp);
626: goto endcase;
627: }
628: if (TTBREAKC(c, lflag)) {
629: tp->t_rocount = 0;
630: catq(&tp->t_rawq, &tp->t_canq);
631: ttwakeup(tp);
632: } else if (tp->t_rocount++ == 0)
633: tp->t_rocol = tp->t_column;
634: if (ISSET(tp->t_state, TS_ERASE)) {
635: /*
636: * end of prterase \.../
637: */
638: CLR(tp->t_state, TS_ERASE);
639: (void)ttyoutput('/', tp);
640: }
641: i = tp->t_column;
642: ttyecho(c, tp);
643: if (CCEQ(cc[VEOF], c) && ISSET(lflag, ECHO)) {
644: /*
645: * Place the cursor over the '^' of the ^D.
646: */
647: i = min(2, tp->t_column - i);
648: while (i > 0) {
649: (void)ttyoutput('\b', tp);
650: i--;
651: }
652: }
653: }
654: endcase:
655: /*
656: * IXANY means allow any character to restart output.
657: */
658: if (ISSET(tp->t_state, TS_TTSTOP) &&
659: !ISSET(iflag, IXANY) && cc[VSTART] != cc[VSTOP])
660: return (0);
661: restartoutput:
662: CLR(tp->t_lflag, FLUSHO);
663: CLR(tp->t_state, TS_TTSTOP);
664: startoutput:
665: return (ttstart(tp));
666: }
667:
668: /*
669: * Output a single character on a tty, doing output processing
670: * as needed (expanding tabs, newline processing, etc.).
671: * Returns < 0 if succeeds, otherwise returns char to resend.
672: * Must be recursive.
673: */
674: static int
675: ttyoutput(c, tp)
676: register int c;
677: register struct tty *tp;
678: {
679: register tcflag_t oflag;
680: register int col, s;
681:
682: oflag = tp->t_oflag;
683: if (!ISSET(oflag, OPOST)) {
684: if (ISSET(tp->t_lflag, FLUSHO))
685: return (-1);
686: if (putc(c, &tp->t_outq))
687: return (c);
688: tk_nout++;
689: tp->t_outcc++;
690: return (-1);
691: }
692: /*
693: * Do tab expansion if OXTABS is set. Special case if we external
694: * processing, we don't do the tab expansion because we'll probably
695: * get it wrong. If tab expansion needs to be done, let it happen
696: * externally.
697: */
698: CLR(c, ~TTY_CHARMASK);
699: if (c == '\t' &&
700: ISSET(oflag, OXTABS) && !ISSET(tp->t_lflag, EXTPROC)) {
701: c = 8 - (tp->t_column & 7);
702: if (!ISSET(tp->t_lflag, FLUSHO)) {
703: s = spltty(); /* Don't interrupt tabs. */
704: c -= b_to_q(" ", c, &tp->t_outq);
705: tk_nout += c;
706: tp->t_outcc += c;
707: splx(s);
708: }
709: tp->t_column += c;
710: return (c ? -1 : '\t');
711: }
712: if (c == CEOT && ISSET(oflag, ONOEOT))
713: return (-1);
714:
715: /*
716: * Newline translation: if ONLCR is set,
717: * translate newline into "\r\n".
718: */
719: if (c == '\n' && ISSET(tp->t_oflag, ONLCR)) {
720: tk_nout++;
721: tp->t_outcc++;
722: if (putc('\r', &tp->t_outq))
723: return (c);
724: }
725: tk_nout++;
726: tp->t_outcc++;
727: if (!ISSET(tp->t_lflag, FLUSHO) && putc(c, &tp->t_outq))
728: return (c);
729:
730: col = tp->t_column;
731: switch (CCLASS(c)) {
732: case BACKSPACE:
733: if (col > 0)
734: --col;
735: break;
736: case CONTROL:
737: break;
738: case NEWLINE:
739: case RETURN:
740: col = 0;
741: break;
742: case ORDINARY:
743: ++col;
744: break;
745: case TAB:
746: col = (col + 8) & ~7;
747: break;
748: }
749: tp->t_column = col;
750: return (-1);
751: }
752:
753: /*
754: * Ioctls for all tty devices. Called after line-discipline specific ioctl
755: * has been called to do discipline-specific functions and/or reject any
756: * of these ioctl commands.
757: */
758: /* ARGSUSED */
759: int
760: #ifndef NeXT
761: ttioctl(tp, cmd, data, flag)
762: register struct tty *tp;
763: int cmd, flag;
764: void *data;
765: #else
766: ttioctl(tp, cmd, data, flag, p)
767: register struct tty *tp;
768: u_long cmd;
769: caddr_t data;
770: int flag;
771: struct proc *p;
772: #endif
773: {
774: #ifndef NeXT
775: register struct proc *p = curproc; /* XXX */
776: #endif
777: int s, error;
778:
779: /* If the ioctl involves modification, hang if in the background. */
780: switch (cmd) {
781: case TIOCFLUSH:
782: case TIOCSETA:
783: case TIOCSETD:
784: case TIOCSETAF:
785: case TIOCSETAW:
786: #ifdef notdef
787: case TIOCSPGRP:
788: #endif
789: case TIOCSTAT:
790: case TIOCSTI:
791: case TIOCSWINSZ:
792: #if defined(COMPAT_43) || defined(COMPAT_SUNOS)
793: case TIOCLBIC:
794: case TIOCLBIS:
795: case TIOCLSET:
796: case TIOCSETC:
797: case OTIOCSETD:
798: case TIOCSETN:
799: case TIOCSETP:
800: case TIOCSLTC:
801: #endif
802: while (isbackground(p, tp) &&
803: (p->p_flag & P_PPWAIT) == 0 &&
804: (p->p_sigignore & sigmask(SIGTTOU)) == 0 &&
805: (p->p_sigmask & sigmask(SIGTTOU)) == 0) {
806: if (p->p_pgrp->pg_jobc == 0)
807: return (EIO);
808: pgsignal(p->p_pgrp, SIGTTOU, 1);
809: error = ttysleep(tp, &lbolt, TTOPRI | PCATCH, "ttybg1",
810: 0);
811: if (error)
812: return (error);
813: }
814: break;
815: }
816:
817: switch (cmd) { /* Process the ioctl. */
818: case FIOASYNC: /* set/clear async i/o */
819: s = spltty();
820: if (*(int *)data)
821: SET(tp->t_state, TS_ASYNC);
822: else
823: CLR(tp->t_state, TS_ASYNC);
824: splx(s);
825: break;
826: case FIONBIO: /* set/clear non-blocking i/o */
827: break; /* XXX: delete. */
828: case FIONREAD: /* get # bytes to read */
829: s = spltty();
830: *(int *)data = ttnread(tp);
831: splx(s);
832: break;
833: case TIOCEXCL: /* set exclusive use of tty */
834: s = spltty();
835: SET(tp->t_state, TS_XCLUDE);
836: splx(s);
837: break;
838: case TIOCFLUSH: { /* flush buffers */
839: register int flags = *(int *)data;
840:
841: if (flags == 0)
842: flags = FREAD | FWRITE;
843: else
844: flags &= FREAD | FWRITE;
845: ttyflush(tp, flags);
846: break;
847: }
848: #ifdef NeXT
849: case TIOCSCONS: {
850: /* Set current console device to this line */
851: int bogusData = 1;
852: data = (caddr_t) &bogusData;
853:
854: /* No break - Fall through to BSD code */
855: }
856: #endif /* NeXT */
857: case TIOCCONS: { /* become virtual console */
858: if (*(int *)data) {
859: if (constty && constty != tp &&
860: ISSET(constty->t_state, TS_CONNECTED)) {
861: return (EBUSY);
862: }
863: #if defined(NeXT) || !defined(UCONSOLE)
864: if ( (error = suser(p->p_ucred, &p->p_acflag)) )
865: return (error);
866: #endif
867: constty = tp;
868: } else if (tp == constty) {
869: constty = NULL;
870: }
871: #ifdef NeXT
872: if (constty) {
873: (*cdevsw[major(cons.t_dev)].d_ioctl)
874: (cons.t_dev, KMIOCDISABLCONS, NULL, 0, p);
875: } else {
876: (*cdevsw[major(tp->t_dev)].d_ioctl)
877: (tp->t_dev, KMIOCDISABLCONS, NULL, 0, p);
878: }
879: #endif /* NeXT */
880: break;
881: }
882: case TIOCDRAIN: /* wait till output drained */
883: error = ttywait(tp);
884: if (error)
885: return (error);
886: break;
887: case TIOCGETA: { /* get termios struct */
888: struct termios *t = (struct termios *)data;
889:
890: bcopy(&tp->t_termios, t, sizeof(struct termios));
891: break;
892: }
893: case TIOCGETD: /* get line discipline */
894: *(int *)data = tp->t_line;
895: break;
896: case TIOCGWINSZ: /* get window size */
897: *(struct winsize *)data = tp->t_winsize;
898: break;
899: case TIOCGPGRP: /* get pgrp of tty */
900: if (!isctty(p, tp))
901: return (ENOTTY);
902: *(int *)data = tp->t_pgrp ? tp->t_pgrp->pg_id : NO_PID;
903: break;
904: #ifdef TIOCHPCL
905: case TIOCHPCL: /* hang up on last close */
906: s = spltty();
907: SET(tp->t_cflag, HUPCL);
908: splx(s);
909: break;
910: #endif
911: case TIOCNXCL: /* reset exclusive use of tty */
912: s = spltty();
913: CLR(tp->t_state, TS_XCLUDE);
914: splx(s);
915: break;
916: case TIOCOUTQ: /* output queue size */
917: *(int *)data = tp->t_outq.c_cc;
918: break;
919: case TIOCSETA: /* set termios struct */
920: case TIOCSETAW: /* drain output, set */
921: case TIOCSETAF: { /* drn out, fls in, set */
922: register struct termios *t = (struct termios *)data;
923:
924: if (t->c_ispeed < 0 || t->c_ospeed < 0)
925: return (EINVAL);
926: s = spltty();
927: if (cmd == TIOCSETAW || cmd == TIOCSETAF) {
928: error = ttywait(tp);
929: if (error) {
930: splx(s);
931: return (error);
932: }
933: if (cmd == TIOCSETAF)
934: ttyflush(tp, FREAD);
935: }
936: if (!ISSET(t->c_cflag, CIGNORE)) {
937: /*
938: * Set device hardware.
939: */
940: if (tp->t_param && (error = (*tp->t_param)(tp, t))) {
941: splx(s);
942: return (error);
943: }
944: if (ISSET(t->c_cflag, CLOCAL) &&
945: !ISSET(tp->t_cflag, CLOCAL)) {
946: /*
947: * XXX disconnections would be too hard to
948: * get rid of without this kludge. The only
949: * way to get rid of controlling terminals
950: * is to exit from the session leader.
951: */
952: CLR(tp->t_state, TS_ZOMBIE);
953:
954: wakeup(TSA_CARR_ON(tp));
955: ttwakeup(tp);
956: ttwwakeup(tp);
957: }
958: if ((ISSET(tp->t_state, TS_CARR_ON) ||
959: ISSET(t->c_cflag, CLOCAL)) &&
960: !ISSET(tp->t_state, TS_ZOMBIE))
961: SET(tp->t_state, TS_CONNECTED);
962: else
963: CLR(tp->t_state, TS_CONNECTED);
964: tp->t_cflag = t->c_cflag;
965: tp->t_ispeed = t->c_ispeed;
966: tp->t_ospeed = t->c_ospeed;
967: ttsetwater(tp);
968: }
969: if (ISSET(t->c_lflag, ICANON) != ISSET(tp->t_lflag, ICANON) &&
970: cmd != TIOCSETAF) {
971: if (ISSET(t->c_lflag, ICANON))
972: SET(tp->t_lflag, PENDIN);
973: else {
974: /*
975: * XXX we really shouldn't allow toggling
976: * ICANON while we're in a non-termios line
977: * discipline. Now we have to worry about
978: * panicing for a null queue.
979: */
980: #ifndef NeXT
981: if (tp->t_canq.c_cbreserved > 0 &&
982: tp->t_rawq.c_cbreserved > 0) {
983: catq(&tp->t_rawq, &tp->t_canq);
984: /*
985: * XXX the queue limits may be
986: * different, so the old queue
987: * swapping method no longer works.
988: */
989: catq(&tp->t_canq, &tp->t_rawq);
990: }
991: #else
992: if (tp->t_rawq.c_cs && tp->t_canq.c_cs) {
993: struct clist tq;
994:
995: catq(&tp->t_rawq, &tp->t_canq);
996: tq = tp->t_rawq;
997: tp->t_rawq = tp->t_canq;
998: tp->t_canq = tq;
999: }
1000: #endif /* !NeXT */
1001: CLR(tp->t_lflag, PENDIN);
1002: }
1003: ttwakeup(tp);
1004: }
1005: tp->t_iflag = t->c_iflag;
1006: tp->t_oflag = t->c_oflag;
1007: /*
1008: * Make the EXTPROC bit read only.
1009: */
1010: if (ISSET(tp->t_lflag, EXTPROC))
1011: SET(t->c_lflag, EXTPROC);
1012: else
1013: CLR(t->c_lflag, EXTPROC);
1014: tp->t_lflag = t->c_lflag | ISSET(tp->t_lflag, PENDIN);
1015: if (t->c_cc[VMIN] != tp->t_cc[VMIN] ||
1016: t->c_cc[VTIME] != tp->t_cc[VTIME])
1017: ttwakeup(tp);
1018: bcopy(t->c_cc, tp->t_cc, sizeof(t->c_cc));
1019: splx(s);
1020: break;
1021: }
1022: case TIOCSETD: { /* set line discipline */
1023: register int t = *(int *)data;
1024: dev_t device = tp->t_dev;
1025: extern int nlinesw;
1026:
1027: if ((u_int)t >= nlinesw)
1028: return (ENXIO);
1029: if (t != tp->t_line) {
1030: s = spltty();
1031: (*linesw[tp->t_line].l_close)(tp, flag);
1032: error = (*linesw[t].l_open)(device, tp);
1033: if (error) {
1034: (void)(*linesw[tp->t_line].l_open)(device, tp);
1035: splx(s);
1036: return (error);
1037: }
1038: tp->t_line = t;
1039: splx(s);
1040: }
1041: break;
1042: }
1043: case TIOCSTART: /* start output, like ^Q */
1044: s = spltty();
1045: if (ISSET(tp->t_state, TS_TTSTOP) ||
1046: ISSET(tp->t_lflag, FLUSHO)) {
1047: CLR(tp->t_lflag, FLUSHO);
1048: CLR(tp->t_state, TS_TTSTOP);
1049: ttstart(tp);
1050: }
1051: splx(s);
1052: break;
1053: case TIOCSTI: /* simulate terminal input */
1054: if (p->p_ucred->cr_uid && (flag & FREAD) == 0)
1055: return (EPERM);
1056: if (p->p_ucred->cr_uid && !isctty(p, tp))
1057: return (EACCES);
1058: s = spltty();
1059: (*linesw[tp->t_line].l_rint)(*(u_char *)data, tp);
1060: splx(s);
1061: break;
1062: case TIOCSTOP: /* stop output, like ^S */
1063: s = spltty();
1064: if (!ISSET(tp->t_state, TS_TTSTOP)) {
1065: SET(tp->t_state, TS_TTSTOP);
1066: ttystop(tp, 0);
1067: }
1068: splx(s);
1069: break;
1070: case TIOCSCTTY: /* become controlling tty */
1071: /* Session ctty vnode pointer set in vnode layer. */
1072: if (!SESS_LEADER(p) ||
1073: ((p->p_session->s_ttyvp || tp->t_session) &&
1074: (tp->t_session != p->p_session)))
1075: return (EPERM);
1076: tp->t_session = p->p_session;
1077: tp->t_pgrp = p->p_pgrp;
1078: p->p_session->s_ttyp = tp;
1079: p->p_flag |= P_CONTROLT;
1080: break;
1081: case TIOCSPGRP: { /* set pgrp of tty */
1082: register struct pgrp *pgrp = pgfind(*(int *)data);
1083:
1084: if (!isctty(p, tp))
1085: return (ENOTTY);
1086: else if (pgrp == NULL || pgrp->pg_session != p->p_session)
1087: return (EPERM);
1088: tp->t_pgrp = pgrp;
1089: break;
1090: }
1091: case TIOCSTAT: /* simulate control-T */
1092: s = spltty();
1093: ttyinfo(tp);
1094: splx(s);
1095: break;
1096: case TIOCSWINSZ: /* set window size */
1097: if (bcmp((caddr_t)&tp->t_winsize, data,
1098: sizeof (struct winsize))) {
1099: tp->t_winsize = *(struct winsize *)data;
1100: pgsignal(tp->t_pgrp, SIGWINCH, 1);
1101: }
1102: break;
1103: case TIOCSDRAINWAIT:
1104: error = suser(p->p_ucred, &p->p_acflag);
1105: if (error)
1106: return (error);
1107: tp->t_timeout = *(int *)data * hz;
1108: wakeup(TSA_OCOMPLETE(tp));
1109: wakeup(TSA_OLOWAT(tp));
1110: break;
1111: case TIOCGDRAINWAIT:
1112: *(int *)data = tp->t_timeout / hz;
1113: break;
1114: default:
1115: #if defined(COMPAT_43) || defined(COMPAT_SUNOS)
1116: #ifdef NeXT
1117: return (ttcompat(tp, cmd, data, flag, p));
1118: #else
1119: return (ttcompat(tp, cmd, data, flag));
1120: #endif /* NeXT */
1121: #else
1122: return (-1);
1123: #endif
1124: }
1125:
1126: return (0);
1127: }
1128:
1129: int
1130: ttyselect(tp, rw, p)
1131: struct tty *tp;
1132: int rw;
1133: struct proc *p;
1134: {
1135: int s;
1136:
1137: if (tp == NULL)
1138: return (ENXIO);
1139:
1140: s = spltty();
1141: switch (rw) {
1142: case FREAD:
1143: if (ttnread(tp) > 0 || ISSET(tp->t_state, TS_ZOMBIE))
1144: goto win;
1145: selrecord(p, &tp->t_rsel);
1146: break;
1147: case FWRITE:
1148: if ((tp->t_outq.c_cc <= tp->t_lowat &&
1149: ISSET(tp->t_state, TS_CONNECTED))
1150: || ISSET(tp->t_state, TS_ZOMBIE)) {
1151: win: splx(s);
1152: return (1);
1153: }
1154: selrecord(p, &tp->t_wsel);
1155: break;
1156: }
1157: splx(s);
1158: return (0);
1159: }
1160:
1161: /*
1162: * This is a wrapper for compatibility with the select vector used by
1163: * cdevsw. It relies on a proper xxxdevtotty routine.
1164: */
1165: int
1166: ttselect(dev, rw, p)
1167: dev_t dev;
1168: int rw;
1169: struct proc *p;
1170: {
1171: #ifndef NeXT
1172: return ttyselect((*cdevsw[major(dev)]->d_devtotty)(dev), rw, p);
1173: #else
1174: return ttyselect(cdevsw[major(dev)].d_ttys[minor(dev)], rw, p);
1175: #endif
1176: }
1177:
1178: /*
1179: * Must be called at spltty().
1180: */
1181: static int
1182: ttnread(tp)
1183: struct tty *tp;
1184: {
1185: int nread;
1186:
1187: if (ISSET(tp->t_lflag, PENDIN))
1188: ttypend(tp);
1189: nread = tp->t_canq.c_cc;
1190: if (!ISSET(tp->t_lflag, ICANON)) {
1191: nread += tp->t_rawq.c_cc;
1192: if (nread < tp->t_cc[VMIN] && tp->t_cc[VTIME] == 0)
1193: nread = 0;
1194: }
1195: return (nread);
1196: }
1197:
1198: /*
1199: * Wait for output to drain.
1200: */
1201: int
1202: ttywait(tp)
1203: register struct tty *tp;
1204: {
1205: int error, s;
1206:
1207: error = 0;
1208: s = spltty();
1209: while ((tp->t_outq.c_cc || ISSET(tp->t_state, TS_BUSY)) &&
1210: ISSET(tp->t_state, TS_CONNECTED) && tp->t_oproc) {
1211: (*tp->t_oproc)(tp);
1212: if ((tp->t_outq.c_cc || ISSET(tp->t_state, TS_BUSY)) &&
1213: ISSET(tp->t_state, TS_CONNECTED)) {
1214: SET(tp->t_state, TS_SO_OCOMPLETE);
1215: error = ttysleep(tp, TSA_OCOMPLETE(tp),
1216: TTOPRI | PCATCH, "ttywai",
1217: tp->t_timeout);
1218: if (error) {
1219: if (error == EWOULDBLOCK)
1220: error = EIO;
1221: break;
1222: }
1223: } else
1224: break;
1225: }
1226: if (!error && (tp->t_outq.c_cc || ISSET(tp->t_state, TS_BUSY)))
1227: error = EIO;
1228: splx(s);
1229: return (error);
1230: }
1231:
1232: static void
1233: ttystop(tp, rw)
1234: struct tty *tp;
1235: int rw;
1236: {
1237: #ifdef sun4c /* XXX */
1238: (*tp->t_stop)(tp, rw);
1239: #elif defined(NeXT)
1240: (*cdevsw[major(tp->t_dev)].d_stop)(tp, rw);
1241: #else
1242: (*cdevsw[major(tp->t_dev)]->d_stop)(tp, rw);
1243: #endif
1244: }
1245:
1246: /*
1247: * Flush if successfully wait.
1248: */
1249: static int
1250: ttywflush(tp)
1251: struct tty *tp;
1252: {
1253: int error;
1254:
1255: if ((error = ttywait(tp)) == 0)
1256: ttyflush(tp, FREAD);
1257: return (error);
1258: }
1259:
1260: /*
1261: * Flush tty read and/or write queues, notifying anyone waiting.
1262: */
1263: void
1264: ttyflush(tp, rw)
1265: register struct tty *tp;
1266: int rw;
1267: {
1268: register int s;
1269:
1270: s = spltty();
1271: #if 0
1272: again:
1273: #endif
1274: if (rw & FWRITE) {
1275: FLUSHQ(&tp->t_outq);
1276: CLR(tp->t_state, TS_TTSTOP);
1277: }
1278: ttystop(tp, rw);
1279: if (rw & FREAD) {
1280: FLUSHQ(&tp->t_canq);
1281: FLUSHQ(&tp->t_rawq);
1282: CLR(tp->t_lflag, PENDIN);
1283: tp->t_rocount = 0;
1284: tp->t_rocol = 0;
1285: CLR(tp->t_state, TS_LOCAL);
1286: ttwakeup(tp);
1287: if (ISSET(tp->t_state, TS_TBLOCK)) {
1288: if (rw & FWRITE)
1289: FLUSHQ(&tp->t_outq);
1290: ttyunblock(tp);
1291:
1292: /*
1293: * Don't let leave any state that might clobber the
1294: * next line discipline (although we should do more
1295: * to send the START char). Not clearing the state
1296: * may have caused the "putc to a clist with no
1297: * reserved cblocks" panic/printf.
1298: */
1299: CLR(tp->t_state, TS_TBLOCK);
1300:
1301: #if 0 /* forget it, sleeping isn't always safe and we don't know when it is */
1302: if (ISSET(tp->t_iflag, IXOFF)) {
1303: /*
1304: * XXX wait a bit in the hope that the stop
1305: * character (if any) will go out. Waiting
1306: * isn't good since it allows races. This
1307: * will be fixed when the stop character is
1308: * put in a special queue. Don't bother with
1309: * the checks in ttywait() since the timeout
1310: * will save us.
1311: */
1312: SET(tp->t_state, TS_SO_OCOMPLETE);
1313: ttysleep(tp, TSA_OCOMPLETE(tp), TTOPRI,
1314: "ttyfls", hz / 10);
1315: /*
1316: * Don't try sending the stop character again.
1317: */
1318: CLR(tp->t_state, TS_TBLOCK);
1319: goto again;
1320: }
1321: #endif
1322: }
1323: }
1324: if (rw & FWRITE) {
1325: FLUSHQ(&tp->t_outq);
1326: ttwwakeup(tp);
1327: }
1328: splx(s);
1329: }
1330:
1331: /*
1332: * Copy in the default termios characters.
1333: */
1334: void
1335: termioschars(t)
1336: struct termios *t;
1337: {
1338:
1339: bcopy(ttydefchars, t->c_cc, sizeof t->c_cc);
1340: }
1341:
1342: /*
1343: * Old interface.
1344: */
1345: void
1346: ttychars(tp)
1347: struct tty *tp;
1348: {
1349:
1350: termioschars(&tp->t_termios);
1351: }
1352:
1353: /*
1354: * Handle input high water. Send stop character for the IXOFF case. Turn
1355: * on our input flow control bit and propagate the changes to the driver.
1356: * XXX the stop character should be put in a special high priority queue.
1357: */
1358: void
1359: ttyblock(tp)
1360: struct tty *tp;
1361: {
1362:
1363: SET(tp->t_state, TS_TBLOCK);
1364: if (ISSET(tp->t_iflag, IXOFF) && tp->t_cc[VSTOP] != _POSIX_VDISABLE &&
1365: putc(tp->t_cc[VSTOP], &tp->t_outq) != 0)
1366: CLR(tp->t_state, TS_TBLOCK); /* try again later */
1367: ttstart(tp);
1368: }
1369:
1370: /*
1371: * Handle input low water. Send start character for the IXOFF case. Turn
1372: * off our input flow control bit and propagate the changes to the driver.
1373: * XXX the start character should be put in a special high priority queue.
1374: */
1375: static void
1376: ttyunblock(tp)
1377: struct tty *tp;
1378: {
1379:
1380: CLR(tp->t_state, TS_TBLOCK);
1381: if (ISSET(tp->t_iflag, IXOFF) && tp->t_cc[VSTART] != _POSIX_VDISABLE &&
1382: putc(tp->t_cc[VSTART], &tp->t_outq) != 0)
1383: SET(tp->t_state, TS_TBLOCK); /* try again later */
1384: ttstart(tp);
1385: }
1386:
1387: #if defined(NeXT) || defined(notyet)
1388: /* FreeBSD: Not used by any current (i386) drivers. */
1389: /*
1390: * Restart after an inter-char delay.
1391: */
1392: void
1393: ttrstrt(tp_arg)
1394: void *tp_arg;
1395: {
1396: struct tty *tp;
1397: int s;
1398:
1399: #if DIAGNOSTIC
1400: if (tp_arg == NULL)
1401: panic("ttrstrt");
1402: #endif
1403: tp = tp_arg;
1404: s = spltty();
1405:
1406: CLR(tp->t_state, TS_TIMEOUT);
1407: ttstart(tp);
1408:
1409: splx(s);
1410: }
1411: #endif /* NeXT || notyet */
1412:
1413: int
1414: ttstart(tp)
1415: struct tty *tp;
1416: {
1417:
1418: if (tp->t_oproc != NULL) /* XXX: Kludge for pty. */
1419: (*tp->t_oproc)(tp);
1420: return (0);
1421: }
1422:
1423: /*
1424: * "close" a line discipline
1425: */
1426: int
1427: ttylclose(tp, flag)
1428: struct tty *tp;
1429: int flag;
1430: {
1431: if ( (flag & FNONBLOCK) || ttywflush(tp))
1432: ttyflush(tp, FREAD | FWRITE);
1433: return (0);
1434: }
1435:
1436: /*
1437: * Handle modem control transition on a tty.
1438: * Flag indicates new state of carrier.
1439: * Returns 0 if the line should be turned off, otherwise 1.
1440: */
1441: int
1442: ttymodem(tp, flag)
1443: register struct tty *tp;
1444: int flag;
1445: {
1446:
1447: if (ISSET(tp->t_state, TS_CARR_ON) && ISSET(tp->t_cflag, MDMBUF)) {
1448: /*
1449: * MDMBUF: do flow control according to carrier flag
1450: * XXX TS_CAR_OFLOW doesn't do anything yet. TS_TTSTOP
1451: * works if IXON and IXANY are clear.
1452: */
1453: if (flag) {
1454: CLR(tp->t_state, TS_CAR_OFLOW);
1455: CLR(tp->t_state, TS_TTSTOP);
1456: ttstart(tp);
1457: } else if (!ISSET(tp->t_state, TS_CAR_OFLOW)) {
1458: SET(tp->t_state, TS_CAR_OFLOW);
1459: SET(tp->t_state, TS_TTSTOP);
1460: ttystop(tp, 0);
1461: }
1462: } else if (flag == 0) {
1463: /*
1464: * Lost carrier.
1465: */
1466: CLR(tp->t_state, TS_CARR_ON);
1467: if (ISSET(tp->t_state, TS_ISOPEN) &&
1468: !ISSET(tp->t_cflag, CLOCAL)) {
1469: SET(tp->t_state, TS_ZOMBIE);
1470: CLR(tp->t_state, TS_CONNECTED);
1471: if (tp->t_session && tp->t_session->s_leader)
1472: psignal(tp->t_session->s_leader, SIGHUP);
1473: ttyflush(tp, FREAD | FWRITE);
1474: return (0);
1475: }
1476: } else {
1477: /*
1478: * Carrier now on.
1479: */
1480: SET(tp->t_state, TS_CARR_ON);
1481: if (!ISSET(tp->t_state, TS_ZOMBIE))
1482: SET(tp->t_state, TS_CONNECTED);
1483: wakeup(TSA_CARR_ON(tp));
1484: ttwakeup(tp);
1485: ttwwakeup(tp);
1486: }
1487: return (1);
1488: }
1489:
1490: /*
1491: * Reinput pending characters after state switch
1492: * call at spltty().
1493: */
1494: static void
1495: ttypend(tp)
1496: register struct tty *tp;
1497: {
1498: struct clist tq;
1499: register int c;
1500:
1501: CLR(tp->t_lflag, PENDIN);
1502: SET(tp->t_state, TS_TYPEN);
1503: #ifndef NeXT
1504: /*
1505: * XXX this assumes too much about clist internals. It may even
1506: * fail if the cblock slush pool is empty. We can't allocate more
1507: * cblocks here because we are called from an interrupt handler
1508: * and clist_alloc_cblocks() can wait.
1509: */
1510: tq = tp->t_rawq;
1511: bzero(&tp->t_rawq, sizeof tp->t_rawq);
1512: tp->t_rawq.c_cbmax = tq.c_cbmax;
1513: tp->t_rawq.c_cbreserved = tq.c_cbreserved;
1514: #else
1515: tq = tp->t_rawq;
1516: tp->t_rawq.c_cc = 0;
1517: tp->t_rawq.c_cf = tp->t_rawq.c_cl = 0;
1518: #endif /* !NeXT */
1519: while ((c = getc(&tq)) >= 0)
1520: ttyinput(c, tp);
1521: CLR(tp->t_state, TS_TYPEN);
1522: }
1523:
1524: /*
1525: * Process a read call on a tty device.
1526: */
1527: int
1528: ttread(tp, uio, flag)
1529: register struct tty *tp;
1530: struct uio *uio;
1531: int flag;
1532: {
1533: register struct clist *qp;
1534: register int c;
1535: register tcflag_t lflag;
1536: register cc_t *cc = tp->t_cc;
1537: register struct proc *p = current_proc();
1538: int s, first, error = 0;
1539: int has_stime = 0, last_cc = 0;
1540: long slp = 0; /* XXX this should be renamed `timo'. */
1541:
1542: loop:
1543: s = spltty();
1544: lflag = tp->t_lflag;
1545: /*
1546: * take pending input first
1547: */
1548: if (ISSET(lflag, PENDIN)) {
1549: ttypend(tp);
1550: splx(s); /* reduce latency */
1551: s = spltty();
1552: lflag = tp->t_lflag; /* XXX ttypend() clobbers it */
1553: }
1554:
1555: /*
1556: * Hang process if it's in the background.
1557: */
1558: if (isbackground(p, tp)) {
1559: splx(s);
1560: if ((p->p_sigignore & sigmask(SIGTTIN)) ||
1561: (p->p_sigmask & sigmask(SIGTTIN)) ||
1562: p->p_flag & P_PPWAIT || p->p_pgrp->pg_jobc == 0)
1563: return (EIO);
1564: pgsignal(p->p_pgrp, SIGTTIN, 1);
1565: error = ttysleep(tp, &lbolt, TTIPRI | PCATCH, "ttybg2", 0);
1566: if (error)
1567: return (error);
1568: goto loop;
1569: }
1570:
1571: if (ISSET(tp->t_state, TS_ZOMBIE)) {
1572: splx(s);
1573: return (0); /* EOF */
1574: }
1575:
1576: /*
1577: * If canonical, use the canonical queue,
1578: * else use the raw queue.
1579: *
1580: * (should get rid of clists...)
1581: */
1582: qp = ISSET(lflag, ICANON) ? &tp->t_canq : &tp->t_rawq;
1583:
1584: if (flag & IO_NDELAY) {
1585: if (qp->c_cc > 0)
1586: goto read;
1587: if (!ISSET(lflag, ICANON) && cc[VMIN] == 0) {
1588: splx(s);
1589: return (0);
1590: }
1591: splx(s);
1592: return (EWOULDBLOCK);
1593: }
1594: if (!ISSET(lflag, ICANON)) {
1595: int m = cc[VMIN];
1596: long t = cc[VTIME];
1597: struct timeval stime, timecopy;
1598: int x;
1599:
1600: /*
1601: * Check each of the four combinations.
1602: * (m > 0 && t == 0) is the normal read case.
1603: * It should be fairly efficient, so we check that and its
1604: * companion case (m == 0 && t == 0) first.
1605: * For the other two cases, we compute the target sleep time
1606: * into slp.
1607: */
1608: if (t == 0) {
1609: if (qp->c_cc < m)
1610: goto sleep;
1611: if (qp->c_cc > 0)
1612: goto read;
1613:
1614: /* m, t and qp->c_cc are all 0. 0 is enough input. */
1615: splx(s);
1616: return (0);
1617: }
1618: t *= 100000; /* time in us */
1619: #define diff(t1, t2) (((t1).tv_sec - (t2).tv_sec) * 1000000 + \
1620: ((t1).tv_usec - (t2).tv_usec))
1621: if (m > 0) {
1622: if (qp->c_cc <= 0)
1623: goto sleep;
1624: if (qp->c_cc >= m)
1625: goto read;
1626: x = splclock();
1627: timecopy = time;
1628: splx(x);
1629: if (!has_stime) {
1630: /* first character, start timer */
1631: has_stime = 1;
1632: stime = timecopy;
1633: slp = t;
1634: } else if (qp->c_cc > last_cc) {
1635: /* got a character, restart timer */
1636: stime = timecopy;
1637: slp = t;
1638: } else {
1639: /* nothing, check expiration */
1640: slp = t - diff(timecopy, stime);
1641: if (slp <= 0)
1642: goto read;
1643: }
1644: last_cc = qp->c_cc;
1645: } else { /* m == 0 */
1646: if (qp->c_cc > 0)
1647: goto read;
1648: x = splclock();
1649: timecopy = time;
1650: splx(x);
1651: if (!has_stime) {
1652: has_stime = 1;
1653: stime = timecopy;
1654: slp = t;
1655: } else {
1656: slp = t - diff(timecopy, stime);
1657: if (slp <= 0) {
1658: /* Timed out, but 0 is enough input. */
1659: splx(s);
1660: return (0);
1661: }
1662: }
1663: }
1664: #undef diff
1665: /*
1666: * Rounding down may make us wake up just short
1667: * of the target, so we round up.
1668: * The formula is ceiling(slp * hz/1000000).
1669: * 32-bit arithmetic is enough for hz < 169.
1670: * XXX see hzto() for how to avoid overflow if hz
1671: * is large (divide by `tick' and/or arrange to
1672: * use hzto() if hz is large).
1673: */
1674: slp = (long) (((u_long)slp * hz) + 999999) / 1000000;
1675: goto sleep;
1676: }
1677: if (qp->c_cc <= 0) {
1678: sleep:
1679: /*
1680: * There is no input, or not enough input and we can block.
1681: */
1682: error = ttysleep(tp, TSA_HUP_OR_INPUT(tp), TTIPRI | PCATCH,
1683: ISSET(tp->t_state, TS_CONNECTED) ?
1684: "ttyin" : "ttyhup", (int)slp);
1685: splx(s);
1686: if (error == EWOULDBLOCK)
1687: error = 0;
1688: else if (error)
1689: return (error);
1690: /*
1691: * XXX what happens if another process eats some input
1692: * while we are asleep (not just here)? It would be
1693: * safest to detect changes and reset our state variables
1694: * (has_stime and last_cc).
1695: */
1696: slp = 0;
1697: goto loop;
1698: }
1699: read:
1700: splx(s);
1701: /*
1702: * Input present, check for input mapping and processing.
1703: */
1704: first = 1;
1705: #ifdef NeXT
1706: if (ISSET(lflag, ICANON)
1707: || (ISSET(lflag, IEXTEN | ISIG) == (IEXTEN | ISIG)) )
1708: #else
1709: if (ISSET(lflag, ICANON | ISIG))
1710: #endif
1711: goto slowcase;
1712: for (;;) {
1713: char ibuf[IBUFSIZ];
1714: int icc;
1715:
1716: icc = min(uio->uio_resid, IBUFSIZ);
1717: icc = q_to_b(qp, ibuf, icc);
1718: if (icc <= 0) {
1719: if (first)
1720: goto loop;
1721: break;
1722: }
1723: error = uiomove(ibuf, icc, uio);
1724: /*
1725: * XXX if there was an error then we should ungetc() the
1726: * unmoved chars and reduce icc here.
1727: */
1728: #if NSNP > 0
1729: if (ISSET(tp->t_lflag, ECHO) &&
1730: ISSET(tp->t_state, TS_SNOOP) && tp->t_sc != NULL)
1731: snpin((struct snoop *)tp->t_sc, ibuf, icc);
1732: #endif
1733: if (error)
1734: break;
1735: if (uio->uio_resid == 0)
1736: break;
1737: first = 0;
1738: }
1739: goto out;
1740: slowcase:
1741: for (;;) {
1742: c = getc(qp);
1743: if (c < 0) {
1744: if (first)
1745: goto loop;
1746: break;
1747: }
1748: /*
1749: * delayed suspend (^Y)
1750: */
1751: if (CCEQ(cc[VDSUSP], c) &&
1752: ISSET(lflag, IEXTEN | ISIG) == (IEXTEN | ISIG)) {
1753: pgsignal(tp->t_pgrp, SIGTSTP, 1);
1754: if (first) {
1755: error = ttysleep(tp, &lbolt, TTIPRI | PCATCH,
1756: "ttybg3", 0);
1757: if (error)
1758: break;
1759: goto loop;
1760: }
1761: break;
1762: }
1763: /*
1764: * Interpret EOF only in canonical mode.
1765: */
1766: if (CCEQ(cc[VEOF], c) && ISSET(lflag, ICANON))
1767: break;
1768: /*
1769: * Give user character.
1770: */
1771: error = ureadc(c, uio);
1772: if (error)
1773: /* XXX should ungetc(c, qp). */
1774: break;
1775: #if NSNP > 0
1776: /*
1777: * Only snoop directly on input in echo mode. Non-echoed
1778: * input will be snooped later iff the application echoes it.
1779: */
1780: if (ISSET(tp->t_lflag, ECHO) &&
1781: ISSET(tp->t_state, TS_SNOOP) && tp->t_sc != NULL)
1782: snpinc((struct snoop *)tp->t_sc, (char)c);
1783: #endif
1784: if (uio->uio_resid == 0)
1785: break;
1786: /*
1787: * In canonical mode check for a "break character"
1788: * marking the end of a "line of input".
1789: */
1790: if (ISSET(lflag, ICANON) && TTBREAKC(c, lflag))
1791: break;
1792: first = 0;
1793: }
1794:
1795: out:
1796: /*
1797: * Look to unblock input now that (presumably)
1798: * the input queue has gone down.
1799: */
1800: s = spltty();
1801: if (ISSET(tp->t_state, TS_TBLOCK) &&
1802: tp->t_rawq.c_cc + tp->t_canq.c_cc <= I_LOW_WATER)
1803: ttyunblock(tp);
1804: splx(s);
1805:
1806: return (error);
1807: }
1808:
1809: /*
1810: * Check the output queue on tp for space for a kernel message (from uprintf
1811: * or tprintf). Allow some space over the normal hiwater mark so we don't
1812: * lose messages due to normal flow control, but don't let the tty run amok.
1813: * Sleeps here are not interruptible, but we return prematurely if new signals
1814: * arrive.
1815: */
1816: int
1817: ttycheckoutq(tp, wait)
1818: register struct tty *tp;
1819: int wait;
1820: {
1821: int hiwat, s, oldsig;
1822:
1823: hiwat = tp->t_hiwat;
1824: s = spltty();
1825: oldsig = wait ? current_proc()->p_siglist : 0;
1826: if (tp->t_outq.c_cc > hiwat + OBUFSIZ + 100)
1827: while (tp->t_outq.c_cc > hiwat) {
1828: ttstart(tp);
1829: if (tp->t_outq.c_cc <= hiwat)
1830: break;
1831: if (wait == 0 || current_proc()->p_siglist != oldsig) {
1832: splx(s);
1833: return (0);
1834: }
1835: SET(tp->t_state, TS_SO_OLOWAT);
1836: tsleep(TSA_OLOWAT(tp), PZERO - 1, "ttoutq", hz);
1837: }
1838: splx(s);
1839: return (1);
1840: }
1841:
1842: /*
1843: * Process a write call on a tty device.
1844: */
1845: int
1846: ttwrite(tp, uio, flag)
1847: register struct tty *tp;
1848: register struct uio *uio;
1849: int flag;
1850: {
1851: register char *cp = NULL;
1852: register int cc, ce;
1853: register struct proc *p;
1854: int i, hiwat, cnt, error, s;
1855: char obuf[OBUFSIZ];
1856:
1857: hiwat = tp->t_hiwat;
1858: cnt = uio->uio_resid;
1859: error = 0;
1860: cc = 0;
1861: loop:
1862: s = spltty();
1863: if (ISSET(tp->t_state, TS_ZOMBIE)) {
1864: splx(s);
1865: if (uio->uio_resid == cnt)
1866: error = EIO;
1867: goto out;
1868: }
1869: if (!ISSET(tp->t_state, TS_CONNECTED)) {
1870: if (flag & IO_NDELAY) {
1871: splx(s);
1872: error = EWOULDBLOCK;
1873: goto out;
1874: }
1875: error = ttysleep(tp, TSA_CARR_ON(tp), TTIPRI | PCATCH,
1876: "ttydcd", 0);
1877: splx(s);
1878: if (error) {
1879: goto out; }
1880: goto loop;
1881: }
1882: splx(s);
1883: /*
1884: * Hang the process if it's in the background.
1885: */
1886: p = current_proc();
1887: if (isbackground(p, tp) &&
1888: ISSET(tp->t_lflag, TOSTOP) && (p->p_flag & P_PPWAIT) == 0 &&
1889: (p->p_sigignore & sigmask(SIGTTOU)) == 0 &&
1890: (p->p_sigmask & sigmask(SIGTTOU)) == 0) {
1891: if (p->p_pgrp->pg_jobc == 0) {
1892: error = EIO;
1893: goto out;
1894: }
1895: pgsignal(p->p_pgrp, SIGTTOU, 1);
1896: error = ttysleep(tp, &lbolt, TTIPRI | PCATCH, "ttybg4", 0);
1897: if (error)
1898: goto out;
1899: goto loop;
1900: }
1901: /*
1902: * Process the user's data in at most OBUFSIZ chunks. Perform any
1903: * output translation. Keep track of high water mark, sleep on
1904: * overflow awaiting device aid in acquiring new space.
1905: */
1906: while (uio->uio_resid > 0 || cc > 0) {
1907: if (ISSET(tp->t_lflag, FLUSHO)) {
1908: uio->uio_resid = 0;
1909: return (0);
1910: }
1911: if (tp->t_outq.c_cc > hiwat)
1912: goto ovhiwat;
1913: /*
1914: * Grab a hunk of data from the user, unless we have some
1915: * leftover from last time.
1916: */
1917: if (cc == 0) {
1918: cc = min(uio->uio_resid, OBUFSIZ);
1919: cp = obuf;
1920: error = uiomove(cp, cc, uio);
1921: if (error) {
1922: cc = 0;
1923: break;
1924: }
1925: #if NSNP > 0
1926: if (ISSET(tp->t_state, TS_SNOOP) && tp->t_sc != NULL)
1927: snpin((struct snoop *)tp->t_sc, cp, cc);
1928: #endif
1929: }
1930: /*
1931: * If nothing fancy need be done, grab those characters we
1932: * can handle without any of ttyoutput's processing and
1933: * just transfer them to the output q. For those chars
1934: * which require special processing (as indicated by the
1935: * bits in char_type), call ttyoutput. After processing
1936: * a hunk of data, look for FLUSHO so ^O's will take effect
1937: * immediately.
1938: */
1939: while (cc > 0) {
1940: if (!ISSET(tp->t_oflag, OPOST))
1941: ce = cc;
1942: else {
1943: ce = cc - scanc((u_int)cc, (u_char *)cp,
1944: (u_char *)char_type, CCLASSMASK);
1945: /*
1946: * If ce is zero, then we're processing
1947: * a special character through ttyoutput.
1948: */
1949: if (ce == 0) {
1950: tp->t_rocount = 0;
1951: if (ttyoutput(*cp, tp) >= 0) {
1952: #ifdef NeXT
1953: /* out of space */
1954: goto overfull;
1955: #else
1956: /* No Clists, wait a bit. */
1957: ttstart(tp);
1958: if (flag & IO_NDELAY) {
1959: error = EWOULDBLOCK;
1960: goto out;
1961: }
1962: error = ttysleep(tp, &lbolt,
1963: TTOPRI|PCATCH,
1964: "ttybf1", 0);
1965: if (error)
1966: goto out;
1967: goto loop;
1968: #endif /* NeXT */
1969: }
1970: cp++;
1971: cc--;
1972: if (ISSET(tp->t_lflag, FLUSHO) ||
1973: tp->t_outq.c_cc > hiwat)
1974: goto ovhiwat;
1975: continue;
1976: }
1977: }
1978: /*
1979: * A bunch of normal characters have been found.
1980: * Transfer them en masse to the output queue and
1981: * continue processing at the top of the loop.
1982: * If there are any further characters in this
1983: * <= OBUFSIZ chunk, the first should be a character
1984: * requiring special handling by ttyoutput.
1985: */
1986: tp->t_rocount = 0;
1987: i = b_to_q(cp, ce, &tp->t_outq);
1988: ce -= i;
1989: tp->t_column += ce;
1990: cp += ce, cc -= ce, tk_nout += ce;
1991: tp->t_outcc += ce;
1992: if (i > 0) {
1993: #ifdef NeXT
1994: /* out of space */
1995: goto overfull;
1996: #else
1997: /* No Clists, wait a bit. */
1998: ttstart(tp);
1999: if (flag & IO_NDELAY) {
2000: error = EWOULDBLOCK;
2001: goto out;
2002: }
2003: error = ttysleep(tp, &lbolt, TTOPRI | PCATCH,
2004: "ttybf2", 0);
2005: if (error)
2006: goto out;
2007: goto loop;
2008: #endif /* NeXT */
2009: }
2010: if (ISSET(tp->t_lflag, FLUSHO) ||
2011: tp->t_outq.c_cc > hiwat)
2012: break;
2013: }
2014: ttstart(tp);
2015: }
2016: out:
2017: /*
2018: * If cc is nonzero, we leave the uio structure inconsistent, as the
2019: * offset and iov pointers have moved forward, but it doesn't matter
2020: * (the call will either return short or restart with a new uio).
2021: */
2022: uio->uio_resid += cc;
2023: return (error);
2024:
2025: #ifdef NeXT
2026: overfull:
2027:
2028: /*
2029: * Since we are using ring buffers, if we can't insert any more into
2030: * the output queue, we can assume the ring is full and that someone
2031: * forgot to set the high water mark correctly. We set it and then
2032: * proceed as normal.
2033: */
2034: hiwat = tp->t_outq.c_cc - 1;
2035: #endif
2036:
2037: ovhiwat:
2038: ttstart(tp);
2039: s = spltty();
2040: /*
2041: * This can only occur if FLUSHO is set in t_lflag,
2042: * or if ttstart/oproc is synchronous (or very fast).
2043: */
2044: if (tp->t_outq.c_cc <= hiwat) {
2045: splx(s);
2046: goto loop;
2047: }
2048: if (flag & IO_NDELAY) {
2049: splx(s);
2050: uio->uio_resid += cc;
2051: return (uio->uio_resid == cnt ? EWOULDBLOCK : 0);
2052: }
2053: SET(tp->t_state, TS_SO_OLOWAT);
2054: error = ttysleep(tp, TSA_OLOWAT(tp), TTOPRI | PCATCH, "ttywri",
2055: tp->t_timeout);
2056: splx(s);
2057: if (error == EWOULDBLOCK)
2058: error = EIO;
2059: if (error)
2060: goto out;
2061: goto loop;
2062: }
2063:
2064: /*
2065: * Rubout one character from the rawq of tp
2066: * as cleanly as possible.
2067: */
2068: static void
2069: ttyrub(c, tp)
2070: register int c;
2071: register struct tty *tp;
2072: {
2073: register u_char *cp;
2074: register int savecol;
2075: int tabc, s;
2076:
2077: if (!ISSET(tp->t_lflag, ECHO) || ISSET(tp->t_lflag, EXTPROC))
2078: return;
2079: CLR(tp->t_lflag, FLUSHO);
2080: if (ISSET(tp->t_lflag, ECHOE)) {
2081: if (tp->t_rocount == 0) {
2082: /*
2083: * Messed up by ttwrite; retype
2084: */
2085: ttyretype(tp);
2086: return;
2087: }
2088: if (c == ('\t' | TTY_QUOTE) || c == ('\n' | TTY_QUOTE))
2089: ttyrubo(tp, 2);
2090: else {
2091: CLR(c, ~TTY_CHARMASK);
2092: switch (CCLASS(c)) {
2093: case ORDINARY:
2094: ttyrubo(tp, 1);
2095: break;
2096: case BACKSPACE:
2097: case CONTROL:
2098: case NEWLINE:
2099: case RETURN:
2100: case VTAB:
2101: if (ISSET(tp->t_lflag, ECHOCTL))
2102: ttyrubo(tp, 2);
2103: break;
2104: case TAB:
2105: if (tp->t_rocount < tp->t_rawq.c_cc) {
2106: ttyretype(tp);
2107: return;
2108: }
2109: s = spltty();
2110: savecol = tp->t_column;
2111: SET(tp->t_state, TS_CNTTB);
2112: SET(tp->t_lflag, FLUSHO);
2113: tp->t_column = tp->t_rocol;
2114: #ifndef NeXT
2115: cp = tp->t_rawq.c_cf;
2116: if (cp)
2117: tabc = *cp; /* XXX FIX NEXTC */
2118: for (; cp; cp = nextc(&tp->t_rawq, cp, &tabc))
2119: ttyecho(tabc, tp);
2120: #else
2121: for (cp = firstc(&tp->t_rawq, &tabc); cp;
2122: cp = nextc(&tp->t_rawq, cp, &tabc))
2123: ttyecho(tabc, tp);
2124: #endif /* !NeXT */
2125: CLR(tp->t_lflag, FLUSHO);
2126: CLR(tp->t_state, TS_CNTTB);
2127: splx(s);
2128:
2129: /* savecol will now be length of the tab. */
2130: savecol -= tp->t_column;
2131: tp->t_column += savecol;
2132: if (savecol > 8)
2133: savecol = 8; /* overflow fixup */
2134: while (--savecol >= 0)
2135: (void)ttyoutput('\b', tp);
2136: break;
2137: default: /* XXX */
2138: #define PANICSTR "ttyrub: would panic c = %d, val = %d\n"
2139: (void)printf(PANICSTR, c, CCLASS(c));
2140: #ifdef notdef
2141: panic(PANICSTR, c, CCLASS(c));
2142: #endif
2143: }
2144: }
2145: } else if (ISSET(tp->t_lflag, ECHOPRT)) {
2146: if (!ISSET(tp->t_state, TS_ERASE)) {
2147: SET(tp->t_state, TS_ERASE);
2148: (void)ttyoutput('\\', tp);
2149: }
2150: ttyecho(c, tp);
2151: } else
2152: ttyecho(tp->t_cc[VERASE], tp);
2153: --tp->t_rocount;
2154: }
2155:
2156: /*
2157: * Back over cnt characters, erasing them.
2158: */
2159: static void
2160: ttyrubo(tp, cnt)
2161: register struct tty *tp;
2162: int cnt;
2163: {
2164:
2165: while (cnt-- > 0) {
2166: (void)ttyoutput('\b', tp);
2167: (void)ttyoutput(' ', tp);
2168: (void)ttyoutput('\b', tp);
2169: }
2170: }
2171:
2172: /*
2173: * ttyretype --
2174: * Reprint the rawq line. Note, it is assumed that c_cc has already
2175: * been checked.
2176: */
2177: static void
2178: ttyretype(tp)
2179: register struct tty *tp;
2180: {
2181: register u_char *cp;
2182: int s, c;
2183:
2184: /* Echo the reprint character. */
2185: if (tp->t_cc[VREPRINT] != _POSIX_VDISABLE)
2186: ttyecho(tp->t_cc[VREPRINT], tp);
2187:
2188: (void)ttyoutput('\n', tp);
2189:
2190: /*
2191: * FREEBSD XXX
2192: * FIX: NEXTC IS BROKEN - DOESN'T CHECK QUOTE
2193: * BIT OF FIRST CHAR.
2194: */
2195: s = spltty();
2196: #ifndef NeXT
2197: for (cp = tp->t_canq.c_cf, c = (cp != NULL ? *cp : 0);
2198: cp != NULL; cp = nextc(&tp->t_canq, cp, &c))
2199: ttyecho(c, tp);
2200: for (cp = tp->t_rawq.c_cf, c = (cp != NULL ? *cp : 0);
2201: cp != NULL; cp = nextc(&tp->t_rawq, cp, &c))
2202: ttyecho(c, tp);
2203: #else NeXT
2204: for (cp = firstc(&tp->t_canq, &c); cp; cp = nextc(&tp->t_canq, cp, &c))
2205: ttyecho(c, tp);
2206: for (cp = firstc(&tp->t_rawq, &c); cp; cp = nextc(&tp->t_rawq, cp, &c))
2207: ttyecho(c, tp);
2208: #endif /* !NeXT */
2209: CLR(tp->t_state, TS_ERASE);
2210: splx(s);
2211:
2212: tp->t_rocount = tp->t_rawq.c_cc;
2213: tp->t_rocol = 0;
2214: }
2215:
2216: /*
2217: * Echo a typed character to the terminal.
2218: */
2219: static void
2220: ttyecho(c, tp)
2221: register int c;
2222: register struct tty *tp;
2223: {
2224:
2225: if (!ISSET(tp->t_state, TS_CNTTB))
2226: CLR(tp->t_lflag, FLUSHO);
2227: if ((!ISSET(tp->t_lflag, ECHO) &&
2228: (c != '\n' || !ISSET(tp->t_lflag, ECHONL))) ||
2229: ISSET(tp->t_lflag, EXTPROC))
2230: return;
2231: if (ISSET(tp->t_lflag, ECHOCTL) &&
2232: ((ISSET(c, TTY_CHARMASK) <= 037 && c != '\t' && c != '\n') ||
2233: ISSET(c, TTY_CHARMASK) == 0177)) {
2234: (void)ttyoutput('^', tp);
2235: CLR(c, ~TTY_CHARMASK);
2236: if (c == 0177)
2237: c = '?';
2238: else
2239: c += 'A' - 1;
2240: }
2241: (void)ttyoutput(c, tp);
2242: }
2243:
2244: /*
2245: * Wake up any readers on a tty.
2246: */
2247: void
2248: ttwakeup(tp)
2249: register struct tty *tp;
2250: {
2251:
2252: #ifndef NeXT
2253: if (tp->t_rsel.si_pid != 0)
2254: #endif
2255: selwakeup(&tp->t_rsel);
2256: if (ISSET(tp->t_state, TS_ASYNC))
2257: pgsignal(tp->t_pgrp, SIGIO, 1);
2258: wakeup(TSA_HUP_OR_INPUT(tp));
2259: }
2260:
2261: /*
2262: * Wake up any writers on a tty.
2263: */
2264: void
2265: ttwwakeup(tp)
2266: register struct tty *tp;
2267: {
2268: #ifndef NeXT
2269: if (tp->t_wsel.si_pid != 0 && tp->t_outq.c_cc <= tp->t_lowat)
2270: #else
2271: if (tp->t_outq.c_cc <= tp->t_lowat)
2272: #endif
2273: selwakeup(&tp->t_wsel);
2274: if (ISSET(tp->t_state, TS_BUSY | TS_SO_OCOMPLETE) ==
2275: TS_SO_OCOMPLETE && tp->t_outq.c_cc == 0) {
2276: CLR(tp->t_state, TS_SO_OCOMPLETE);
2277: wakeup(TSA_OCOMPLETE(tp));
2278: }
2279: if (ISSET(tp->t_state, TS_SO_OLOWAT) &&
2280: tp->t_outq.c_cc <= tp->t_lowat) {
2281: CLR(tp->t_state, TS_SO_OLOWAT);
2282: wakeup(TSA_OLOWAT(tp));
2283: }
2284: }
2285:
2286: /*
2287: * Look up a code for a specified speed in a conversion table;
2288: * used by drivers to map software speed values to hardware parameters.
2289: */
2290: int
2291: ttspeedtab(speed, table)
2292: int speed;
2293: register struct speedtab *table;
2294: {
2295:
2296: for ( ; table->sp_speed != -1; table++)
2297: if (table->sp_speed == speed)
2298: return (table->sp_code);
2299: return (-1);
2300: }
2301:
2302: /*
2303: * Set tty hi and low water marks.
2304: *
2305: * Try to arrange the dynamics so there's about one second
2306: * from hi to low water.
2307: *
2308: */
2309: void
2310: ttsetwater(tp)
2311: struct tty *tp;
2312: {
2313: register int cps, x;
2314:
2315: #define CLAMP(x, h, l) ((x) > h ? h : ((x) < l) ? l : (x))
2316:
2317: cps = tp->t_ospeed / 10;
2318: tp->t_lowat = x = CLAMP(cps / 2, TTMAXLOWAT, TTMINLOWAT);
2319: x += cps;
2320: x = CLAMP(x, TTMAXHIWAT, TTMINHIWAT);
2321: tp->t_hiwat = roundup(x, CBSIZE);
2322: #undef CLAMP
2323: }
2324:
2325: /* NeXT ttyinfo has been converted to the MACH kernel */
2326: #include <mach/thread_info.h>
2327:
2328: /*
2329: * Report on state of foreground process group.
2330: */
2331: void
2332: ttyinfo(tp)
2333: register struct tty *tp;
2334: {
2335: /* NOT IMPLEMENTED FOR MACH */
2336: }
2337:
2338: #ifndef NeXT
2339: /*
2340: * Returns 1 if p2 is "better" than p1
2341: *
2342: * The algorithm for picking the "interesting" process is thus:
2343: *
2344: * 1) Only foreground processes are eligible - implied.
2345: * 2) Runnable processes are favored over anything else. The runner
2346: * with the highest cpu utilization is picked (p_estcpu). Ties are
2347: * broken by picking the highest pid.
2348: * 3) The sleeper with the shortest sleep time is next. With ties,
2349: * we pick out just "short-term" sleepers (P_SINTR == 0).
2350: * 4) Further ties are broken by picking the highest pid.
2351: */
2352: #define ISRUN(p) (((p)->p_stat == SRUN) || ((p)->p_stat == SIDL))
2353: #define TESTAB(a, b) ((a)<<1 | (b))
2354: #define ONLYA 2
2355: #define ONLYB 1
2356: #define BOTH 3
2357:
2358: static int
2359: proc_compare(p1, p2)
2360: register struct proc *p1, *p2;
2361: {
2362:
2363: if (p1 == NULL)
2364: return (1);
2365: /*
2366: * see if at least one of them is runnable
2367: */
2368: switch (TESTAB(ISRUN(p1), ISRUN(p2))) {
2369: case ONLYA:
2370: return (0);
2371: case ONLYB:
2372: return (1);
2373: case BOTH:
2374: /*
2375: * tie - favor one with highest recent cpu utilization
2376: */
2377: if (p2->p_estcpu > p1->p_estcpu)
2378: return (1);
2379: if (p1->p_estcpu > p2->p_estcpu)
2380: return (0);
2381: return (p2->p_pid > p1->p_pid); /* tie - return highest pid */
2382: }
2383: /*
2384: * weed out zombies
2385: */
2386: switch (TESTAB(p1->p_stat == SZOMB, p2->p_stat == SZOMB)) {
2387: case ONLYA:
2388: return (1);
2389: case ONLYB:
2390: return (0);
2391: case BOTH:
2392: return (p2->p_pid > p1->p_pid); /* tie - return highest pid */
2393: }
2394: /*
2395: * pick the one with the smallest sleep time
2396: */
2397: if (p2->p_slptime > p1->p_slptime)
2398: return (0);
2399: if (p1->p_slptime > p2->p_slptime)
2400: return (1);
2401: /*
2402: * favor one sleeping in a non-interruptible sleep
2403: */
2404: if (p1->p_flag & P_SINTR && (p2->p_flag & P_SINTR) == 0)
2405: return (1);
2406: if (p2->p_flag & P_SINTR && (p1->p_flag & P_SINTR) == 0)
2407: return (0);
2408: return (p2->p_pid > p1->p_pid); /* tie - return highest pid */
2409: }
2410: #endif /* NeXT */
2411:
2412: /*
2413: * Output char to tty; console putchar style.
2414: */
2415: int
2416: tputchar(c, tp)
2417: int c;
2418: struct tty *tp;
2419: {
2420: register int s;
2421:
2422: s = spltty();
2423: if (!ISSET(tp->t_state, TS_CONNECTED)) {
2424: splx(s);
2425: return (-1);
2426: }
2427: if (c == '\n')
2428: (void)ttyoutput('\r', tp);
2429: (void)ttyoutput(c, tp);
2430: ttstart(tp);
2431: splx(s);
2432: return (0);
2433: }
2434:
2435: /*
2436: * Sleep on chan, returning ERESTART if tty changed while we napped and
2437: * returning any errors (e.g. EINTR/EWOULDBLOCK) reported by tsleep. If
2438: * the tty is revoked, restarting a pending call will redo validation done
2439: * at the start of the call.
2440: */
2441: int
2442: ttysleep(tp, chan, pri, wmesg, timo)
2443: struct tty *tp;
2444: void *chan;
2445: int pri, timo;
2446: char *wmesg;
2447: {
2448: int error;
2449: int gen;
2450:
2451: gen = tp->t_gen;
2452: error = tsleep(chan, pri, wmesg, timo);
2453: if (error)
2454: return (error);
2455: return (tp->t_gen == gen ? 0 : ERESTART);
2456: }
2457:
2458: #ifdef NeXT
2459: /*
2460: * Allocate a tty structure and its associated buffers.
2461: */
2462: struct tty *
2463: ttymalloc()
2464: {
2465: struct tty *tp;
2466:
2467: MALLOC(tp, struct tty *, sizeof(struct tty), M_TTYS, M_WAITOK);
2468: bzero(tp, sizeof *tp);
2469: /* XXX: default to TTYCLSIZE(1024) chars for now */
2470: clalloc(&tp->t_rawq, TTYCLSIZE, 1);
2471: clalloc(&tp->t_canq, TTYCLSIZE, 1);
2472: /* output queue doesn't need quoting */
2473: clalloc(&tp->t_outq, TTYCLSIZE, 0);
2474: return(tp);
2475: }
2476:
2477: /*
2478: * Free a tty structure and its buffers.
2479: */
2480: void
2481: ttyfree(tp)
2482: struct tty *tp;
2483: {
2484: clfree(&tp->t_rawq);
2485: clfree(&tp->t_canq);
2486: clfree(&tp->t_outq);
2487: FREE(tp, M_TTYS);
2488: }
2489:
2490: #else /* !NeXT */
2491:
2492: #ifdef notyet
2493: /*
2494: * XXX this is usable not useful or used. Most tty drivers have
2495: * ifdefs for using ttymalloc() but assume a different interface.
2496: */
2497: /*
2498: * Allocate a tty struct. Clists in the struct will be allocated by
2499: * ttyopen().
2500: */
2501: struct tty *
2502: ttymalloc()
2503: {
2504: struct tty *tp;
2505:
2506: tp = _MALLOC(sizeof *tp, M_TTYS, M_WAITOK);
2507: bzero(tp, sizeof *tp);
2508: return (tp);
2509: }
2510: #endif
2511:
2512: #if 0 /* XXX not yet usable: session leader holds a ref (see kern_exit.c). */
2513: /*
2514: * Free a tty struct. Clists in the struct should have been freed by
2515: * ttyclose().
2516: */
2517: void
2518: ttyfree(tp)
2519: struct tty *tp;
2520: {
2521: FREE(tp, M_TTYS);
2522: }
2523: #endif /* 0 */
2524: #endif /* NeXT */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.