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