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