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