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