tty.c revision 1.116 1 1.116 thorpej /* $NetBSD: tty.c,v 1.116 2000/03/23 06:30:12 thorpej Exp $ */
2 1.49 cgd
3 1.49 cgd /*-
4 1.49 cgd * Copyright (c) 1982, 1986, 1990, 1991, 1993
5 1.49 cgd * The Regents of the University of California. All rights reserved.
6 1.49 cgd * (c) UNIX System Laboratories, Inc.
7 1.49 cgd * All or some portions of this file are derived from material licensed
8 1.49 cgd * to the University of California by American Telephone and Telegraph
9 1.49 cgd * Co. or Unix System Laboratories, Inc. and are reproduced herein with
10 1.49 cgd * the permission of UNIX System Laboratories, Inc.
11 1.49 cgd *
12 1.49 cgd * Redistribution and use in source and binary forms, with or without
13 1.49 cgd * modification, are permitted provided that the following conditions
14 1.49 cgd * are met:
15 1.49 cgd * 1. Redistributions of source code must retain the above copyright
16 1.49 cgd * notice, this list of conditions and the following disclaimer.
17 1.49 cgd * 2. Redistributions in binary form must reproduce the above copyright
18 1.49 cgd * notice, this list of conditions and the following disclaimer in the
19 1.49 cgd * documentation and/or other materials provided with the distribution.
20 1.49 cgd * 3. All advertising materials mentioning features or use of this software
21 1.49 cgd * must display the following acknowledgement:
22 1.49 cgd * This product includes software developed by the University of
23 1.49 cgd * California, Berkeley and its contributors.
24 1.49 cgd * 4. Neither the name of the University nor the names of its contributors
25 1.49 cgd * may be used to endorse or promote products derived from this software
26 1.49 cgd * without specific prior written permission.
27 1.49 cgd *
28 1.49 cgd * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
29 1.49 cgd * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
30 1.49 cgd * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
31 1.49 cgd * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
32 1.49 cgd * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
33 1.49 cgd * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
34 1.49 cgd * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
35 1.49 cgd * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
36 1.49 cgd * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
37 1.49 cgd * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
38 1.49 cgd * SUCH DAMAGE.
39 1.49 cgd *
40 1.105 fvdl * @(#)tty.c 8.13 (Berkeley) 1/9/95
41 1.49 cgd */
42 1.100 thorpej
43 1.100 thorpej #include "opt_uconsole.h"
44 1.49 cgd
45 1.49 cgd #include <sys/param.h>
46 1.49 cgd #include <sys/systm.h>
47 1.49 cgd #include <sys/ioctl.h>
48 1.49 cgd #include <sys/proc.h>
49 1.49 cgd #define TTYDEFCHARS
50 1.49 cgd #include <sys/tty.h>
51 1.49 cgd #undef TTYDEFCHARS
52 1.49 cgd #include <sys/file.h>
53 1.49 cgd #include <sys/conf.h>
54 1.49 cgd #include <sys/dkstat.h>
55 1.49 cgd #include <sys/uio.h>
56 1.49 cgd #include <sys/kernel.h>
57 1.49 cgd #include <sys/vnode.h>
58 1.49 cgd #include <sys/syslog.h>
59 1.49 cgd #include <sys/malloc.h>
60 1.111 thorpej #include <sys/pool.h>
61 1.65 christos #include <sys/signalvar.h>
62 1.65 christos #include <sys/resourcevar.h>
63 1.74 mycroft #include <sys/poll.h>
64 1.49 cgd
65 1.49 cgd #include <vm/vm.h>
66 1.49 cgd
67 1.65 christos static int ttnread __P((struct tty *));
68 1.65 christos static void ttyblock __P((struct tty *));
69 1.65 christos static void ttyecho __P((int, struct tty *));
70 1.65 christos static void ttyrubo __P((struct tty *, int));
71 1.65 christos static int proc_compare __P((struct proc *, struct proc *));
72 1.49 cgd
73 1.49 cgd /* Symbolic sleep message strings. */
74 1.98 mycroft const char ttclos[] = "ttycls";
75 1.98 mycroft const char ttopen[] = "ttyopn";
76 1.98 mycroft const char ttybg[] = "ttybg";
77 1.98 mycroft const char ttyin[] = "ttyin";
78 1.98 mycroft const char ttyout[] = "ttyout";
79 1.49 cgd
80 1.49 cgd /*
81 1.83 mycroft * Used to determine whether we still have a connection. This is true in
82 1.83 mycroft * one of 3 cases:
83 1.83 mycroft * 1) We have carrier.
84 1.83 mycroft * 2) It's a locally attached terminal, and we are therefore ignoring carrier.
85 1.83 mycroft * 3) We're using a flow control mechanism that overloads the carrier signal.
86 1.83 mycroft */
87 1.83 mycroft #define CONNECTED(tp) (ISSET(tp->t_state, TS_CARR_ON) || \
88 1.83 mycroft ISSET(tp->t_cflag, CLOCAL | MDMBUF))
89 1.83 mycroft
90 1.83 mycroft /*
91 1.49 cgd * Table with character classes and parity. The 8th bit indicates parity,
92 1.49 cgd * the 7th bit indicates the character is an alphameric or underscore (for
93 1.49 cgd * ALTWERASE), and the low 6 bits indicate delay type. If the low 6 bits
94 1.49 cgd * are 0 then the character needs no special processing on output; classes
95 1.49 cgd * other than 0 might be translated or (not currently) require delays.
96 1.49 cgd */
97 1.49 cgd #define E 0x00 /* Even parity. */
98 1.49 cgd #define O 0x80 /* Odd parity. */
99 1.49 cgd #define PARITY(c) (char_type[c] & O)
100 1.49 cgd
101 1.49 cgd #define ALPHA 0x40 /* Alpha or underscore. */
102 1.49 cgd #define ISALPHA(c) (char_type[(c) & TTY_CHARMASK] & ALPHA)
103 1.49 cgd
104 1.49 cgd #define CCLASSMASK 0x3f
105 1.49 cgd #define CCLASS(c) (char_type[c] & CCLASSMASK)
106 1.49 cgd
107 1.49 cgd #define BS BACKSPACE
108 1.49 cgd #define CC CONTROL
109 1.49 cgd #define CR RETURN
110 1.49 cgd #define NA ORDINARY | ALPHA
111 1.49 cgd #define NL NEWLINE
112 1.49 cgd #define NO ORDINARY
113 1.49 cgd #define TB TAB
114 1.49 cgd #define VT VTAB
115 1.49 cgd
116 1.49 cgd char const char_type[] = {
117 1.49 cgd E|CC, O|CC, O|CC, E|CC, O|CC, E|CC, E|CC, O|CC, /* nul - bel */
118 1.49 cgd O|BS, E|TB, E|NL, O|CC, E|VT, O|CR, O|CC, E|CC, /* bs - si */
119 1.49 cgd O|CC, E|CC, E|CC, O|CC, E|CC, O|CC, O|CC, E|CC, /* dle - etb */
120 1.49 cgd E|CC, O|CC, O|CC, E|CC, O|CC, E|CC, E|CC, O|CC, /* can - us */
121 1.49 cgd O|NO, E|NO, E|NO, O|NO, E|NO, O|NO, O|NO, E|NO, /* sp - ' */
122 1.49 cgd E|NO, O|NO, O|NO, E|NO, O|NO, E|NO, E|NO, O|NO, /* ( - / */
123 1.49 cgd E|NA, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* 0 - 7 */
124 1.49 cgd O|NA, E|NA, E|NO, O|NO, E|NO, O|NO, O|NO, E|NO, /* 8 - ? */
125 1.49 cgd O|NO, E|NA, E|NA, O|NA, E|NA, O|NA, O|NA, E|NA, /* @ - G */
126 1.49 cgd E|NA, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* H - O */
127 1.49 cgd E|NA, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* P - W */
128 1.49 cgd O|NA, E|NA, E|NA, O|NO, E|NO, O|NO, O|NO, O|NA, /* X - _ */
129 1.49 cgd E|NO, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* ` - g */
130 1.49 cgd O|NA, E|NA, E|NA, O|NA, E|NA, O|NA, O|NA, E|NA, /* h - o */
131 1.49 cgd O|NA, E|NA, E|NA, O|NA, E|NA, O|NA, O|NA, E|NA, /* p - w */
132 1.49 cgd E|NA, O|NA, O|NA, E|NO, O|NO, E|NO, E|NO, O|CC, /* x - del */
133 1.49 cgd /*
134 1.49 cgd * Meta chars; should be settable per character set;
135 1.49 cgd * for now, treat them all as normal characters.
136 1.49 cgd */
137 1.49 cgd NA, NA, NA, NA, NA, NA, NA, NA,
138 1.49 cgd NA, NA, NA, NA, NA, NA, NA, NA,
139 1.49 cgd NA, NA, NA, NA, NA, NA, NA, NA,
140 1.49 cgd NA, NA, NA, NA, NA, NA, NA, NA,
141 1.49 cgd NA, NA, NA, NA, NA, NA, NA, NA,
142 1.49 cgd NA, NA, NA, NA, NA, NA, NA, NA,
143 1.49 cgd NA, NA, NA, NA, NA, NA, NA, NA,
144 1.49 cgd NA, NA, NA, NA, NA, NA, NA, NA,
145 1.49 cgd NA, NA, NA, NA, NA, NA, NA, NA,
146 1.49 cgd NA, NA, NA, NA, NA, NA, NA, NA,
147 1.49 cgd NA, NA, NA, NA, NA, NA, NA, NA,
148 1.49 cgd NA, NA, NA, NA, NA, NA, NA, NA,
149 1.49 cgd NA, NA, NA, NA, NA, NA, NA, NA,
150 1.49 cgd NA, NA, NA, NA, NA, NA, NA, NA,
151 1.49 cgd NA, NA, NA, NA, NA, NA, NA, NA,
152 1.49 cgd NA, NA, NA, NA, NA, NA, NA, NA,
153 1.49 cgd };
154 1.49 cgd #undef BS
155 1.49 cgd #undef CC
156 1.49 cgd #undef CR
157 1.49 cgd #undef NA
158 1.49 cgd #undef NL
159 1.49 cgd #undef NO
160 1.49 cgd #undef TB
161 1.49 cgd #undef VT
162 1.49 cgd
163 1.49 cgd /* Macros to clear/set/test flags. */
164 1.49 cgd #define SET(t, f) (t) |= (f)
165 1.65 christos #define CLR(t, f) (t) &= ~((unsigned)(f))
166 1.49 cgd #define ISSET(t, f) ((t) & (f))
167 1.49 cgd
168 1.69 mrg struct ttylist_head ttylist; /* TAILQ_HEAD */
169 1.69 mrg int tty_count;
170 1.69 mrg
171 1.111 thorpej struct pool tty_pool;
172 1.111 thorpej
173 1.107 mycroft int
174 1.107 mycroft ttyopen(tp, dialout, nonblock)
175 1.107 mycroft struct tty *tp;
176 1.107 mycroft int dialout, nonblock;
177 1.107 mycroft {
178 1.107 mycroft int s;
179 1.107 mycroft int error;
180 1.107 mycroft
181 1.107 mycroft s = spltty();
182 1.107 mycroft
183 1.107 mycroft if (dialout) {
184 1.107 mycroft /*
185 1.107 mycroft * If the device is already open for non-dialout, fail.
186 1.107 mycroft * Otherwise, set TS_DIALOUT to block any pending non-dialout
187 1.107 mycroft * opens.
188 1.107 mycroft */
189 1.107 mycroft if (ISSET(tp->t_state, TS_ISOPEN) &&
190 1.107 mycroft !ISSET(tp->t_state, TS_DIALOUT)) {
191 1.107 mycroft splx(s);
192 1.107 mycroft return (EBUSY);
193 1.107 mycroft }
194 1.107 mycroft SET(tp->t_state, TS_DIALOUT);
195 1.107 mycroft } else {
196 1.107 mycroft if (!nonblock) {
197 1.107 mycroft /*
198 1.107 mycroft * Wait for carrier. Also wait for any dialout
199 1.107 mycroft * processes to close the tty first.
200 1.107 mycroft */
201 1.107 mycroft while (ISSET(tp->t_state, TS_DIALOUT) ||
202 1.107 mycroft (!ISSET(tp->t_state, TS_CARR_ON) &&
203 1.107 mycroft !ISSET(tp->t_cflag, CLOCAL | MDMBUF))) {
204 1.107 mycroft tp->t_wopen++;
205 1.107 mycroft error = ttysleep(tp, &tp->t_rawq,
206 1.107 mycroft TTIPRI | PCATCH, ttopen, 0);
207 1.107 mycroft tp->t_wopen--;
208 1.107 mycroft if (error) {
209 1.107 mycroft splx(s);
210 1.107 mycroft return (error);
211 1.107 mycroft }
212 1.107 mycroft }
213 1.107 mycroft } else {
214 1.107 mycroft /*
215 1.107 mycroft * Don't allow a non-blocking non-dialout open if the
216 1.107 mycroft * device is already open for dialout.
217 1.107 mycroft */
218 1.107 mycroft if (ISSET(tp->t_state, TS_DIALOUT)) {
219 1.107 mycroft splx(s);
220 1.107 mycroft return (EBUSY);
221 1.107 mycroft }
222 1.107 mycroft }
223 1.107 mycroft }
224 1.107 mycroft
225 1.107 mycroft splx(s);
226 1.107 mycroft return (0);
227 1.107 mycroft }
228 1.107 mycroft
229 1.49 cgd /*
230 1.49 cgd * Initial open of tty, or (re)entry to standard tty line discipline.
231 1.49 cgd */
232 1.49 cgd int
233 1.107 mycroft ttylopen(device, tp)
234 1.49 cgd dev_t device;
235 1.49 cgd register struct tty *tp;
236 1.49 cgd {
237 1.49 cgd int s;
238 1.49 cgd
239 1.49 cgd s = spltty();
240 1.49 cgd tp->t_dev = device;
241 1.49 cgd if (!ISSET(tp->t_state, TS_ISOPEN)) {
242 1.49 cgd SET(tp->t_state, TS_ISOPEN);
243 1.109 perry memset(&tp->t_winsize, 0, sizeof(tp->t_winsize));
244 1.66 christos #ifdef COMPAT_OLDTTY
245 1.50 mycroft tp->t_flags = 0;
246 1.50 mycroft #endif
247 1.49 cgd }
248 1.49 cgd splx(s);
249 1.49 cgd return (0);
250 1.49 cgd }
251 1.49 cgd
252 1.49 cgd /*
253 1.49 cgd * Handle close() on a tty line: flush and set to initial state,
254 1.49 cgd * bumping generation number so that pending read/write calls
255 1.49 cgd * can detect recycling of the tty.
256 1.49 cgd */
257 1.49 cgd int
258 1.49 cgd ttyclose(tp)
259 1.49 cgd register struct tty *tp;
260 1.49 cgd {
261 1.49 cgd extern struct tty *constty; /* Temporary virtual console. */
262 1.49 cgd
263 1.49 cgd if (constty == tp)
264 1.49 cgd constty = NULL;
265 1.49 cgd
266 1.49 cgd ttyflush(tp, FREAD | FWRITE);
267 1.49 cgd
268 1.49 cgd tp->t_gen++;
269 1.49 cgd tp->t_pgrp = NULL;
270 1.49 cgd tp->t_session = NULL;
271 1.49 cgd tp->t_state = 0;
272 1.49 cgd return (0);
273 1.49 cgd }
274 1.49 cgd
275 1.49 cgd #define FLUSHQ(q) { \
276 1.49 cgd if ((q)->c_cc) \
277 1.49 cgd ndflush(q, (q)->c_cc); \
278 1.49 cgd }
279 1.49 cgd
280 1.88 kleink /*
281 1.88 kleink * This macro is used in canonical mode input processing, where a read
282 1.88 kleink * request shall not return unless a 'line delimiter' ('\n') or 'break'
283 1.88 kleink * (EOF, EOL, EOL2) character (or a signal) has been received. As EOL2
284 1.88 kleink * is an extension to the POSIX.1 defined set of special characters,
285 1.88 kleink * recognize it only if IEXTEN is set in the set of local flags.
286 1.88 kleink */
287 1.85 kleink #define TTBREAKC(c, lflg) \
288 1.87 cgd ((c) == '\n' || (((c) == cc[VEOF] || (c) == cc[VEOL] || \
289 1.85 kleink ((c) == cc[VEOL2] && ISSET(lflg, IEXTEN))) && (c) != _POSIX_VDISABLE))
290 1.49 cgd
291 1.49 cgd
292 1.49 cgd /*
293 1.49 cgd * Process input of a single character received on a tty.
294 1.49 cgd */
295 1.49 cgd int
296 1.49 cgd ttyinput(c, tp)
297 1.49 cgd register int c;
298 1.49 cgd register struct tty *tp;
299 1.49 cgd {
300 1.49 cgd register int iflag, lflag;
301 1.49 cgd register u_char *cc;
302 1.65 christos int i, error;
303 1.78 christos
304 1.78 christos /*
305 1.78 christos * Unless the receiver is enabled, drop incoming data.
306 1.78 christos */
307 1.78 christos if (!ISSET(tp->t_cflag, CREAD))
308 1.78 christos return (0);
309 1.49 cgd
310 1.49 cgd /*
311 1.49 cgd * If input is pending take it first.
312 1.49 cgd */
313 1.49 cgd lflag = tp->t_lflag;
314 1.49 cgd if (ISSET(lflag, PENDIN))
315 1.49 cgd ttypend(tp);
316 1.49 cgd /*
317 1.49 cgd * Gather stats.
318 1.49 cgd */
319 1.49 cgd if (ISSET(lflag, ICANON)) {
320 1.49 cgd ++tk_cancc;
321 1.49 cgd ++tp->t_cancc;
322 1.49 cgd } else {
323 1.49 cgd ++tk_rawcc;
324 1.49 cgd ++tp->t_rawcc;
325 1.49 cgd }
326 1.49 cgd ++tk_nin;
327 1.49 cgd
328 1.49 cgd cc = tp->t_cc;
329 1.94 kleink
330 1.94 kleink /*
331 1.94 kleink * Handle exceptional conditions (break, parity, framing).
332 1.94 kleink */
333 1.49 cgd iflag = tp->t_iflag;
334 1.65 christos if ((error = (ISSET(c, TTY_ERRORMASK))) != 0) {
335 1.49 cgd CLR(c, TTY_ERRORMASK);
336 1.94 kleink if (ISSET(error, TTY_FE) && c == 0) { /* Break. */
337 1.49 cgd if (ISSET(iflag, IGNBRK))
338 1.94 kleink return (0);
339 1.94 kleink else if (ISSET(iflag, BRKINT)) {
340 1.94 kleink ttyflush(tp, FREAD | FWRITE);
341 1.94 kleink pgsignal(tp->t_pgrp, SIGINT, 1);
342 1.94 kleink return (0);
343 1.94 kleink }
344 1.49 cgd else if (ISSET(iflag, PARMRK))
345 1.49 cgd goto parmrk;
346 1.94 kleink }
347 1.94 kleink else if ((ISSET(error, TTY_PE) && ISSET(iflag, INPCK)) ||
348 1.94 kleink ISSET(error, TTY_FE)) {
349 1.49 cgd if (ISSET(iflag, IGNPAR))
350 1.94 kleink return (0);
351 1.49 cgd else if (ISSET(iflag, PARMRK)) {
352 1.49 cgd parmrk: (void)putc(0377 | TTY_QUOTE, &tp->t_rawq);
353 1.94 kleink (void)putc(0 | TTY_QUOTE, &tp->t_rawq);
354 1.94 kleink (void)putc(c | TTY_QUOTE, &tp->t_rawq);
355 1.94 kleink return (0);
356 1.94 kleink }
357 1.94 kleink else
358 1.49 cgd c = 0;
359 1.49 cgd }
360 1.49 cgd }
361 1.94 kleink else if (c == 0377 &&
362 1.94 kleink ISSET(iflag, ISTRIP|IGNPAR|INPCK|PARMRK) == (INPCK|PARMRK)) {
363 1.94 kleink /* "Escape" a valid character of '\377'. */
364 1.94 kleink (void)putc(0377 | TTY_QUOTE, &tp->t_rawq);
365 1.94 kleink (void)putc(0377 | TTY_QUOTE, &tp->t_rawq);
366 1.94 kleink goto endcase;
367 1.94 kleink }
368 1.94 kleink
369 1.49 cgd /*
370 1.49 cgd * In tandem mode, check high water mark.
371 1.49 cgd */
372 1.49 cgd if (ISSET(iflag, IXOFF) || ISSET(tp->t_cflag, CHWFLOW))
373 1.49 cgd ttyblock(tp);
374 1.49 cgd if (!ISSET(tp->t_state, TS_TYPEN) && ISSET(iflag, ISTRIP))
375 1.49 cgd CLR(c, 0x80);
376 1.49 cgd if (!ISSET(lflag, EXTPROC)) {
377 1.49 cgd /*
378 1.49 cgd * Check for literal nexting very first
379 1.49 cgd */
380 1.49 cgd if (ISSET(tp->t_state, TS_LNCH)) {
381 1.49 cgd SET(c, TTY_QUOTE);
382 1.49 cgd CLR(tp->t_state, TS_LNCH);
383 1.49 cgd }
384 1.49 cgd /*
385 1.49 cgd * Scan for special characters. This code
386 1.49 cgd * is really just a big case statement with
387 1.49 cgd * non-constant cases. The bottom of the
388 1.49 cgd * case statement is labeled ``endcase'', so goto
389 1.49 cgd * it after a case match, or similar.
390 1.49 cgd */
391 1.49 cgd
392 1.49 cgd /*
393 1.49 cgd * Control chars which aren't controlled
394 1.49 cgd * by ICANON, ISIG, or IXON.
395 1.49 cgd */
396 1.49 cgd if (ISSET(lflag, IEXTEN)) {
397 1.49 cgd if (CCEQ(cc[VLNEXT], c)) {
398 1.49 cgd if (ISSET(lflag, ECHO)) {
399 1.49 cgd if (ISSET(lflag, ECHOE)) {
400 1.49 cgd (void)ttyoutput('^', tp);
401 1.49 cgd (void)ttyoutput('\b', tp);
402 1.49 cgd } else
403 1.49 cgd ttyecho(c, tp);
404 1.49 cgd }
405 1.49 cgd SET(tp->t_state, TS_LNCH);
406 1.49 cgd goto endcase;
407 1.49 cgd }
408 1.49 cgd if (CCEQ(cc[VDISCARD], c)) {
409 1.49 cgd if (ISSET(lflag, FLUSHO))
410 1.49 cgd CLR(tp->t_lflag, FLUSHO);
411 1.49 cgd else {
412 1.49 cgd ttyflush(tp, FWRITE);
413 1.49 cgd ttyecho(c, tp);
414 1.49 cgd if (tp->t_rawq.c_cc + tp->t_canq.c_cc)
415 1.49 cgd ttyretype(tp);
416 1.49 cgd SET(tp->t_lflag, FLUSHO);
417 1.49 cgd }
418 1.49 cgd goto startoutput;
419 1.49 cgd }
420 1.49 cgd }
421 1.49 cgd /*
422 1.49 cgd * Signals.
423 1.49 cgd */
424 1.49 cgd if (ISSET(lflag, ISIG)) {
425 1.49 cgd if (CCEQ(cc[VINTR], c) || CCEQ(cc[VQUIT], c)) {
426 1.49 cgd if (!ISSET(lflag, NOFLSH))
427 1.49 cgd ttyflush(tp, FREAD | FWRITE);
428 1.49 cgd ttyecho(c, tp);
429 1.49 cgd pgsignal(tp->t_pgrp,
430 1.49 cgd CCEQ(cc[VINTR], c) ? SIGINT : SIGQUIT, 1);
431 1.49 cgd goto endcase;
432 1.49 cgd }
433 1.49 cgd if (CCEQ(cc[VSUSP], c)) {
434 1.49 cgd if (!ISSET(lflag, NOFLSH))
435 1.49 cgd ttyflush(tp, FREAD);
436 1.49 cgd ttyecho(c, tp);
437 1.49 cgd pgsignal(tp->t_pgrp, SIGTSTP, 1);
438 1.49 cgd goto endcase;
439 1.49 cgd }
440 1.49 cgd }
441 1.49 cgd /*
442 1.49 cgd * Handle start/stop characters.
443 1.49 cgd */
444 1.49 cgd if (ISSET(iflag, IXON)) {
445 1.49 cgd if (CCEQ(cc[VSTOP], c)) {
446 1.49 cgd if (!ISSET(tp->t_state, TS_TTSTOP)) {
447 1.49 cgd SET(tp->t_state, TS_TTSTOP);
448 1.49 cgd (*cdevsw[major(tp->t_dev)].d_stop)(tp,
449 1.49 cgd 0);
450 1.49 cgd return (0);
451 1.49 cgd }
452 1.49 cgd if (!CCEQ(cc[VSTART], c))
453 1.49 cgd return (0);
454 1.49 cgd /*
455 1.49 cgd * if VSTART == VSTOP then toggle
456 1.49 cgd */
457 1.49 cgd goto endcase;
458 1.49 cgd }
459 1.49 cgd if (CCEQ(cc[VSTART], c))
460 1.49 cgd goto restartoutput;
461 1.49 cgd }
462 1.49 cgd /*
463 1.49 cgd * IGNCR, ICRNL, & INLCR
464 1.49 cgd */
465 1.49 cgd if (c == '\r') {
466 1.49 cgd if (ISSET(iflag, IGNCR))
467 1.49 cgd goto endcase;
468 1.49 cgd else if (ISSET(iflag, ICRNL))
469 1.49 cgd c = '\n';
470 1.49 cgd } else if (c == '\n' && ISSET(iflag, INLCR))
471 1.49 cgd c = '\r';
472 1.49 cgd }
473 1.49 cgd if (!ISSET(tp->t_lflag, EXTPROC) && ISSET(lflag, ICANON)) {
474 1.49 cgd /*
475 1.49 cgd * From here on down canonical mode character
476 1.49 cgd * processing takes place.
477 1.49 cgd */
478 1.49 cgd /*
479 1.49 cgd * erase (^H / ^?)
480 1.49 cgd */
481 1.49 cgd if (CCEQ(cc[VERASE], c)) {
482 1.49 cgd if (tp->t_rawq.c_cc)
483 1.49 cgd ttyrub(unputc(&tp->t_rawq), tp);
484 1.49 cgd goto endcase;
485 1.49 cgd }
486 1.49 cgd /*
487 1.49 cgd * kill (^U)
488 1.49 cgd */
489 1.49 cgd if (CCEQ(cc[VKILL], c)) {
490 1.49 cgd if (ISSET(lflag, ECHOKE) &&
491 1.49 cgd tp->t_rawq.c_cc == tp->t_rocount &&
492 1.49 cgd !ISSET(lflag, ECHOPRT))
493 1.49 cgd while (tp->t_rawq.c_cc)
494 1.49 cgd ttyrub(unputc(&tp->t_rawq), tp);
495 1.49 cgd else {
496 1.49 cgd ttyecho(c, tp);
497 1.49 cgd if (ISSET(lflag, ECHOK) ||
498 1.49 cgd ISSET(lflag, ECHOKE))
499 1.49 cgd ttyecho('\n', tp);
500 1.49 cgd FLUSHQ(&tp->t_rawq);
501 1.49 cgd tp->t_rocount = 0;
502 1.49 cgd }
503 1.49 cgd CLR(tp->t_state, TS_LOCAL);
504 1.49 cgd goto endcase;
505 1.49 cgd }
506 1.49 cgd /*
507 1.81 kleink * Extensions to the POSIX.1 GTI set of functions.
508 1.49 cgd */
509 1.81 kleink if (ISSET(lflag, IEXTEN)) {
510 1.49 cgd /*
511 1.81 kleink * word erase (^W)
512 1.49 cgd */
513 1.81 kleink if (CCEQ(cc[VWERASE], c)) {
514 1.81 kleink int alt = ISSET(lflag, ALTWERASE);
515 1.81 kleink int ctype;
516 1.81 kleink
517 1.81 kleink /*
518 1.81 kleink * erase whitespace
519 1.81 kleink */
520 1.81 kleink while ((c = unputc(&tp->t_rawq)) == ' ' ||
521 1.81 kleink c == '\t')
522 1.81 kleink ttyrub(c, tp);
523 1.81 kleink if (c == -1)
524 1.81 kleink goto endcase;
525 1.81 kleink /*
526 1.81 kleink * erase last char of word and remember the
527 1.81 kleink * next chars type (for ALTWERASE)
528 1.81 kleink */
529 1.49 cgd ttyrub(c, tp);
530 1.81 kleink c = unputc(&tp->t_rawq);
531 1.81 kleink if (c == -1)
532 1.81 kleink goto endcase;
533 1.81 kleink if (c == ' ' || c == '\t') {
534 1.81 kleink (void)putc(c, &tp->t_rawq);
535 1.81 kleink goto endcase;
536 1.81 kleink }
537 1.81 kleink ctype = ISALPHA(c);
538 1.81 kleink /*
539 1.81 kleink * erase rest of word
540 1.81 kleink */
541 1.81 kleink do {
542 1.81 kleink ttyrub(c, tp);
543 1.81 kleink c = unputc(&tp->t_rawq);
544 1.81 kleink if (c == -1)
545 1.81 kleink goto endcase;
546 1.81 kleink } while (c != ' ' && c != '\t' &&
547 1.81 kleink (alt == 0 || ISALPHA(c) == ctype));
548 1.81 kleink (void)putc(c, &tp->t_rawq);
549 1.49 cgd goto endcase;
550 1.81 kleink }
551 1.49 cgd /*
552 1.81 kleink * reprint line (^R)
553 1.49 cgd */
554 1.81 kleink if (CCEQ(cc[VREPRINT], c)) {
555 1.81 kleink ttyretype(tp);
556 1.49 cgd goto endcase;
557 1.49 cgd }
558 1.49 cgd /*
559 1.81 kleink * ^T - kernel info and generate SIGINFO
560 1.49 cgd */
561 1.81 kleink if (CCEQ(cc[VSTATUS], c)) {
562 1.81 kleink if (ISSET(lflag, ISIG))
563 1.81 kleink pgsignal(tp->t_pgrp, SIGINFO, 1);
564 1.81 kleink if (!ISSET(lflag, NOKERNINFO))
565 1.81 kleink ttyinfo(tp);
566 1.81 kleink goto endcase;
567 1.81 kleink }
568 1.49 cgd }
569 1.49 cgd }
570 1.49 cgd /*
571 1.49 cgd * Check for input buffer overflow
572 1.49 cgd */
573 1.49 cgd if (tp->t_rawq.c_cc + tp->t_canq.c_cc >= TTYHOG) {
574 1.49 cgd if (ISSET(iflag, IMAXBEL)) {
575 1.49 cgd if (tp->t_outq.c_cc < tp->t_hiwat)
576 1.49 cgd (void)ttyoutput(CTRL('g'), tp);
577 1.49 cgd } else
578 1.49 cgd ttyflush(tp, FREAD | FWRITE);
579 1.49 cgd goto endcase;
580 1.49 cgd }
581 1.49 cgd /*
582 1.49 cgd * Put data char in q for user and
583 1.49 cgd * wakeup on seeing a line delimiter.
584 1.49 cgd */
585 1.49 cgd if (putc(c, &tp->t_rawq) >= 0) {
586 1.49 cgd if (!ISSET(lflag, ICANON)) {
587 1.49 cgd ttwakeup(tp);
588 1.49 cgd ttyecho(c, tp);
589 1.49 cgd goto endcase;
590 1.49 cgd }
591 1.85 kleink if (TTBREAKC(c, lflag)) {
592 1.49 cgd tp->t_rocount = 0;
593 1.49 cgd catq(&tp->t_rawq, &tp->t_canq);
594 1.49 cgd ttwakeup(tp);
595 1.49 cgd } else if (tp->t_rocount++ == 0)
596 1.49 cgd tp->t_rocol = tp->t_column;
597 1.49 cgd if (ISSET(tp->t_state, TS_ERASE)) {
598 1.49 cgd /*
599 1.49 cgd * end of prterase \.../
600 1.49 cgd */
601 1.49 cgd CLR(tp->t_state, TS_ERASE);
602 1.49 cgd (void)ttyoutput('/', tp);
603 1.49 cgd }
604 1.49 cgd i = tp->t_column;
605 1.49 cgd ttyecho(c, tp);
606 1.49 cgd if (CCEQ(cc[VEOF], c) && ISSET(lflag, ECHO)) {
607 1.49 cgd /*
608 1.49 cgd * Place the cursor over the '^' of the ^D.
609 1.49 cgd */
610 1.49 cgd i = min(2, tp->t_column - i);
611 1.49 cgd while (i > 0) {
612 1.49 cgd (void)ttyoutput('\b', tp);
613 1.49 cgd i--;
614 1.49 cgd }
615 1.49 cgd }
616 1.49 cgd }
617 1.49 cgd endcase:
618 1.49 cgd /*
619 1.49 cgd * IXANY means allow any character to restart output.
620 1.49 cgd */
621 1.49 cgd if (ISSET(tp->t_state, TS_TTSTOP) &&
622 1.49 cgd !ISSET(iflag, IXANY) && cc[VSTART] != cc[VSTOP])
623 1.49 cgd return (0);
624 1.49 cgd restartoutput:
625 1.49 cgd CLR(tp->t_lflag, FLUSHO);
626 1.49 cgd CLR(tp->t_state, TS_TTSTOP);
627 1.49 cgd startoutput:
628 1.49 cgd return (ttstart(tp));
629 1.49 cgd }
630 1.49 cgd
631 1.49 cgd /*
632 1.49 cgd * Output a single character on a tty, doing output processing
633 1.49 cgd * as needed (expanding tabs, newline processing, etc.).
634 1.49 cgd * Returns < 0 if succeeds, otherwise returns char to resend.
635 1.49 cgd * Must be recursive.
636 1.49 cgd */
637 1.49 cgd int
638 1.49 cgd ttyoutput(c, tp)
639 1.49 cgd register int c;
640 1.49 cgd register struct tty *tp;
641 1.49 cgd {
642 1.49 cgd register long oflag;
643 1.49 cgd register int col, notout, s;
644 1.49 cgd
645 1.49 cgd oflag = tp->t_oflag;
646 1.49 cgd if (!ISSET(oflag, OPOST)) {
647 1.49 cgd tk_nout++;
648 1.49 cgd tp->t_outcc++;
649 1.99 mycroft if (!ISSET(tp->t_lflag, FLUSHO) && putc(c, &tp->t_outq))
650 1.99 mycroft return (c);
651 1.49 cgd return (-1);
652 1.49 cgd }
653 1.49 cgd /*
654 1.103 kleink * Do tab expansion if OXTABS is set. Special case if we do external
655 1.49 cgd * processing, we don't do the tab expansion because we'll probably
656 1.49 cgd * get it wrong. If tab expansion needs to be done, let it happen
657 1.49 cgd * externally.
658 1.49 cgd */
659 1.49 cgd CLR(c, ~TTY_CHARMASK);
660 1.49 cgd if (c == '\t' &&
661 1.49 cgd ISSET(oflag, OXTABS) && !ISSET(tp->t_lflag, EXTPROC)) {
662 1.49 cgd c = 8 - (tp->t_column & 7);
663 1.49 cgd if (ISSET(tp->t_lflag, FLUSHO)) {
664 1.49 cgd notout = 0;
665 1.49 cgd } else {
666 1.49 cgd s = spltty(); /* Don't interrupt tabs. */
667 1.49 cgd notout = b_to_q(" ", c, &tp->t_outq);
668 1.49 cgd c -= notout;
669 1.49 cgd tk_nout += c;
670 1.49 cgd tp->t_outcc += c;
671 1.49 cgd splx(s);
672 1.49 cgd }
673 1.49 cgd tp->t_column += c;
674 1.49 cgd return (notout ? '\t' : -1);
675 1.49 cgd }
676 1.49 cgd if (c == CEOT && ISSET(oflag, ONOEOT))
677 1.49 cgd return (-1);
678 1.49 cgd
679 1.49 cgd /*
680 1.49 cgd * Newline translation: if ONLCR is set,
681 1.49 cgd * translate newline into "\r\n".
682 1.49 cgd */
683 1.49 cgd if (c == '\n' && ISSET(tp->t_oflag, ONLCR)) {
684 1.49 cgd tk_nout++;
685 1.49 cgd tp->t_outcc++;
686 1.99 mycroft if (!ISSET(tp->t_lflag, FLUSHO) && putc('\r', &tp->t_outq))
687 1.49 cgd return (c);
688 1.49 cgd }
689 1.103 kleink /* If OCRNL is set, translate "\r" into "\n". */
690 1.79 kleink else if (c == '\r' && ISSET(tp->t_oflag, OCRNL))
691 1.79 kleink c = '\n';
692 1.103 kleink /* If ONOCR is set, don't transmit CRs when on column 0. */
693 1.103 kleink else if (c == '\r' && ISSET(tp->t_oflag, ONOCR) && tp->t_column == 0)
694 1.103 kleink return (-1);
695 1.79 kleink
696 1.49 cgd tk_nout++;
697 1.49 cgd tp->t_outcc++;
698 1.49 cgd if (!ISSET(tp->t_lflag, FLUSHO) && putc(c, &tp->t_outq))
699 1.49 cgd return (c);
700 1.49 cgd
701 1.49 cgd col = tp->t_column;
702 1.49 cgd switch (CCLASS(c)) {
703 1.49 cgd case BACKSPACE:
704 1.49 cgd if (col > 0)
705 1.49 cgd --col;
706 1.49 cgd break;
707 1.49 cgd case CONTROL:
708 1.49 cgd break;
709 1.49 cgd case NEWLINE:
710 1.103 kleink if (ISSET(tp->t_oflag, ONLCR | ONLRET))
711 1.79 kleink col = 0;
712 1.79 kleink break;
713 1.49 cgd case RETURN:
714 1.49 cgd col = 0;
715 1.49 cgd break;
716 1.49 cgd case ORDINARY:
717 1.49 cgd ++col;
718 1.49 cgd break;
719 1.49 cgd case TAB:
720 1.49 cgd col = (col + 8) & ~7;
721 1.49 cgd break;
722 1.49 cgd }
723 1.49 cgd tp->t_column = col;
724 1.49 cgd return (-1);
725 1.49 cgd }
726 1.49 cgd
727 1.49 cgd /*
728 1.49 cgd * Ioctls for all tty devices. Called after line-discipline specific ioctl
729 1.49 cgd * has been called to do discipline-specific functions and/or reject any
730 1.49 cgd * of these ioctl commands.
731 1.49 cgd */
732 1.49 cgd /* ARGSUSED */
733 1.49 cgd int
734 1.49 cgd ttioctl(tp, cmd, data, flag, p)
735 1.49 cgd register struct tty *tp;
736 1.55 cgd u_long cmd;
737 1.56 mycroft caddr_t data;
738 1.55 cgd int flag;
739 1.49 cgd struct proc *p;
740 1.49 cgd {
741 1.49 cgd extern struct tty *constty; /* Temporary virtual console. */
742 1.49 cgd extern int nlinesw;
743 1.49 cgd int s, error;
744 1.49 cgd
745 1.49 cgd /* If the ioctl involves modification, hang if in the background. */
746 1.49 cgd switch (cmd) {
747 1.49 cgd case TIOCFLUSH:
748 1.92 kleink case TIOCDRAIN:
749 1.95 kleink case TIOCSBRK:
750 1.95 kleink case TIOCCBRK:
751 1.95 kleink case TIOCSTART:
752 1.49 cgd case TIOCSETA:
753 1.49 cgd case TIOCSETD:
754 1.49 cgd case TIOCSETAF:
755 1.49 cgd case TIOCSETAW:
756 1.49 cgd #ifdef notdef
757 1.49 cgd case TIOCSPGRP:
758 1.49 cgd #endif
759 1.49 cgd case TIOCSTAT:
760 1.49 cgd case TIOCSTI:
761 1.49 cgd case TIOCSWINSZ:
762 1.66 christos #ifdef COMPAT_OLDTTY
763 1.49 cgd case TIOCLBIC:
764 1.49 cgd case TIOCLBIS:
765 1.49 cgd case TIOCLSET:
766 1.49 cgd case TIOCSETC:
767 1.49 cgd case OTIOCSETD:
768 1.49 cgd case TIOCSETN:
769 1.49 cgd case TIOCSETP:
770 1.49 cgd case TIOCSLTC:
771 1.49 cgd #endif
772 1.49 cgd while (isbackground(curproc, tp) &&
773 1.49 cgd p->p_pgrp->pg_jobc && (p->p_flag & P_PPWAIT) == 0 &&
774 1.112 mycroft !sigismember(&p->p_sigignore, SIGTTOU) &&
775 1.112 mycroft !sigismember(&p->p_sigmask, SIGTTOU)) {
776 1.49 cgd pgsignal(p->p_pgrp, SIGTTOU, 1);
777 1.112 mycroft error = ttysleep(tp, &lbolt, TTOPRI | PCATCH, ttybg, 0);
778 1.65 christos if (error)
779 1.49 cgd return (error);
780 1.49 cgd }
781 1.49 cgd break;
782 1.49 cgd }
783 1.49 cgd
784 1.49 cgd switch (cmd) { /* Process the ioctl. */
785 1.49 cgd case FIOASYNC: /* set/clear async i/o */
786 1.49 cgd s = spltty();
787 1.49 cgd if (*(int *)data)
788 1.49 cgd SET(tp->t_state, TS_ASYNC);
789 1.49 cgd else
790 1.49 cgd CLR(tp->t_state, TS_ASYNC);
791 1.49 cgd splx(s);
792 1.49 cgd break;
793 1.49 cgd case FIONBIO: /* set/clear non-blocking i/o */
794 1.49 cgd break; /* XXX: delete. */
795 1.49 cgd case FIONREAD: /* get # bytes to read */
796 1.49 cgd *(int *)data = ttnread(tp);
797 1.49 cgd break;
798 1.49 cgd case TIOCEXCL: /* set exclusive use of tty */
799 1.49 cgd s = spltty();
800 1.49 cgd SET(tp->t_state, TS_XCLUDE);
801 1.49 cgd splx(s);
802 1.49 cgd break;
803 1.49 cgd case TIOCFLUSH: { /* flush buffers */
804 1.49 cgd register int flags = *(int *)data;
805 1.49 cgd
806 1.49 cgd if (flags == 0)
807 1.49 cgd flags = FREAD | FWRITE;
808 1.49 cgd else
809 1.49 cgd flags &= FREAD | FWRITE;
810 1.49 cgd ttyflush(tp, flags);
811 1.49 cgd break;
812 1.49 cgd }
813 1.49 cgd case TIOCCONS: /* become virtual console */
814 1.49 cgd if (*(int *)data) {
815 1.49 cgd if (constty && constty != tp &&
816 1.49 cgd ISSET(constty->t_state, TS_CARR_ON | TS_ISOPEN) ==
817 1.49 cgd (TS_CARR_ON | TS_ISOPEN))
818 1.49 cgd return (EBUSY);
819 1.49 cgd #ifndef UCONSOLE
820 1.65 christos if ((error = suser(p->p_ucred, &p->p_acflag)) != 0)
821 1.49 cgd return (error);
822 1.49 cgd #endif
823 1.49 cgd constty = tp;
824 1.49 cgd } else if (tp == constty)
825 1.49 cgd constty = NULL;
826 1.49 cgd break;
827 1.49 cgd case TIOCDRAIN: /* wait till output drained */
828 1.65 christos if ((error = ttywait(tp)) != 0)
829 1.49 cgd return (error);
830 1.49 cgd break;
831 1.49 cgd case TIOCGETA: { /* get termios struct */
832 1.49 cgd struct termios *t = (struct termios *)data;
833 1.49 cgd
834 1.109 perry memcpy(t, &tp->t_termios, sizeof(struct termios));
835 1.49 cgd break;
836 1.49 cgd }
837 1.49 cgd case TIOCGETD: /* get line discipline */
838 1.49 cgd *(int *)data = tp->t_line;
839 1.49 cgd break;
840 1.49 cgd case TIOCGWINSZ: /* get window size */
841 1.49 cgd *(struct winsize *)data = tp->t_winsize;
842 1.49 cgd break;
843 1.49 cgd case TIOCGPGRP: /* get pgrp of tty */
844 1.49 cgd if (!isctty(p, tp))
845 1.49 cgd return (ENOTTY);
846 1.49 cgd *(int *)data = tp->t_pgrp ? tp->t_pgrp->pg_id : NO_PID;
847 1.104 thorpej break;
848 1.104 thorpej case TIOCGSID: /* get sid of tty */
849 1.104 thorpej if (!isctty(p, tp))
850 1.104 thorpej return (ENOTTY);
851 1.104 thorpej *(int *)data = tp->t_session->s_sid;
852 1.49 cgd break;
853 1.49 cgd #ifdef TIOCHPCL
854 1.49 cgd case TIOCHPCL: /* hang up on last close */
855 1.49 cgd s = spltty();
856 1.49 cgd SET(tp->t_cflag, HUPCL);
857 1.49 cgd splx(s);
858 1.49 cgd break;
859 1.49 cgd #endif
860 1.49 cgd case TIOCNXCL: /* reset exclusive use of tty */
861 1.49 cgd s = spltty();
862 1.49 cgd CLR(tp->t_state, TS_XCLUDE);
863 1.49 cgd splx(s);
864 1.49 cgd break;
865 1.49 cgd case TIOCOUTQ: /* output queue size */
866 1.49 cgd *(int *)data = tp->t_outq.c_cc;
867 1.49 cgd break;
868 1.49 cgd case TIOCSETA: /* set termios struct */
869 1.49 cgd case TIOCSETAW: /* drain output, set */
870 1.49 cgd case TIOCSETAF: { /* drn out, fls in, set */
871 1.49 cgd register struct termios *t = (struct termios *)data;
872 1.49 cgd
873 1.49 cgd s = spltty();
874 1.49 cgd if (cmd == TIOCSETAW || cmd == TIOCSETAF) {
875 1.65 christos if ((error = ttywait(tp)) != 0) {
876 1.49 cgd splx(s);
877 1.49 cgd return (error);
878 1.49 cgd }
879 1.49 cgd if (cmd == TIOCSETAF)
880 1.49 cgd ttyflush(tp, FREAD);
881 1.49 cgd }
882 1.49 cgd if (!ISSET(t->c_cflag, CIGNORE)) {
883 1.49 cgd /*
884 1.49 cgd * Set device hardware.
885 1.49 cgd */
886 1.49 cgd if (tp->t_param && (error = (*tp->t_param)(tp, t))) {
887 1.49 cgd splx(s);
888 1.49 cgd return (error);
889 1.49 cgd } else {
890 1.49 cgd tp->t_cflag = t->c_cflag;
891 1.49 cgd tp->t_ispeed = t->c_ispeed;
892 1.49 cgd tp->t_ospeed = t->c_ospeed;
893 1.49 cgd if (t->c_ospeed == 0 && tp->t_session &&
894 1.49 cgd tp->t_session->s_leader)
895 1.49 cgd psignal(tp->t_session->s_leader,
896 1.49 cgd SIGHUP);
897 1.49 cgd }
898 1.49 cgd ttsetwater(tp);
899 1.49 cgd }
900 1.49 cgd if (cmd != TIOCSETAF) {
901 1.49 cgd if (ISSET(t->c_lflag, ICANON) !=
902 1.110 thorpej ISSET(tp->t_lflag, ICANON)) {
903 1.49 cgd if (ISSET(t->c_lflag, ICANON)) {
904 1.49 cgd SET(tp->t_lflag, PENDIN);
905 1.49 cgd ttwakeup(tp);
906 1.49 cgd } else {
907 1.49 cgd struct clist tq;
908 1.49 cgd
909 1.49 cgd catq(&tp->t_rawq, &tp->t_canq);
910 1.49 cgd tq = tp->t_rawq;
911 1.49 cgd tp->t_rawq = tp->t_canq;
912 1.49 cgd tp->t_canq = tq;
913 1.49 cgd CLR(tp->t_lflag, PENDIN);
914 1.49 cgd }
915 1.110 thorpej }
916 1.49 cgd }
917 1.49 cgd tp->t_iflag = t->c_iflag;
918 1.49 cgd tp->t_oflag = t->c_oflag;
919 1.49 cgd /*
920 1.49 cgd * Make the EXTPROC bit read only.
921 1.49 cgd */
922 1.49 cgd if (ISSET(tp->t_lflag, EXTPROC))
923 1.49 cgd SET(t->c_lflag, EXTPROC);
924 1.49 cgd else
925 1.49 cgd CLR(t->c_lflag, EXTPROC);
926 1.49 cgd tp->t_lflag = t->c_lflag | ISSET(tp->t_lflag, PENDIN);
927 1.109 perry memcpy(tp->t_cc, t->c_cc, sizeof(t->c_cc));
928 1.49 cgd splx(s);
929 1.49 cgd break;
930 1.49 cgd }
931 1.49 cgd case TIOCSETD: { /* set line discipline */
932 1.49 cgd register int t = *(int *)data;
933 1.49 cgd dev_t device = tp->t_dev;
934 1.49 cgd
935 1.49 cgd if ((u_int)t >= nlinesw)
936 1.49 cgd return (ENXIO);
937 1.49 cgd if (t != tp->t_line) {
938 1.49 cgd s = spltty();
939 1.49 cgd (*linesw[tp->t_line].l_close)(tp, flag);
940 1.49 cgd error = (*linesw[t].l_open)(device, tp);
941 1.49 cgd if (error) {
942 1.49 cgd (void)(*linesw[tp->t_line].l_open)(device, tp);
943 1.49 cgd splx(s);
944 1.49 cgd return (error);
945 1.49 cgd }
946 1.49 cgd tp->t_line = t;
947 1.49 cgd splx(s);
948 1.49 cgd }
949 1.49 cgd break;
950 1.49 cgd }
951 1.49 cgd case TIOCSTART: /* start output, like ^Q */
952 1.49 cgd s = spltty();
953 1.49 cgd if (ISSET(tp->t_state, TS_TTSTOP) ||
954 1.49 cgd ISSET(tp->t_lflag, FLUSHO)) {
955 1.49 cgd CLR(tp->t_lflag, FLUSHO);
956 1.49 cgd CLR(tp->t_state, TS_TTSTOP);
957 1.49 cgd ttstart(tp);
958 1.49 cgd }
959 1.49 cgd splx(s);
960 1.49 cgd break;
961 1.49 cgd case TIOCSTI: /* simulate terminal input */
962 1.49 cgd if (p->p_ucred->cr_uid && (flag & FREAD) == 0)
963 1.49 cgd return (EPERM);
964 1.49 cgd if (p->p_ucred->cr_uid && !isctty(p, tp))
965 1.49 cgd return (EACCES);
966 1.49 cgd (*linesw[tp->t_line].l_rint)(*(u_char *)data, tp);
967 1.49 cgd break;
968 1.49 cgd case TIOCSTOP: /* stop output, like ^S */
969 1.49 cgd s = spltty();
970 1.49 cgd if (!ISSET(tp->t_state, TS_TTSTOP)) {
971 1.49 cgd SET(tp->t_state, TS_TTSTOP);
972 1.49 cgd (*cdevsw[major(tp->t_dev)].d_stop)(tp, 0);
973 1.49 cgd }
974 1.49 cgd splx(s);
975 1.49 cgd break;
976 1.49 cgd case TIOCSCTTY: /* become controlling tty */
977 1.49 cgd /* Session ctty vnode pointer set in vnode layer. */
978 1.49 cgd if (!SESS_LEADER(p) ||
979 1.65 christos ((p->p_session->s_ttyvp || tp->t_session) &&
980 1.65 christos (tp->t_session != p->p_session)))
981 1.49 cgd return (EPERM);
982 1.49 cgd tp->t_session = p->p_session;
983 1.49 cgd tp->t_pgrp = p->p_pgrp;
984 1.49 cgd p->p_session->s_ttyp = tp;
985 1.49 cgd p->p_flag |= P_CONTROLT;
986 1.49 cgd break;
987 1.49 cgd case TIOCSPGRP: { /* set pgrp of tty */
988 1.49 cgd register struct pgrp *pgrp = pgfind(*(int *)data);
989 1.49 cgd
990 1.49 cgd if (!isctty(p, tp))
991 1.49 cgd return (ENOTTY);
992 1.93 kleink else if (pgrp == NULL)
993 1.93 kleink return (EINVAL);
994 1.93 kleink else if (pgrp->pg_session != p->p_session)
995 1.49 cgd return (EPERM);
996 1.49 cgd tp->t_pgrp = pgrp;
997 1.49 cgd break;
998 1.49 cgd }
999 1.49 cgd case TIOCSTAT: /* get load avg stats */
1000 1.49 cgd ttyinfo(tp);
1001 1.49 cgd break;
1002 1.49 cgd case TIOCSWINSZ: /* set window size */
1003 1.109 perry if (memcmp((caddr_t)&tp->t_winsize, data,
1004 1.108 perry sizeof(struct winsize))) {
1005 1.49 cgd tp->t_winsize = *(struct winsize *)data;
1006 1.49 cgd pgsignal(tp->t_pgrp, SIGWINCH, 1);
1007 1.49 cgd }
1008 1.49 cgd break;
1009 1.49 cgd default:
1010 1.66 christos #ifdef COMPAT_OLDTTY
1011 1.49 cgd return (ttcompat(tp, cmd, data, flag, p));
1012 1.49 cgd #else
1013 1.49 cgd return (-1);
1014 1.49 cgd #endif
1015 1.49 cgd }
1016 1.49 cgd return (0);
1017 1.49 cgd }
1018 1.49 cgd
1019 1.49 cgd int
1020 1.74 mycroft ttpoll(dev, events, p)
1021 1.74 mycroft dev_t dev;
1022 1.74 mycroft int events;
1023 1.49 cgd struct proc *p;
1024 1.49 cgd {
1025 1.74 mycroft register struct tty *tp = (*cdevsw[major(dev)].d_tty)(dev);
1026 1.74 mycroft int revents = 0;
1027 1.74 mycroft int s = spltty();
1028 1.74 mycroft
1029 1.74 mycroft if (events & (POLLIN | POLLRDNORM))
1030 1.74 mycroft if (ttnread(tp) > 0)
1031 1.74 mycroft revents |= events & (POLLIN | POLLRDNORM);
1032 1.74 mycroft
1033 1.74 mycroft if (events & (POLLOUT | POLLWRNORM))
1034 1.74 mycroft if (tp->t_outq.c_cc <= tp->t_lowat)
1035 1.74 mycroft revents |= events & (POLLOUT | POLLWRNORM);
1036 1.74 mycroft
1037 1.74 mycroft if (events & POLLHUP)
1038 1.83 mycroft if (!CONNECTED(tp))
1039 1.74 mycroft revents |= POLLHUP;
1040 1.74 mycroft
1041 1.74 mycroft if (revents == 0) {
1042 1.74 mycroft if (events & (POLLIN | POLLHUP | POLLRDNORM))
1043 1.74 mycroft selrecord(p, &tp->t_rsel);
1044 1.49 cgd
1045 1.74 mycroft if (events & (POLLOUT | POLLWRNORM))
1046 1.74 mycroft selrecord(p, &tp->t_wsel);
1047 1.74 mycroft }
1048 1.49 cgd
1049 1.49 cgd splx(s);
1050 1.74 mycroft return (revents);
1051 1.49 cgd }
1052 1.49 cgd
1053 1.49 cgd static int
1054 1.49 cgd ttnread(tp)
1055 1.49 cgd struct tty *tp;
1056 1.49 cgd {
1057 1.49 cgd int nread;
1058 1.49 cgd
1059 1.49 cgd if (ISSET(tp->t_lflag, PENDIN))
1060 1.49 cgd ttypend(tp);
1061 1.49 cgd nread = tp->t_canq.c_cc;
1062 1.49 cgd if (!ISSET(tp->t_lflag, ICANON)) {
1063 1.49 cgd nread += tp->t_rawq.c_cc;
1064 1.49 cgd if (nread < tp->t_cc[VMIN] && !tp->t_cc[VTIME])
1065 1.49 cgd nread = 0;
1066 1.49 cgd }
1067 1.49 cgd return (nread);
1068 1.49 cgd }
1069 1.49 cgd
1070 1.49 cgd /*
1071 1.49 cgd * Wait for output to drain.
1072 1.49 cgd */
1073 1.49 cgd int
1074 1.49 cgd ttywait(tp)
1075 1.49 cgd register struct tty *tp;
1076 1.49 cgd {
1077 1.49 cgd int error, s;
1078 1.49 cgd
1079 1.49 cgd error = 0;
1080 1.49 cgd s = spltty();
1081 1.49 cgd while ((tp->t_outq.c_cc || ISSET(tp->t_state, TS_BUSY)) &&
1082 1.83 mycroft CONNECTED(tp) && tp->t_oproc) {
1083 1.49 cgd (*tp->t_oproc)(tp);
1084 1.49 cgd SET(tp->t_state, TS_ASLEEP);
1085 1.65 christos error = ttysleep(tp, &tp->t_outq, TTOPRI | PCATCH, ttyout, 0);
1086 1.65 christos if (error)
1087 1.49 cgd break;
1088 1.49 cgd }
1089 1.49 cgd splx(s);
1090 1.49 cgd return (error);
1091 1.49 cgd }
1092 1.49 cgd
1093 1.49 cgd /*
1094 1.49 cgd * Flush if successfully wait.
1095 1.49 cgd */
1096 1.49 cgd int
1097 1.49 cgd ttywflush(tp)
1098 1.49 cgd struct tty *tp;
1099 1.49 cgd {
1100 1.49 cgd int error;
1101 1.49 cgd
1102 1.49 cgd if ((error = ttywait(tp)) == 0)
1103 1.49 cgd ttyflush(tp, FREAD);
1104 1.49 cgd return (error);
1105 1.49 cgd }
1106 1.49 cgd
1107 1.49 cgd /*
1108 1.49 cgd * Flush tty read and/or write queues, notifying anyone waiting.
1109 1.49 cgd */
1110 1.49 cgd void
1111 1.49 cgd ttyflush(tp, rw)
1112 1.49 cgd register struct tty *tp;
1113 1.49 cgd int rw;
1114 1.49 cgd {
1115 1.49 cgd register int s;
1116 1.49 cgd
1117 1.49 cgd s = spltty();
1118 1.49 cgd if (rw & FREAD) {
1119 1.49 cgd FLUSHQ(&tp->t_canq);
1120 1.49 cgd FLUSHQ(&tp->t_rawq);
1121 1.49 cgd tp->t_rocount = 0;
1122 1.49 cgd tp->t_rocol = 0;
1123 1.49 cgd CLR(tp->t_state, TS_LOCAL);
1124 1.49 cgd ttwakeup(tp);
1125 1.49 cgd }
1126 1.49 cgd if (rw & FWRITE) {
1127 1.49 cgd CLR(tp->t_state, TS_TTSTOP);
1128 1.49 cgd (*cdevsw[major(tp->t_dev)].d_stop)(tp, rw);
1129 1.49 cgd FLUSHQ(&tp->t_outq);
1130 1.49 cgd wakeup((caddr_t)&tp->t_outq);
1131 1.49 cgd selwakeup(&tp->t_wsel);
1132 1.49 cgd }
1133 1.49 cgd splx(s);
1134 1.49 cgd }
1135 1.49 cgd
1136 1.49 cgd /*
1137 1.49 cgd * Copy in the default termios characters.
1138 1.49 cgd */
1139 1.49 cgd void
1140 1.49 cgd ttychars(tp)
1141 1.49 cgd struct tty *tp;
1142 1.49 cgd {
1143 1.49 cgd
1144 1.109 perry memcpy(tp->t_cc, ttydefchars, sizeof(ttydefchars));
1145 1.49 cgd }
1146 1.49 cgd
1147 1.49 cgd /*
1148 1.49 cgd * Send stop character on input overflow.
1149 1.49 cgd */
1150 1.49 cgd static void
1151 1.49 cgd ttyblock(tp)
1152 1.49 cgd register struct tty *tp;
1153 1.49 cgd {
1154 1.49 cgd register int total;
1155 1.49 cgd
1156 1.49 cgd total = tp->t_rawq.c_cc + tp->t_canq.c_cc;
1157 1.49 cgd if (tp->t_rawq.c_cc > TTYHOG) {
1158 1.49 cgd ttyflush(tp, FREAD | FWRITE);
1159 1.49 cgd CLR(tp->t_state, TS_TBLOCK);
1160 1.49 cgd }
1161 1.49 cgd /*
1162 1.49 cgd * Block further input iff: current input > threshold
1163 1.49 cgd * AND input is available to user program.
1164 1.49 cgd */
1165 1.101 drochner if (total >= TTYHOG / 2 &&
1166 1.101 drochner !ISSET(tp->t_state, TS_TBLOCK) &&
1167 1.101 drochner (!ISSET(tp->t_lflag, ICANON) || tp->t_canq.c_cc > 0)) {
1168 1.60 mycroft if (ISSET(tp->t_iflag, IXOFF) &&
1169 1.60 mycroft tp->t_cc[VSTOP] != _POSIX_VDISABLE &&
1170 1.60 mycroft putc(tp->t_cc[VSTOP], &tp->t_outq) == 0) {
1171 1.49 cgd SET(tp->t_state, TS_TBLOCK);
1172 1.49 cgd ttstart(tp);
1173 1.49 cgd }
1174 1.59 mycroft /* Try to block remote output via hardware flow control. */
1175 1.49 cgd if (ISSET(tp->t_cflag, CHWFLOW) && tp->t_hwiflow &&
1176 1.49 cgd (*tp->t_hwiflow)(tp, 1) != 0)
1177 1.49 cgd SET(tp->t_state, TS_TBLOCK);
1178 1.49 cgd }
1179 1.49 cgd }
1180 1.49 cgd
1181 1.49 cgd void
1182 1.49 cgd ttrstrt(tp_arg)
1183 1.49 cgd void *tp_arg;
1184 1.49 cgd {
1185 1.49 cgd struct tty *tp;
1186 1.49 cgd int s;
1187 1.49 cgd
1188 1.49 cgd #ifdef DIAGNOSTIC
1189 1.49 cgd if (tp_arg == NULL)
1190 1.49 cgd panic("ttrstrt");
1191 1.49 cgd #endif
1192 1.49 cgd tp = tp_arg;
1193 1.49 cgd s = spltty();
1194 1.49 cgd
1195 1.49 cgd CLR(tp->t_state, TS_TIMEOUT);
1196 1.49 cgd ttstart(tp);
1197 1.49 cgd
1198 1.49 cgd splx(s);
1199 1.49 cgd }
1200 1.49 cgd
1201 1.49 cgd int
1202 1.49 cgd ttstart(tp)
1203 1.49 cgd struct tty *tp;
1204 1.49 cgd {
1205 1.49 cgd
1206 1.49 cgd if (tp->t_oproc != NULL) /* XXX: Kludge for pty. */
1207 1.49 cgd (*tp->t_oproc)(tp);
1208 1.49 cgd return (0);
1209 1.49 cgd }
1210 1.49 cgd
1211 1.49 cgd /*
1212 1.49 cgd * "close" a line discipline
1213 1.49 cgd */
1214 1.49 cgd int
1215 1.49 cgd ttylclose(tp, flag)
1216 1.49 cgd struct tty *tp;
1217 1.49 cgd int flag;
1218 1.49 cgd {
1219 1.49 cgd
1220 1.61 mycroft if (flag & FNONBLOCK)
1221 1.49 cgd ttyflush(tp, FREAD | FWRITE);
1222 1.49 cgd else
1223 1.49 cgd ttywflush(tp);
1224 1.49 cgd return (0);
1225 1.49 cgd }
1226 1.49 cgd
1227 1.49 cgd /*
1228 1.49 cgd * Handle modem control transition on a tty.
1229 1.49 cgd * Flag indicates new state of carrier.
1230 1.49 cgd * Returns 0 if the line should be turned off, otherwise 1.
1231 1.49 cgd */
1232 1.49 cgd int
1233 1.49 cgd ttymodem(tp, flag)
1234 1.49 cgd register struct tty *tp;
1235 1.49 cgd int flag;
1236 1.49 cgd {
1237 1.49 cgd
1238 1.83 mycroft if (flag == 0) {
1239 1.96 kleink if (ISSET(tp->t_state, TS_CARR_ON)) {
1240 1.96 kleink /*
1241 1.96 kleink * Lost carrier.
1242 1.96 kleink */
1243 1.96 kleink CLR(tp->t_state, TS_CARR_ON);
1244 1.96 kleink if (ISSET(tp->t_state, TS_ISOPEN) && !CONNECTED(tp)) {
1245 1.96 kleink if (tp->t_session && tp->t_session->s_leader)
1246 1.96 kleink psignal(tp->t_session->s_leader, SIGHUP);
1247 1.96 kleink ttyflush(tp, FREAD | FWRITE);
1248 1.96 kleink return (0);
1249 1.96 kleink }
1250 1.49 cgd }
1251 1.49 cgd } else {
1252 1.96 kleink if (!ISSET(tp->t_state, TS_CARR_ON)) {
1253 1.96 kleink /*
1254 1.96 kleink * Carrier now on.
1255 1.96 kleink */
1256 1.96 kleink SET(tp->t_state, TS_CARR_ON);
1257 1.96 kleink ttwakeup(tp);
1258 1.96 kleink }
1259 1.49 cgd }
1260 1.49 cgd return (1);
1261 1.49 cgd }
1262 1.49 cgd
1263 1.49 cgd /*
1264 1.49 cgd * Default modem control routine (for other line disciplines).
1265 1.49 cgd * Return argument flag, to turn off device on carrier drop.
1266 1.49 cgd */
1267 1.49 cgd int
1268 1.49 cgd nullmodem(tp, flag)
1269 1.49 cgd register struct tty *tp;
1270 1.49 cgd int flag;
1271 1.49 cgd {
1272 1.49 cgd
1273 1.49 cgd if (flag)
1274 1.49 cgd SET(tp->t_state, TS_CARR_ON);
1275 1.49 cgd else {
1276 1.49 cgd CLR(tp->t_state, TS_CARR_ON);
1277 1.83 mycroft if (!CONNECTED(tp)) {
1278 1.49 cgd if (tp->t_session && tp->t_session->s_leader)
1279 1.49 cgd psignal(tp->t_session->s_leader, SIGHUP);
1280 1.49 cgd return (0);
1281 1.49 cgd }
1282 1.49 cgd }
1283 1.49 cgd return (1);
1284 1.49 cgd }
1285 1.49 cgd
1286 1.49 cgd /*
1287 1.49 cgd * Reinput pending characters after state switch
1288 1.49 cgd * call at spltty().
1289 1.49 cgd */
1290 1.49 cgd void
1291 1.49 cgd ttypend(tp)
1292 1.49 cgd register struct tty *tp;
1293 1.49 cgd {
1294 1.49 cgd struct clist tq;
1295 1.102 kleink register int c;
1296 1.49 cgd
1297 1.49 cgd CLR(tp->t_lflag, PENDIN);
1298 1.49 cgd SET(tp->t_state, TS_TYPEN);
1299 1.49 cgd tq = tp->t_rawq;
1300 1.49 cgd tp->t_rawq.c_cc = 0;
1301 1.49 cgd tp->t_rawq.c_cf = tp->t_rawq.c_cl = 0;
1302 1.49 cgd while ((c = getc(&tq)) >= 0)
1303 1.49 cgd ttyinput(c, tp);
1304 1.49 cgd CLR(tp->t_state, TS_TYPEN);
1305 1.49 cgd }
1306 1.49 cgd
1307 1.49 cgd /*
1308 1.49 cgd * Process a read call on a tty device.
1309 1.49 cgd */
1310 1.49 cgd int
1311 1.49 cgd ttread(tp, uio, flag)
1312 1.49 cgd register struct tty *tp;
1313 1.49 cgd struct uio *uio;
1314 1.49 cgd int flag;
1315 1.49 cgd {
1316 1.49 cgd register struct clist *qp;
1317 1.49 cgd register int c;
1318 1.49 cgd register long lflag;
1319 1.49 cgd register u_char *cc = tp->t_cc;
1320 1.49 cgd register struct proc *p = curproc;
1321 1.49 cgd int s, first, error = 0;
1322 1.49 cgd struct timeval stime;
1323 1.65 christos int has_stime = 0, last_cc = 0;
1324 1.49 cgd long slp = 0;
1325 1.49 cgd
1326 1.49 cgd loop: lflag = tp->t_lflag;
1327 1.49 cgd s = spltty();
1328 1.49 cgd /*
1329 1.49 cgd * take pending input first
1330 1.49 cgd */
1331 1.49 cgd if (ISSET(lflag, PENDIN))
1332 1.49 cgd ttypend(tp);
1333 1.49 cgd splx(s);
1334 1.49 cgd
1335 1.49 cgd /*
1336 1.49 cgd * Hang process if it's in the background.
1337 1.49 cgd */
1338 1.49 cgd if (isbackground(p, tp)) {
1339 1.112 mycroft if (sigismember(&p->p_sigignore, SIGTTIN) ||
1340 1.112 mycroft sigismember(&p->p_sigmask, SIGTTIN) ||
1341 1.49 cgd p->p_flag & P_PPWAIT || p->p_pgrp->pg_jobc == 0)
1342 1.49 cgd return (EIO);
1343 1.49 cgd pgsignal(p->p_pgrp, SIGTTIN, 1);
1344 1.65 christos error = ttysleep(tp, &lbolt, TTIPRI | PCATCH, ttybg, 0);
1345 1.65 christos if (error)
1346 1.49 cgd return (error);
1347 1.49 cgd goto loop;
1348 1.49 cgd }
1349 1.49 cgd
1350 1.49 cgd s = spltty();
1351 1.49 cgd if (!ISSET(lflag, ICANON)) {
1352 1.49 cgd int m = cc[VMIN];
1353 1.49 cgd long t = cc[VTIME];
1354 1.49 cgd
1355 1.49 cgd qp = &tp->t_rawq;
1356 1.49 cgd /*
1357 1.49 cgd * Check each of the four combinations.
1358 1.49 cgd * (m > 0 && t == 0) is the normal read case.
1359 1.49 cgd * It should be fairly efficient, so we check that and its
1360 1.49 cgd * companion case (m == 0 && t == 0) first.
1361 1.49 cgd * For the other two cases, we compute the target sleep time
1362 1.49 cgd * into slp.
1363 1.49 cgd */
1364 1.49 cgd if (t == 0) {
1365 1.49 cgd if (qp->c_cc < m)
1366 1.49 cgd goto sleep;
1367 1.49 cgd goto read;
1368 1.49 cgd }
1369 1.49 cgd t *= 100000; /* time in us */
1370 1.49 cgd #define diff(t1, t2) (((t1).tv_sec - (t2).tv_sec) * 1000000 + \
1371 1.49 cgd ((t1).tv_usec - (t2).tv_usec))
1372 1.49 cgd if (m > 0) {
1373 1.49 cgd if (qp->c_cc <= 0)
1374 1.49 cgd goto sleep;
1375 1.49 cgd if (qp->c_cc >= m)
1376 1.49 cgd goto read;
1377 1.49 cgd if (!has_stime) {
1378 1.49 cgd /* first character, start timer */
1379 1.49 cgd has_stime = 1;
1380 1.49 cgd stime = time;
1381 1.49 cgd slp = t;
1382 1.49 cgd } else if (qp->c_cc > last_cc) {
1383 1.49 cgd /* got a character, restart timer */
1384 1.49 cgd stime = time;
1385 1.49 cgd slp = t;
1386 1.49 cgd } else {
1387 1.49 cgd /* nothing, check expiration */
1388 1.49 cgd slp = t - diff(time, stime);
1389 1.49 cgd }
1390 1.49 cgd } else { /* m == 0 */
1391 1.49 cgd if (qp->c_cc > 0)
1392 1.49 cgd goto read;
1393 1.49 cgd if (!has_stime) {
1394 1.49 cgd has_stime = 1;
1395 1.49 cgd stime = time;
1396 1.49 cgd slp = t;
1397 1.49 cgd } else
1398 1.49 cgd slp = t - diff(time, stime);
1399 1.49 cgd }
1400 1.54 mycroft last_cc = qp->c_cc;
1401 1.49 cgd #undef diff
1402 1.49 cgd if (slp > 0) {
1403 1.49 cgd /*
1404 1.49 cgd * Rounding down may make us wake up just short
1405 1.49 cgd * of the target, so we round up.
1406 1.49 cgd * The formula is ceiling(slp * hz/1000000).
1407 1.49 cgd * 32-bit arithmetic is enough for hz < 169.
1408 1.49 cgd *
1409 1.49 cgd * Also, use plain wakeup() not ttwakeup().
1410 1.49 cgd */
1411 1.49 cgd slp = (long) (((u_long)slp * hz) + 999999) / 1000000;
1412 1.49 cgd goto sleep;
1413 1.49 cgd }
1414 1.49 cgd } else if ((qp = &tp->t_canq)->c_cc <= 0) {
1415 1.49 cgd int carrier;
1416 1.49 cgd
1417 1.49 cgd sleep:
1418 1.49 cgd /*
1419 1.49 cgd * If there is no input, sleep on rawq
1420 1.49 cgd * awaiting hardware receipt and notification.
1421 1.49 cgd * If we have data, we don't need to check for carrier.
1422 1.49 cgd */
1423 1.83 mycroft carrier = CONNECTED(tp);
1424 1.49 cgd if (!carrier && ISSET(tp->t_state, TS_ISOPEN)) {
1425 1.49 cgd splx(s);
1426 1.49 cgd return (0); /* EOF */
1427 1.49 cgd }
1428 1.49 cgd if (flag & IO_NDELAY) {
1429 1.49 cgd splx(s);
1430 1.49 cgd return (EWOULDBLOCK);
1431 1.49 cgd }
1432 1.49 cgd error = ttysleep(tp, &tp->t_rawq, TTIPRI | PCATCH,
1433 1.53 mycroft carrier ? ttyin : ttopen, slp);
1434 1.49 cgd splx(s);
1435 1.82 kleink /* VMIN == 0: any quantity read satisfies */
1436 1.82 kleink if (cc[VMIN] == 0 && error == EWOULDBLOCK)
1437 1.82 kleink return (0);
1438 1.54 mycroft if (error && error != EWOULDBLOCK)
1439 1.49 cgd return (error);
1440 1.49 cgd goto loop;
1441 1.49 cgd }
1442 1.49 cgd read:
1443 1.49 cgd splx(s);
1444 1.49 cgd
1445 1.49 cgd /*
1446 1.49 cgd * Input present, check for input mapping and processing.
1447 1.49 cgd */
1448 1.49 cgd first = 1;
1449 1.49 cgd while ((c = getc(qp)) >= 0) {
1450 1.49 cgd /*
1451 1.49 cgd * delayed suspend (^Y)
1452 1.49 cgd */
1453 1.81 kleink if (CCEQ(cc[VDSUSP], c) &&
1454 1.81 kleink ISSET(lflag, IEXTEN|ISIG) == (IEXTEN|ISIG)) {
1455 1.49 cgd pgsignal(tp->t_pgrp, SIGTSTP, 1);
1456 1.49 cgd if (first) {
1457 1.65 christos error = ttysleep(tp, &lbolt,
1458 1.65 christos TTIPRI | PCATCH, ttybg, 0);
1459 1.65 christos if (error)
1460 1.49 cgd break;
1461 1.49 cgd goto loop;
1462 1.49 cgd }
1463 1.49 cgd break;
1464 1.49 cgd }
1465 1.49 cgd /*
1466 1.49 cgd * Interpret EOF only in canonical mode.
1467 1.49 cgd */
1468 1.49 cgd if (CCEQ(cc[VEOF], c) && ISSET(lflag, ICANON))
1469 1.49 cgd break;
1470 1.49 cgd /*
1471 1.49 cgd * Give user character.
1472 1.49 cgd */
1473 1.49 cgd error = ureadc(c, uio);
1474 1.49 cgd if (error)
1475 1.49 cgd break;
1476 1.49 cgd if (uio->uio_resid == 0)
1477 1.49 cgd break;
1478 1.49 cgd /*
1479 1.49 cgd * In canonical mode check for a "break character"
1480 1.49 cgd * marking the end of a "line of input".
1481 1.49 cgd */
1482 1.85 kleink if (ISSET(lflag, ICANON) && TTBREAKC(c, lflag))
1483 1.49 cgd break;
1484 1.49 cgd first = 0;
1485 1.49 cgd }
1486 1.49 cgd /*
1487 1.49 cgd * Look to unblock output now that (presumably)
1488 1.49 cgd * the input queue has gone down.
1489 1.49 cgd */
1490 1.49 cgd s = spltty();
1491 1.49 cgd if (ISSET(tp->t_state, TS_TBLOCK) && tp->t_rawq.c_cc < TTYHOG/5) {
1492 1.60 mycroft if (ISSET(tp->t_iflag, IXOFF) &&
1493 1.60 mycroft cc[VSTART] != _POSIX_VDISABLE &&
1494 1.49 cgd putc(cc[VSTART], &tp->t_outq) == 0) {
1495 1.49 cgd CLR(tp->t_state, TS_TBLOCK);
1496 1.49 cgd ttstart(tp);
1497 1.49 cgd }
1498 1.59 mycroft /* Try to unblock remote output via hardware flow control. */
1499 1.59 mycroft if (ISSET(tp->t_cflag, CHWFLOW) && tp->t_hwiflow &&
1500 1.49 cgd (*tp->t_hwiflow)(tp, 0) != 0)
1501 1.59 mycroft CLR(tp->t_state, TS_TBLOCK);
1502 1.49 cgd }
1503 1.49 cgd splx(s);
1504 1.49 cgd return (error);
1505 1.49 cgd }
1506 1.49 cgd
1507 1.49 cgd /*
1508 1.49 cgd * Check the output queue on tp for space for a kernel message (from uprintf
1509 1.49 cgd * or tprintf). Allow some space over the normal hiwater mark so we don't
1510 1.49 cgd * lose messages due to normal flow control, but don't let the tty run amok.
1511 1.49 cgd * Sleeps here are not interruptible, but we return prematurely if new signals
1512 1.49 cgd * arrive.
1513 1.49 cgd */
1514 1.49 cgd int
1515 1.49 cgd ttycheckoutq(tp, wait)
1516 1.49 cgd register struct tty *tp;
1517 1.49 cgd int wait;
1518 1.49 cgd {
1519 1.112 mycroft int hiwat, s;
1520 1.112 mycroft int error;
1521 1.49 cgd
1522 1.49 cgd hiwat = tp->t_hiwat;
1523 1.49 cgd s = spltty();
1524 1.49 cgd if (tp->t_outq.c_cc > hiwat + 200)
1525 1.49 cgd while (tp->t_outq.c_cc > hiwat) {
1526 1.49 cgd ttstart(tp);
1527 1.112 mycroft if (wait == 0) {
1528 1.49 cgd splx(s);
1529 1.49 cgd return (0);
1530 1.49 cgd }
1531 1.116 thorpej callout_reset(&tp->t_outq_ch, hz,
1532 1.116 thorpej (void (*)__P((void *)))wakeup, &tp->t_outq);
1533 1.49 cgd SET(tp->t_state, TS_ASLEEP);
1534 1.112 mycroft error = tsleep(&tp->t_outq, (PZERO - 1) | PCATCH,
1535 1.112 mycroft "ttckoutq", 0);
1536 1.112 mycroft if (error == EINTR)
1537 1.112 mycroft wait = 0;
1538 1.49 cgd }
1539 1.49 cgd splx(s);
1540 1.49 cgd return (1);
1541 1.49 cgd }
1542 1.49 cgd
1543 1.49 cgd /*
1544 1.49 cgd * Process a write call on a tty device.
1545 1.49 cgd */
1546 1.49 cgd int
1547 1.49 cgd ttwrite(tp, uio, flag)
1548 1.49 cgd register struct tty *tp;
1549 1.49 cgd register struct uio *uio;
1550 1.49 cgd int flag;
1551 1.49 cgd {
1552 1.65 christos register u_char *cp = NULL;
1553 1.49 cgd register int cc, ce;
1554 1.49 cgd register struct proc *p;
1555 1.49 cgd int i, hiwat, cnt, error, s;
1556 1.49 cgd u_char obuf[OBUFSIZ];
1557 1.49 cgd
1558 1.49 cgd hiwat = tp->t_hiwat;
1559 1.49 cgd cnt = uio->uio_resid;
1560 1.49 cgd error = 0;
1561 1.49 cgd cc = 0;
1562 1.49 cgd loop:
1563 1.49 cgd s = spltty();
1564 1.83 mycroft if (!CONNECTED(tp)) {
1565 1.49 cgd if (ISSET(tp->t_state, TS_ISOPEN)) {
1566 1.49 cgd splx(s);
1567 1.49 cgd return (EIO);
1568 1.49 cgd } else if (flag & IO_NDELAY) {
1569 1.49 cgd splx(s);
1570 1.49 cgd error = EWOULDBLOCK;
1571 1.49 cgd goto out;
1572 1.49 cgd } else {
1573 1.49 cgd /* Sleep awaiting carrier. */
1574 1.49 cgd error = ttysleep(tp,
1575 1.49 cgd &tp->t_rawq, TTIPRI | PCATCH, ttopen, 0);
1576 1.49 cgd splx(s);
1577 1.49 cgd if (error)
1578 1.49 cgd goto out;
1579 1.49 cgd goto loop;
1580 1.49 cgd }
1581 1.49 cgd }
1582 1.49 cgd splx(s);
1583 1.49 cgd /*
1584 1.49 cgd * Hang the process if it's in the background.
1585 1.49 cgd */
1586 1.49 cgd p = curproc;
1587 1.49 cgd if (isbackground(p, tp) &&
1588 1.49 cgd ISSET(tp->t_lflag, TOSTOP) && (p->p_flag & P_PPWAIT) == 0 &&
1589 1.112 mycroft !sigismember(&p->p_sigignore, SIGTTOU) &&
1590 1.112 mycroft !sigismember(&p->p_sigmask, SIGTTOU)) {
1591 1.86 kleink if (p->p_pgrp->pg_jobc == 0) {
1592 1.86 kleink error = EIO;
1593 1.86 kleink goto out;
1594 1.86 kleink }
1595 1.49 cgd pgsignal(p->p_pgrp, SIGTTOU, 1);
1596 1.65 christos error = ttysleep(tp, &lbolt, TTIPRI | PCATCH, ttybg, 0);
1597 1.65 christos if (error)
1598 1.49 cgd goto out;
1599 1.49 cgd goto loop;
1600 1.49 cgd }
1601 1.49 cgd /*
1602 1.49 cgd * Process the user's data in at most OBUFSIZ chunks. Perform any
1603 1.49 cgd * output translation. Keep track of high water mark, sleep on
1604 1.49 cgd * overflow awaiting device aid in acquiring new space.
1605 1.49 cgd */
1606 1.49 cgd while (uio->uio_resid > 0 || cc > 0) {
1607 1.49 cgd if (ISSET(tp->t_lflag, FLUSHO)) {
1608 1.49 cgd uio->uio_resid = 0;
1609 1.49 cgd return (0);
1610 1.49 cgd }
1611 1.49 cgd if (tp->t_outq.c_cc > hiwat)
1612 1.49 cgd goto ovhiwat;
1613 1.49 cgd /*
1614 1.49 cgd * Grab a hunk of data from the user, unless we have some
1615 1.49 cgd * leftover from last time.
1616 1.49 cgd */
1617 1.49 cgd if (cc == 0) {
1618 1.49 cgd cc = min(uio->uio_resid, OBUFSIZ);
1619 1.49 cgd cp = obuf;
1620 1.49 cgd error = uiomove(cp, cc, uio);
1621 1.49 cgd if (error) {
1622 1.49 cgd cc = 0;
1623 1.49 cgd break;
1624 1.49 cgd }
1625 1.49 cgd }
1626 1.49 cgd /*
1627 1.49 cgd * If nothing fancy need be done, grab those characters we
1628 1.49 cgd * can handle without any of ttyoutput's processing and
1629 1.49 cgd * just transfer them to the output q. For those chars
1630 1.49 cgd * which require special processing (as indicated by the
1631 1.49 cgd * bits in char_type), call ttyoutput. After processing
1632 1.49 cgd * a hunk of data, look for FLUSHO so ^O's will take effect
1633 1.49 cgd * immediately.
1634 1.49 cgd */
1635 1.49 cgd while (cc > 0) {
1636 1.49 cgd if (!ISSET(tp->t_oflag, OPOST))
1637 1.49 cgd ce = cc;
1638 1.49 cgd else {
1639 1.77 cgd ce = cc - scanc((u_int)cc, cp, char_type,
1640 1.77 cgd CCLASSMASK);
1641 1.49 cgd /*
1642 1.49 cgd * If ce is zero, then we're processing
1643 1.49 cgd * a special character through ttyoutput.
1644 1.49 cgd */
1645 1.49 cgd if (ce == 0) {
1646 1.49 cgd tp->t_rocount = 0;
1647 1.49 cgd if (ttyoutput(*cp, tp) >= 0) {
1648 1.49 cgd /* out of space */
1649 1.49 cgd goto overfull;
1650 1.49 cgd }
1651 1.49 cgd cp++;
1652 1.49 cgd cc--;
1653 1.49 cgd if (ISSET(tp->t_lflag, FLUSHO) ||
1654 1.49 cgd tp->t_outq.c_cc > hiwat)
1655 1.49 cgd goto ovhiwat;
1656 1.49 cgd continue;
1657 1.49 cgd }
1658 1.49 cgd }
1659 1.49 cgd /*
1660 1.49 cgd * A bunch of normal characters have been found.
1661 1.49 cgd * Transfer them en masse to the output queue and
1662 1.49 cgd * continue processing at the top of the loop.
1663 1.49 cgd * If there are any further characters in this
1664 1.49 cgd * <= OBUFSIZ chunk, the first should be a character
1665 1.49 cgd * requiring special handling by ttyoutput.
1666 1.49 cgd */
1667 1.49 cgd tp->t_rocount = 0;
1668 1.49 cgd i = b_to_q(cp, ce, &tp->t_outq);
1669 1.49 cgd ce -= i;
1670 1.49 cgd tp->t_column += ce;
1671 1.49 cgd cp += ce, cc -= ce, tk_nout += ce;
1672 1.49 cgd tp->t_outcc += ce;
1673 1.49 cgd if (i > 0) {
1674 1.49 cgd /* out of space */
1675 1.49 cgd goto overfull;
1676 1.49 cgd }
1677 1.49 cgd if (ISSET(tp->t_lflag, FLUSHO) ||
1678 1.49 cgd tp->t_outq.c_cc > hiwat)
1679 1.49 cgd break;
1680 1.49 cgd }
1681 1.49 cgd ttstart(tp);
1682 1.49 cgd }
1683 1.49 cgd out:
1684 1.49 cgd /*
1685 1.49 cgd * If cc is nonzero, we leave the uio structure inconsistent, as the
1686 1.49 cgd * offset and iov pointers have moved forward, but it doesn't matter
1687 1.49 cgd * (the call will either return short or restart with a new uio).
1688 1.49 cgd */
1689 1.49 cgd uio->uio_resid += cc;
1690 1.49 cgd return (error);
1691 1.49 cgd
1692 1.49 cgd overfull:
1693 1.49 cgd /*
1694 1.49 cgd * Since we are using ring buffers, if we can't insert any more into
1695 1.49 cgd * the output queue, we can assume the ring is full and that someone
1696 1.49 cgd * forgot to set the high water mark correctly. We set it and then
1697 1.49 cgd * proceed as normal.
1698 1.49 cgd */
1699 1.49 cgd hiwat = tp->t_outq.c_cc - 1;
1700 1.49 cgd
1701 1.49 cgd ovhiwat:
1702 1.49 cgd ttstart(tp);
1703 1.49 cgd s = spltty();
1704 1.49 cgd /*
1705 1.49 cgd * This can only occur if FLUSHO is set in t_lflag,
1706 1.49 cgd * or if ttstart/oproc is synchronous (or very fast).
1707 1.49 cgd */
1708 1.49 cgd if (tp->t_outq.c_cc <= hiwat) {
1709 1.49 cgd splx(s);
1710 1.49 cgd goto loop;
1711 1.49 cgd }
1712 1.49 cgd if (flag & IO_NDELAY) {
1713 1.49 cgd splx(s);
1714 1.49 cgd uio->uio_resid += cc;
1715 1.49 cgd return (uio->uio_resid == cnt ? EWOULDBLOCK : 0);
1716 1.49 cgd }
1717 1.49 cgd SET(tp->t_state, TS_ASLEEP);
1718 1.49 cgd error = ttysleep(tp, &tp->t_outq, TTOPRI | PCATCH, ttyout, 0);
1719 1.49 cgd splx(s);
1720 1.49 cgd if (error)
1721 1.49 cgd goto out;
1722 1.49 cgd goto loop;
1723 1.49 cgd }
1724 1.49 cgd
1725 1.49 cgd /*
1726 1.49 cgd * Rubout one character from the rawq of tp
1727 1.49 cgd * as cleanly as possible.
1728 1.49 cgd */
1729 1.49 cgd void
1730 1.49 cgd ttyrub(c, tp)
1731 1.49 cgd int c;
1732 1.49 cgd register struct tty *tp;
1733 1.49 cgd {
1734 1.49 cgd register u_char *cp;
1735 1.49 cgd register int savecol;
1736 1.49 cgd int tabc, s;
1737 1.49 cgd
1738 1.49 cgd if (!ISSET(tp->t_lflag, ECHO) || ISSET(tp->t_lflag, EXTPROC))
1739 1.49 cgd return;
1740 1.49 cgd CLR(tp->t_lflag, FLUSHO);
1741 1.49 cgd if (ISSET(tp->t_lflag, ECHOE)) {
1742 1.49 cgd if (tp->t_rocount == 0) {
1743 1.49 cgd /*
1744 1.49 cgd * Screwed by ttwrite; retype
1745 1.49 cgd */
1746 1.49 cgd ttyretype(tp);
1747 1.49 cgd return;
1748 1.49 cgd }
1749 1.49 cgd if (c == ('\t' | TTY_QUOTE) || c == ('\n' | TTY_QUOTE))
1750 1.49 cgd ttyrubo(tp, 2);
1751 1.49 cgd else {
1752 1.49 cgd CLR(c, ~TTY_CHARMASK);
1753 1.49 cgd switch (CCLASS(c)) {
1754 1.49 cgd case ORDINARY:
1755 1.49 cgd ttyrubo(tp, 1);
1756 1.49 cgd break;
1757 1.49 cgd case BACKSPACE:
1758 1.49 cgd case CONTROL:
1759 1.49 cgd case NEWLINE:
1760 1.49 cgd case RETURN:
1761 1.49 cgd case VTAB:
1762 1.49 cgd if (ISSET(tp->t_lflag, ECHOCTL))
1763 1.49 cgd ttyrubo(tp, 2);
1764 1.49 cgd break;
1765 1.49 cgd case TAB:
1766 1.49 cgd if (tp->t_rocount < tp->t_rawq.c_cc) {
1767 1.49 cgd ttyretype(tp);
1768 1.49 cgd return;
1769 1.49 cgd }
1770 1.49 cgd s = spltty();
1771 1.49 cgd savecol = tp->t_column;
1772 1.49 cgd SET(tp->t_state, TS_CNTTB);
1773 1.49 cgd SET(tp->t_lflag, FLUSHO);
1774 1.49 cgd tp->t_column = tp->t_rocol;
1775 1.52 deraadt for (cp = firstc(&tp->t_rawq, &tabc); cp;
1776 1.49 cgd cp = nextc(&tp->t_rawq, cp, &tabc))
1777 1.49 cgd ttyecho(tabc, tp);
1778 1.49 cgd CLR(tp->t_lflag, FLUSHO);
1779 1.49 cgd CLR(tp->t_state, TS_CNTTB);
1780 1.49 cgd splx(s);
1781 1.49 cgd
1782 1.49 cgd /* savecol will now be length of the tab. */
1783 1.49 cgd savecol -= tp->t_column;
1784 1.49 cgd tp->t_column += savecol;
1785 1.49 cgd if (savecol > 8)
1786 1.49 cgd savecol = 8; /* overflow screw */
1787 1.49 cgd while (--savecol >= 0)
1788 1.49 cgd (void)ttyoutput('\b', tp);
1789 1.49 cgd break;
1790 1.49 cgd default: /* XXX */
1791 1.49 cgd #define PANICSTR "ttyrub: would panic c = %d, val = %d\n"
1792 1.76 christos (void)printf(PANICSTR, c, CCLASS(c));
1793 1.49 cgd #ifdef notdef
1794 1.49 cgd panic(PANICSTR, c, CCLASS(c));
1795 1.49 cgd #endif
1796 1.49 cgd }
1797 1.49 cgd }
1798 1.49 cgd } else if (ISSET(tp->t_lflag, ECHOPRT)) {
1799 1.49 cgd if (!ISSET(tp->t_state, TS_ERASE)) {
1800 1.49 cgd SET(tp->t_state, TS_ERASE);
1801 1.49 cgd (void)ttyoutput('\\', tp);
1802 1.49 cgd }
1803 1.49 cgd ttyecho(c, tp);
1804 1.49 cgd } else
1805 1.49 cgd ttyecho(tp->t_cc[VERASE], tp);
1806 1.49 cgd --tp->t_rocount;
1807 1.49 cgd }
1808 1.49 cgd
1809 1.49 cgd /*
1810 1.49 cgd * Back over cnt characters, erasing them.
1811 1.49 cgd */
1812 1.49 cgd static void
1813 1.49 cgd ttyrubo(tp, cnt)
1814 1.49 cgd register struct tty *tp;
1815 1.49 cgd int cnt;
1816 1.49 cgd {
1817 1.49 cgd
1818 1.49 cgd while (cnt-- > 0) {
1819 1.49 cgd (void)ttyoutput('\b', tp);
1820 1.49 cgd (void)ttyoutput(' ', tp);
1821 1.49 cgd (void)ttyoutput('\b', tp);
1822 1.49 cgd }
1823 1.49 cgd }
1824 1.49 cgd
1825 1.49 cgd /*
1826 1.49 cgd * ttyretype --
1827 1.49 cgd * Reprint the rawq line. Note, it is assumed that c_cc has already
1828 1.49 cgd * been checked.
1829 1.49 cgd */
1830 1.49 cgd void
1831 1.49 cgd ttyretype(tp)
1832 1.49 cgd register struct tty *tp;
1833 1.49 cgd {
1834 1.49 cgd register u_char *cp;
1835 1.49 cgd int s, c;
1836 1.49 cgd
1837 1.49 cgd /* Echo the reprint character. */
1838 1.49 cgd if (tp->t_cc[VREPRINT] != _POSIX_VDISABLE)
1839 1.49 cgd ttyecho(tp->t_cc[VREPRINT], tp);
1840 1.49 cgd
1841 1.49 cgd (void)ttyoutput('\n', tp);
1842 1.49 cgd
1843 1.49 cgd s = spltty();
1844 1.49 cgd for (cp = firstc(&tp->t_canq, &c); cp; cp = nextc(&tp->t_canq, cp, &c))
1845 1.49 cgd ttyecho(c, tp);
1846 1.49 cgd for (cp = firstc(&tp->t_rawq, &c); cp; cp = nextc(&tp->t_rawq, cp, &c))
1847 1.49 cgd ttyecho(c, tp);
1848 1.49 cgd CLR(tp->t_state, TS_ERASE);
1849 1.49 cgd splx(s);
1850 1.49 cgd
1851 1.49 cgd tp->t_rocount = tp->t_rawq.c_cc;
1852 1.49 cgd tp->t_rocol = 0;
1853 1.49 cgd }
1854 1.49 cgd
1855 1.49 cgd /*
1856 1.49 cgd * Echo a typed character to the terminal.
1857 1.49 cgd */
1858 1.49 cgd static void
1859 1.49 cgd ttyecho(c, tp)
1860 1.49 cgd register int c;
1861 1.49 cgd register struct tty *tp;
1862 1.49 cgd {
1863 1.49 cgd
1864 1.49 cgd if (!ISSET(tp->t_state, TS_CNTTB))
1865 1.49 cgd CLR(tp->t_lflag, FLUSHO);
1866 1.49 cgd if ((!ISSET(tp->t_lflag, ECHO) &&
1867 1.64 pk (!ISSET(tp->t_lflag, ECHONL) || c != '\n')) ||
1868 1.49 cgd ISSET(tp->t_lflag, EXTPROC))
1869 1.49 cgd return;
1870 1.65 christos if (((ISSET(tp->t_lflag, ECHOCTL) &&
1871 1.65 christos (ISSET(c, TTY_CHARMASK) <= 037 && c != '\t' && c != '\n')) ||
1872 1.49 cgd ISSET(c, TTY_CHARMASK) == 0177)) {
1873 1.49 cgd (void)ttyoutput('^', tp);
1874 1.49 cgd CLR(c, ~TTY_CHARMASK);
1875 1.49 cgd if (c == 0177)
1876 1.49 cgd c = '?';
1877 1.49 cgd else
1878 1.49 cgd c += 'A' - 1;
1879 1.49 cgd }
1880 1.49 cgd (void)ttyoutput(c, tp);
1881 1.49 cgd }
1882 1.49 cgd
1883 1.49 cgd /*
1884 1.49 cgd * Wake up any readers on a tty.
1885 1.49 cgd */
1886 1.49 cgd void
1887 1.49 cgd ttwakeup(tp)
1888 1.49 cgd register struct tty *tp;
1889 1.49 cgd {
1890 1.49 cgd
1891 1.49 cgd selwakeup(&tp->t_rsel);
1892 1.49 cgd if (ISSET(tp->t_state, TS_ASYNC))
1893 1.49 cgd pgsignal(tp->t_pgrp, SIGIO, 1);
1894 1.49 cgd wakeup((caddr_t)&tp->t_rawq);
1895 1.49 cgd }
1896 1.49 cgd
1897 1.49 cgd /*
1898 1.49 cgd * Look up a code for a specified speed in a conversion table;
1899 1.49 cgd * used by drivers to map software speed values to hardware parameters.
1900 1.49 cgd */
1901 1.49 cgd int
1902 1.49 cgd ttspeedtab(speed, table)
1903 1.49 cgd int speed;
1904 1.49 cgd register struct speedtab *table;
1905 1.49 cgd {
1906 1.49 cgd
1907 1.49 cgd for ( ; table->sp_speed != -1; table++)
1908 1.49 cgd if (table->sp_speed == speed)
1909 1.49 cgd return (table->sp_code);
1910 1.49 cgd return (-1);
1911 1.49 cgd }
1912 1.49 cgd
1913 1.49 cgd /*
1914 1.49 cgd * Set tty hi and low water marks.
1915 1.49 cgd *
1916 1.49 cgd * Try to arrange the dynamics so there's about one second
1917 1.49 cgd * from hi to low water.
1918 1.49 cgd */
1919 1.49 cgd void
1920 1.49 cgd ttsetwater(tp)
1921 1.49 cgd struct tty *tp;
1922 1.49 cgd {
1923 1.49 cgd register int cps, x;
1924 1.49 cgd
1925 1.49 cgd #define CLAMP(x, h, l) ((x) > h ? h : ((x) < l) ? l : (x))
1926 1.49 cgd
1927 1.49 cgd cps = tp->t_ospeed / 10;
1928 1.49 cgd tp->t_lowat = x = CLAMP(cps / 2, TTMAXLOWAT, TTMINLOWAT);
1929 1.49 cgd x += cps;
1930 1.49 cgd x = CLAMP(x, TTMAXHIWAT, TTMINHIWAT);
1931 1.49 cgd tp->t_hiwat = roundup(x, CBSIZE);
1932 1.49 cgd #undef CLAMP
1933 1.49 cgd }
1934 1.49 cgd
1935 1.49 cgd /*
1936 1.49 cgd * Report on state of foreground process group.
1937 1.49 cgd */
1938 1.49 cgd void
1939 1.49 cgd ttyinfo(tp)
1940 1.49 cgd register struct tty *tp;
1941 1.49 cgd {
1942 1.49 cgd register struct proc *p, *pick;
1943 1.49 cgd struct timeval utime, stime;
1944 1.49 cgd int tmp;
1945 1.49 cgd
1946 1.49 cgd if (ttycheckoutq(tp,0) == 0)
1947 1.49 cgd return;
1948 1.49 cgd
1949 1.49 cgd /* Print load average. */
1950 1.49 cgd tmp = (averunnable.ldavg[0] * 100 + FSCALE / 2) >> FSHIFT;
1951 1.49 cgd ttyprintf(tp, "load: %d.%02d ", tmp / 100, tmp % 100);
1952 1.49 cgd
1953 1.49 cgd if (tp->t_session == NULL)
1954 1.49 cgd ttyprintf(tp, "not a controlling terminal\n");
1955 1.49 cgd else if (tp->t_pgrp == NULL)
1956 1.49 cgd ttyprintf(tp, "no foreground process group\n");
1957 1.51 mycroft else if ((p = tp->t_pgrp->pg_members.lh_first) == 0)
1958 1.49 cgd ttyprintf(tp, "empty foreground process group\n");
1959 1.49 cgd else {
1960 1.49 cgd /* Pick interesting process. */
1961 1.115 tron for (pick = NULL; p != NULL; p = p->p_pglist.le_next)
1962 1.49 cgd if (proc_compare(pick, p))
1963 1.49 cgd pick = p;
1964 1.49 cgd
1965 1.49 cgd ttyprintf(tp, " cmd: %s %d [%s] ", pick->p_comm, pick->p_pid,
1966 1.49 cgd pick->p_stat == SRUN ? "running" :
1967 1.49 cgd pick->p_wmesg ? pick->p_wmesg : "iowait");
1968 1.49 cgd
1969 1.49 cgd calcru(pick, &utime, &stime, NULL);
1970 1.49 cgd
1971 1.62 cgd /* Round up and print user time. */
1972 1.62 cgd utime.tv_usec += 5000;
1973 1.62 cgd if (utime.tv_usec >= 1000000) {
1974 1.62 cgd utime.tv_sec += 1;
1975 1.62 cgd utime.tv_usec -= 1000000;
1976 1.62 cgd }
1977 1.67 christos ttyprintf(tp, "%ld.%02ldu ", utime.tv_sec,
1978 1.62 cgd utime.tv_usec / 10000);
1979 1.62 cgd
1980 1.62 cgd /* Round up and print system time. */
1981 1.62 cgd stime.tv_usec += 5000;
1982 1.62 cgd if (stime.tv_usec >= 1000000) {
1983 1.62 cgd stime.tv_sec += 1;
1984 1.62 cgd stime.tv_usec -= 1000000;
1985 1.62 cgd }
1986 1.67 christos ttyprintf(tp, "%ld.%02lds ", stime.tv_sec,
1987 1.62 cgd stime.tv_usec / 10000);
1988 1.49 cgd
1989 1.68 christos #define pgtok(a) (((u_long) ((a) * NBPG) / 1024))
1990 1.90 gwr /* Print percentage cpu. */
1991 1.66 christos tmp = (pick->p_pctcpu * 10000 + FSCALE / 2) >> FSHIFT;
1992 1.90 gwr ttyprintf(tp, "%d%% ", tmp / 100);
1993 1.90 gwr
1994 1.90 gwr /* Print resident set size. */
1995 1.115 tron if (pick->p_stat == SIDL || P_ZOMBIE(pick))
1996 1.90 gwr tmp = 0;
1997 1.90 gwr else {
1998 1.90 gwr register struct vmspace *vm = pick->p_vmspace;
1999 1.90 gwr tmp = pgtok(vm_resident_count(vm));
2000 1.90 gwr }
2001 1.91 thorpej ttyprintf(tp, "%dk\n", tmp);
2002 1.49 cgd }
2003 1.49 cgd tp->t_rocount = 0; /* so pending input will be retyped if BS */
2004 1.49 cgd }
2005 1.49 cgd
2006 1.49 cgd /*
2007 1.49 cgd * Returns 1 if p2 is "better" than p1
2008 1.49 cgd *
2009 1.49 cgd * The algorithm for picking the "interesting" process is thus:
2010 1.49 cgd *
2011 1.49 cgd * 1) Only foreground processes are eligible - implied.
2012 1.49 cgd * 2) Runnable processes are favored over anything else. The runner
2013 1.49 cgd * with the highest cpu utilization is picked (p_estcpu). Ties are
2014 1.49 cgd * broken by picking the highest pid.
2015 1.49 cgd * 3) The sleeper with the shortest sleep time is next. With ties,
2016 1.49 cgd * we pick out just "short-term" sleepers (P_SINTR == 0).
2017 1.49 cgd * 4) Further ties are broken by picking the highest pid.
2018 1.49 cgd */
2019 1.49 cgd #define ISRUN(p) (((p)->p_stat == SRUN) || ((p)->p_stat == SIDL))
2020 1.49 cgd #define TESTAB(a, b) ((a)<<1 | (b))
2021 1.49 cgd #define ONLYA 2
2022 1.49 cgd #define ONLYB 1
2023 1.49 cgd #define BOTH 3
2024 1.49 cgd
2025 1.49 cgd static int
2026 1.49 cgd proc_compare(p1, p2)
2027 1.49 cgd register struct proc *p1, *p2;
2028 1.49 cgd {
2029 1.49 cgd
2030 1.49 cgd if (p1 == NULL)
2031 1.49 cgd return (1);
2032 1.49 cgd /*
2033 1.49 cgd * see if at least one of them is runnable
2034 1.49 cgd */
2035 1.49 cgd switch (TESTAB(ISRUN(p1), ISRUN(p2))) {
2036 1.49 cgd case ONLYA:
2037 1.49 cgd return (0);
2038 1.49 cgd case ONLYB:
2039 1.49 cgd return (1);
2040 1.49 cgd case BOTH:
2041 1.49 cgd /*
2042 1.49 cgd * tie - favor one with highest recent cpu utilization
2043 1.49 cgd */
2044 1.49 cgd if (p2->p_estcpu > p1->p_estcpu)
2045 1.49 cgd return (1);
2046 1.49 cgd if (p1->p_estcpu > p2->p_estcpu)
2047 1.49 cgd return (0);
2048 1.49 cgd return (p2->p_pid > p1->p_pid); /* tie - return highest pid */
2049 1.49 cgd }
2050 1.49 cgd /*
2051 1.49 cgd * weed out zombies
2052 1.49 cgd */
2053 1.114 thorpej switch (TESTAB(P_ZOMBIE(p1), P_ZOMBIE(p2))) {
2054 1.49 cgd case ONLYA:
2055 1.49 cgd return (1);
2056 1.49 cgd case ONLYB:
2057 1.49 cgd return (0);
2058 1.49 cgd case BOTH:
2059 1.49 cgd return (p2->p_pid > p1->p_pid); /* tie - return highest pid */
2060 1.49 cgd }
2061 1.49 cgd /*
2062 1.49 cgd * pick the one with the smallest sleep time
2063 1.49 cgd */
2064 1.49 cgd if (p2->p_slptime > p1->p_slptime)
2065 1.49 cgd return (0);
2066 1.49 cgd if (p1->p_slptime > p2->p_slptime)
2067 1.49 cgd return (1);
2068 1.49 cgd /*
2069 1.49 cgd * favor one sleeping in a non-interruptible sleep
2070 1.49 cgd */
2071 1.49 cgd if (p1->p_flag & P_SINTR && (p2->p_flag & P_SINTR) == 0)
2072 1.49 cgd return (1);
2073 1.49 cgd if (p2->p_flag & P_SINTR && (p1->p_flag & P_SINTR) == 0)
2074 1.49 cgd return (0);
2075 1.49 cgd return (p2->p_pid > p1->p_pid); /* tie - return highest pid */
2076 1.49 cgd }
2077 1.49 cgd
2078 1.49 cgd /*
2079 1.49 cgd * Output char to tty; console putchar style.
2080 1.49 cgd */
2081 1.49 cgd int
2082 1.49 cgd tputchar(c, tp)
2083 1.49 cgd int c;
2084 1.49 cgd struct tty *tp;
2085 1.49 cgd {
2086 1.49 cgd register int s;
2087 1.49 cgd
2088 1.49 cgd s = spltty();
2089 1.49 cgd if (ISSET(tp->t_state,
2090 1.49 cgd TS_CARR_ON | TS_ISOPEN) != (TS_CARR_ON | TS_ISOPEN)) {
2091 1.49 cgd splx(s);
2092 1.49 cgd return (-1);
2093 1.49 cgd }
2094 1.49 cgd if (c == '\n')
2095 1.49 cgd (void)ttyoutput('\r', tp);
2096 1.49 cgd (void)ttyoutput(c, tp);
2097 1.49 cgd ttstart(tp);
2098 1.49 cgd splx(s);
2099 1.49 cgd return (0);
2100 1.49 cgd }
2101 1.49 cgd
2102 1.49 cgd /*
2103 1.49 cgd * Sleep on chan, returning ERESTART if tty changed while we napped and
2104 1.49 cgd * returning any errors (e.g. EINTR/ETIMEDOUT) reported by tsleep. If
2105 1.49 cgd * the tty is revoked, restarting a pending call will redo validation done
2106 1.49 cgd * at the start of the call.
2107 1.49 cgd */
2108 1.49 cgd int
2109 1.49 cgd ttysleep(tp, chan, pri, wmesg, timo)
2110 1.49 cgd struct tty *tp;
2111 1.49 cgd void *chan;
2112 1.49 cgd int pri, timo;
2113 1.97 mycroft const char *wmesg;
2114 1.49 cgd {
2115 1.49 cgd int error;
2116 1.49 cgd short gen;
2117 1.49 cgd
2118 1.49 cgd gen = tp->t_gen;
2119 1.65 christos if ((error = tsleep(chan, pri, wmesg, timo)) != 0)
2120 1.49 cgd return (error);
2121 1.49 cgd return (tp->t_gen == gen ? 0 : ERESTART);
2122 1.49 cgd }
2123 1.49 cgd
2124 1.49 cgd /*
2125 1.69 mrg * Initialise the global tty list.
2126 1.69 mrg */
2127 1.69 mrg void
2128 1.69 mrg tty_init()
2129 1.69 mrg {
2130 1.71 cgd
2131 1.69 mrg TAILQ_INIT(&ttylist);
2132 1.69 mrg tty_count = 0;
2133 1.111 thorpej
2134 1.111 thorpej pool_init(&tty_pool, sizeof(struct tty), 0, 0, 0, "ttypl",
2135 1.111 thorpej 0, pool_page_alloc_nointr, pool_page_free_nointr, M_TTYS);
2136 1.69 mrg }
2137 1.69 mrg
2138 1.69 mrg /*
2139 1.69 mrg * Attach a tty to the tty list.
2140 1.72 mrg *
2141 1.72 mrg * This should be called ONLY once per real tty (including pty's).
2142 1.72 mrg * eg, on the sparc, the keyboard and mouse have struct tty's that are
2143 1.72 mrg * distinctly NOT usable as tty's, and thus should not be attached to
2144 1.72 mrg * the ttylist. This is why this call is not done from ttymalloc().
2145 1.72 mrg *
2146 1.72 mrg * Device drivers should attach tty's at a similar time that they are
2147 1.72 mrg * ttymalloc()'ed, or, for the case of statically allocated struct tty's
2148 1.72 mrg * either in the attach or (first) open routine.
2149 1.69 mrg */
2150 1.69 mrg void
2151 1.69 mrg tty_attach(tp)
2152 1.69 mrg struct tty *tp;
2153 1.69 mrg {
2154 1.71 cgd
2155 1.69 mrg TAILQ_INSERT_TAIL(&ttylist, tp, tty_link);
2156 1.69 mrg ++tty_count;
2157 1.69 mrg }
2158 1.69 mrg
2159 1.69 mrg /*
2160 1.69 mrg * Remove a tty from the tty list.
2161 1.69 mrg */
2162 1.69 mrg void
2163 1.69 mrg tty_detach(tp)
2164 1.69 mrg struct tty *tp;
2165 1.69 mrg {
2166 1.71 cgd
2167 1.69 mrg --tty_count;
2168 1.69 mrg #ifdef DIAGNOSTIC
2169 1.69 mrg if (tty_count < 0)
2170 1.69 mrg panic("tty_detach: tty_count < 0");
2171 1.69 mrg #endif
2172 1.70 mrg TAILQ_REMOVE(&ttylist, tp, tty_link);
2173 1.69 mrg }
2174 1.69 mrg
2175 1.69 mrg /*
2176 1.49 cgd * Allocate a tty structure and its associated buffers.
2177 1.49 cgd */
2178 1.49 cgd struct tty *
2179 1.49 cgd ttymalloc()
2180 1.49 cgd {
2181 1.49 cgd struct tty *tp;
2182 1.49 cgd
2183 1.111 thorpej tp = pool_get(&tty_pool, PR_WAITOK);
2184 1.109 perry memset(tp, 0, sizeof(*tp));
2185 1.116 thorpej callout_init(&tp->t_outq_ch);
2186 1.116 thorpej callout_init(&tp->t_rstrt_ch);
2187 1.84 mycroft /* XXX: default to 1024 chars for now */
2188 1.84 mycroft clalloc(&tp->t_rawq, 1024, 1);
2189 1.84 mycroft clalloc(&tp->t_canq, 1024, 1);
2190 1.49 cgd /* output queue doesn't need quoting */
2191 1.84 mycroft clalloc(&tp->t_outq, 1024, 0);
2192 1.49 cgd return(tp);
2193 1.49 cgd }
2194 1.49 cgd
2195 1.49 cgd /*
2196 1.49 cgd * Free a tty structure and its buffers.
2197 1.73 mrg *
2198 1.73 mrg * Be sure to call tty_detach() for any tty that has been
2199 1.73 mrg * tty_attach()ed.
2200 1.49 cgd */
2201 1.49 cgd void
2202 1.49 cgd ttyfree(tp)
2203 1.71 cgd struct tty *tp;
2204 1.49 cgd {
2205 1.71 cgd
2206 1.116 thorpej callout_stop(&tp->t_outq_ch);
2207 1.116 thorpej callout_stop(&tp->t_rstrt_ch);
2208 1.49 cgd clfree(&tp->t_rawq);
2209 1.49 cgd clfree(&tp->t_canq);
2210 1.49 cgd clfree(&tp->t_outq);
2211 1.111 thorpej pool_put(&tty_pool, tp);
2212 1.49 cgd }
2213