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