?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
kernel: Remove the FFS_ROOT option. It was a no-op since 4.9.
[dragonfly.git] / sys / kern / tty.c
blob6641b3ae4478263bac60344b831c57e69f934aad
1 /*-
2 * (MPSAFE)
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.8 (Berkeley) 1/21/94
37 * $FreeBSD: src/sys/kern/tty.c,v 1.129.2.5 2002/03/11 01:32:31 dd Exp $
38 */
39
40 /*
41 * MPSAFE NOTE:
42 * Almost all functions in this file are acquiring the tty token due to their
43 * access and modifications of the 'tp' (struct tty) objects.
44 */
45
46 /*-
47 * TODO:
48 * o Fix races for sending the start char in ttyflush().
49 * o Handle inter-byte timeout for "MIN > 0, TIME > 0" in ttyselect().
50 * With luck, there will be MIN chars before select() returns().
51 * o Handle CLOCAL consistently for ptys. Perhaps disallow setting it.
52 * o Don't allow input in TS_ZOMBIE case. It would be visible through
53 * FIONREAD.
54 * o Do the new sio locking stuff here and use it to avoid special
55 * case for EXTPROC?
56 * o Lock PENDIN too?
57 * o Move EXTPROC and/or PENDIN to t_state?
58 * o Wrap most of ttioctl in spltty/splx.
59 * o Implement TIOCNOTTY or remove it from <sys/ioctl.h>.
60 * o Send STOP if IXOFF is toggled off while TS_TBLOCK is set.
61 * o Don't allow certain termios flags to affect disciplines other
62 * than TTYDISC. Cancel their effects before switch disciplines
63 * and ignore them if they are set while we are in another
64 * discipline.
65 * o Now that historical speed conversions are handled here, don't
66 * do them in drivers.
67 * o Check for TS_CARR_ON being set while everything is closed and not
68 * waiting for carrier. TS_CARR_ON isn't cleared if nothing is open,
69 * so it would live until the next open even if carrier drops.
70 * o Restore TS_WOPEN since it is useful in pstat. It must be cleared
71 * only when _all_ openers leave open().
72 */
73
74 #include "opt_uconsole.h"
75
76 #include <sys/param.h>
77 #include <sys/systm.h>
78 #include <sys/filio.h>
79 #include <sys/proc.h>
80 #include <sys/priv.h>
81 #include <sys/tty.h>
82 #define TTYDEFCHARS
83 #include <sys/ttydefaults.h> /* for ttydefchars, CEOT */
84 #undef TTYDEFCHARS
85 #include <sys/fcntl.h>
86 #include <sys/conf.h>
87 #include <sys/dkstat.h>
88 #include <sys/kernel.h>
89 #include <sys/vnode.h>
90 #include <sys/signalvar.h>
91 #include <sys/signal2.h>
92 #include <sys/resourcevar.h>
93 #include <sys/malloc.h>
94 #include <sys/filedesc.h>
95 #include <sys/sysctl.h>
96 #include <sys/thread2.h>
97
98 #include <vm/vm.h>
99 #include <sys/lock.h>
100 #include <vm/pmap.h>
101 #include <vm/vm_map.h>
102 #include <vm/vm_extern.h>
103
104 MALLOC_DEFINE(M_TTYS, "ttys", "tty data structures");
105
106 static int proc_compare (struct proc *p1, struct proc *p2);
107 static int ttnread (struct tty *tp);
108 static void ttyecho (int c, struct tty *tp);
109 static int ttyoutput (int c, struct tty *tp);
110 static void ttypend (struct tty *tp);
111 static void ttyretype (struct tty *tp);
112 static void ttyrub (int c, struct tty *tp);
113 static void ttyrubo (struct tty *tp, int cnt);
114 static void ttyunblock (struct tty *tp);
115 static int ttywflush (struct tty *tp);
116 static int filt_ttyread (struct knote *kn, long hint);
117 static void filt_ttyrdetach (struct knote *kn);
118 static int filt_ttywrite (struct knote *kn, long hint);
119 static void filt_ttywdetach (struct knote *kn);
120
121 /*
122 * Table with character classes and parity. The 8th bit indicates parity,
123 * the 7th bit indicates the character is an alphameric or underscore (for
124 * ALTWERASE), and the low 6 bits indicate delay type. If the low 6 bits
125 * are 0 then the character needs no special processing on output; classes
126 * other than 0 might be translated or (not currently) require delays.
127 */
128 #define E 0x00 /* Even parity. */
129 #define O 0x80 /* Odd parity. */
130 #define PARITY(c) (char_type[c] & O)
131
132 #define ALPHA 0x40 /* Alpha or underscore. */
133 #define ISALPHA(c) (char_type[(c) & TTY_CHARMASK] & ALPHA)
134
135 #define CCLASSMASK 0x3f
136 #define CCLASS(c) (char_type[c] & CCLASSMASK)
137
138 #define BS BACKSPACE
139 #define CC CONTROL
140 #define CR RETURN
141 #define NA ORDINARY | ALPHA
142 #define NL NEWLINE
143 #define NO ORDINARY
144 #define TB TAB
145 #define VT VTAB
146
147 static u_char const char_type[] = {
148 E|CC, O|CC, O|CC, E|CC, O|CC, E|CC, E|CC, O|CC, /* nul - bel */
149 O|BS, E|TB, E|NL, O|CC, E|VT, O|CR, O|CC, E|CC, /* bs - si */
150 O|CC, E|CC, E|CC, O|CC, E|CC, O|CC, O|CC, E|CC, /* dle - etb */
151 E|CC, O|CC, O|CC, E|CC, O|CC, E|CC, E|CC, O|CC, /* can - us */
152 O|NO, E|NO, E|NO, O|NO, E|NO, O|NO, O|NO, E|NO, /* sp - ' */
153 E|NO, O|NO, O|NO, E|NO, O|NO, E|NO, E|NO, O|NO, /* ( - / */
154 E|NA, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* 0 - 7 */
155 O|NA, E|NA, E|NO, O|NO, E|NO, O|NO, O|NO, E|NO, /* 8 - ? */
156 O|NO, E|NA, E|NA, O|NA, E|NA, O|NA, O|NA, E|NA, /* @ - G */
157 E|NA, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* H - O */
158 E|NA, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* P - W */
159 O|NA, E|NA, E|NA, O|NO, E|NO, O|NO, O|NO, O|NA, /* X - _ */
160 E|NO, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* ` - g */
161 O|NA, E|NA, E|NA, O|NA, E|NA, O|NA, O|NA, E|NA, /* h - o */
162 O|NA, E|NA, E|NA, O|NA, E|NA, O|NA, O|NA, E|NA, /* p - w */
163 E|NA, O|NA, O|NA, E|NO, O|NO, E|NO, E|NO, O|CC, /* x - del */
164 /*
165 * Meta chars; should be settable per character set;
166 * for now, treat them all as normal characters.
167 */
168 NA, NA, NA, NA, NA, NA, NA, NA,
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 };
185 #undef BS
186 #undef CC
187 #undef CR
188 #undef NA
189 #undef NL
190 #undef NO
191 #undef TB
192 #undef VT
193
194 /* Macros to clear/set/test flags. */
195 #define SET(t, f) (t) |= (f)
196 #define CLR(t, f) (t) &= ~(f)
197 #define ISSET(t, f) ((t) & (f))
198
199 #undef MAX_INPUT /* XXX wrong in <sys/syslimits.h> */
200 #define MAX_INPUT TTYHOG /* XXX limit is usually larger for !ICANON */
201
202 uint64_t tk_nin;
203 SYSCTL_OPAQUE(_kern, OID_AUTO, tk_nin, CTLFLAG_RD, &tk_nin, sizeof(tk_nin),
204 "LU", "TTY input statistic");
205 uint64_t tk_nout;
206 SYSCTL_OPAQUE(_kern, OID_AUTO, tk_nout, CTLFLAG_RD, &tk_nout, sizeof(tk_nout),
207 "LU", "TTY output statistic");
208 uint64_t tk_rawcc;
209
210 /*
211 * list of struct tty where pstat(8) can pick it up with sysctl
212 */
213 static TAILQ_HEAD(, tty) tty_list = TAILQ_HEAD_INITIALIZER(tty_list);
214
215 /*
216 * Initial open of tty, or (re)entry to standard tty line discipline.
217 */
218 int
219 ttyopen(cdev_t device, struct tty *tp)
220 {
221 lwkt_gettoken(&tp->t_token);
222 tp->t_dev = device;
223 if (!ISSET(tp->t_state, TS_ISOPEN)) {
224 SET(tp->t_state, TS_ISOPEN);
225 if (ISSET(tp->t_cflag, CLOCAL)) {
226 SET(tp->t_state, TS_CONNECTED);
227 }
228 bzero(&tp->t_winsize, sizeof(tp->t_winsize));
229 }
230 ttsetwater(tp);
231 lwkt_reltoken(&tp->t_token);
232
233 return (0);
234 }
235
236 /*
237 * Handle close() on a tty line: flush and set to initial state,
238 * bumping generation number so that pending read/write calls
239 * can detect recycling of the tty.
240 *
241 * XXX our caller should have done `spltty(); l_close(); ttyclose();'
242 * and l_close() should have flushed, but we repeat the spltty() and
243 * the flush in case there are buggy callers.
244 */
245 int
246 ttyclose(struct tty *tp)
247 {
248 lwkt_gettoken(&tp->t_token);
249 funsetown(&tp->t_sigio);
250 if (constty == tp)
251 constty = NULL;
252
253 ttyflush(tp, FREAD | FWRITE);
254 clist_free_cblocks(&tp->t_canq);
255 clist_free_cblocks(&tp->t_outq);
256 clist_free_cblocks(&tp->t_rawq);
257
258 tp->t_gen++;
259 tp->t_line = TTYDISC;
260 ttyclearsession(tp);
261 tp->t_state &= TS_REGISTERED; /* clear all bits except */
262 lwkt_reltoken(&tp->t_token);
263
264 return (0);
265 }
266
267 /*
268 * Disassociate the tty from its session. Traditionally this has only been
269 * a half-close, meaning that the session was still allowed to point at the
270 * tty (resulting in the tty in the ps command showing something like 'p0-'),
271 * even though the tty is no longer pointing at the session.
272 *
273 * The half close seems to be useful only for 'ps' output but there is as
274 * yet no reason to remove the feature. The full-close code is currently
275 * #if 0'd out. See also sess_rele() in kern/kern_proc.c.
276 */
277 void
278 ttyclearsession(struct tty *tp)
279 {
280 struct session *sp;
281 struct procglob *prg;
282 struct pgrp *opgrp;
283
284 lwkt_gettoken(&tp->t_token);
285 opgrp = tp->t_pgrp;
286 tp->t_pgrp = NULL;
287 if (opgrp) {
288 pgrel(opgrp);
289 opgrp = NULL;
290 }
291
292 again:
293 if ((sp = tp->t_session) != NULL) {
294 prg = sp->s_prg;
295 lwkt_gettoken(&prg->proc_token);
296 if (sp != tp->t_session) {
297 lwkt_reltoken(&prg->proc_token);
298 goto again;
299 }
300 tp->t_session = NULL;
301
302 #ifdef TTY_DO_FULL_CLOSE
303 /* FULL CLOSE (not yet) */
304 if (sp->s_ttyp == tp) {
305 sp->s_ttyp = NULL;
306 ttyunhold(tp);
307 } else {
308 kprintf("ttyclearsession: warning: sp->s_ttyp != tp "
309 "%p/%p\n", sp->s_ttyp, tp);
310 }
311 #endif
312 lwkt_reltoken(&prg->proc_token);
313 }
314 lwkt_reltoken(&tp->t_token);
315 }
316
317 /*
318 * Release the tty vnode association for a session. This is the
319 * 'other half' of the close. Because multiple opens of /dev/tty
320 * only generate a single open to the actual tty, the file modes
321 * are locked to FREAD|FWRITE.
322 *
323 * If dorevoke is non-zero, the session is also revoked. We have to
324 * close the vnode if VCTTYISOPEN is set.
325 */
326 void
327 ttyclosesession(struct session *sp, int dorevoke)
328 {
329 struct vnode *vp;
330 struct procglob *prg;
331
332 prg = sp->s_prg;
333 lwkt_gettoken(&prg->proc_token);
334 retry:
335 /*
336 * There may not be a controlling terminal or it may have been closed
337 * out from under us.
338 */
339 if ((vp = sp->s_ttyvp) == NULL) {
340 lwkt_reltoken(&prg->proc_token);
341 return;
342 }
343
344 /*
345 * We need a lock if we have to close or revoke.
346 */
347 if ((vp->v_flag & VCTTYISOPEN) || dorevoke) {
348 vhold(vp);
349 if (vn_lock(vp, LK_EXCLUSIVE | LK_RETRY | LK_FAILRECLAIM)) {
350 vdrop(vp);
351 goto retry;
352 }
353
354 /*
355 * Retry if the vnode was ripped out from under us
356 */
357 if (vp != sp->s_ttyvp) {
358 vn_unlock(vp);
359 vdrop(vp);
360 goto retry;
361 }
362
363 /*
364 * Close and revoke as needed
365 */
366 sp->s_ttyvp = NULL;
367 if (vp->v_flag & VCTTYISOPEN) {
368 vclrflags(vp, VCTTYISOPEN);
369 VOP_CLOSE(vp, FREAD|FWRITE, NULL);
370 }
371 vn_unlock(vp);
372 if (dorevoke)
373 vrevoke(vp, proc0.p_ucred);
374 vdrop(vp);
375 } else {
376 sp->s_ttyvp = NULL;
377 }
378 vrele(vp);
379 lwkt_reltoken(&prg->proc_token);
380 }
381
382 #define FLUSHQ(q) { \
383 if ((q)->c_cc) \
384 ndflush(q, (q)->c_cc); \
385 }
386
387 /* Is 'c' a line delimiter ("break" character)? */
388 #define TTBREAKC(c, lflag) \
389 ((c) == '\n' || (((c) == cc[VEOF] || \
390 (c) == cc[VEOL] || ((c) == cc[VEOL2] && lflag & IEXTEN)) && \
391 (c) != _POSIX_VDISABLE))
392
393 /*
394 * Process input of a single character received on a tty.
395 */
396 int
397 ttyinput(int c, struct tty *tp)
398 {
399 tcflag_t iflag, lflag;
400 cc_t *cc;
401 int i, err;
402
403 lwkt_gettoken(&tp->t_token);
404 /*
405 * If input is pending take it first.
406 */
407 lflag = tp->t_lflag;
408 if (ISSET(lflag, PENDIN))
409 ttypend(tp);
410 /*
411 * Gather stats.
412 */
413 if (ISSET(lflag, ICANON))
414 ++tp->t_cancc;
415 else
416 ++tp->t_rawcc;
417 ++tk_nin;
418
419 /*
420 * Block further input iff:
421 * current input > threshold AND input is available to user program
422 * AND input flow control is enabled and not yet invoked.
423 * The 3 is slop for PARMRK.
424 */
425 iflag = tp->t_iflag;
426 if (tp->t_rawq.c_cc + tp->t_canq.c_cc > tp->t_ihiwat - 3 &&
427 (!ISSET(lflag, ICANON) || tp->t_canq.c_cc != 0) &&
428 (ISSET(tp->t_cflag, CRTS_IFLOW) || ISSET(iflag, IXOFF)) &&
429 !ISSET(tp->t_state, TS_TBLOCK))
430 ttyblock(tp);
431
432 /* Handle exceptional conditions (break, parity, framing). */
433 cc = tp->t_cc;
434 err = (ISSET(c, TTY_ERRORMASK));
435 if (err) {
436 CLR(c, TTY_ERRORMASK);
437 if (ISSET(err, TTY_BI)) {
438 if (ISSET(iflag, IGNBRK)) {
439 lwkt_reltoken(&tp->t_token);
440 return (0);
441 }
442 if (ISSET(iflag, BRKINT)) {
443 ttyflush(tp, FREAD | FWRITE);
444 pgsignal(tp->t_pgrp, SIGINT, 1);
445 goto endcase;
446 }
447 if (ISSET(iflag, PARMRK))
448 goto parmrk;
449 } else if ((ISSET(err, TTY_PE) && ISSET(iflag, INPCK))
450 || ISSET(err, TTY_FE)) {
451 if (ISSET(iflag, IGNPAR)) {
452 lwkt_reltoken(&tp->t_token);
453 return (0);
454 }
455 else if (ISSET(iflag, PARMRK)) {
456 parmrk:
457 if (tp->t_rawq.c_cc + tp->t_canq.c_cc >
458 MAX_INPUT - 3)
459 goto input_overflow;
460 clist_putc(0377 | TTY_QUOTE, &tp->t_rawq);
461 clist_putc(0 | TTY_QUOTE, &tp->t_rawq);
462 clist_putc(c | TTY_QUOTE, &tp->t_rawq);
463 goto endcase;
464 } else
465 c = 0;
466 }
467 }
468
469 if (!ISSET(tp->t_state, TS_TYPEN) && ISSET(iflag, ISTRIP))
470 CLR(c, 0x80);
471 if (!ISSET(lflag, EXTPROC)) {
472 /*
473 * Check for literal nexting very first
474 */
475 if (ISSET(tp->t_state, TS_LNCH)) {
476 SET(c, TTY_QUOTE);
477 CLR(tp->t_state, TS_LNCH);
478 }
479 /*
480 * Scan for special characters. This code
481 * is really just a big case statement with
482 * non-constant cases. The bottom of the
483 * case statement is labeled ``endcase'', so goto
484 * it after a case match, or similar.
485 */
486
487 /*
488 * Control chars which aren't controlled
489 * by ICANON, ISIG, or IXON.
490 */
491 if (ISSET(lflag, IEXTEN)) {
492 if (CCEQ(cc[VLNEXT], c)) {
493 if (ISSET(lflag, ECHO)) {
494 if (ISSET(lflag, ECHOE)) {
495 (void)ttyoutput('^', tp);
496 (void)ttyoutput('\b', tp);
497 } else
498 ttyecho(c, tp);
499 }
500 SET(tp->t_state, TS_LNCH);
501 goto endcase;
502 }
503 if (CCEQ(cc[VDISCARD], c)) {
504 if (ISSET(lflag, FLUSHO))
505 CLR(tp->t_lflag, FLUSHO);
506 else {
507 ttyflush(tp, FWRITE);
508 ttyecho(c, tp);
509 if (tp->t_rawq.c_cc + tp->t_canq.c_cc)
510 ttyretype(tp);
511 SET(tp->t_lflag, FLUSHO);
512 }
513 goto startoutput;
514 }
515 }
516 /*
517 * Signals.
518 */
519 if (ISSET(lflag, ISIG)) {
520 if (CCEQ(cc[VINTR], c) || CCEQ(cc[VQUIT], c)) {
521 if (!ISSET(lflag, NOFLSH))
522 ttyflush(tp, FREAD | FWRITE);
523 ttyecho(c, tp);
524 pgsignal(tp->t_pgrp,
525 CCEQ(cc[VINTR], c) ? SIGINT : SIGQUIT, 1);
526 goto endcase;
527 }
528 if (CCEQ(cc[VSUSP], c)) {
529 if (!ISSET(lflag, NOFLSH))
530 ttyflush(tp, FREAD);
531 ttyecho(c, tp);
532 pgsignal(tp->t_pgrp, SIGTSTP, 1);
533 goto endcase;
534 }
535 }
536 /*
537 * Handle start/stop characters.
538 */
539 if (ISSET(iflag, IXON)) {
540 if (CCEQ(cc[VSTOP], c)) {
541 if (!ISSET(tp->t_state, TS_TTSTOP)) {
542 SET(tp->t_state, TS_TTSTOP);
543 (*tp->t_stop)(tp, 0);
544 lwkt_reltoken(&tp->t_token);
545 return (0);
546 }
547 if (!CCEQ(cc[VSTART], c)) {
548 lwkt_reltoken(&tp->t_token);
549 return (0);
550 }
551 /*
552 * if VSTART == VSTOP then toggle
553 */
554 goto endcase;
555 }
556 if (CCEQ(cc[VSTART], c))
557 goto restartoutput;
558 }
559 /*
560 * IGNCR, ICRNL, & INLCR
561 */
562 if (c == '\r') {
563 if (ISSET(iflag, IGNCR)) {
564 lwkt_reltoken(&tp->t_token);
565 return (0);
566 }
567 else if (ISSET(iflag, ICRNL))
568 c = '\n';
569 } else if (c == '\n' && ISSET(iflag, INLCR))
570 c = '\r';
571 }
572 if (!ISSET(tp->t_lflag, EXTPROC) && ISSET(lflag, ICANON)) {
573 /*
574 * From here on down canonical mode character
575 * processing takes place.
576 */
577 /*
578 * erase or erase2 (^H / ^?)
579 */
580 if (CCEQ(cc[VERASE], c) || CCEQ(cc[VERASE2], c) ) {
581 if (tp->t_rawq.c_cc)
582 ttyrub(clist_unputc(&tp->t_rawq), tp);
583 goto endcase;
584 }
585 /*
586 * kill (^U)
587 */
588 if (CCEQ(cc[VKILL], c)) {
589 if (ISSET(lflag, ECHOKE) &&
590 tp->t_rawq.c_cc == tp->t_rocount &&
591 !ISSET(lflag, ECHOPRT))
592 while (tp->t_rawq.c_cc)
593 ttyrub(clist_unputc(&tp->t_rawq), tp);
594 else {
595 ttyecho(c, tp);
596 if (ISSET(lflag, ECHOK) ||
597 ISSET(lflag, ECHOKE))
598 ttyecho('\n', tp);
599 FLUSHQ(&tp->t_rawq);
600 tp->t_rocount = 0;
601 }
602 CLR(tp->t_state, TS_LOCAL);
603 goto endcase;
604 }
605 /*
606 * word erase (^W)
607 */
608 if (CCEQ(cc[VWERASE], c) && ISSET(lflag, IEXTEN)) {
609 int ctype;
610
611 /*
612 * erase whitespace
613 */
614 while ((c = clist_unputc(&tp->t_rawq)) == ' ' || c == '\t')
615 ttyrub(c, tp);
616 if (c == -1)
617 goto endcase;
618 /*
619 * erase last char of word and remember the
620 * next chars type (for ALTWERASE)
621 */
622 ttyrub(c, tp);
623 c = clist_unputc(&tp->t_rawq);
624 if (c == -1)
625 goto endcase;
626 if (c == ' ' || c == '\t') {
627 clist_putc(c, &tp->t_rawq);
628 goto endcase;
629 }
630 ctype = ISALPHA(c);
631 /*
632 * erase rest of word
633 */
634 do {
635 ttyrub(c, tp);
636 c = clist_unputc(&tp->t_rawq);
637 if (c == -1)
638 goto endcase;
639 } while (c != ' ' && c != '\t' &&
640 (!ISSET(lflag, ALTWERASE) || ISALPHA(c) == ctype));
641 clist_putc(c, &tp->t_rawq);
642 goto endcase;
643 }
644 /*
645 * reprint line (^R)
646 */
647 if (CCEQ(cc[VREPRINT], c) && ISSET(lflag, IEXTEN)) {
648 ttyretype(tp);
649 goto endcase;
650 }
651 /*
652 * ^T - kernel info and generate SIGINFO
653 */
654 if (CCEQ(cc[VSTATUS], c) && ISSET(lflag, IEXTEN)) {
655 if (ISSET(lflag, ISIG))
656 pgsignal(tp->t_pgrp, SIGINFO, 1);
657 if (!ISSET(lflag, NOKERNINFO))
658 ttyinfo(tp);
659 goto endcase;
660 }
661 if (CCEQ(cc[VCHECKPT], c) && ISSET(lflag, IEXTEN)) {
662 if (ISSET(lflag, ISIG))
663 pgsignal(tp->t_pgrp, SIGCKPT, 1);
664 goto endcase;
665 }
666 }
667 /*
668 * Check for input buffer overflow
669 */
670 if (tp->t_rawq.c_cc + tp->t_canq.c_cc >= MAX_INPUT) {
671 input_overflow:
672 if (ISSET(iflag, IMAXBEL)) {
673 if (tp->t_outq.c_cc < tp->t_ohiwat)
674 (void)ttyoutput(CTRL('g'), tp);
675 }
676 goto endcase;
677 }
678
679 if (c == 0377 && ISSET(iflag, PARMRK) && !ISSET(iflag, ISTRIP) &&
680 ISSET(iflag, IGNBRK|IGNPAR) != (IGNBRK|IGNPAR)) {
681 clist_putc(0377 | TTY_QUOTE, &tp->t_rawq);
682 }
683
684 /*
685 * Put data char in q for user and
686 * wakeup on seeing a line delimiter.
687 */
688 if (clist_putc(c, &tp->t_rawq) >= 0) {
689 if (!ISSET(lflag, ICANON)) {
690 ttwakeup(tp);
691 ttyecho(c, tp);
692 goto endcase;
693 }
694 if (TTBREAKC(c, lflag)) {
695 tp->t_rocount = 0;
696 clist_catq(&tp->t_rawq, &tp->t_canq);
697 ttwakeup(tp);
698 } else if (tp->t_rocount++ == 0)
699 tp->t_rocol = tp->t_column;
700 if (ISSET(tp->t_state, TS_ERASE)) {
701 /*
702 * end of prterase \.../
703 */
704 CLR(tp->t_state, TS_ERASE);
705 (void)ttyoutput('/', tp);
706 }
707 i = tp->t_column;
708 ttyecho(c, tp);
709 if (CCEQ(cc[VEOF], c) && ISSET(lflag, ECHO)) {
710 /*
711 * Place the cursor over the '^' of the ^D.
712 */
713 i = imin(2, tp->t_column - i);
714 while (i > 0) {
715 (void)ttyoutput('\b', tp);
716 i--;
717 }
718 }
719 }
720 endcase:
721 /*
722 * IXANY means allow any character to restart output.
723 */
724 if (ISSET(tp->t_state, TS_TTSTOP) &&
725 !ISSET(iflag, IXANY) && cc[VSTART] != cc[VSTOP]) {
726 lwkt_reltoken(&tp->t_token);
727 return (0);
728 }
729 restartoutput:
730 CLR(tp->t_lflag, FLUSHO);
731 CLR(tp->t_state, TS_TTSTOP);
732 startoutput:
733 lwkt_reltoken(&tp->t_token);
734 return (ttstart(tp));
735 }
736
737 /*
738 * Output a single character on a tty, doing output processing
739 * as needed (expanding tabs, newline processing, etc.).
740 * Returns < 0 if succeeds, otherwise returns char to resend.
741 * Must be recursive.
742 */
743 static int
744 ttyoutput(int c, struct tty *tp)
745 {
746 tcflag_t oflag;
747 int col;
748
749 lwkt_gettoken(&tp->t_token);
750 oflag = tp->t_oflag;
751 if (!ISSET(oflag, OPOST)) {
752 if (ISSET(tp->t_lflag, FLUSHO)) {
753 lwkt_reltoken(&tp->t_token);
754 return (-1);
755 }
756 if (clist_putc(c, &tp->t_outq)) {
757 lwkt_reltoken(&tp->t_token);
758 return (c);
759 }
760 tk_nout++;
761 tp->t_outcc++;
762 lwkt_reltoken(&tp->t_token);
763 return (-1);
764 }
765 /*
766 * Do tab expansion if OXTABS is set. Special case if we external
767 * processing, we don't do the tab expansion because we'll probably
768 * get it wrong. If tab expansion needs to be done, let it happen
769 * externally.
770 */
771 CLR(c, ~TTY_CHARMASK);
772 if (c == '\t' &&
773 ISSET(oflag, OXTABS) && !ISSET(tp->t_lflag, EXTPROC)) {
774 c = 8 - (tp->t_column & 7);
775 if (!ISSET(tp->t_lflag, FLUSHO)) {
776 c -= clist_btoq(" ", c, &tp->t_outq);
777 tk_nout += c;
778 tp->t_outcc += c;
779 }
780 tp->t_column += c;
781 lwkt_reltoken(&tp->t_token);
782 return (c ? -1 : '\t');
783 }
784 if (c == CEOT && ISSET(oflag, ONOEOT)) {
785 lwkt_reltoken(&tp->t_token);
786 return (-1);
787 }
788
789 /*
790 * Newline translation: if ONLCR is set,
791 * translate newline into "\r\n".
792 */
793 if (c == '\n' && ISSET(tp->t_oflag, ONLCR)) {
794 tk_nout++;
795 tp->t_outcc++;
796 if (!ISSET(tp->t_lflag, FLUSHO) && clist_putc('\r', &tp->t_outq)) {
797 lwkt_reltoken(&tp->t_token);
798 return (c);
799 }
800 }
801 /* If OCRNL is set, translate "\r" into "\n". */
802 else if (c == '\r' && ISSET(tp->t_oflag, OCRNL))
803 c = '\n';
804 /* If ONOCR is set, don't transmit CRs when on column 0. */
805 else if (c == '\r' && ISSET(tp->t_oflag, ONOCR) && tp->t_column == 0) {
806 lwkt_reltoken(&tp->t_token);
807 return (-1);
808 }
809
810 tk_nout++;
811 tp->t_outcc++;
812 if (!ISSET(tp->t_lflag, FLUSHO) && clist_putc(c, &tp->t_outq)) {
813 lwkt_reltoken(&tp->t_token);
814 return (c);
815 }
816
817 col = tp->t_column;
818 switch (CCLASS(c)) {
819 case BACKSPACE:
820 if (col > 0)
821 --col;
822 break;
823 case CONTROL:
824 break;
825 case NEWLINE:
826 if (ISSET(tp->t_oflag, ONLCR | ONLRET))
827 col = 0;
828 break;
829 case RETURN:
830 col = 0;
831 break;
832 case ORDINARY:
833 ++col;
834 break;
835 case TAB:
836 col = (col + 8) & ~7;
837 break;
838 }
839 tp->t_column = col;
840 lwkt_reltoken(&tp->t_token);
841
842 return (-1);
843 }
844
845 /*
846 * Ioctls for all tty devices. Called after line-discipline specific ioctl
847 * has been called to do discipline-specific functions and/or reject any
848 * of these ioctl commands.
849 */
850 /* ARGSUSED */
851 int
852 ttioctl(struct tty *tp, u_long cmd, void *data, int flag)
853 {
854 struct thread *td = curthread;
855 struct lwp *lp = td->td_lwp;
856 struct proc *p = td->td_proc;
857 struct pgrp *opgrp;
858 struct tty *otp;
859 int error;
860
861 KKASSERT(p);
862 lwkt_gettoken(&tp->t_token);
863 lwkt_gettoken(&p->p_token);
864
865 /* If the ioctl involves modification, hang if in the background. */
866 switch (cmd) {
867 case TIOCCBRK:
868 case TIOCCONS:
869 case TIOCDRAIN:
870 case TIOCEXCL:
871 case TIOCFLUSH:
872 #ifdef TIOCHPCL
873 case TIOCHPCL:
874 #endif
875 case TIOCNXCL:
876 case TIOCSBRK:
877 case TIOCSCTTY:
878 case TIOCSDRAINWAIT:
879 case TIOCSETA:
880 case TIOCSETAF:
881 case TIOCSETAW:
882 case TIOCSETD:
883 case TIOCSPGRP:
884 case TIOCSTART:
885 case TIOCSTAT:
886 case TIOCSTI:
887 case TIOCSTOP:
888 case TIOCSWINSZ:
889 while (isbackground(p, tp) && !(p->p_flags & P_PPWAIT) &&
890 !SIGISMEMBER(p->p_sigignore, SIGTTOU) &&
891 !SIGISMEMBER(lp->lwp_sigmask, SIGTTOU)) {
892 if (p->p_pgrp->pg_jobc == 0) {
893 lwkt_reltoken(&p->p_token);
894 lwkt_reltoken(&tp->t_token);
895 return (EIO);
896 }
897 pgsignal(p->p_pgrp, SIGTTOU, 1);
898 error = ttysleep(tp, &lbolt, PCATCH, "ttybg1",
899 0);
900 if (error) {
901 lwkt_reltoken(&p->p_token);
902 lwkt_reltoken(&tp->t_token);
903 return (error);
904 }
905 }
906 break;
907 }
908
909 switch (cmd) { /* Process the ioctl. */
910 case FIOASYNC: /* set/clear async i/o */
911 if (*(int *)data)
912 SET(tp->t_state, TS_ASYNC);
913 else
914 CLR(tp->t_state, TS_ASYNC);
915 break;
916 case FIONREAD: /* get # bytes to read */
917 *(int *)data = ttnread(tp);
918 break;
919
920 case FIOSETOWN:
921 /*
922 * Policy -- Don't allow FIOSETOWN on someone else's
923 * controlling tty
924 */
925 if (tp->t_session != NULL && !isctty(p, tp)) {
926 lwkt_reltoken(&p->p_token);
927 lwkt_reltoken(&tp->t_token);
928 return (ENOTTY);
929 }
930
931 error = fsetown(*(int *)data, &tp->t_sigio);
932 if (error) {
933 lwkt_reltoken(&p->p_token);
934 lwkt_reltoken(&tp->t_token);
935 return (error);
936 }
937 break;
938 case FIOGETOWN:
939 if (tp->t_session != NULL && !isctty(p, tp)) {
940 lwkt_reltoken(&p->p_token);
941 lwkt_reltoken(&tp->t_token);
942 return (ENOTTY);
943 }
944 *(int *)data = fgetown(&tp->t_sigio);
945 break;
946
947 case TIOCEXCL: /* set exclusive use of tty */
948 SET(tp->t_state, TS_XCLUDE);
949 break;
950 case TIOCFLUSH: { /* flush buffers */
951 int flags = *(int *)data;
952
953 if (flags == 0)
954 flags = FREAD | FWRITE;
955 else
956 flags &= FREAD | FWRITE;
957 ttyflush(tp, flags);
958 break;
959 }
960 case TIOCCONS: /* become virtual console */
961 if (*(int *)data) {
962 if (constty && constty != tp &&
963 ISSET(constty->t_state, TS_CONNECTED)) {
964 lwkt_reltoken(&p->p_token);
965 lwkt_reltoken(&tp->t_token);
966 return (EBUSY);
967 }
968 #ifndef UCONSOLE
969 if ((error = priv_check(td, PRIV_ROOT)) != 0) {
970 lwkt_reltoken(&p->p_token);
971 lwkt_reltoken(&tp->t_token);
972 return (error);
973 }
974 #endif
975 constty = tp;
976 } else if (tp == constty)
977 constty = NULL;
978 break;
979 case TIOCDRAIN: /* wait till output drained */
980 error = ttywait(tp);
981 if (error) {
982 lwkt_reltoken(&p->p_token);
983 lwkt_reltoken(&tp->t_token);
984 return (error);
985 }
986 break;
987 case TIOCGETA: { /* get termios struct */
988 struct termios *t = (struct termios *)data;
989
990 bcopy(&tp->t_termios, t, sizeof(struct termios));
991 break;
992 }
993 case TIOCGETD: /* get line discipline */
994 *(int *)data = tp->t_line;
995 break;
996 case TIOCGWINSZ: /* get window size */
997 *(struct winsize *)data = tp->t_winsize;
998 break;
999 case TIOCGPGRP: /* get pgrp of tty */
1000 if (!isctty(p, tp)) {
1001 lwkt_reltoken(&p->p_token);
1002 lwkt_reltoken(&tp->t_token);
1003 return (ENOTTY);
1004 }
1005 *(int *)data = tp->t_pgrp ? tp->t_pgrp->pg_id : NO_PID;
1006 break;
1007 case TIOCGSID: /* get sid of tty */
1008 if (!isctty(p, tp)) {
1009 lwkt_reltoken(&p->p_token);
1010 lwkt_reltoken(&tp->t_token);
1011 return (ENOTTY);
1012 }
1013 *(int *)data = tp->t_session->s_sid;
1014 break;
1015 #ifdef TIOCHPCL
1016 case TIOCHPCL: /* hang up on last close */
1017 SET(tp->t_cflag, HUPCL);
1018 break;
1019 #endif
1020 case TIOCNXCL: /* reset exclusive use of tty */
1021 CLR(tp->t_state, TS_XCLUDE);
1022 break;
1023 case TIOCOUTQ: /* output queue size */
1024 *(int *)data = tp->t_outq.c_cc;
1025 break;
1026 case TIOCSETA: /* set termios struct */
1027 case TIOCSETAW: /* drain output, set */
1028 case TIOCSETAF: { /* drn out, fls in, set */
1029 struct termios *t = (struct termios *)data;
1030
1031 if (t->c_ispeed == 0)
1032 t->c_ispeed = t->c_ospeed;
1033 if (t->c_ispeed == 0)
1034 t->c_ispeed = tp->t_ospeed;
1035 if (t->c_ispeed == 0) {
1036 lwkt_reltoken(&p->p_token);
1037 lwkt_reltoken(&tp->t_token);
1038 return (EINVAL);
1039 }
1040 if (cmd == TIOCSETAW || cmd == TIOCSETAF) {
1041 error = ttywait(tp);
1042 if (error) {
1043 lwkt_reltoken(&p->p_token);
1044 lwkt_reltoken(&tp->t_token);
1045 return (error);
1046 }
1047 if (cmd == TIOCSETAF)
1048 ttyflush(tp, FREAD);
1049 }
1050 if (!ISSET(t->c_cflag, CIGNORE)) {
1051 /*
1052 * Set device hardware.
1053 */
1054 if (tp->t_param && (error = (*tp->t_param)(tp, t))) {
1055 lwkt_reltoken(&p->p_token);
1056 lwkt_reltoken(&tp->t_token);
1057 return (error);
1058 }
1059 if (ISSET(t->c_cflag, CLOCAL) &&
1060 !ISSET(tp->t_cflag, CLOCAL)) {
1061 /*
1062 * XXX disconnections would be too hard to
1063 * get rid of without this kludge. The only
1064 * way to get rid of controlling terminals
1065 * is to exit from the session leader.
1066 */
1067 CLR(tp->t_state, TS_ZOMBIE);
1068
1069 wakeup(TSA_CARR_ON(tp));
1070 ttwakeup(tp);
1071 ttwwakeup(tp);
1072 }
1073 if ((ISSET(tp->t_state, TS_CARR_ON) ||
1074 ISSET(t->c_cflag, CLOCAL)) &&
1075 !ISSET(tp->t_state, TS_ZOMBIE))
1076 SET(tp->t_state, TS_CONNECTED);
1077 else
1078 CLR(tp->t_state, TS_CONNECTED);
1079 tp->t_cflag = t->c_cflag;
1080 tp->t_ispeed = t->c_ispeed;
1081 if (t->c_ospeed != 0)
1082 tp->t_ospeed = t->c_ospeed;
1083 ttsetwater(tp);
1084 }
1085 if (ISSET(t->c_lflag, ICANON) != ISSET(tp->t_lflag, ICANON) &&
1086 cmd != TIOCSETAF) {
1087 if (ISSET(t->c_lflag, ICANON))
1088 SET(tp->t_lflag, PENDIN);
1089 else {
1090 /*
1091 * XXX we really shouldn't allow toggling
1092 * ICANON while we're in a non-termios line
1093 * discipline. Now we have to worry about
1094 * panicing for a null queue.
1095 */
1096 if (tp->t_canq.c_ccmax > 0 &&
1097 tp->t_rawq.c_ccmax > 0) {
1098 clist_catq(&tp->t_rawq, &tp->t_canq);
1099 /*
1100 * XXX the queue limits may be
1101 * different, so the old queue
1102 * swapping method no longer works.
1103 */
1104 clist_catq(&tp->t_canq, &tp->t_rawq);
1105 }
1106 CLR(tp->t_lflag, PENDIN);
1107 }
1108 ttwakeup(tp);
1109 }
1110 tp->t_iflag = t->c_iflag;
1111 tp->t_oflag = t->c_oflag;
1112 /*
1113 * Make the EXTPROC bit read only.
1114 */
1115 if (ISSET(tp->t_lflag, EXTPROC))
1116 SET(t->c_lflag, EXTPROC);
1117 else
1118 CLR(t->c_lflag, EXTPROC);
1119 tp->t_lflag = t->c_lflag | ISSET(tp->t_lflag, PENDIN);
1120 if (t->c_cc[VMIN] != tp->t_cc[VMIN] ||
1121 t->c_cc[VTIME] != tp->t_cc[VTIME])
1122 ttwakeup(tp);
1123 bcopy(t->c_cc, tp->t_cc, sizeof(t->c_cc));
1124 break;
1125 }
1126 case TIOCSETD: { /* set line discipline */
1127 int t = *(int *)data;
1128 cdev_t device = tp->t_dev;
1129
1130 if ((u_int)t >= nlinesw) {
1131 lwkt_reltoken(&p->p_token);
1132 lwkt_reltoken(&tp->t_token);
1133 return (ENXIO);
1134 }
1135 if (t != tp->t_line) {
1136 (*linesw[tp->t_line].l_close)(tp, flag);
1137 error = (*linesw[t].l_open)(device, tp);
1138 if (error) {
1139 (void)(*linesw[tp->t_line].l_open)(device, tp);
1140 lwkt_reltoken(&p->p_token);
1141 lwkt_reltoken(&tp->t_token);
1142 return (error);
1143 }
1144 tp->t_line = t;
1145 }
1146 break;
1147 }
1148 case TIOCSTART: /* start output, like ^Q */
1149 if (ISSET(tp->t_state, TS_TTSTOP) ||
1150 ISSET(tp->t_lflag, FLUSHO)) {
1151 CLR(tp->t_lflag, FLUSHO);
1152 CLR(tp->t_state, TS_TTSTOP);
1153 ttstart(tp);
1154 }
1155 break;
1156 case TIOCSTI: /* simulate terminal input */
1157 if ((flag & FREAD) == 0 && priv_check(td, PRIV_ROOT)) {
1158 lwkt_reltoken(&p->p_token);
1159 lwkt_reltoken(&tp->t_token);
1160 return (EPERM);
1161 }
1162 if (!isctty(p, tp) && priv_check(td, PRIV_ROOT)) {
1163 lwkt_reltoken(&p->p_token);
1164 lwkt_reltoken(&tp->t_token);
1165 return (EACCES);
1166 }
1167 (*linesw[tp->t_line].l_rint)(*(u_char *)data, tp);
1168 break;
1169 case TIOCSTOP: /* stop output, like ^S */
1170 if (!ISSET(tp->t_state, TS_TTSTOP)) {
1171 SET(tp->t_state, TS_TTSTOP);
1172 (*tp->t_stop)(tp, 0);
1173 }
1174 break;
1175 case TIOCSCTTY: /* become controlling tty */
1176 /* Session ctty vnode pointer set in vnode layer. */
1177 if (!SESS_LEADER(p) ||
1178 ((p->p_session->s_ttyvp || tp->t_session) &&
1179 (tp->t_session != p->p_session))) {
1180 lwkt_reltoken(&p->p_token);
1181 lwkt_reltoken(&tp->t_token);
1182 return (EPERM);
1183 }
1184 ttyhold(tp);
1185 tp->t_session = p->p_session;
1186 opgrp = tp->t_pgrp;
1187 pgref(p->p_pgrp);
1188 tp->t_pgrp = p->p_pgrp;
1189 otp = p->p_session->s_ttyp;
1190 p->p_session->s_ttyp = tp;
1191 p->p_flags |= P_CONTROLT;
1192 if (otp)
1193 ttyunhold(otp);
1194 if (opgrp) {
1195 pgrel(opgrp);
1196 opgrp = NULL;
1197 }
1198 break;
1199 case TIOCSPGRP: { /* set pgrp of tty */
1200 pid_t pgid = *(int *)data;
1201
1202 if (!isctty(p, tp)) {
1203 lwkt_reltoken(&p->p_token);
1204 lwkt_reltoken(&tp->t_token);
1205 return (ENOTTY);
1206 }
1207 else if (pgid < 1 || pgid > PID_MAX) {
1208 lwkt_reltoken(&p->p_token);
1209 lwkt_reltoken(&tp->t_token);
1210 return (EINVAL);
1211 } else {
1212 struct pgrp *pgrp = pgfind(pgid);
1213 if (pgrp == NULL || pgrp->pg_session != p->p_session) {
1214 if (pgrp)
1215 pgrel(pgrp);
1216 lwkt_reltoken(&p->p_token);
1217 lwkt_reltoken(&tp->t_token);
1218 return (EPERM);
1219 }
1220 opgrp = tp->t_pgrp;
1221 tp->t_pgrp = pgrp;
1222 if (opgrp) {
1223 pgrel(opgrp);
1224 opgrp = NULL;
1225 }
1226 }
1227 break;
1228 }
1229 case TIOCSTAT: /* simulate control-T */
1230 ttyinfo(tp);
1231 break;
1232 case TIOCSWINSZ: /* set window size */
1233 if (bcmp((caddr_t)&tp->t_winsize, data,
1234 sizeof (struct winsize))) {
1235 tp->t_winsize = *(struct winsize *)data;
1236 pgsignal(tp->t_pgrp, SIGWINCH, 1);
1237 }
1238 break;
1239 case TIOCSDRAINWAIT:
1240 error = priv_check(td, PRIV_ROOT);
1241 if (error) {
1242 lwkt_reltoken(&p->p_token);
1243 lwkt_reltoken(&tp->t_token);
1244 return (error);
1245 }
1246 tp->t_timeout = *(int *)data * hz;
1247 wakeup(TSA_OCOMPLETE(tp));
1248 wakeup(TSA_OLOWAT(tp));
1249 break;
1250 case TIOCGDRAINWAIT:
1251 *(int *)data = tp->t_timeout / hz;
1252 break;
1253 default:
1254 lwkt_reltoken(&p->p_token);
1255 lwkt_reltoken(&tp->t_token);
1256 return (ENOIOCTL);
1257 }
1258 lwkt_reltoken(&p->p_token);
1259 lwkt_reltoken(&tp->t_token);
1260 return (0);
1261 }
1262
1263 static struct filterops ttyread_filtops =
1264 { FILTEROP_ISFD|FILTEROP_MPSAFE, NULL, filt_ttyrdetach, filt_ttyread };
1265 static struct filterops ttywrite_filtops =
1266 { FILTEROP_ISFD|FILTEROP_MPSAFE, NULL, filt_ttywdetach, filt_ttywrite };
1267
1268 int
1269 ttykqfilter(struct dev_kqfilter_args *ap)
1270 {
1271 cdev_t dev = ap->a_head.a_dev;
1272 struct knote *kn = ap->a_kn;
1273 struct tty *tp = dev->si_tty;
1274 struct klist *klist;
1275
1276 ap->a_result = 0;
1277
1278 lwkt_gettoken(&tp->t_token);
1279 switch (kn->kn_filter) {
1280 case EVFILT_READ:
1281 klist = &tp->t_rkq.ki_note;
1282 kn->kn_fop = &ttyread_filtops;
1283 break;
1284 case EVFILT_WRITE:
1285 klist = &tp->t_wkq.ki_note;
1286 kn->kn_fop = &ttywrite_filtops;
1287 break;
1288 default:
1289 ap->a_result = EOPNOTSUPP;
1290 lwkt_reltoken(&tp->t_token);
1291 return (0);
1292 }
1293 lwkt_reltoken(&tp->t_token);
1294 kn->kn_hook = (caddr_t)dev;
1295 knote_insert(klist, kn);
1296
1297 return (0);
1298 }
1299
1300 static void
1301 filt_ttyrdetach(struct knote *kn)
1302 {
1303 struct tty *tp = ((cdev_t)kn->kn_hook)->si_tty;
1304
1305 lwkt_gettoken(&tp->t_token);
1306 knote_remove(&tp->t_rkq.ki_note, kn);
1307 lwkt_reltoken(&tp->t_token);
1308 }
1309
1310 static int
1311 filt_ttyread(struct knote *kn, long hint)
1312 {
1313 struct tty *tp = ((cdev_t)kn->kn_hook)->si_tty;
1314
1315 lwkt_gettoken(&tp->t_token);
1316 kn->kn_data = ttnread(tp);
1317 if (ISSET(tp->t_state, TS_ZOMBIE)) {
1318 kn->kn_flags |= (EV_EOF | EV_NODATA);
1319 lwkt_reltoken(&tp->t_token);
1320 return (1);
1321 }
1322 lwkt_reltoken(&tp->t_token);
1323 return (kn->kn_data > 0);
1324 }
1325
1326 static void
1327 filt_ttywdetach(struct knote *kn)
1328 {
1329 struct tty *tp = ((cdev_t)kn->kn_hook)->si_tty;
1330
1331 lwkt_gettoken(&tp->t_token);
1332 knote_remove(&tp->t_wkq.ki_note, kn);
1333 lwkt_reltoken(&tp->t_token);
1334 }
1335
1336 static int
1337 filt_ttywrite(struct knote *kn, long hint)
1338 {
1339 struct tty *tp = ((cdev_t)kn->kn_hook)->si_tty;
1340 int ret;
1341
1342 lwkt_gettoken(&tp->t_token);
1343 kn->kn_data = tp->t_outq.c_cc;
1344 if (ISSET(tp->t_state, TS_ZOMBIE)) {
1345 lwkt_reltoken(&tp->t_token);
1346 return (1);
1347 }
1348 ret = (kn->kn_data <= tp->t_olowat &&
1349 ISSET(tp->t_state, TS_CONNECTED));
1350 lwkt_reltoken(&tp->t_token);
1351 return ret;
1352 }
1353
1354 /*
1355 * NOTE: tp->t_token must be held.
1356 */
1357 static int
1358 ttnread(struct tty *tp)
1359 {
1360 int nread;
1361
1362 ASSERT_LWKT_TOKEN_HELD(&tp->t_token);
1363 if (ISSET(tp->t_lflag, PENDIN))
1364 ttypend(tp);
1365 nread = tp->t_canq.c_cc;
1366 if (!ISSET(tp->t_lflag, ICANON)) {
1367 nread += tp->t_rawq.c_cc;
1368 if (nread < tp->t_cc[VMIN] && tp->t_cc[VTIME] == 0)
1369 nread = 0;
1370 }
1371 return (nread);
1372 }
1373
1374 /*
1375 * Wait for output to drain.
1376 */
1377 int
1378 ttywait(struct tty *tp)
1379 {
1380 int error;
1381
1382 error = 0;
1383 lwkt_gettoken(&tp->t_token);
1384 while ((tp->t_outq.c_cc || ISSET(tp->t_state, TS_BUSY)) &&
1385 ISSET(tp->t_state, TS_CONNECTED) && tp->t_oproc) {
1386 (*tp->t_oproc)(tp);
1387 if ((tp->t_outq.c_cc || ISSET(tp->t_state, TS_BUSY)) &&
1388 ISSET(tp->t_state, TS_CONNECTED)) {
1389 SET(tp->t_state, TS_SO_OCOMPLETE);
1390 error = ttysleep(tp, TSA_OCOMPLETE(tp),
1391 PCATCH, "ttywai",
1392 tp->t_timeout);
1393 if (error) {
1394 if (error == EWOULDBLOCK)
1395 error = EIO;
1396 break;
1397 }
1398 } else
1399 break;
1400 }
1401 if (!error && (tp->t_outq.c_cc || ISSET(tp->t_state, TS_BUSY)))
1402 error = EIO;
1403 lwkt_reltoken(&tp->t_token);
1404
1405 return (error);
1406 }
1407
1408 /*
1409 * Flush if successfully wait.
1410 */
1411 static int
1412 ttywflush(struct tty *tp)
1413 {
1414 int error;
1415
1416 if ((error = ttywait(tp)) == 0)
1417 ttyflush(tp, FREAD);
1418 return (error);
1419 }
1420
1421 /*
1422 * Flush tty read and/or write queues, notifying anyone waiting.
1423 */
1424 void
1425 ttyflush(struct tty *tp, int rw)
1426 {
1427 lwkt_gettoken(&tp->t_token);
1428 #if 0
1429 again:
1430 #endif
1431 if (rw & FWRITE) {
1432 FLUSHQ(&tp->t_outq);
1433 CLR(tp->t_state, TS_TTSTOP);
1434 }
1435 (*tp->t_stop)(tp, rw);
1436 if (rw & FREAD) {
1437 FLUSHQ(&tp->t_canq);
1438 FLUSHQ(&tp->t_rawq);
1439 CLR(tp->t_lflag, PENDIN);
1440 tp->t_rocount = 0;
1441 tp->t_rocol = 0;
1442 CLR(tp->t_state, TS_LOCAL);
1443 ttwakeup(tp);
1444 if (ISSET(tp->t_state, TS_TBLOCK)) {
1445 if (rw & FWRITE)
1446 FLUSHQ(&tp->t_outq);
1447 ttyunblock(tp);
1448
1449 /*
1450 * Don't let leave any state that might clobber the
1451 * next line discipline (although we should do more
1452 * to send the START char). Not clearing the state
1453 * may have caused the "putc to a clist with no
1454 * reserved cblocks" panic/kprintf.
1455 */
1456 CLR(tp->t_state, TS_TBLOCK);
1457
1458 #if 0 /* forget it, sleeping isn't always safe and we don't know when it is */
1459 if (ISSET(tp->t_iflag, IXOFF)) {
1460 /*
1461 * XXX wait a bit in the hope that the stop
1462 * character (if any) will go out. Waiting
1463 * isn't good since it allows races. This
1464 * will be fixed when the stop character is
1465 * put in a special queue. Don't bother with
1466 * the checks in ttywait() since the timeout
1467 * will save us.
1468 */
1469 SET(tp->t_state, TS_SO_OCOMPLETE);
1470 ttysleep(tp, TSA_OCOMPLETE(tp), 0,
1471 "ttyfls", hz / 10);
1472 /*
1473 * Don't try sending the stop character again.
1474 */
1475 CLR(tp->t_state, TS_TBLOCK);
1476 goto again;
1477 }
1478 #endif
1479 }
1480 }
1481 if (rw & FWRITE) {
1482 FLUSHQ(&tp->t_outq);
1483 ttwwakeup(tp);
1484 }
1485 lwkt_reltoken(&tp->t_token);
1486 }
1487
1488 /*
1489 * Copy in the default termios characters.
1490 */
1491 void
1492 termioschars(struct termios *t)
1493 {
1494 bcopy(ttydefchars, t->c_cc, sizeof t->c_cc);
1495 }
1496
1497 /*
1498 * Old interface.
1499 */
1500 void
1501 ttychars(struct tty *tp)
1502 {
1503 lwkt_gettoken(&tp->t_token);
1504 termioschars(&tp->t_termios);
1505 lwkt_reltoken(&tp->t_token);
1506 }
1507
1508 /*
1509 * Handle input high water. Send stop character for the IXOFF case. Turn
1510 * on our input flow control bit and propagate the changes to the driver.
1511 * XXX the stop character should be put in a special high priority queue.
1512 */
1513 void
1514 ttyblock(struct tty *tp)
1515 {
1516 lwkt_gettoken(&tp->t_token);
1517 SET(tp->t_state, TS_TBLOCK);
1518 if (ISSET(tp->t_iflag, IXOFF) && tp->t_cc[VSTOP] != _POSIX_VDISABLE &&
1519 clist_putc(tp->t_cc[VSTOP], &tp->t_outq) != 0)
1520 CLR(tp->t_state, TS_TBLOCK); /* try again later */
1521 ttstart(tp);
1522 lwkt_reltoken(&tp->t_token);
1523 }
1524
1525 /*
1526 * Handle input low water. Send start character for the IXOFF case. Turn
1527 * off our input flow control bit and propagate the changes to the driver.
1528 * XXX the start character should be put in a special high priority queue.
1529 */
1530 static void
1531 ttyunblock(struct tty *tp)
1532 {
1533 lwkt_gettoken(&tp->t_token);
1534 CLR(tp->t_state, TS_TBLOCK);
1535 if (ISSET(tp->t_iflag, IXOFF) && tp->t_cc[VSTART] != _POSIX_VDISABLE &&
1536 clist_putc(tp->t_cc[VSTART], &tp->t_outq) != 0)
1537 SET(tp->t_state, TS_TBLOCK); /* try again later */
1538 ttstart(tp);
1539 lwkt_reltoken(&tp->t_token);
1540 }
1541
1542 int
1543 ttstart(struct tty *tp)
1544 {
1545 lwkt_gettoken(&tp->t_token);
1546 if (tp->t_oproc != NULL) /* XXX: Kludge for pty. */
1547 (*tp->t_oproc)(tp);
1548 lwkt_reltoken(&tp->t_token);
1549 return (0);
1550 }
1551
1552 /*
1553 * "close" a line discipline
1554 */
1555 int
1556 ttylclose(struct tty *tp, int flag)
1557 {
1558 lwkt_gettoken(&tp->t_token);
1559 if (flag & FNONBLOCK || ttywflush(tp))
1560 ttyflush(tp, FREAD | FWRITE);
1561 lwkt_reltoken(&tp->t_token);
1562 return (0);
1563 }
1564
1565 void
1566 ttyhold(struct tty *tp)
1567 {
1568 lwkt_gettoken(&tp->t_token);
1569 ++tp->t_refs;
1570 lwkt_reltoken(&tp->t_token);
1571 }
1572
1573 void
1574 ttyunhold(struct tty *tp)
1575 {
1576 lwkt_gettoken(&tp->t_token);
1577 if (tp->t_unhold)
1578 tp->t_unhold(tp);
1579 else
1580 --tp->t_refs;
1581 lwkt_reltoken(&tp->t_token);
1582 }
1583
1584 /*
1585 * Handle modem control transition on a tty.
1586 * Flag indicates new state of carrier.
1587 * Returns 0 if the line should be turned off, otherwise 1.
1588 */
1589 int
1590 ttymodem(struct tty *tp, int flag)
1591 {
1592 lwkt_gettoken(&tp->t_token);
1593 if (ISSET(tp->t_state, TS_CARR_ON) && ISSET(tp->t_cflag, MDMBUF)) {
1594 /*
1595 * MDMBUF: do flow control according to carrier flag
1596 * XXX TS_CAR_OFLOW doesn't do anything yet. TS_TTSTOP
1597 * works if IXON and IXANY are clear.
1598 */
1599 if (flag) {
1600 CLR(tp->t_state, TS_CAR_OFLOW);
1601 CLR(tp->t_state, TS_TTSTOP);
1602 ttstart(tp);
1603 } else if (!ISSET(tp->t_state, TS_CAR_OFLOW)) {
1604 SET(tp->t_state, TS_CAR_OFLOW);
1605 SET(tp->t_state, TS_TTSTOP);
1606 (*tp->t_stop)(tp, 0);
1607 }
1608 } else if (flag == 0) {
1609 /*
1610 * Lost carrier.
1611 */
1612 CLR(tp->t_state, TS_CARR_ON);
1613 if (ISSET(tp->t_state, TS_ISOPEN) &&
1614 !ISSET(tp->t_cflag, CLOCAL)) {
1615 SET(tp->t_state, TS_ZOMBIE);
1616 CLR(tp->t_state, TS_CONNECTED);
1617 if (tp->t_session && tp->t_session->s_leader)
1618 ksignal(tp->t_session->s_leader, SIGHUP);
1619 ttyflush(tp, FREAD | FWRITE);
1620 lwkt_reltoken(&tp->t_token);
1621 return (0);
1622 }
1623 } else {
1624 /*
1625 * Carrier now on.
1626 */
1627 SET(tp->t_state, TS_CARR_ON);
1628 if (!ISSET(tp->t_state, TS_ZOMBIE))
1629 SET(tp->t_state, TS_CONNECTED);
1630 wakeup(TSA_CARR_ON(tp));
1631 ttwakeup(tp);
1632 ttwwakeup(tp);
1633 }
1634 lwkt_reltoken(&tp->t_token);
1635 return (1);
1636 }
1637
1638 /*
1639 * Reinput pending characters after state switch
1640 */
1641 static void
1642 ttypend(struct tty *tp)
1643 {
1644 struct clist tq;
1645 int c;
1646
1647 lwkt_gettoken(&tp->t_token);
1648 CLR(tp->t_lflag, PENDIN);
1649 SET(tp->t_state, TS_TYPEN);
1650 /*
1651 * XXX this assumes too much about clist internals. It may even
1652 * fail if the cblock slush pool is empty. We can't allocate more
1653 * cblocks here because we are called from an interrupt handler
1654 * and clist_alloc_cblocks() can wait.
1655 */
1656 tq = tp->t_rawq;
1657 bzero(&tp->t_rawq, sizeof tp->t_rawq);
1658 clist_alloc_cblocks(&tp->t_rawq, tq.c_ccmax);
1659 while ((c = clist_getc(&tq)) >= 0)
1660 ttyinput(c, tp);
1661 CLR(tp->t_state, TS_TYPEN);
1662 clist_free_cblocks(&tq);
1663 lwkt_reltoken(&tp->t_token);
1664 }
1665
1666 /*
1667 * Process a read call on a tty device.
1668 */
1669 int
1670 ttread(struct tty *tp, struct uio *uio, int flag)
1671 {
1672 struct clist *qp;
1673 int c;
1674 tcflag_t lflag;
1675 cc_t *cc = tp->t_cc;
1676 struct proc *pp;
1677 struct lwp *lp;
1678 int first, error = 0;
1679 int has_stime = 0, last_cc = 0;
1680 long slp = 0; /* XXX this should be renamed `timo'. */
1681 struct timeval stime;
1682
1683 lp = curthread->td_lwp;
1684 stime.tv_sec = 0; /* fix compiler warnings */
1685 stime.tv_usec = 0;
1686
1687 lwkt_gettoken(&tp->t_token);
1688 loop:
1689 lflag = tp->t_lflag;
1690 /*
1691 * take pending input first
1692 */
1693 if (ISSET(lflag, PENDIN)) {
1694 ttypend(tp);
1695 splz(); /* reduce latency */
1696 lflag = tp->t_lflag; /* XXX ttypend() clobbers it */
1697 }
1698
1699 /*
1700 * Hang process if it's in the background.
1701 */
1702 if ((pp = curproc) != NULL)
1703 lwkt_gettoken(&pp->p_token);
1704 if (pp && isbackground(pp, tp)) {
1705 if (SIGISMEMBER(pp->p_sigignore, SIGTTIN) ||
1706 SIGISMEMBER(lp->lwp_sigmask, SIGTTIN) ||
1707 (pp->p_flags & P_PPWAIT) || pp->p_pgrp->pg_jobc == 0) {
1708 lwkt_reltoken(&pp->p_token);
1709 lwkt_reltoken(&tp->t_token);
1710 return (EIO);
1711 }
1712 pgsignal(pp->p_pgrp, SIGTTIN, 1);
1713 error = ttysleep(tp, &lbolt, PCATCH, "ttybg2", 0);
1714 if (error) {
1715 lwkt_reltoken(&pp->p_token);
1716 lwkt_reltoken(&tp->t_token);
1717 return (error);
1718 }
1719 lwkt_reltoken(&pp->p_token);
1720 goto loop;
1721 }
1722 if (pp)
1723 lwkt_reltoken(&pp->p_token);
1724
1725 if (ISSET(tp->t_state, TS_ZOMBIE)) {
1726 lwkt_reltoken(&tp->t_token);
1727 return (0); /* EOF */
1728 }
1729
1730 /*
1731 * If canonical, use the canonical queue,
1732 * else use the raw queue.
1733 *
1734 * (should get rid of clists...)
1735 */
1736 qp = ISSET(lflag, ICANON) ? &tp->t_canq : &tp->t_rawq;
1737
1738 if (flag & IO_NDELAY) {
1739 if (qp->c_cc > 0)
1740 goto read;
1741 if (!ISSET(lflag, ICANON) && cc[VMIN] == 0) {
1742 lwkt_reltoken(&tp->t_token);
1743 return (0);
1744 }
1745 lwkt_reltoken(&tp->t_token);
1746 return (EWOULDBLOCK);
1747 }
1748 if (!ISSET(lflag, ICANON)) {
1749 int m = cc[VMIN];
1750 long t = cc[VTIME];
1751 struct timeval timecopy;
1752
1753 /*
1754 * Check each of the four combinations.
1755 * (m > 0 && t == 0) is the normal read case.
1756 * It should be fairly efficient, so we check that and its
1757 * companion case (m == 0 && t == 0) first.
1758 * For the other two cases, we compute the target sleep time
1759 * into slp.
1760 */
1761 if (t == 0) {
1762 if (qp->c_cc < m)
1763 goto sleep;
1764 if (qp->c_cc > 0)
1765 goto read;
1766
1767 /* m, t and qp->c_cc are all 0. 0 is enough input. */
1768 lwkt_reltoken(&tp->t_token);
1769 return (0);
1770 }
1771 t *= 100000; /* time in us */
1772 #define diff(t1, t2) (((t1).tv_sec - (t2).tv_sec) * 1000000 + \
1773 ((t1).tv_usec - (t2).tv_usec))
1774 if (m > 0) {
1775 if (qp->c_cc <= 0)
1776 goto sleep;
1777 if (qp->c_cc >= m)
1778 goto read;
1779 getmicrotime(&timecopy);
1780 if (has_stime == 0) {
1781 /* first character, start timer */
1782 has_stime = 1;
1783 stime = timecopy;
1784 slp = t;
1785 } else if (qp->c_cc > last_cc) {
1786 /* got a character, restart timer */
1787 stime = timecopy;
1788 slp = t;
1789 } else {
1790 /* nothing, check expiration */
1791 slp = t - diff(timecopy, stime);
1792 if (slp <= 0)
1793 goto read;
1794 }
1795 last_cc = qp->c_cc;
1796 } else { /* m == 0 */
1797 if (qp->c_cc > 0)
1798 goto read;
1799 getmicrotime(&timecopy);
1800 if (has_stime == 0) {
1801 has_stime = 1;
1802 stime = timecopy;
1803 slp = t;
1804 } else {
1805 slp = t - diff(timecopy, stime);
1806 if (slp <= 0) {
1807 /* Timed out, but 0 is enough input. */
1808 lwkt_reltoken(&tp->t_token);
1809 return (0);
1810 }
1811 }
1812 }
1813 #undef diff
1814 /*
1815 * Rounding down may make us wake up just short
1816 * of the target, so we round up.
1817 * The formula is ceiling(slp * hz/1000000).
1818 * 32-bit arithmetic is enough for hz < 169.
1819 * XXX see tvtohz() for how to avoid overflow if hz
1820 * is large (divide by `tick' and/or arrange to
1821 * use tvtohz() if hz is large).
1822 */
1823 slp = (long) (((u_long)slp * hz) + 999999) / 1000000;
1824 goto sleep;
1825 }
1826 if (qp->c_cc <= 0) {
1827 sleep:
1828 /*
1829 * There is no input, or not enough input and we can block.
1830 */
1831 error = ttysleep(tp, TSA_HUP_OR_INPUT(tp), PCATCH,
1832 ISSET(tp->t_state, TS_CONNECTED) ?
1833 "ttyin" : "ttyhup", (int)slp);
1834 if (error == EWOULDBLOCK)
1835 error = 0;
1836 else if (error) {
1837 lwkt_reltoken(&tp->t_token);
1838 return (error);
1839 }
1840 /*
1841 * XXX what happens if another process eats some input
1842 * while we are asleep (not just here)? It would be
1843 * safest to detect changes and reset our state variables
1844 * (has_stime and last_cc).
1845 */
1846 slp = 0;
1847 goto loop;
1848 }
1849 read:
1850 /*
1851 * Input present, check for input mapping and processing.
1852 */
1853 first = 1;
1854 if (ISSET(lflag, ICANON | ISIG))
1855 goto slowcase;
1856 for (;;) {
1857 char ibuf[IBUFSIZ];
1858 int icc;
1859
1860 icc = (int)szmin(uio->uio_resid, IBUFSIZ);
1861 icc = clist_qtob(qp, ibuf, icc);
1862 if (icc <= 0) {
1863 if (first)
1864 goto loop;
1865 break;
1866 }
1867 error = uiomove(ibuf, (size_t)icc, uio);
1868 /*
1869 * XXX if there was an error then we should ungetc() the
1870 * unmoved chars and reduce icc here.
1871 */
1872 if (error)
1873 break;
1874 if (uio->uio_resid == 0)
1875 break;
1876 first = 0;
1877 }
1878 goto out;
1879 slowcase:
1880 for (;;) {
1881 c = clist_getc(qp);
1882 if (c < 0) {
1883 if (first)
1884 goto loop;
1885 break;
1886 }
1887 /*
1888 * delayed suspend (^Y)
1889 */
1890 if (CCEQ(cc[VDSUSP], c) &&
1891 ISSET(lflag, IEXTEN | ISIG) == (IEXTEN | ISIG)) {
1892 pgsignal(tp->t_pgrp, SIGTSTP, 1);
1893 if (first) {
1894 error = ttysleep(tp, &lbolt, PCATCH,
1895 "ttybg3", 0);
1896 if (error)
1897 break;
1898 goto loop;
1899 }
1900 break;
1901 }
1902 /*
1903 * Interpret EOF only in canonical mode.
1904 */
1905 if (CCEQ(cc[VEOF], c) && ISSET(lflag, ICANON))
1906 break;
1907 /*
1908 * Give user character.
1909 */
1910 error = ureadc(c, uio);
1911 if (error)
1912 /* XXX should ungetc(c, qp). */
1913 break;
1914 if (uio->uio_resid == 0)
1915 break;
1916 /*
1917 * In canonical mode check for a "break character"
1918 * marking the end of a "line of input".
1919 */
1920 if (ISSET(lflag, ICANON) && TTBREAKC(c, lflag))
1921 break;
1922 first = 0;
1923 }
1924
1925 out:
1926 /*
1927 * Look to unblock input now that (presumably)
1928 * the input queue has gone down.
1929 */
1930 if (ISSET(tp->t_state, TS_TBLOCK) &&
1931 tp->t_rawq.c_cc + tp->t_canq.c_cc <= tp->t_ilowat) {
1932 ttyunblock(tp);
1933 }
1934
1935 lwkt_reltoken(&tp->t_token);
1936 return (error);
1937 }
1938
1939 /*
1940 * Check the output queue on tp for space for a kernel message (from uprintf
1941 * or tprintf). Allow some space over the normal hiwater mark so we don't
1942 * lose messages due to normal flow control, but don't let the tty run amok.
1943 * Sleeps here are not interruptible, but we return prematurely if new signals
1944 * arrive.
1945 */
1946 int
1947 ttycheckoutq(struct tty *tp, int wait)
1948 {
1949 struct lwp *lp = curthread->td_lwp;
1950 int hiwat;
1951 sigset_t oldset, newset;
1952
1953 lwkt_gettoken(&tp->t_token);
1954 hiwat = tp->t_ohiwat;
1955 SIGEMPTYSET(oldset);
1956 SIGEMPTYSET(newset);
1957 if (wait)
1958 oldset = lwp_sigpend(lp);
1959 if (tp->t_outq.c_cc > hiwat + OBUFSIZ + 100) {
1960 while (tp->t_outq.c_cc > hiwat) {
1961 ttstart(tp);
1962 if (tp->t_outq.c_cc <= hiwat)
1963 break;
1964 if (wait)
1965 newset = lwp_sigpend(lp);
1966 if (!wait || SIGSETNEQ(oldset, newset)) {
1967 lwkt_reltoken(&tp->t_token);
1968 return (0);
1969 }
1970 SET(tp->t_state, TS_SO_OLOWAT);
1971 tsleep(TSA_OLOWAT(tp), 0, "ttoutq", hz);
1972 }
1973 }
1974 lwkt_reltoken(&tp->t_token);
1975 return (1);
1976 }
1977
1978 /*
1979 * Process a write call on a tty device.
1980 */
1981 int
1982 ttwrite(struct tty *tp, struct uio *uio, int flag)
1983 {
1984 char *cp = NULL;
1985 int cc, ce;
1986 struct proc *pp;
1987 struct lwp *lp;
1988 int i, hiwat, error;
1989 size_t cnt;
1990
1991 char obuf[OBUFSIZ];
1992
1993 lwkt_gettoken(&tp->t_token);
1994 lp = curthread->td_lwp;
1995 hiwat = tp->t_ohiwat;
1996 cnt = uio->uio_resid;
1997 error = 0;
1998 cc = 0;
1999 loop:
2000 if (ISSET(tp->t_state, TS_ZOMBIE)) {
2001 if (uio->uio_resid == cnt)
2002 error = EIO;
2003 goto out;
2004 }
2005 if (!ISSET(tp->t_state, TS_CONNECTED)) {
2006 if (flag & IO_NDELAY) {
2007 error = EWOULDBLOCK;
2008 goto out;
2009 }
2010 error = ttysleep(tp, TSA_CARR_ON(tp), PCATCH, "ttydcd", 0);
2011 if (error)
2012 goto out;
2013 goto loop;
2014 }
2015
2016 /*
2017 * Hang the process if it's in the background.
2018 */
2019 if ((pp = curproc) != NULL)
2020 lwkt_gettoken(&pp->p_token);
2021 if (pp && isbackground(pp, tp) &&
2022 ISSET(tp->t_lflag, TOSTOP) && !(pp->p_flags & P_PPWAIT) &&
2023 !SIGISMEMBER(pp->p_sigignore, SIGTTOU) &&
2024 !SIGISMEMBER(lp->lwp_sigmask, SIGTTOU)) {
2025 if (pp->p_pgrp->pg_jobc == 0) {
2026 error = EIO;
2027 lwkt_reltoken(&pp->p_token);
2028 goto out;
2029 }
2030 pgsignal(pp->p_pgrp, SIGTTOU, 1);
2031 lwkt_reltoken(&pp->p_token);
2032 error = ttysleep(tp, &lbolt, PCATCH, "ttybg4", 0);
2033 if (error)
2034 goto out;
2035 goto loop;
2036 }
2037 if (pp)
2038 lwkt_reltoken(&pp->p_token);
2039 /*
2040 * Process the user's data in at most OBUFSIZ chunks. Perform any
2041 * output translation. Keep track of high water mark, sleep on
2042 * overflow awaiting device aid in acquiring new space.
2043 */
2044 while (uio->uio_resid > 0 || cc > 0) {
2045 if (ISSET(tp->t_lflag, FLUSHO)) {
2046 uio->uio_resid = 0;
2047 lwkt_reltoken(&tp->t_token);
2048 return (0);
2049 }
2050 if (tp->t_outq.c_cc > hiwat)
2051 goto ovhiwat;
2052 /*
2053 * Grab a hunk of data from the user, unless we have some
2054 * leftover from last time.
2055 */
2056 if (cc == 0) {
2057 cc = szmin(uio->uio_resid, OBUFSIZ);
2058 cp = obuf;
2059 error = uiomove(cp, (size_t)cc, uio);
2060 if (error) {
2061 cc = 0;
2062 break;
2063 }
2064 }
2065 /*
2066 * If nothing fancy need be done, grab those characters we
2067 * can handle without any of ttyoutput's processing and
2068 * just transfer them to the output q. For those chars
2069 * which require special processing (as indicated by the
2070 * bits in char_type), call ttyoutput. After processing
2071 * a hunk of data, look for FLUSHO so ^O's will take effect
2072 * immediately.
2073 */
2074 while (cc > 0) {
2075 if (!ISSET(tp->t_oflag, OPOST))
2076 ce = cc;
2077 else {
2078 ce = cc - scanc((u_int)cc, (u_char *)cp,
2079 char_type, CCLASSMASK);
2080 /*
2081 * If ce is zero, then we're processing
2082 * a special character through ttyoutput.
2083 */
2084 if (ce == 0) {
2085 tp->t_rocount = 0;
2086 if (ttyoutput(*cp, tp) >= 0) {
2087 /* No Clists, wait a bit. */
2088 ttstart(tp);
2089 if (flag & IO_NDELAY) {
2090 error = EWOULDBLOCK;
2091 goto out;
2092 }
2093 error = ttysleep(tp, &lbolt,
2094 PCATCH,
2095 "ttybf1", 0);
2096 if (error)
2097 goto out;
2098 goto loop;
2099 }
2100 cp++;
2101 cc--;
2102 if (ISSET(tp->t_lflag, FLUSHO) ||
2103 tp->t_outq.c_cc > hiwat)
2104 goto ovhiwat;
2105 continue;
2106 }
2107 }
2108 /*
2109 * A bunch of normal characters have been found.
2110 * Transfer them en masse to the output queue and
2111 * continue processing at the top of the loop.
2112 * If there are any further characters in this
2113 * <= OBUFSIZ chunk, the first should be a character
2114 * requiring special handling by ttyoutput.
2115 */
2116 tp->t_rocount = 0;
2117 i = clist_btoq(cp, ce, &tp->t_outq);
2118 ce -= i;
2119 tp->t_column += ce;
2120 cp += ce, cc -= ce, tk_nout += ce;
2121 tp->t_outcc += ce;
2122 if (i > 0) {
2123 /* No Clists, wait a bit. */
2124 ttstart(tp);
2125 if (flag & IO_NDELAY) {
2126 error = EWOULDBLOCK;
2127 goto out;
2128 }
2129 error = ttysleep(tp, &lbolt, PCATCH,
2130 "ttybf2", 0);
2131 if (error)
2132 goto out;
2133 goto loop;
2134 }
2135 if (ISSET(tp->t_lflag, FLUSHO) ||
2136 tp->t_outq.c_cc > hiwat)
2137 break;
2138 }
2139 ttstart(tp);
2140 }
2141 out:
2142 /*
2143 * If cc is nonzero, we leave the uio structure inconsistent, as the
2144 * offset and iov pointers have moved forward, but it doesn't matter
2145 * (the call will either return short or restart with a new uio).
2146 */
2147 uio->uio_resid += cc;
2148 lwkt_reltoken(&tp->t_token);
2149 return (error);
2150
2151 ovhiwat:
2152 ttstart(tp);
2153 /*
2154 * This can only occur if FLUSHO is set in t_lflag,
2155 * or if ttstart/oproc is synchronous (or very fast).
2156 */
2157 if (tp->t_outq.c_cc <= hiwat) {
2158 goto loop;
2159 }
2160 if (flag & IO_NDELAY) {
2161 uio->uio_resid += cc;
2162 lwkt_reltoken(&tp->t_token);
2163 return (uio->uio_resid == cnt ? EWOULDBLOCK : 0);
2164 }
2165 SET(tp->t_state, TS_SO_OLOWAT);
2166 error = ttysleep(tp, TSA_OLOWAT(tp), PCATCH, "ttywri", tp->t_timeout);
2167 if (error == EWOULDBLOCK)
2168 error = EIO;
2169 if (error)
2170 goto out;
2171 goto loop;
2172 }
2173
2174 /*
2175 * Rubout one character from the rawq of tp
2176 * as cleanly as possible.
2177 * NOTE: Must be called with tp->t_token held
2178 */
2179 static void
2180 ttyrub(int c, struct tty *tp)
2181 {
2182 void *cp;
2183 int savecol;
2184 int tabc;
2185
2186 ASSERT_LWKT_TOKEN_HELD(&tp->t_token);
2187 if (!ISSET(tp->t_lflag, ECHO) || ISSET(tp->t_lflag, EXTPROC))
2188 return;
2189 CLR(tp->t_lflag, FLUSHO);
2190 if (ISSET(tp->t_lflag, ECHOE)) {
2191 if (tp->t_rocount == 0) {
2192 /*
2193 * Screwed by ttwrite; retype
2194 */
2195 ttyretype(tp);
2196 return;
2197 }
2198 if (c == ('\t' | TTY_QUOTE) || c == ('\n' | TTY_QUOTE))
2199 ttyrubo(tp, 2);
2200 else {
2201 CLR(c, ~TTY_CHARMASK);
2202 switch (CCLASS(c)) {
2203 case ORDINARY:
2204 ttyrubo(tp, 1);
2205 break;
2206 case BACKSPACE:
2207 case CONTROL:
2208 case NEWLINE:
2209 case RETURN:
2210 case VTAB:
2211 if (ISSET(tp->t_lflag, ECHOCTL))
2212 ttyrubo(tp, 2);
2213 break;
2214 case TAB:
2215 if (tp->t_rocount < tp->t_rawq.c_cc) {
2216 ttyretype(tp);
2217 return;
2218 }
2219 savecol = tp->t_column;
2220 SET(tp->t_state, TS_CNTTB);
2221 SET(tp->t_lflag, FLUSHO);
2222 tp->t_column = tp->t_rocol;
2223
2224 cp = clist_nextc(&tp->t_rawq, NULL, &tabc);
2225 while (cp) {
2226 ttyecho(tabc, tp);
2227 cp = clist_nextc(&tp->t_rawq,
2228 cp, &tabc);
2229 }
2230 CLR(tp->t_lflag, FLUSHO);
2231 CLR(tp->t_state, TS_CNTTB);
2232
2233 /* savecol will now be length of the tab. */
2234 savecol -= tp->t_column;
2235 tp->t_column += savecol;
2236 if (savecol > 8)
2237 savecol = 8; /* overflow screw */
2238 while (--savecol >= 0)
2239 (void)ttyoutput('\b', tp);
2240 break;
2241 default: /* XXX */
2242 #define PANICSTR "ttyrub: would panic c = %d, val = %d\n"
2243 (void)kprintf(PANICSTR, c, CCLASS(c));
2244 #ifdef notdef
2245 panic(PANICSTR, c, CCLASS(c));
2246 #endif
2247 }
2248 }
2249 } else if (ISSET(tp->t_lflag, ECHOPRT)) {
2250 if (!ISSET(tp->t_state, TS_ERASE)) {
2251 SET(tp->t_state, TS_ERASE);
2252 (void)ttyoutput('\\', tp);
2253 }
2254 ttyecho(c, tp);
2255 } else {
2256 ttyecho(tp->t_cc[VERASE], tp);
2257 /*
2258 * This code may be executed not only when an ERASE key
2259 * is pressed, but also when ^U (KILL) or ^W (WERASE) are.
2260 * So, I didn't think it was worthwhile to pass the extra
2261 * information (which would need an extra parameter,
2262 * changing every call) needed to distinguish the ERASE2
2263 * case from the ERASE.
2264 */
2265 }
2266 --tp->t_rocount;
2267 }
2268
2269 /*
2270 * Back over cnt characters, erasing them.
2271 * NOTE: Must be called with tp->t_token held
2272 */
2273 static void
2274 ttyrubo(struct tty *tp, int cnt)
2275 {
2276 ASSERT_LWKT_TOKEN_HELD(&tp->t_token);
2277 while (cnt-- > 0) {
2278 (void)ttyoutput('\b', tp);
2279 (void)ttyoutput(' ', tp);
2280 (void)ttyoutput('\b', tp);
2281 }
2282 }
2283
2284 /*
2285 * ttyretype --
2286 * Reprint the rawq line. Note, it is assumed that c_cc has already
2287 * been checked.
2288 * NOTE: Must be called with tp->t_token held
2289 */
2290 static void
2291 ttyretype(struct tty *tp)
2292 {
2293 void *cp;
2294 int c;
2295
2296 ASSERT_LWKT_TOKEN_HELD(&tp->t_token);
2297 /* Echo the reprint character. */
2298 if (tp->t_cc[VREPRINT] != _POSIX_VDISABLE)
2299 ttyecho(tp->t_cc[VREPRINT], tp);
2300
2301 (void)ttyoutput('\n', tp);
2302
2303 /*
2304 * XXX
2305 * FIX: NEXTC IS BROKEN - DOESN'T CHECK QUOTE
2306 * BIT OF FIRST CHAR.
2307 */
2308 cp = clist_nextc(&tp->t_canq, NULL, &c);
2309 while (cp) {
2310 ttyecho(c, tp);
2311 cp = clist_nextc(&tp->t_canq, cp, &c);
2312 }
2313 cp = clist_nextc(&tp->t_rawq, NULL, &c);
2314 while (cp) {
2315 ttyecho(c, tp);
2316 cp = clist_nextc(&tp->t_rawq, cp, &c);
2317 }
2318 CLR(tp->t_state, TS_ERASE);
2319
2320 tp->t_rocount = tp->t_rawq.c_cc;
2321 tp->t_rocol = 0;
2322 }
2323
2324 /*
2325 * Echo a typed character to the terminal.
2326 * NOTE: Must be called with tp->t_token held
2327 */
2328 static void
2329 ttyecho(int c, struct tty *tp)
2330 {
2331 ASSERT_LWKT_TOKEN_HELD(&tp->t_token);
2332
2333 if (!ISSET(tp->t_state, TS_CNTTB))
2334 CLR(tp->t_lflag, FLUSHO);
2335 if ((!ISSET(tp->t_lflag, ECHO) &&
2336 (c != '\n' || !ISSET(tp->t_lflag, ECHONL))) ||
2337 ISSET(tp->t_lflag, EXTPROC))
2338 return;
2339 if (ISSET(tp->t_lflag, ECHOCTL) &&
2340 ((ISSET(c, TTY_CHARMASK) <= 037 && c != '\t' && c != '\n') ||
2341 ISSET(c, TTY_CHARMASK) == 0177)) {
2342 (void)ttyoutput('^', tp);
2343 CLR(c, ~TTY_CHARMASK);
2344 if (c == 0177)
2345 c = '?';
2346 else
2347 c += 'A' - 1;
2348 }
2349 (void)ttyoutput(c, tp);
2350 }
2351
2352 /*
2353 * Wake up any readers on a tty.
2354 */
2355 void
2356 ttwakeup(struct tty *tp)
2357 {
2358 lwkt_gettoken(&tp->t_token);
2359 if (ISSET(tp->t_state, TS_ASYNC) && tp->t_sigio != NULL)
2360 pgsigio(tp->t_sigio, SIGIO, (tp->t_session != NULL));
2361 wakeup(TSA_HUP_OR_INPUT(tp));
2362 KNOTE(&tp->t_rkq.ki_note, 0);
2363 lwkt_reltoken(&tp->t_token);
2364 }
2365
2366 /*
2367 * Wake up any writers on a tty.
2368 */
2369 void
2370 ttwwakeup(struct tty *tp)
2371 {
2372 lwkt_gettoken(&tp->t_token);
2373 if (ISSET(tp->t_state, TS_ASYNC) && tp->t_sigio != NULL)
2374 pgsigio(tp->t_sigio, SIGIO, (tp->t_session != NULL));
2375 if (ISSET(tp->t_state, TS_BUSY | TS_SO_OCOMPLETE) ==
2376 TS_SO_OCOMPLETE && tp->t_outq.c_cc == 0) {
2377 CLR(tp->t_state, TS_SO_OCOMPLETE);
2378 wakeup(TSA_OCOMPLETE(tp));
2379 }
2380 if (ISSET(tp->t_state, TS_SO_OLOWAT) &&
2381 tp->t_outq.c_cc <= tp->t_olowat) {
2382 CLR(tp->t_state, TS_SO_OLOWAT);
2383 wakeup(TSA_OLOWAT(tp));
2384 }
2385 KNOTE(&tp->t_wkq.ki_note, 0);
2386 lwkt_reltoken(&tp->t_token);
2387 }
2388
2389 /*
2390 * Look up a code for a specified speed in a conversion table;
2391 * used by drivers to map software speed values to hardware parameters.
2392 * No requirements
2393 */
2394 int
2395 ttspeedtab(int speed, struct speedtab *table)
2396 {
2397
2398 for ( ; table->sp_speed != -1; table++)
2399 if (table->sp_speed == speed)
2400 return (table->sp_code);
2401 return (-1);
2402 }
2403
2404 /*
2405 * Set input and output watermarks and buffer sizes. For input, the
2406 * high watermark is about one second's worth of input above empty, the
2407 * low watermark is slightly below high water, and the buffer size is a
2408 * driver-dependent amount above high water. For output, the watermarks
2409 * are near the ends of the buffer, with about 1 second's worth of input
2410 * between them. All this only applies to the standard line discipline.
2411 */
2412 #define CLAMP(x, h, l) ((x) > h ? h : ((x) < l) ? l : (x))
2413
2414 void
2415 ttsetwater(struct tty *tp)
2416 {
2417 int ttmaxhiwat; /* maximum high water mark */
2418 int cps; /* characters per second */
2419 int x;
2420
2421 lwkt_gettoken(&tp->t_token);
2422
2423 /*
2424 * Input side.
2425 *
2426 * Calculate nominal low and high water marks, leave a little
2427 * room to absorb flow control latencies.
2428 */
2429 clist_alloc_cblocks(&tp->t_canq, TTYHOG);
2430
2431 switch (tp->t_ispeedwat) {
2432 case (speed_t)-1:
2433 cps = tp->t_ispeed / 10;
2434 break;
2435 case 0:
2436 /*
2437 * This case is for old drivers that don't know about
2438 * t_ispeedwat. Arrange for them to get the old buffer
2439 * sizes and watermarks.
2440 */
2441 cps = TTYHOG - 2 * 256;
2442 tp->t_ififosize = 2 * 2048;
2443 break;
2444 default:
2445 cps = tp->t_ispeedwat / 10;
2446 break;
2447 }
2448 tp->t_ihiwat = cps;
2449 tp->t_ilowat = 7 * cps / 8;
2450 x = cps + tp->t_ififosize;
2451 clist_alloc_cblocks(&tp->t_rawq, x);
2452
2453 /*
2454 * Output side.
2455 *
2456 * Calculate nominal low and high water marks, and make the
2457 * actual buffer just a tad larger to absorb flow control latencies.
2458 */
2459 switch (tp->t_ospeedwat) {
2460 case (speed_t)-1:
2461 cps = tp->t_ospeed / 10;
2462 ttmaxhiwat = 2 * TTMAXHIWAT;
2463 break;
2464 case 0:
2465 cps = tp->t_ospeed / 10;
2466 ttmaxhiwat = TTMAXHIWAT;
2467 break;
2468 default:
2469 cps = tp->t_ospeedwat / 10;
2470 ttmaxhiwat = 8 * TTMAXHIWAT;
2471 break;
2472 }
2473
2474 x = CLAMP(cps / 2, TTMAXLOWAT, TTMINLOWAT);
2475 tp->t_olowat = x;
2476
2477 x += cps;
2478 x = CLAMP(x, ttmaxhiwat, TTMINHIWAT);
2479 tp->t_ohiwat = x;
2480
2481 x = imax(tp->t_ohiwat, TTMAXHIWAT);
2482 x += OBUFSIZ + 100;
2483 clist_alloc_cblocks(&tp->t_outq, x);
2484
2485 lwkt_reltoken(&tp->t_token);
2486 }
2487
2488 #undef CLAMP
2489
2490 /*
2491 * Report on state of foreground process group.
2492 */
2493 void
2494 ttyinfo(struct tty *tp)
2495 {
2496 struct pgrp *pgrp;
2497 struct proc *p, *pick;
2498 struct lwp *lp;
2499 struct rusage ru;
2500 char buf[64];
2501 const char *str;
2502 struct vmspace *vm;
2503 long vmsz;
2504 int pctcpu;
2505 int tmp;
2506
2507 if (ttycheckoutq(tp,0) == 0)
2508 return;
2509
2510 lwkt_gettoken(&tp->t_token);
2511
2512 /*
2513 * We always print the load average, then figure out what else to
2514 * print based on the state of the current process group.
2515 */
2516 tmp = (averunnable.ldavg[0] * 100 + FSCALE / 2) >> FSHIFT;
2517 ttyprintf(tp, "load: %d.%02d ", tmp / 100, tmp % 100);
2518
2519 if (tp->t_session == NULL) {
2520 ttyprintf(tp, "not a controlling terminal\n");
2521 goto done2;
2522 }
2523 if ((pgrp = tp->t_pgrp) == NULL) {
2524 ttyprintf(tp, "no foreground process group\n");
2525 goto done2;
2526 }
2527
2528 /*
2529 * Pick an interesting process. Note that certain elements,
2530 * in particular the wmesg.
2531 *
2532 * NOTE: lwp_wmesg is lwp_thread->td_wmesg.
2533 */
2534 pgref(pgrp);
2535 lwkt_gettoken(&pgrp->pg_token);
2536
2537 pick = NULL;
2538 for (p = LIST_FIRST(&pgrp->pg_members);
2539 p != NULL;
2540 p = LIST_NEXT(p, p_pglist)) {
2541 PHOLD(p);
2542 if (proc_compare(pick, p)) {
2543 if (pick)
2544 PRELE(pick);
2545 pick = p;
2546 } else {
2547 PRELE(p);
2548 }
2549 }
2550 if (pick == NULL) {
2551 ttyprintf(tp, "empty foreground process group\n");
2552 goto done1;
2553 }
2554
2555 /*
2556 * Pick an interesting LWP (XXX)
2557 *
2558 * pick is held.
2559 */
2560 lp = FIRST_LWP_IN_PROC(pick);
2561 if (lp == NULL) {
2562 PRELE(pick);
2563 ttyprintf(tp, "foreground process without lwp\n");
2564 goto done1;
2565 }
2566
2567 /*
2568 * Figure out what wait/process-state message, and command
2569 * buffer to present
2570 */
2571 /*
2572 * XXX lwp This is a horrible mixture. We need to rework this
2573 * as soon as lwps have their own runnable status.
2574 */
2575 LWPHOLD(lp);
2576 if (pick->p_flags & P_WEXIT)
2577 str = "exiting";
2578 else if (lp->lwp_stat == LSRUN)
2579 str = "running";
2580 else if (pick->p_stat == SIDL)
2581 str = "spawning";
2582 else if (lp->lwp_wmesg) /* lwp_thread must not be NULL */
2583 str = lp->lwp_wmesg;
2584 else
2585 str = "iowait";
2586
2587 ksnprintf(buf, sizeof(buf), "cmd: %s %d [%s]",
2588 pick->p_comm, pick->p_pid, str);
2589
2590 /*
2591 * Calculate cpu usage, percent cpu, and cmsz. Note that
2592 * 'pick' becomes invalid the moment we release the token.
2593 */
2594 if (lp->lwp_thread && (pick->p_flags & P_SWAPPEDOUT) == 0)
2595 calcru_proc(pick, &ru);
2596
2597 pctcpu = (lp->lwp_pctcpu * 10000 + FSCALE / 2) >> FSHIFT;
2598
2599 LWPRELE(lp);
2600
2601 /*
2602 * NOTE: vmspace should be protected from destruction by the
2603 * combination of pg_token and the fact that we are not
2604 * flagged as a zombie.
2605 */
2606 if (pick->p_stat == SIDL || pick->p_stat == SZOMB) {
2607 vmsz = 0;
2608 } else if ((vm = pick->p_vmspace) == NULL) {
2609 vmsz = 0;
2610 } else {
2611 vmspace_hold(vm);
2612 vmsz = pgtok(vmspace_resident_count(vm));
2613 vmspace_drop(vm);
2614 }
2615 PRELE(pick);
2616
2617 /*
2618 * Dump the output
2619 */
2620 ttyprintf(tp, " %s ",
2621 buf);
2622 ttyprintf(tp, "%ld.%02ldu ",
2623 ru.ru_utime.tv_sec, ru.ru_utime.tv_usec / 10000);
2624 ttyprintf(tp, "%ld.%02lds ",
2625 ru.ru_stime.tv_sec, ru.ru_stime.tv_usec / 10000);
2626 ttyprintf(tp, "%d%% %ldk\n",
2627 pctcpu / 100, vmsz);
2628
2629 done1:
2630 lwkt_reltoken(&pgrp->pg_token);
2631 pgrel(pgrp);
2632 done2:
2633 tp->t_rocount = 0; /* so pending input will be retyped if BS */
2634 lwkt_reltoken(&tp->t_token);
2635 }
2636
2637 /*
2638 * Returns 1 if p2 is "better" than p1
2639 *
2640 * The algorithm for picking the "interesting" process is thus:
2641 *
2642 * 1) Only foreground processes are eligible - implied.
2643 * 2) Runnable processes are favored over anything else. The runner
2644 * with the highest cpu utilization is picked (p_cpticks). Ties are
2645 * broken by picking the highest pid.
2646 * 3) The sleeper with the shortest sleep time is next. With ties,
2647 * we pick out just "short-term" sleepers (LWP_SINTR == 0).
2648 * 4) Further ties are broken by picking the highest pid.
2649 *
2650 * NOTE: must be called with p1 and p2 held.
2651 */
2652 #define ISRUN(lp) ((lp)->lwp_stat == LSRUN)
2653 #define TESTAB(a, b) ((a)<<1 | (b))
2654 #define ONLYA 2
2655 #define ONLYB 1
2656 #define BOTH 3
2657
2658 static int
2659 proc_compare(struct proc *p1, struct proc *p2)
2660 {
2661 struct lwp *lp1, *lp2;
2662 int res;
2663
2664 if (p1 == NULL)
2665 return (1);
2666 if (lwkt_trytoken(&p1->p_token) == 0)
2667 return (1);
2668 if (lwkt_trytoken(&p2->p_token) == 0) {
2669 lwkt_reltoken(&p1->p_token);
2670 return (0);
2671 }
2672
2673 /*
2674 * weed out zombies
2675 */
2676 switch (TESTAB(p1->p_stat == SZOMB, p2->p_stat == SZOMB)) {
2677 case ONLYA:
2678 res = 1;
2679 goto done;
2680 case ONLYB:
2681 res = 0;
2682 goto done;
2683 case BOTH:
2684 res = (p2->p_pid > p1->p_pid); /* tie - return highest pid */
2685 goto done;
2686 default:
2687 break;
2688 }
2689
2690 /* XXX choose the best lwp? */
2691 lp1 = FIRST_LWP_IN_PROC(p1);
2692 lp2 = FIRST_LWP_IN_PROC(p2);
2693
2694 /*
2695 * Favor one with LWPs verses one that has none (is exiting).
2696 */
2697 if (lp1 == NULL) {
2698 res = 1;
2699 goto done;
2700 }
2701 if (lp2 == NULL) {
2702 res = 0;
2703 goto done;
2704 }
2705
2706 /*
2707 * see if at least one of them is runnable
2708 */
2709 switch (TESTAB(ISRUN(lp1), ISRUN(lp2))) {
2710 case ONLYA:
2711 res = 0;
2712 goto done;
2713 case ONLYB:
2714 res = 1;
2715 goto done;
2716 case BOTH:
2717 /*
2718 * tie - favor one with highest recent cpu utilization
2719 */
2720 if (lp2->lwp_cpticks > lp1->lwp_cpticks)
2721 res = 1;
2722 else if (lp1->lwp_cpticks > lp2->lwp_cpticks)
2723 res = 0;
2724 else
2725 res = (p2->p_pid > p1->p_pid); /* tie - ret highest */
2726 goto done;
2727 default:
2728 break;
2729 }
2730
2731 /*
2732 * Pick the one with the smallest sleep time
2733 */
2734 if (lp2->lwp_slptime > lp1->lwp_slptime) {
2735 res = 0;
2736 goto done;
2737 }
2738 if (lp1->lwp_slptime > lp2->lwp_slptime) {
2739 res = 1;
2740 goto done;
2741 }
2742
2743 /*
2744 * Favor one sleeping in a non-interruptible sleep
2745 */
2746 if ((lp1->lwp_flags & LWP_SINTR) && (lp2->lwp_flags & LWP_SINTR) == 0)
2747 res = 1;
2748 else
2749 if ((lp2->lwp_flags & LWP_SINTR) && (lp1->lwp_flags & LWP_SINTR) == 0)
2750 res = 0;
2751 else
2752 res = (p2->p_pid > p1->p_pid); /* tie - return highest pid */
2753 /* fall through */
2754
2755 done:
2756 lwkt_reltoken(&p2->p_token);
2757 lwkt_reltoken(&p1->p_token);
2758 return (res);
2759 }
2760
2761 /*
2762 * Output char to tty; console putchar style.
2763 */
2764 int
2765 tputchar(int c, struct tty *tp)
2766 {
2767 lwkt_gettoken(&tp->t_token);
2768 if (!ISSET(tp->t_state, TS_CONNECTED)) {
2769 lwkt_reltoken(&tp->t_token);
2770 return (-1);
2771 }
2772 if (c == '\n')
2773 (void)ttyoutput('\r', tp);
2774 (void)ttyoutput(c, tp);
2775 ttstart(tp);
2776 lwkt_reltoken(&tp->t_token);
2777
2778 return (0);
2779 }
2780
2781 /*
2782 * Sleep on chan, returning ERESTART if tty changed while we napped and
2783 * returning any errors (e.g. EINTR/EWOULDBLOCK) reported by tsleep. If
2784 * the tty is revoked, restarting a pending call will redo validation done
2785 * at the start of the call.
2786 */
2787 int
2788 ttysleep(struct tty *tp, void *chan, int slpflags, char *wmesg, int timo)
2789 {
2790 int error;
2791 int gen;
2792
2793 gen = tp->t_gen;
2794 error = tsleep(chan, slpflags, wmesg, timo);
2795 if (error)
2796 return (error);
2797 return (tp->t_gen == gen ? 0 : ERESTART);
2798 }
2799
2800 /*
2801 * Revoke a tty.
2802 *
2803 * We bump the gen to force any ttysleep()'s to return with ERESTART
2804 * and flush the tty. The related fp's should already have been
2805 * replaced so the tty will close when the last references on the
2806 * original fp's go away.
2807 */
2808 int
2809 ttyrevoke(struct dev_revoke_args *ap)
2810 {
2811 struct tty *tp;
2812
2813 tp = ap->a_head.a_dev->si_tty;
2814 lwkt_gettoken(&tp->t_token);
2815 tp->t_gen++;
2816 ttyflush(tp, FREAD | FWRITE);
2817 wakeup(TSA_CARR_ON(tp));
2818 ttwakeup(tp);
2819 ttwwakeup(tp);
2820 lwkt_reltoken(&tp->t_token);
2821
2822 return (0);
2823 }
2824
2825 /*
2826 * Allocate a tty struct. Clists in the struct will be allocated by
2827 * ttyopen(). The tty itself is protected by tp->t_token. tty_token
2828 * is primarily used to interlock the NULL test and for registration.
2829 *
2830 * by convention, once allocated, tty structures are never freed. This
2831 * saves us from numerous release race scenarios that can occur due to the
2832 * token being embedded in the tty structure.
2833 */
2834 struct tty *
2835 ttymalloc(struct tty **tpp)
2836 {
2837 struct tty *tp;
2838
2839 if ((tp = *tpp) == NULL) {
2840 tp = kmalloc(sizeof *tp, M_TTYS, M_WAITOK|M_ZERO);
2841 lwkt_gettoken(&tty_token);
2842 if (*tpp == NULL) { /* recheck after blocking kmalloc */
2843 *tpp = tp;
2844 ttyinit(tp);
2845 ttyregister(tp);
2846 } else {
2847 kfree(tp, M_TTYS);
2848 }
2849 lwkt_reltoken(&tty_token);
2850 }
2851 return (tp);
2852 }
2853
2854 /*
2855 * Caller must hold tp->t_token
2856 */
2857 void
2858 ttyunregister(struct tty *tp)
2859 {
2860 lwkt_gettoken(&tty_token);
2861 if (ISSET(tp->t_state, TS_REGISTERED)) {
2862 CLR(tp->t_state, TS_REGISTERED);
2863 TAILQ_REMOVE(&tty_list, tp, t_list);
2864 }
2865 lwkt_reltoken(&tty_token);
2866 }
2867
2868 void
2869 ttyinit(struct tty *tp)
2870 {
2871 lwkt_token_init(&tp->t_token, "tp");
2872 }
2873
2874 void
2875 ttyregister(struct tty *tp)
2876 {
2877 lwkt_gettoken(&tty_token);
2878 if (!ISSET(tp->t_state, TS_REGISTERED)) {
2879 SET(tp->t_state, TS_REGISTERED);
2880 TAILQ_INSERT_HEAD(&tty_list, tp, t_list);
2881 }
2882 lwkt_reltoken(&tty_token);
2883 }
2884
2885 static int
2886 sysctl_kern_ttys(SYSCTL_HANDLER_ARGS)
2887 {
2888 int error;
2889 struct tty *tp;
2890 struct tty t;
2891 struct tty marker;
2892
2893 bzero(&marker, sizeof(marker));
2894 marker.t_state = TS_MARKER;
2895 error = 0;
2896
2897 lwkt_gettoken(&tty_token);
2898
2899 TAILQ_INSERT_HEAD(&tty_list, &marker, t_list);
2900 while ((tp = TAILQ_NEXT(&marker, t_list)) != NULL) {
2901 TAILQ_REMOVE(&tty_list, &marker, t_list);
2902 TAILQ_INSERT_AFTER(&tty_list, tp, &marker, t_list);
2903 if (tp->t_state & TS_MARKER)
2904 continue;
2905 t = *tp;
2906 if (t.t_dev)
2907 t.t_dev = (cdev_t)(uintptr_t)dev2udev(t.t_dev);
2908 error = SYSCTL_OUT(req, (caddr_t)&t, sizeof(t));
2909 if (error)
2910 break;
2911 }
2912 TAILQ_REMOVE(&tty_list, &marker, t_list);
2913 lwkt_reltoken(&tty_token);
2914 return (error);
2915 }
2916
2917 SYSCTL_PROC(_kern, OID_AUTO, ttys, CTLTYPE_OPAQUE|CTLFLAG_RD,
2918 0, 0, sysctl_kern_ttys, "S,tty", "All struct ttys");
2919
2920 void
2921 nottystop(struct tty *tp, int rw)
2922 {
2923 return;
2924 }
2925
2926 int
2927 ttyread(struct dev_read_args *ap)
2928 {
2929 struct tty *tp;
2930 int ret;
2931
2932 tp = ap->a_head.a_dev->si_tty;
2933 if (tp == NULL)
2934 return (ENODEV);
2935 lwkt_gettoken(&tp->t_token);
2936 ret = ((*linesw[tp->t_line].l_read)(tp, ap->a_uio, ap->a_ioflag));
2937 lwkt_reltoken(&tp->t_token);
2938
2939 return ret;
2940 }
2941
2942 int
2943 ttywrite(struct dev_write_args *ap)
2944 {
2945 struct tty *tp;
2946 int ret;
2947
2948 tp = ap->a_head.a_dev->si_tty;
2949 if (tp == NULL)
2950 return (ENODEV);
2951 lwkt_gettoken(&tp->t_token);
2952 ret = ((*linesw[tp->t_line].l_write)(tp, ap->a_uio, ap->a_ioflag));
2953 lwkt_reltoken(&tp->t_token);
2954
2955 return ret;
2956 }
DragonFly BSD