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