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