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