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