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