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