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