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