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