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