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