1 /* $OpenBSD: tty.c,v 1.143 2018/09/06 11:50:54 jsg 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 enqueue_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 nid.ni_unveil = UNVEIL_READ | UNVEIL_WRITE; 796 error = namei(&nid); 797 if (error) 798 return (error); 799 vn_lock(nid.ni_vp, LK_EXCLUSIVE | LK_RETRY); 800 error = VOP_ACCESS(nid.ni_vp, VREAD, p->p_ucred, p); 801 VOP_UNLOCK(nid.ni_vp); 802 vrele(nid.ni_vp); 803 if (error) 804 return (error); 805 806 constty = tp; 807 } else if (tp == constty) 808 constty = NULL; 809 break; 810 } 811 case TIOCDRAIN: /* wait till output drained */ 812 if ((error = ttywait(tp)) != 0) 813 return (error); 814 break; 815 case TIOCGETA: { /* get termios struct */ 816 struct termios *t = (struct termios *)data; 817 818 memcpy(t, &tp->t_termios, sizeof(struct termios)); 819 break; 820 } 821 case TIOCGETD: /* get line discipline */ 822 *(int *)data = tp->t_line; 823 break; 824 case TIOCGWINSZ: /* get window size */ 825 *(struct winsize *)data = tp->t_winsize; 826 break; 827 case TIOCGTSTAMP: 828 s = spltty(); 829 *(struct timeval *)data = tp->t_tv; 830 splx(s); 831 break; 832 case TIOCGPGRP: /* get pgrp of tty */ 833 if (!isctty(pr, tp) && suser(p)) 834 return (ENOTTY); 835 *(int *)data = tp->t_pgrp ? tp->t_pgrp->pg_id : NO_PID; 836 break; 837 case TIOCGSID: /* get sid of tty */ 838 if (!isctty(pr, tp)) 839 return (ENOTTY); 840 *(int *)data = tp->t_session->s_leader->ps_pid; 841 break; 842 #ifdef TIOCHPCL 843 case TIOCHPCL: /* hang up on last close */ 844 s = spltty(); 845 SET(tp->t_cflag, HUPCL); 846 splx(s); 847 break; 848 #endif 849 case TIOCNXCL: /* reset exclusive use of tty */ 850 s = spltty(); 851 CLR(tp->t_state, TS_XCLUDE); 852 splx(s); 853 break; 854 case TIOCOUTQ: /* output queue size */ 855 *(int *)data = tp->t_outq.c_cc; 856 break; 857 case TIOCSETA: /* set termios struct */ 858 case TIOCSETAW: /* drain output, set */ 859 case TIOCSETAF: { /* drn out, fls in, set */ 860 struct termios *t = (struct termios *)data; 861 862 s = spltty(); 863 if (cmd == TIOCSETAW || cmd == TIOCSETAF) { 864 if ((error = ttywait(tp)) != 0) { 865 splx(s); 866 return (error); 867 } 868 if (cmd == TIOCSETAF) 869 ttyflush(tp, FREAD); 870 } 871 if (!ISSET(t->c_cflag, CIGNORE)) { 872 /* 873 * Some minor validation is necessary. 874 */ 875 if (t->c_ispeed < 0 || t->c_ospeed < 0) { 876 splx(s); 877 return (EINVAL); 878 } 879 /* 880 * Set device hardware. 881 */ 882 if (tp->t_param && (error = (*tp->t_param)(tp, t))) { 883 splx(s); 884 return (error); 885 } else { 886 if (!ISSET(tp->t_state, TS_CARR_ON) && 887 ISSET(tp->t_cflag, CLOCAL) && 888 !ISSET(t->c_cflag, CLOCAL)) { 889 CLR(tp->t_state, TS_ISOPEN); 890 SET(tp->t_state, TS_WOPEN); 891 ttwakeup(tp); 892 } 893 tp->t_cflag = t->c_cflag; 894 tp->t_ispeed = t->c_ispeed; 895 tp->t_ospeed = t->c_ospeed; 896 if (t->c_ospeed == 0 && tp->t_session && 897 tp->t_session->s_leader) 898 prsignal(tp->t_session->s_leader, 899 SIGHUP); 900 } 901 ttsetwater(tp); 902 } 903 if (cmd != TIOCSETAF) { 904 if (ISSET(t->c_lflag, ICANON) != 905 ISSET(tp->t_lflag, ICANON)) { 906 if (ISSET(t->c_lflag, ICANON)) { 907 SET(tp->t_lflag, PENDIN); 908 ttwakeup(tp); 909 } else { 910 struct clist tq; 911 912 catq(&tp->t_rawq, &tp->t_canq); 913 tq = tp->t_rawq; 914 tp->t_rawq = tp->t_canq; 915 tp->t_canq = tq; 916 CLR(tp->t_lflag, PENDIN); 917 } 918 } 919 } 920 tp->t_iflag = t->c_iflag; 921 tp->t_oflag = t->c_oflag; 922 /* 923 * Make the EXTPROC bit read only. 924 */ 925 if (ISSET(tp->t_lflag, EXTPROC)) 926 SET(t->c_lflag, EXTPROC); 927 else 928 CLR(t->c_lflag, EXTPROC); 929 tp->t_lflag = t->c_lflag | ISSET(tp->t_lflag, PENDIN); 930 memcpy(tp->t_cc, t->c_cc, sizeof(t->c_cc)); 931 splx(s); 932 break; 933 } 934 case TIOCSETD: { /* set line discipline */ 935 int t = *(int *)data; 936 dev_t device = tp->t_dev; 937 938 if ((u_int)t >= nlinesw) 939 return (ENXIO); 940 if (t != tp->t_line) { 941 s = spltty(); 942 (*linesw[tp->t_line].l_close)(tp, flag, p); 943 error = (*linesw[t].l_open)(device, tp, p); 944 if (error) { 945 (*linesw[tp->t_line].l_open)(device, tp, p); 946 splx(s); 947 return (error); 948 } 949 tp->t_line = t; 950 splx(s); 951 } 952 break; 953 } 954 case TIOCSTART: /* start output, like ^Q */ 955 s = spltty(); 956 if (ISSET(tp->t_state, TS_TTSTOP) || 957 ISSET(tp->t_lflag, FLUSHO)) { 958 CLR(tp->t_lflag, FLUSHO); 959 CLR(tp->t_state, TS_TTSTOP); 960 ttstart(tp); 961 } 962 splx(s); 963 break; 964 case TIOCSTOP: /* stop output, like ^S */ 965 s = spltty(); 966 if (!ISSET(tp->t_state, TS_TTSTOP)) { 967 SET(tp->t_state, TS_TTSTOP); 968 (*cdevsw[major(tp->t_dev)].d_stop)(tp, 0); 969 } 970 splx(s); 971 break; 972 case TIOCSCTTY: /* become controlling tty */ 973 /* Session ctty vnode pointer set in vnode layer. */ 974 if (!SESS_LEADER(pr) || 975 ((pr->ps_session->s_ttyvp || tp->t_session) && 976 (tp->t_session != pr->ps_session))) 977 return (EPERM); 978 if (tp->t_session) 979 SESSRELE(tp->t_session); 980 SESSHOLD(pr->ps_session); 981 tp->t_session = pr->ps_session; 982 tp->t_pgrp = pr->ps_pgrp; 983 pr->ps_session->s_ttyp = tp; 984 atomic_setbits_int(&pr->ps_flags, PS_CONTROLT); 985 break; 986 case TIOCSPGRP: { /* set pgrp of tty */ 987 struct pgrp *pgrp = pgfind(*(int *)data); 988 989 if (!isctty(pr, tp)) 990 return (ENOTTY); 991 else if (pgrp == NULL) 992 return (EINVAL); 993 else if (pgrp->pg_session != pr->ps_session) 994 return (EPERM); 995 tp->t_pgrp = pgrp; 996 break; 997 } 998 case TIOCSTAT: /* get load avg stats */ 999 ttyinfo(tp); 1000 break; 1001 case TIOCSWINSZ: /* set window size */ 1002 if (bcmp((caddr_t)&tp->t_winsize, data, 1003 sizeof (struct winsize))) { 1004 tp->t_winsize = *(struct winsize *)data; 1005 pgsignal(tp->t_pgrp, SIGWINCH, 1); 1006 } 1007 break; 1008 case TIOCSTSTAMP: { 1009 struct tstamps *ts = (struct tstamps *)data; 1010 1011 s = spltty(); 1012 CLR(tp->t_flags, TS_TSTAMPDCDSET); 1013 CLR(tp->t_flags, TS_TSTAMPCTSSET); 1014 CLR(tp->t_flags, TS_TSTAMPDCDCLR); 1015 CLR(tp->t_flags, TS_TSTAMPCTSCLR); 1016 if (ISSET(ts->ts_set, TIOCM_CAR)) 1017 SET(tp->t_flags, TS_TSTAMPDCDSET); 1018 if (ISSET(ts->ts_set, TIOCM_CTS)) 1019 SET(tp->t_flags, TS_TSTAMPCTSSET); 1020 if (ISSET(ts->ts_clr, TIOCM_CAR)) 1021 SET(tp->t_flags, TS_TSTAMPDCDCLR); 1022 if (ISSET(ts->ts_clr, TIOCM_CTS)) 1023 SET(tp->t_flags, TS_TSTAMPCTSCLR); 1024 splx(s); 1025 break; 1026 } 1027 default: 1028 return (-1); 1029 } 1030 return (0); 1031 } 1032 1033 int 1034 ttpoll(dev_t device, int events, struct proc *p) 1035 { 1036 struct tty *tp; 1037 int revents, s; 1038 1039 tp = (*cdevsw[major(device)].d_tty)(device); 1040 1041 revents = 0; 1042 s = spltty(); 1043 if (events & (POLLIN | POLLRDNORM)) { 1044 if (ttnread(tp) > 0 || (!ISSET(tp->t_cflag, CLOCAL) && 1045 !ISSET(tp->t_state, TS_CARR_ON))) 1046 revents |= events & (POLLIN | POLLRDNORM); 1047 } 1048 /* NOTE: POLLHUP and POLLOUT/POLLWRNORM are mutually exclusive */ 1049 if (!ISSET(tp->t_cflag, CLOCAL) && !ISSET(tp->t_state, TS_CARR_ON)) { 1050 revents |= POLLHUP; 1051 } else if (events & (POLLOUT | POLLWRNORM)) { 1052 if (tp->t_outq.c_cc <= tp->t_lowat) 1053 revents |= events & (POLLOUT | POLLWRNORM); 1054 } 1055 if (revents == 0) { 1056 if (events & (POLLIN | POLLRDNORM)) 1057 selrecord(p, &tp->t_rsel); 1058 if (events & (POLLOUT | POLLWRNORM)) 1059 selrecord(p, &tp->t_wsel); 1060 } 1061 splx(s); 1062 return (revents); 1063 } 1064 1065 struct filterops ttyread_filtops = 1066 { 1, NULL, filt_ttyrdetach, filt_ttyread }; 1067 struct filterops ttywrite_filtops = 1068 { 1, NULL, filt_ttywdetach, filt_ttywrite }; 1069 1070 int 1071 ttkqfilter(dev_t dev, struct knote *kn) 1072 { 1073 struct tty *tp = (*cdevsw[major(dev)].d_tty)(dev); 1074 struct klist *klist; 1075 int s; 1076 1077 switch (kn->kn_filter) { 1078 case EVFILT_READ: 1079 klist = &tp->t_rsel.si_note; 1080 kn->kn_fop = &ttyread_filtops; 1081 break; 1082 case EVFILT_WRITE: 1083 klist = &tp->t_wsel.si_note; 1084 kn->kn_fop = &ttywrite_filtops; 1085 break; 1086 default: 1087 return (EINVAL); 1088 } 1089 1090 kn->kn_hook = (caddr_t)((u_long)dev); 1091 1092 s = spltty(); 1093 SLIST_INSERT_HEAD(klist, kn, kn_selnext); 1094 splx(s); 1095 1096 return (0); 1097 } 1098 1099 void 1100 ttkqflush(struct klist *klist) 1101 { 1102 struct knote *kn, *kn1; 1103 1104 SLIST_FOREACH_SAFE(kn, klist, kn_selnext, kn1) { 1105 SLIST_REMOVE(klist, kn, knote, kn_selnext); 1106 kn->kn_hook = (caddr_t)((u_long)NODEV); 1107 kn->kn_flags |= EV_EOF; 1108 knote_activate(kn); 1109 } 1110 } 1111 1112 void 1113 filt_ttyrdetach(struct knote *kn) 1114 { 1115 dev_t dev = (dev_t)((u_long)kn->kn_hook); 1116 struct tty *tp; 1117 int s; 1118 1119 if (dev == NODEV) 1120 return; 1121 tp = (*cdevsw[major(dev)].d_tty)(dev); 1122 1123 s = spltty(); 1124 SLIST_REMOVE(&tp->t_rsel.si_note, kn, knote, kn_selnext); 1125 splx(s); 1126 } 1127 1128 int 1129 filt_ttyread(struct knote *kn, long hint) 1130 { 1131 dev_t dev = (dev_t)((u_long)kn->kn_hook); 1132 struct tty *tp; 1133 int s; 1134 1135 if (dev == NODEV) { 1136 kn->kn_flags |= EV_EOF; 1137 return (1); 1138 } 1139 tp = (*cdevsw[major(dev)].d_tty)(dev); 1140 1141 s = spltty(); 1142 kn->kn_data = ttnread(tp); 1143 splx(s); 1144 if (!ISSET(tp->t_cflag, CLOCAL) && !ISSET(tp->t_state, TS_CARR_ON)) { 1145 kn->kn_flags |= EV_EOF; 1146 return (1); 1147 } 1148 return (kn->kn_data > 0); 1149 } 1150 1151 void 1152 filt_ttywdetach(struct knote *kn) 1153 { 1154 dev_t dev = (dev_t)((u_long)kn->kn_hook); 1155 struct tty *tp; 1156 int s; 1157 1158 if (dev == NODEV) 1159 return; 1160 tp = (*cdevsw[major(dev)].d_tty)(dev); 1161 1162 s = spltty(); 1163 SLIST_REMOVE(&tp->t_wsel.si_note, kn, knote, kn_selnext); 1164 splx(s); 1165 } 1166 1167 int 1168 filt_ttywrite(struct knote *kn, long hint) 1169 { 1170 dev_t dev = (dev_t)((u_long)kn->kn_hook); 1171 struct tty *tp; 1172 int canwrite, s; 1173 1174 if (dev == NODEV) { 1175 kn->kn_flags |= EV_EOF; 1176 return (1); 1177 } 1178 tp = (*cdevsw[major(dev)].d_tty)(dev); 1179 1180 s = spltty(); 1181 kn->kn_data = tp->t_outq.c_cn - tp->t_outq.c_cc; 1182 canwrite = (tp->t_outq.c_cc <= tp->t_lowat); 1183 splx(s); 1184 return (canwrite); 1185 } 1186 1187 static int 1188 ttnread(struct tty *tp) 1189 { 1190 int nread; 1191 1192 splassert(IPL_TTY); 1193 1194 if (ISSET(tp->t_lflag, PENDIN)) 1195 ttypend(tp); 1196 nread = tp->t_canq.c_cc; 1197 if (!ISSET(tp->t_lflag, ICANON)) { 1198 nread += tp->t_rawq.c_cc; 1199 if (nread < tp->t_cc[VMIN] && !tp->t_cc[VTIME]) 1200 nread = 0; 1201 } 1202 return (nread); 1203 } 1204 1205 /* 1206 * Wait for output to drain. 1207 */ 1208 int 1209 ttywait(struct tty *tp) 1210 { 1211 int error, s; 1212 1213 error = 0; 1214 s = spltty(); 1215 while ((tp->t_outq.c_cc || ISSET(tp->t_state, TS_BUSY)) && 1216 (ISSET(tp->t_state, TS_CARR_ON) || ISSET(tp->t_cflag, CLOCAL)) && 1217 tp->t_oproc) { 1218 (*tp->t_oproc)(tp); 1219 if ((tp->t_outq.c_cc || ISSET(tp->t_state, TS_BUSY)) && 1220 (ISSET(tp->t_state, TS_CARR_ON) || ISSET(tp->t_cflag, CLOCAL)) 1221 && tp->t_oproc) { 1222 SET(tp->t_state, TS_ASLEEP); 1223 error = ttysleep(tp, &tp->t_outq, TTOPRI | PCATCH, ttyout, 0); 1224 if (error) 1225 break; 1226 } else 1227 break; 1228 } 1229 splx(s); 1230 return (error); 1231 } 1232 1233 /* 1234 * Flush if successfully wait. 1235 */ 1236 int 1237 ttywflush(struct tty *tp) 1238 { 1239 int error; 1240 1241 if ((error = ttywait(tp)) == 0) 1242 ttyflush(tp, FREAD); 1243 return (error); 1244 } 1245 1246 /* 1247 * Flush tty read and/or write queues, notifying anyone waiting. 1248 */ 1249 void 1250 ttyflush(struct tty *tp, int rw) 1251 { 1252 int s; 1253 1254 s = spltty(); 1255 if (rw & FREAD) { 1256 FLUSHQ(&tp->t_canq); 1257 FLUSHQ(&tp->t_rawq); 1258 tp->t_rocount = 0; 1259 tp->t_rocol = 0; 1260 CLR(tp->t_state, TS_LOCAL); 1261 ttyunblock(tp); 1262 ttwakeup(tp); 1263 } 1264 if (rw & FWRITE) { 1265 CLR(tp->t_state, TS_TTSTOP); 1266 (*cdevsw[major(tp->t_dev)].d_stop)(tp, rw); 1267 FLUSHQ(&tp->t_outq); 1268 wakeup((caddr_t)&tp->t_outq); 1269 selwakeup(&tp->t_wsel); 1270 } 1271 splx(s); 1272 } 1273 1274 /* 1275 * Copy in the default termios characters. 1276 */ 1277 void 1278 ttychars(struct tty *tp) 1279 { 1280 1281 memcpy(tp->t_cc, ttydefchars, sizeof(ttydefchars)); 1282 } 1283 1284 /* 1285 * Send stop character on input overflow. 1286 */ 1287 static void 1288 ttyblock(struct tty *tp) 1289 { 1290 int total; 1291 1292 total = tp->t_rawq.c_cc + tp->t_canq.c_cc; 1293 if (tp->t_rawq.c_cc > TTYHOG(tp)) { 1294 ttyflush(tp, FREAD | FWRITE); 1295 CLR(tp->t_state, TS_TBLOCK); 1296 } 1297 /* 1298 * Block further input iff: current input > threshold 1299 * AND input is available to user program. 1300 */ 1301 if ((total >= TTYHOG(tp) / 2 && 1302 !ISSET(tp->t_state, TS_TBLOCK) && 1303 !ISSET(tp->t_lflag, ICANON)) || tp->t_canq.c_cc > 0) { 1304 if (ISSET(tp->t_iflag, IXOFF) && 1305 tp->t_cc[VSTOP] != _POSIX_VDISABLE && 1306 putc(tp->t_cc[VSTOP], &tp->t_outq) == 0) { 1307 SET(tp->t_state, TS_TBLOCK); 1308 ttstart(tp); 1309 } 1310 /* Try to block remote output via hardware flow control. */ 1311 if (ISSET(tp->t_cflag, CHWFLOW) && tp->t_hwiflow && 1312 (*tp->t_hwiflow)(tp, 1) != 0) 1313 SET(tp->t_state, TS_TBLOCK); 1314 } 1315 } 1316 1317 void 1318 ttrstrt(void *tp_arg) 1319 { 1320 struct tty *tp; 1321 int s; 1322 1323 #ifdef DIAGNOSTIC 1324 if (tp_arg == NULL) 1325 panic("ttrstrt"); 1326 #endif 1327 tp = tp_arg; 1328 s = spltty(); 1329 1330 CLR(tp->t_state, TS_TIMEOUT); 1331 ttstart(tp); 1332 1333 splx(s); 1334 } 1335 1336 int 1337 ttstart(struct tty *tp) 1338 { 1339 1340 if (tp->t_oproc != NULL) /* XXX: Kludge for pty. */ 1341 (*tp->t_oproc)(tp); 1342 return (0); 1343 } 1344 1345 /* 1346 * "close" a line discipline 1347 */ 1348 int 1349 ttylclose(struct tty *tp, int flag, struct proc *p) 1350 { 1351 1352 if (flag & FNONBLOCK) 1353 ttyflush(tp, FREAD | FWRITE); 1354 else 1355 ttywflush(tp); 1356 return (0); 1357 } 1358 1359 /* 1360 * Handle modem control transition on a tty. 1361 * Flag indicates new state of carrier. 1362 * Returns 0 if the line should be turned off, otherwise 1. 1363 */ 1364 int 1365 ttymodem(struct tty *tp, int flag) 1366 { 1367 1368 if (!ISSET(tp->t_state, TS_WOPEN) && ISSET(tp->t_cflag, MDMBUF)) { 1369 /* 1370 * MDMBUF: do flow control according to carrier flag 1371 */ 1372 if (flag) { 1373 CLR(tp->t_state, TS_TTSTOP); 1374 ttstart(tp); 1375 } else if (!ISSET(tp->t_state, TS_TTSTOP)) { 1376 SET(tp->t_state, TS_TTSTOP); 1377 (*cdevsw[major(tp->t_dev)].d_stop)(tp, 0); 1378 } 1379 } else if (flag == 0) { 1380 /* 1381 * Lost carrier. 1382 */ 1383 CLR(tp->t_state, TS_CARR_ON); 1384 if (ISSET(tp->t_state, TS_ISOPEN) && 1385 !ISSET(tp->t_cflag, CLOCAL)) { 1386 if (tp->t_session && tp->t_session->s_leader) 1387 prsignal(tp->t_session->s_leader, SIGHUP); 1388 ttyflush(tp, FREAD | FWRITE); 1389 return (0); 1390 } 1391 } else { 1392 /* 1393 * Carrier now on. 1394 */ 1395 SET(tp->t_state, TS_CARR_ON); 1396 ttwakeup(tp); 1397 } 1398 return (1); 1399 } 1400 1401 /* 1402 * Default modem control routine (for other line disciplines). 1403 * Return argument flag, to turn off device on carrier drop. 1404 */ 1405 int 1406 nullmodem(struct tty *tp, int flag) 1407 { 1408 1409 if (flag) 1410 SET(tp->t_state, TS_CARR_ON); 1411 else { 1412 CLR(tp->t_state, TS_CARR_ON); 1413 if (ISSET(tp->t_state, TS_ISOPEN) && 1414 !ISSET(tp->t_cflag, CLOCAL)) { 1415 if (tp->t_session && tp->t_session->s_leader) 1416 prsignal(tp->t_session->s_leader, SIGHUP); 1417 ttyflush(tp, FREAD | FWRITE); 1418 return (0); 1419 } 1420 } 1421 return (1); 1422 } 1423 1424 /* 1425 * Reinput pending characters after state switch 1426 * call at spltty(). 1427 */ 1428 void 1429 ttypend(struct tty *tp) 1430 { 1431 struct clist tq; 1432 int c; 1433 1434 splassert(IPL_TTY); 1435 1436 CLR(tp->t_lflag, PENDIN); 1437 SET(tp->t_state, TS_TYPEN); 1438 tq = tp->t_rawq; 1439 tp->t_rawq.c_cc = 0; 1440 tp->t_rawq.c_cf = tp->t_rawq.c_cl = 0; 1441 while ((c = getc(&tq)) >= 0) 1442 ttyinput(c, tp); 1443 CLR(tp->t_state, TS_TYPEN); 1444 } 1445 1446 void ttvtimeout(void *); 1447 1448 void 1449 ttvtimeout(void *arg) 1450 { 1451 struct tty *tp = (struct tty *)arg; 1452 1453 wakeup(&tp->t_rawq); 1454 } 1455 1456 /* 1457 * Process a read call on a tty device. 1458 */ 1459 int 1460 ttread(struct tty *tp, struct uio *uio, int flag) 1461 { 1462 struct timeout *stime = NULL; 1463 struct proc *p = curproc; 1464 struct process *pr = p->p_p; 1465 int s, first, error = 0; 1466 u_char *cc = tp->t_cc; 1467 struct clist *qp; 1468 int last_cc = 0; 1469 long lflag; 1470 int c; 1471 1472 loop: lflag = tp->t_lflag; 1473 s = spltty(); 1474 /* 1475 * take pending input first 1476 */ 1477 if (ISSET(lflag, PENDIN)) 1478 ttypend(tp); 1479 splx(s); 1480 1481 /* 1482 * Hang process if it's in the background. 1483 */ 1484 if (isbackground(pr, tp)) { 1485 if ((pr->ps_sigacts->ps_sigignore & sigmask(SIGTTIN)) || 1486 (p->p_sigmask & sigmask(SIGTTIN)) || 1487 pr->ps_flags & PS_PPWAIT || pr->ps_pgrp->pg_jobc == 0) { 1488 error = EIO; 1489 goto out; 1490 } 1491 pgsignal(pr->ps_pgrp, SIGTTIN, 1); 1492 error = ttysleep(tp, &lbolt, TTIPRI | PCATCH, ttybg, 0); 1493 if (error) 1494 goto out; 1495 goto loop; 1496 } 1497 1498 s = spltty(); 1499 if (!ISSET(lflag, ICANON)) { 1500 int m = cc[VMIN]; 1501 long t; 1502 1503 /* 1504 * Note - since cc[VTIME] is a u_char, this won't overflow 1505 * until we have 32-bit longs and a hz > 8388608. 1506 * Hopefully this code and 32-bit longs are obsolete by then. 1507 */ 1508 t = cc[VTIME] * hz / 10; 1509 1510 qp = &tp->t_rawq; 1511 /* 1512 * Check each of the four combinations. 1513 * (m > 0 && t == 0) is the normal read case. 1514 * It should be fairly efficient, so we check that and its 1515 * companion case (m == 0 && t == 0) first. 1516 */ 1517 if (t == 0) { 1518 if (qp->c_cc < m) 1519 goto sleep; 1520 goto read; 1521 } 1522 if (m > 0) { 1523 if (qp->c_cc <= 0) 1524 goto sleep; 1525 if (qp->c_cc >= m) 1526 goto read; 1527 if (stime == NULL) { 1528 alloc_timer: 1529 stime = malloc(sizeof(*stime), M_TEMP, M_WAITOK); 1530 timeout_set(stime, ttvtimeout, tp); 1531 timeout_add(stime, t); 1532 } else if (qp->c_cc > last_cc) { 1533 /* got a character, restart timer */ 1534 timeout_add(stime, t); 1535 } 1536 } else { /* m == 0 */ 1537 if (qp->c_cc > 0) 1538 goto read; 1539 if (stime == NULL) { 1540 goto alloc_timer; 1541 } 1542 } 1543 last_cc = qp->c_cc; 1544 if (stime && !timeout_triggered(stime)) { 1545 goto sleep; 1546 } 1547 } else if ((qp = &tp->t_canq)->c_cc <= 0) { 1548 int carrier; 1549 1550 sleep: 1551 /* 1552 * If there is no input, sleep on rawq 1553 * awaiting hardware receipt and notification. 1554 * If we have data, we don't need to check for carrier. 1555 */ 1556 carrier = ISSET(tp->t_state, TS_CARR_ON) || 1557 ISSET(tp->t_cflag, CLOCAL); 1558 if (!carrier && ISSET(tp->t_state, TS_ISOPEN)) { 1559 splx(s); 1560 error = 0; 1561 goto out; 1562 } 1563 if (flag & IO_NDELAY) { 1564 splx(s); 1565 error = EWOULDBLOCK; 1566 goto out; 1567 } 1568 error = ttysleep(tp, &tp->t_rawq, TTIPRI | PCATCH, 1569 carrier ? ttyin : ttopen, 0); 1570 splx(s); 1571 if (stime && timeout_triggered(stime)) 1572 error = EWOULDBLOCK; 1573 if (cc[VMIN] == 0 && error == EWOULDBLOCK) { 1574 error = 0; 1575 goto out; 1576 } 1577 if (error && error != EWOULDBLOCK) 1578 goto out; 1579 error = 0; 1580 goto loop; 1581 } 1582 read: 1583 splx(s); 1584 1585 /* 1586 * Input present, check for input mapping and processing. 1587 */ 1588 first = 1; 1589 while ((c = getc(qp)) >= 0) { 1590 /* 1591 * delayed suspend (^Y) 1592 */ 1593 if (CCEQ(cc[VDSUSP], c) && 1594 ISSET(lflag, IEXTEN | ISIG) == (IEXTEN | ISIG)) { 1595 pgsignal(tp->t_pgrp, SIGTSTP, 1); 1596 if (first) { 1597 error = ttysleep(tp, &lbolt, TTIPRI | PCATCH, 1598 ttybg, 0); 1599 if (error) 1600 break; 1601 goto loop; 1602 } 1603 break; 1604 } 1605 /* 1606 * Interpret EOF only in canonical mode. 1607 */ 1608 if (CCEQ(cc[VEOF], c) && ISSET(lflag, ICANON)) 1609 break; 1610 /* 1611 * Give user character. 1612 */ 1613 error = ureadc(c, uio); 1614 if (error) 1615 break; 1616 if (uio->uio_resid == 0) 1617 break; 1618 /* 1619 * In canonical mode check for a "break character" 1620 * marking the end of a "line of input". 1621 */ 1622 if (ISSET(lflag, ICANON) && TTBREAKC(c, lflag)) 1623 break; 1624 first = 0; 1625 } 1626 /* 1627 * Look to unblock output now that (presumably) 1628 * the input queue has gone down. 1629 */ 1630 s = spltty(); 1631 if (tp->t_rawq.c_cc < TTYHOG(tp)/5) 1632 ttyunblock(tp); 1633 splx(s); 1634 1635 out: 1636 if (stime) { 1637 timeout_del(stime); 1638 free(stime, M_TEMP, sizeof(*stime)); 1639 } 1640 return (error); 1641 } 1642 1643 /* Call at spltty */ 1644 void 1645 ttyunblock(struct tty *tp) 1646 { 1647 u_char *cc = tp->t_cc; 1648 1649 splassert(IPL_TTY); 1650 1651 if (ISSET(tp->t_state, TS_TBLOCK)) { 1652 if (ISSET(tp->t_iflag, IXOFF) && 1653 cc[VSTART] != _POSIX_VDISABLE && 1654 putc(cc[VSTART], &tp->t_outq) == 0) { 1655 CLR(tp->t_state, TS_TBLOCK); 1656 ttstart(tp); 1657 } 1658 /* Try to unblock remote output via hardware flow control. */ 1659 if (ISSET(tp->t_cflag, CHWFLOW) && tp->t_hwiflow && 1660 (*tp->t_hwiflow)(tp, 0) != 0) 1661 CLR(tp->t_state, TS_TBLOCK); 1662 } 1663 } 1664 1665 /* 1666 * Check the output queue on tp for space for a kernel message (from uprintf 1667 * or tprintf). Allow some space over the normal hiwater mark so we don't 1668 * lose messages due to normal flow control, but don't let the tty run amok. 1669 * Sleeps here are not interruptible, but we return prematurely if new signals 1670 * arrive. 1671 */ 1672 int 1673 ttycheckoutq(struct tty *tp, int wait) 1674 { 1675 int hiwat, s, oldsig; 1676 1677 hiwat = tp->t_hiwat; 1678 s = spltty(); 1679 oldsig = wait ? curproc->p_siglist : 0; 1680 if (tp->t_outq.c_cc > hiwat + TTHIWATMINSPACE) 1681 while (tp->t_outq.c_cc > hiwat) { 1682 ttstart(tp); 1683 if (wait == 0 || curproc->p_siglist != oldsig) { 1684 splx(s); 1685 return (0); 1686 } 1687 SET(tp->t_state, TS_ASLEEP); 1688 tsleep(&tp->t_outq, PZERO - 1, "ttckoutq", hz); 1689 } 1690 splx(s); 1691 return (1); 1692 } 1693 1694 /* 1695 * Process a write call on a tty device. 1696 */ 1697 int 1698 ttwrite(struct tty *tp, struct uio *uio, int flag) 1699 { 1700 u_char *cp = NULL; 1701 int cc, ce, obufcc = 0; 1702 struct proc *p; 1703 struct process *pr; 1704 int hiwat, error, s; 1705 size_t cnt; 1706 u_char obuf[OBUFSIZ]; 1707 1708 hiwat = tp->t_hiwat; 1709 cnt = uio->uio_resid; 1710 error = 0; 1711 cc = 0; 1712 loop: 1713 s = spltty(); 1714 if (!ISSET(tp->t_state, TS_CARR_ON) && 1715 !ISSET(tp->t_cflag, CLOCAL)) { 1716 if (ISSET(tp->t_state, TS_ISOPEN)) { 1717 splx(s); 1718 error = EIO; 1719 goto done; 1720 } else if (flag & IO_NDELAY) { 1721 splx(s); 1722 error = EWOULDBLOCK; 1723 goto out; 1724 } else { 1725 /* Sleep awaiting carrier. */ 1726 error = ttysleep(tp, 1727 &tp->t_rawq, TTIPRI | PCATCH, ttopen, 0); 1728 splx(s); 1729 if (error) 1730 goto out; 1731 goto loop; 1732 } 1733 } 1734 splx(s); 1735 /* 1736 * Hang the process if it's in the background. 1737 */ 1738 p = curproc; 1739 pr = p->p_p; 1740 if (isbackground(pr, tp) && 1741 ISSET(tp->t_lflag, TOSTOP) && (pr->ps_flags & PS_PPWAIT) == 0 && 1742 (pr->ps_sigacts->ps_sigignore & sigmask(SIGTTOU)) == 0 && 1743 (p->p_sigmask & sigmask(SIGTTOU)) == 0) { 1744 if (pr->ps_pgrp->pg_jobc == 0) { 1745 error = EIO; 1746 goto out; 1747 } 1748 pgsignal(pr->ps_pgrp, SIGTTOU, 1); 1749 error = ttysleep(tp, &lbolt, TTIPRI | PCATCH, ttybg, 0); 1750 if (error) 1751 goto out; 1752 goto loop; 1753 } 1754 /* 1755 * Process the user's data in at most OBUFSIZ chunks. Perform any 1756 * output translation. Keep track of high water mark, sleep on 1757 * overflow awaiting device aid in acquiring new space. 1758 */ 1759 while (uio->uio_resid > 0 || cc > 0) { 1760 if (ISSET(tp->t_lflag, FLUSHO)) { 1761 uio->uio_resid = 0; 1762 goto done; 1763 } 1764 if (tp->t_outq.c_cc > hiwat) 1765 goto ovhiwat; 1766 /* 1767 * Grab a hunk of data from the user, unless we have some 1768 * leftover from last time. 1769 */ 1770 if (cc == 0) { 1771 cc = MIN(uio->uio_resid, OBUFSIZ); 1772 cp = obuf; 1773 error = uiomove(cp, cc, uio); 1774 if (error) { 1775 cc = 0; 1776 break; 1777 } 1778 if (cc > obufcc) 1779 obufcc = cc; 1780 1781 /* duplicate /dev/console output into console buffer */ 1782 if (consbufp && cn_tab && 1783 cn_tab->cn_dev == tp->t_dev && tp->t_gen == 0) { 1784 int i; 1785 for (i = 0; i < cc; i++) { 1786 char c = cp[i]; 1787 if (c != '\0' && c != '\r' && c != 0177) 1788 msgbuf_putchar(consbufp, c); 1789 } 1790 } 1791 } 1792 /* 1793 * If nothing fancy need be done, grab those characters we 1794 * can handle without any of ttyoutput's processing and 1795 * just transfer them to the output q. For those chars 1796 * which require special processing (as indicated by the 1797 * bits in char_type), call ttyoutput. After processing 1798 * a hunk of data, look for FLUSHO so ^O's will take effect 1799 * immediately. 1800 */ 1801 while (cc > 0) { 1802 int i; 1803 if (!ISSET(tp->t_oflag, OPOST)) 1804 ce = cc; 1805 else { 1806 ce = cc - scanc((u_int)cc, cp, char_type, 1807 CCLASSMASK); 1808 /* 1809 * If ce is zero, then we're processing 1810 * a special character through ttyoutput. 1811 */ 1812 if (ce == 0) { 1813 tp->t_rocount = 0; 1814 if (ttyoutput(*cp, tp) >= 0) { 1815 /* out of space */ 1816 goto ovhiwat; 1817 } 1818 cp++; 1819 cc--; 1820 if (ISSET(tp->t_lflag, FLUSHO) || 1821 tp->t_outq.c_cc > hiwat) 1822 goto ovhiwat; 1823 continue; 1824 } 1825 } 1826 /* 1827 * A bunch of normal characters have been found. 1828 * Transfer them en masse to the output queue and 1829 * continue processing at the top of the loop. 1830 * If there are any further characters in this 1831 * <= OBUFSIZ chunk, the first should be a character 1832 * requiring special handling by ttyoutput. 1833 */ 1834 tp->t_rocount = 0; 1835 i = b_to_q(cp, ce, &tp->t_outq); 1836 ce -= i; 1837 tp->t_column += ce; 1838 cp += ce, cc -= ce, tk_nout += ce; 1839 tp->t_outcc += ce; 1840 if (i > 0) { 1841 /* out of space */ 1842 goto ovhiwat; 1843 } 1844 if (ISSET(tp->t_lflag, FLUSHO) || 1845 tp->t_outq.c_cc > hiwat) 1846 break; 1847 } 1848 ttstart(tp); 1849 } 1850 out: 1851 /* 1852 * If cc is nonzero, we leave the uio structure inconsistent, as the 1853 * offset and iov pointers have moved forward, but it doesn't matter 1854 * (the call will either return short or restart with a new uio). 1855 */ 1856 uio->uio_resid += cc; 1857 done: 1858 if (obufcc) 1859 explicit_bzero(obuf, obufcc); 1860 return (error); 1861 1862 ovhiwat: 1863 ttstart(tp); 1864 s = spltty(); 1865 /* 1866 * This can only occur if FLUSHO is set in t_lflag, 1867 * or if ttstart/oproc is synchronous (or very fast). 1868 */ 1869 if (tp->t_outq.c_cc <= hiwat) { 1870 splx(s); 1871 goto loop; 1872 } 1873 if (flag & IO_NDELAY) { 1874 splx(s); 1875 uio->uio_resid += cc; 1876 if (obufcc) 1877 explicit_bzero(obuf, obufcc); 1878 return (uio->uio_resid == cnt ? EWOULDBLOCK : 0); 1879 } 1880 SET(tp->t_state, TS_ASLEEP); 1881 error = ttysleep(tp, &tp->t_outq, TTOPRI | PCATCH, ttyout, 0); 1882 splx(s); 1883 if (error) 1884 goto out; 1885 goto loop; 1886 } 1887 1888 /* 1889 * Rubout one character from the rawq of tp 1890 * as cleanly as possible. 1891 */ 1892 void 1893 ttyrub(int c, struct tty *tp) 1894 { 1895 u_char *cp; 1896 int savecol; 1897 int tabc, s; 1898 1899 if (!ISSET(tp->t_lflag, ECHO) || ISSET(tp->t_lflag, EXTPROC)) 1900 return; 1901 CLR(tp->t_lflag, FLUSHO); 1902 if (ISSET(tp->t_lflag, ECHOE)) { 1903 if (tp->t_rocount == 0) { 1904 /* 1905 * Screwed by ttwrite; retype 1906 */ 1907 ttyretype(tp); 1908 return; 1909 } 1910 if (c == ('\t' | TTY_QUOTE) || c == ('\n' | TTY_QUOTE)) 1911 ttyrubo(tp, 2); 1912 else { 1913 CLR(c, ~TTY_CHARMASK); 1914 switch (CCLASS(c)) { 1915 case ORDINARY: 1916 ttyrubo(tp, 1); 1917 break; 1918 case BACKSPACE: 1919 case CONTROL: 1920 case NEWLINE: 1921 case RETURN: 1922 case VTAB: 1923 if (ISSET(tp->t_lflag, ECHOCTL)) 1924 ttyrubo(tp, 2); 1925 break; 1926 case TAB: 1927 if (tp->t_rocount < tp->t_rawq.c_cc) { 1928 ttyretype(tp); 1929 return; 1930 } 1931 s = spltty(); 1932 savecol = tp->t_column; 1933 SET(tp->t_state, TS_CNTTB); 1934 SET(tp->t_lflag, FLUSHO); 1935 tp->t_column = tp->t_rocol; 1936 for (cp = firstc(&tp->t_rawq, &tabc); cp; 1937 cp = nextc(&tp->t_rawq, cp, &tabc)) 1938 ttyecho(tabc, tp); 1939 CLR(tp->t_lflag, FLUSHO); 1940 CLR(tp->t_state, TS_CNTTB); 1941 splx(s); 1942 1943 /* savecol will now be length of the tab. */ 1944 savecol -= tp->t_column; 1945 tp->t_column += savecol; 1946 if (savecol > 8) 1947 savecol = 8; /* overflow screw */ 1948 while (--savecol >= 0) 1949 (void)ttyoutput('\b', tp); 1950 break; 1951 default: /* XXX */ 1952 #define PANICSTR "ttyrub: would panic c = %d, val = %d\n" 1953 (void)printf(PANICSTR, c, CCLASS(c)); 1954 #ifdef notdef 1955 panic(PANICSTR, c, CCLASS(c)); 1956 #endif 1957 } 1958 } 1959 } else if (ISSET(tp->t_lflag, ECHOPRT)) { 1960 if (!ISSET(tp->t_state, TS_ERASE)) { 1961 SET(tp->t_state, TS_ERASE); 1962 (void)ttyoutput('\\', tp); 1963 } 1964 ttyecho(c, tp); 1965 } else 1966 ttyecho(tp->t_cc[VERASE], tp); 1967 --tp->t_rocount; 1968 } 1969 1970 /* 1971 * Back over cnt characters, erasing them. 1972 */ 1973 static void 1974 ttyrubo(struct tty *tp, int cnt) 1975 { 1976 1977 while (cnt-- > 0) { 1978 (void)ttyoutput('\b', tp); 1979 (void)ttyoutput(' ', tp); 1980 (void)ttyoutput('\b', tp); 1981 } 1982 } 1983 1984 /* 1985 * ttyretype -- 1986 * Reprint the rawq line. Note, it is assumed that c_cc has already 1987 * been checked. 1988 */ 1989 void 1990 ttyretype(struct tty *tp) 1991 { 1992 u_char *cp; 1993 int s, c; 1994 1995 /* Echo the reprint character. */ 1996 if (tp->t_cc[VREPRINT] != _POSIX_VDISABLE) 1997 ttyecho(tp->t_cc[VREPRINT], tp); 1998 1999 (void)ttyoutput('\n', tp); 2000 2001 s = spltty(); 2002 for (cp = firstc(&tp->t_canq, &c); cp; cp = nextc(&tp->t_canq, cp, &c)) 2003 ttyecho(c, tp); 2004 for (cp = firstc(&tp->t_rawq, &c); cp; cp = nextc(&tp->t_rawq, cp, &c)) 2005 ttyecho(c, tp); 2006 CLR(tp->t_state, TS_ERASE); 2007 splx(s); 2008 2009 tp->t_rocount = tp->t_rawq.c_cc; 2010 tp->t_rocol = 0; 2011 } 2012 2013 /* 2014 * Echo a typed character to the terminal. 2015 */ 2016 static void 2017 ttyecho(int c, struct tty *tp) 2018 { 2019 2020 if (!ISSET(tp->t_state, TS_CNTTB)) 2021 CLR(tp->t_lflag, FLUSHO); 2022 if ((!ISSET(tp->t_lflag, ECHO) && 2023 (!ISSET(tp->t_lflag, ECHONL) || c != '\n')) || 2024 ISSET(tp->t_lflag, EXTPROC)) 2025 return; 2026 if (((ISSET(tp->t_lflag, ECHOCTL) && 2027 (ISSET(c, TTY_CHARMASK) <= 037 && c != '\t' && c != '\n')) || 2028 ISSET(c, TTY_CHARMASK) == 0177)) { 2029 (void)ttyoutput('^', tp); 2030 CLR(c, ~TTY_CHARMASK); 2031 if (c == 0177) 2032 c = '?'; 2033 else 2034 c += 'A' - 1; 2035 } 2036 (void)ttyoutput(c, tp); 2037 } 2038 2039 /* 2040 * Wakeup any writers if necessary. 2041 */ 2042 void 2043 ttwakeupwr(struct tty *tp) 2044 { 2045 2046 if (tp->t_outq.c_cc <= tp->t_lowat) { 2047 if (ISSET(tp->t_state, TS_ASLEEP)) { 2048 CLR(tp->t_state, TS_ASLEEP); 2049 wakeup(&tp->t_outq); 2050 } 2051 selwakeup(&tp->t_wsel); 2052 } 2053 } 2054 2055 /* 2056 * Wake up any readers on a tty. 2057 */ 2058 void 2059 ttwakeup(struct tty *tp) 2060 { 2061 2062 selwakeup(&tp->t_rsel); 2063 if (ISSET(tp->t_state, TS_ASYNC)) 2064 pgsignal(tp->t_pgrp, SIGIO, 1); 2065 wakeup((caddr_t)&tp->t_rawq); 2066 } 2067 2068 /* 2069 * Look up a code for a specified speed in a conversion table; 2070 * used by drivers to map software speed values to hardware parameters. 2071 */ 2072 int 2073 ttspeedtab(int speed, const struct speedtab *table) 2074 { 2075 2076 for ( ; table->sp_speed != -1; table++) 2077 if (table->sp_speed == speed) 2078 return (table->sp_code); 2079 return (-1); 2080 } 2081 2082 /* 2083 * Set tty hi and low water marks. 2084 * 2085 * Try to arrange the dynamics so there's about one second 2086 * from hi to low water. 2087 */ 2088 void 2089 ttsetwater(struct tty *tp) 2090 { 2091 int cps, x; 2092 2093 #define CLAMP(x, h, l) ((x) > h ? h : ((x) < l) ? l : (x)) 2094 2095 cps = tp->t_ospeed / 10; 2096 tp->t_lowat = x = CLAMP(cps / 2, TTMAXLOWAT, TTMINLOWAT); 2097 x += cps; 2098 tp->t_hiwat = CLAMP(x, tp->t_outq.c_cn - TTHIWATMINSPACE, TTMINHIWAT); 2099 #undef CLAMP 2100 } 2101 2102 /* 2103 * Get the total estcpu for a process, summing across threads. 2104 * Returns true if at least one thread is runnable/running. 2105 */ 2106 static int 2107 process_sum(struct process *pr, fixpt_t *estcpup) 2108 { 2109 struct proc *p; 2110 fixpt_t estcpu; 2111 int ret; 2112 2113 ret = 0; 2114 estcpu = 0; 2115 TAILQ_FOREACH(p, &pr->ps_threads, p_thr_link) { 2116 if (p->p_stat == SRUN || p->p_stat == SONPROC) 2117 ret = 1; 2118 estcpu += p->p_pctcpu; 2119 } 2120 2121 *estcpup = estcpu; 2122 return (ret); 2123 } 2124 2125 /* 2126 * Report on state of foreground process group. 2127 */ 2128 void 2129 ttyinfo(struct tty *tp) 2130 { 2131 struct process *pr, *pickpr; 2132 struct proc *p, *pick; 2133 struct timespec utime, stime; 2134 int tmp; 2135 2136 if (ttycheckoutq(tp,0) == 0) 2137 return; 2138 2139 /* Print load average. */ 2140 tmp = (averunnable.ldavg[0] * 100 + FSCALE / 2) >> FSHIFT; 2141 ttyprintf(tp, "load: %d.%02d ", tmp / 100, tmp % 100); 2142 2143 if (tp->t_session == NULL) 2144 ttyprintf(tp, "not a controlling terminal\n"); 2145 else if (tp->t_pgrp == NULL) 2146 ttyprintf(tp, "no foreground process group\n"); 2147 else if ((pr = LIST_FIRST(&tp->t_pgrp->pg_members)) == NULL) 2148 empty: ttyprintf(tp, "empty foreground process group\n"); 2149 else { 2150 const char *state; 2151 fixpt_t pctcpu, pctcpu2; 2152 int run, run2; 2153 int calc_pctcpu; 2154 long rss; 2155 2156 /* 2157 * Pick the most active process: 2158 * - prefer at least one running/runnable thread 2159 * - prefer higher total pctcpu 2160 * - prefer non-zombie 2161 * Otherwise take the most recently added to this process group 2162 */ 2163 pickpr = pr; 2164 run = process_sum(pickpr, &pctcpu); 2165 while ((pr = LIST_NEXT(pr, ps_pglist)) != NULL) { 2166 run2 = process_sum(pr, &pctcpu2); 2167 if (run) { 2168 /* 2169 * pick is running; is p running w/same or 2170 * more cpu? 2171 */ 2172 if (run2 && pctcpu2 >= pctcpu) 2173 goto update_pickpr; 2174 continue; 2175 } 2176 /* pick isn't running; is p running *or* w/more cpu? */ 2177 if (run2 || pctcpu2 > pctcpu) 2178 goto update_pickpr; 2179 2180 /* if p has less cpu or is zombie, then it's worse */ 2181 if (pctcpu2 < pctcpu || (pr->ps_flags & PS_ZOMBIE)) 2182 continue; 2183 update_pickpr: 2184 pickpr = pr; 2185 run = run2; 2186 pctcpu = pctcpu2; 2187 } 2188 2189 /* Calculate percentage cpu, resident set size. */ 2190 calc_pctcpu = (pctcpu * 10000 + FSCALE / 2) >> FSHIFT; 2191 rss = (pickpr->ps_flags & (PS_EMBRYO | PS_ZOMBIE)) ? 0 : 2192 vm_resident_count(pickpr->ps_vmspace); 2193 2194 calctsru(&pickpr->ps_tu, &utime, &stime, NULL); 2195 2196 /* Round up and print user time. */ 2197 utime.tv_nsec += 5000000; 2198 if (utime.tv_nsec >= 1000000000) { 2199 utime.tv_sec += 1; 2200 utime.tv_nsec -= 1000000000; 2201 } 2202 2203 /* Round up and print system time. */ 2204 stime.tv_nsec += 5000000; 2205 if (stime.tv_nsec >= 1000000000) { 2206 stime.tv_sec += 1; 2207 stime.tv_nsec -= 1000000000; 2208 } 2209 2210 /* 2211 * Find the most active thread: 2212 * - prefer runnable 2213 * - prefer higher pctcpu 2214 * - prefer living 2215 * Otherwise take the newest thread 2216 */ 2217 pick = p = TAILQ_FIRST(&pickpr->ps_threads); 2218 if (p == NULL) 2219 goto empty; 2220 run = p->p_stat == SRUN || p->p_stat == SONPROC; 2221 pctcpu = p->p_pctcpu; 2222 while ((p = TAILQ_NEXT(p, p_thr_link)) != NULL) { 2223 run2 = p->p_stat == SRUN || p->p_stat == SONPROC; 2224 pctcpu2 = p->p_pctcpu; 2225 if (run) { 2226 /* 2227 * pick is running; is p running w/same or 2228 * more cpu? 2229 */ 2230 if (run2 && pctcpu2 >= pctcpu) 2231 goto update_pick; 2232 continue; 2233 } 2234 /* pick isn't running; is p running *or* w/more cpu? */ 2235 if (run2 || pctcpu2 > pctcpu) 2236 goto update_pick; 2237 2238 /* if p has less cpu or is exiting, then it's worse */ 2239 if (pctcpu2 < pctcpu || p->p_flag & P_WEXIT) 2240 continue; 2241 update_pick: 2242 pick = p; 2243 run = run2; 2244 pctcpu = p->p_pctcpu; 2245 } 2246 state = pick->p_stat == SONPROC ? "running" : 2247 pick->p_stat == SRUN ? "runnable" : 2248 pick->p_wmesg ? pick->p_wmesg : "iowait"; 2249 2250 ttyprintf(tp, 2251 " cmd: %s %d [%s] %lld.%02ldu %lld.%02lds %d%% %ldk\n", 2252 pickpr->ps_comm, pickpr->ps_pid, state, 2253 (long long)utime.tv_sec, utime.tv_nsec / 10000000, 2254 (long long)stime.tv_sec, stime.tv_nsec / 10000000, 2255 calc_pctcpu / 100, rss); 2256 } 2257 tp->t_rocount = 0; /* so pending input will be retyped if BS */ 2258 } 2259 2260 /* 2261 * Output char to tty; console putchar style. 2262 */ 2263 int 2264 tputchar(int c, struct tty *tp) 2265 { 2266 int s; 2267 2268 s = spltty(); 2269 if (ISSET(tp->t_state, TS_ISOPEN) == 0 || 2270 !(ISSET(tp->t_state, TS_CARR_ON) || ISSET(tp->t_cflag, CLOCAL))) { 2271 splx(s); 2272 return (-1); 2273 } 2274 if (c == '\n') 2275 (void)ttyoutput('\r', tp); 2276 (void)ttyoutput(c, tp); 2277 ttstart(tp); 2278 splx(s); 2279 return (0); 2280 } 2281 2282 /* 2283 * Sleep on chan, returning ERESTART if tty changed while we napped and 2284 * returning any errors (e.g. EINTR/ETIMEDOUT) reported by tsleep. If 2285 * the tty is revoked, restarting a pending call will redo validation done 2286 * at the start of the call. 2287 */ 2288 int 2289 ttysleep(struct tty *tp, void *chan, int pri, char *wmesg, int timo) 2290 { 2291 int error; 2292 short gen; 2293 2294 gen = tp->t_gen; 2295 if ((error = tsleep(chan, pri, wmesg, timo)) != 0) 2296 return (error); 2297 return (tp->t_gen == gen ? 0 : ERESTART); 2298 } 2299 2300 /* 2301 * Initialise the global tty list. 2302 */ 2303 void 2304 tty_init(void) 2305 { 2306 2307 TAILQ_INIT(&ttylist); 2308 tty_count = 0; 2309 } 2310 2311 /* 2312 * Allocate a tty structure and its associated buffers, and attach it to the 2313 * tty list. 2314 */ 2315 struct tty * 2316 ttymalloc(int baud) 2317 { 2318 struct tty *tp; 2319 2320 tp = malloc(sizeof(struct tty), M_TTYS, M_WAITOK|M_ZERO); 2321 2322 if (baud == 0) 2323 baud = 115200; 2324 2325 if (baud <= 9600) 2326 tp->t_qlen = 1024; 2327 else if (baud <= 115200) 2328 tp->t_qlen = 4096; 2329 else 2330 tp->t_qlen = 8192; 2331 clalloc(&tp->t_rawq, tp->t_qlen, 1); 2332 clalloc(&tp->t_canq, tp->t_qlen, 1); 2333 /* output queue doesn't need quoting */ 2334 clalloc(&tp->t_outq, tp->t_qlen, 0); 2335 2336 TAILQ_INSERT_TAIL(&ttylist, tp, tty_link); 2337 ++tty_count; 2338 timeout_set(&tp->t_rstrt_to, ttrstrt, tp); 2339 2340 return(tp); 2341 } 2342 2343 2344 /* 2345 * Free a tty structure and its buffers, after removing it from the tty list. 2346 */ 2347 void 2348 ttyfree(struct tty *tp) 2349 { 2350 2351 --tty_count; 2352 #ifdef DIAGNOSTIC 2353 if (tty_count < 0) 2354 panic("ttyfree: tty_count < 0"); 2355 #endif 2356 TAILQ_REMOVE(&ttylist, tp, tty_link); 2357 2358 ttkqflush(&tp->t_rsel.si_note); 2359 ttkqflush(&tp->t_wsel.si_note); 2360 2361 clfree(&tp->t_rawq); 2362 clfree(&tp->t_canq); 2363 clfree(&tp->t_outq); 2364 free(tp, M_TTYS, sizeof(*tp)); 2365 } 2366 2367 void 2368 ttystats_init(struct itty **ttystats, size_t *ttystatssiz) 2369 { 2370 struct itty *itp; 2371 struct tty *tp; 2372 2373 *ttystatssiz = tty_count * sizeof(struct itty); 2374 *ttystats = mallocarray(tty_count, sizeof(struct itty), 2375 M_SYSCTL, M_WAITOK|M_ZERO); 2376 for (tp = TAILQ_FIRST(&ttylist), itp = *ttystats; tp; 2377 tp = TAILQ_NEXT(tp, tty_link), itp++) { 2378 itp->t_dev = tp->t_dev; 2379 itp->t_rawq_c_cc = tp->t_rawq.c_cc; 2380 itp->t_canq_c_cc = tp->t_canq.c_cc; 2381 itp->t_outq_c_cc = tp->t_outq.c_cc; 2382 itp->t_hiwat = tp->t_hiwat; 2383 itp->t_lowat = tp->t_lowat; 2384 itp->t_column = tp->t_column; 2385 itp->t_state = tp->t_state; 2386 itp->t_session = tp->t_session; 2387 if (tp->t_pgrp) 2388 itp->t_pgrp_pg_id = tp->t_pgrp->pg_id; 2389 else 2390 itp->t_pgrp_pg_id = 0; 2391 itp->t_line = tp->t_line; 2392 } 2393 } 2394 2395 /* 2396 * Return tty-related information. 2397 */ 2398 int 2399 sysctl_tty(int *name, u_int namelen, void *oldp, size_t *oldlenp, void *newp, 2400 size_t newlen) 2401 { 2402 int err; 2403 2404 if (namelen != 1) 2405 return (ENOTDIR); 2406 2407 switch (name[0]) { 2408 case KERN_TTY_TKNIN: 2409 return (sysctl_rdquad(oldp, oldlenp, newp, tk_nin)); 2410 case KERN_TTY_TKNOUT: 2411 return (sysctl_rdquad(oldp, oldlenp, newp, tk_nout)); 2412 case KERN_TTY_TKRAWCC: 2413 return (sysctl_rdquad(oldp, oldlenp, newp, tk_rawcc)); 2414 case KERN_TTY_TKCANCC: 2415 return (sysctl_rdquad(oldp, oldlenp, newp, tk_cancc)); 2416 case KERN_TTY_INFO: 2417 { 2418 struct itty *ttystats; 2419 size_t ttystatssiz; 2420 2421 ttystats_init(&ttystats, &ttystatssiz); 2422 err = sysctl_rdstruct(oldp, oldlenp, newp, ttystats, 2423 tty_count * sizeof(struct itty)); 2424 free(ttystats, M_SYSCTL, ttystatssiz); 2425 return (err); 2426 } 2427 default: 2428 #if NPTY > 0 2429 return (sysctl_pty(name, namelen, oldp, oldlenp, newp, newlen)); 2430 #else 2431 return (EOPNOTSUPP); 2432 #endif 2433 } 2434 /* NOTREACHED */ 2435 } 2436 2437 void 2438 ttytstamp(struct tty *tp, int octs, int ncts, int odcd, int ndcd) 2439 { 2440 int doit = 0; 2441 2442 if (ncts ^ octs) 2443 doit |= ncts ? ISSET(tp->t_flags, TS_TSTAMPCTSSET) : 2444 ISSET(tp->t_flags, TS_TSTAMPCTSCLR); 2445 if (ndcd ^ odcd) 2446 doit |= ndcd ? ISSET(tp->t_flags, TS_TSTAMPDCDSET) : 2447 ISSET(tp->t_flags, TS_TSTAMPDCDCLR); 2448 2449 if (doit) 2450 microtime(&tp->t_tv); 2451 } 2452