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