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