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