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