tty.c revision 3396
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.8 1994/10/03 01:12:18 ache 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#ifndef CBLOCKS_PER_TTY 76#define CBLOCKS_PER_TTY 10 77#endif 78 79/* 80 * Table with character classes and parity. The 8th bit indicates parity, 81 * the 7th bit indicates the character is an alphameric or underscore (for 82 * ALTWERASE), and the low 6 bits indicate delay type. If the low 6 bits 83 * are 0 then the character needs no special processing on output; classes 84 * other than 0 might be translated or (not currently) require delays. 85 */ 86#define E 0x00 /* Even parity. */ 87#define O 0x80 /* Odd parity. */ 88#define PARITY(c) (char_type[c] & O) 89 90#define ALPHA 0x40 /* Alpha or underscore. */ 91#define ISALPHA(c) (char_type[(c) & TTY_CHARMASK] & ALPHA) 92 93#define CCLASSMASK 0x3f 94#define CCLASS(c) (char_type[c] & CCLASSMASK) 95 96#define BS BACKSPACE 97#define CC CONTROL 98#define CR RETURN 99#define NA ORDINARY | ALPHA 100#define NL NEWLINE 101#define NO ORDINARY 102#define TB TAB 103#define VT VTAB 104 105char const char_type[] = { 106 E|CC, O|CC, O|CC, E|CC, O|CC, E|CC, E|CC, O|CC, /* nul - bel */ 107 O|BS, E|TB, E|NL, O|CC, E|VT, O|CR, O|CC, E|CC, /* bs - si */ 108 O|CC, E|CC, E|CC, O|CC, E|CC, O|CC, O|CC, E|CC, /* dle - etb */ 109 E|CC, O|CC, O|CC, E|CC, O|CC, E|CC, E|CC, O|CC, /* can - us */ 110 O|NO, E|NO, E|NO, O|NO, E|NO, O|NO, O|NO, E|NO, /* sp - ' */ 111 E|NO, O|NO, O|NO, E|NO, O|NO, E|NO, E|NO, O|NO, /* ( - / */ 112 E|NA, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* 0 - 7 */ 113 O|NA, E|NA, E|NO, O|NO, E|NO, O|NO, O|NO, E|NO, /* 8 - ? */ 114 O|NO, E|NA, E|NA, O|NA, E|NA, O|NA, O|NA, E|NA, /* @ - G */ 115 E|NA, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* H - O */ 116 E|NA, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* P - W */ 117 O|NA, E|NA, E|NA, O|NO, E|NO, O|NO, O|NO, O|NA, /* X - _ */ 118 E|NO, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* ` - g */ 119 O|NA, E|NA, E|NA, O|NA, E|NA, O|NA, O|NA, E|NA, /* h - o */ 120 O|NA, E|NA, E|NA, O|NA, E|NA, O|NA, O|NA, E|NA, /* p - w */ 121 E|NA, O|NA, O|NA, E|NO, O|NO, E|NO, E|NO, O|CC, /* x - del */ 122 /* 123 * Meta chars; should be settable per character set; 124 * for now, treat them all as normal characters. 125 */ 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 NA, NA, NA, NA, NA, NA, NA, NA, 139 NA, NA, NA, NA, NA, NA, NA, NA, 140 NA, NA, NA, NA, NA, NA, NA, NA, 141 NA, NA, NA, NA, NA, NA, NA, NA, 142}; 143#undef BS 144#undef CC 145#undef CR 146#undef NA 147#undef NL 148#undef NO 149#undef TB 150#undef VT 151 152/* Macros to clear/set/test flags. */ 153#define SET(t, f) (t) |= (f) 154#define CLR(t, f) (t) &= ~(f) 155#define ISSET(t, f) ((t) & (f)) 156 157/* 158 * Initial open of tty, or (re)entry to standard tty line discipline. 159 */ 160int 161ttyopen(device, tp) 162 dev_t device; 163 register struct tty *tp; 164{ 165 int s; 166 167 s = spltty(); 168 tp->t_dev = device; 169 if (!ISSET(tp->t_state, TS_ISOPEN)) { 170 SET(tp->t_state, TS_ISOPEN); 171 bzero(&tp->t_winsize, sizeof(tp->t_winsize)); 172 /* 173 * Add some cblocks to the clistfree pool. 174 */ 175 cblock_alloc_cblocks(CBLOCKS_PER_TTY); 176 } 177 CLR(tp->t_state, TS_WOPEN); 178 splx(s); 179 return (0); 180} 181 182/* 183 * Handle close() on a tty line: flush and set to initial state, 184 * bumping generation number so that pending read/write calls 185 * can detect recycling of the tty. 186 */ 187int 188ttyclose(tp) 189 register struct tty *tp; 190{ 191 extern struct tty *constty; /* Temporary virtual console. */ 192 193 if (constty == tp) 194 constty = NULL; 195 196 ttyflush(tp, FREAD | FWRITE); 197 198 tp->t_gen++; 199 tp->t_pgrp = NULL; 200 tp->t_session = NULL; 201 /* 202 * If the tty has not already been closed, free the cblocks 203 * that were allocated in ttyopen() back to the system malloc 204 * pool. 205 */ 206 if (ISSET(tp->t_state, (TS_ISOPEN|TS_WOPEN))) 207 cblock_free_cblocks(CBLOCKS_PER_TTY); 208 tp->t_state = 0; 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 SET(tp->t_state, TS_ASLEEP); 984 error = ttysleep(tp, &tp->t_outq, TTOPRI | PCATCH, ttyout, 0); 985 if (error) 986 break; 987 } 988 splx(s); 989 return (error); 990} 991 992/* 993 * Flush if successfully wait. 994 */ 995int 996ttywflush(tp) 997 struct tty *tp; 998{ 999 int error; 1000 1001 if ((error = ttywait(tp)) == 0) 1002 ttyflush(tp, FREAD); 1003 return (error); 1004} 1005 1006/* 1007 * Flush tty read and/or write queues, notifying anyone waiting. 1008 */ 1009void 1010ttyflush(tp, rw) 1011 register struct tty *tp; 1012 int rw; 1013{ 1014 register int s; 1015 1016 s = spltty(); 1017 if (rw & FREAD) { 1018 FLUSHQ(&tp->t_canq); 1019 FLUSHQ(&tp->t_rawq); 1020 tp->t_rocount = 0; 1021 tp->t_rocol = 0; 1022 CLR(tp->t_state, TS_LOCAL); 1023 ttwakeup(tp); 1024 } 1025 if (rw & FWRITE) { 1026 CLR(tp->t_state, TS_TTSTOP); 1027#ifdef sun4c /* XXX */ 1028 (*tp->t_stop)(tp, rw); 1029#else 1030 (*cdevsw[major(tp->t_dev)].d_stop)(tp, rw); 1031#endif 1032 FLUSHQ(&tp->t_outq); 1033 wakeup((caddr_t)&tp->t_outq); 1034 selwakeup(&tp->t_wsel); 1035 } 1036 splx(s); 1037} 1038 1039/* 1040 * Copy in the default termios characters. 1041 */ 1042void 1043ttychars(tp) 1044 struct tty *tp; 1045{ 1046 1047 bcopy(ttydefchars, tp->t_cc, sizeof(ttydefchars)); 1048} 1049 1050/* 1051 * Send stop character on input overflow. 1052 */ 1053static void 1054ttyblock(tp) 1055 register struct tty *tp; 1056{ 1057 register int total; 1058 1059 total = tp->t_rawq.c_cc + tp->t_canq.c_cc; 1060 if (tp->t_rawq.c_cc > TTYHOG) { 1061 ttyflush(tp, FREAD | FWRITE); 1062 CLR(tp->t_state, TS_TBLOCK); 1063 } 1064 /* 1065 * Block further input iff: current input > threshold 1066 * AND input is available to user program. 1067 */ 1068 if ((total >= TTYHOG / 2 && 1069 !ISSET(tp->t_state, TS_TBLOCK) && 1070 !ISSET(tp->t_lflag, ICANON)) || (tp->t_canq.c_cc > 0 && 1071 tp->t_cc[VSTOP] != _POSIX_VDISABLE)) { 1072 if (putc(tp->t_cc[VSTOP], &tp->t_outq) == 0) { 1073 SET(tp->t_state, TS_TBLOCK); 1074 ttstart(tp); 1075 } 1076 } 1077} 1078 1079void 1080ttrstrt(tp_arg) 1081 void *tp_arg; 1082{ 1083 struct tty *tp; 1084 int s; 1085 1086#ifdef DIAGNOSTIC 1087 if (tp_arg == NULL) 1088 panic("ttrstrt"); 1089#endif 1090 tp = tp_arg; 1091 s = spltty(); 1092 1093 CLR(tp->t_state, TS_TIMEOUT); 1094 ttstart(tp); 1095 1096 splx(s); 1097} 1098 1099int 1100ttstart(tp) 1101 struct tty *tp; 1102{ 1103 1104 if (tp->t_oproc != NULL) /* XXX: Kludge for pty. */ 1105 (*tp->t_oproc)(tp); 1106 return (0); 1107} 1108 1109/* 1110 * "close" a line discipline 1111 */ 1112int 1113ttylclose(tp, flag) 1114 struct tty *tp; 1115 int flag; 1116{ 1117 1118 if (flag & IO_NDELAY) 1119 ttyflush(tp, FREAD | FWRITE); 1120 else 1121 ttywflush(tp); 1122 return (0); 1123} 1124 1125/* 1126 * Handle modem control transition on a tty. 1127 * Flag indicates new state of carrier. 1128 * Returns 0 if the line should be turned off, otherwise 1. 1129 */ 1130int 1131ttymodem(tp, flag) 1132 register struct tty *tp; 1133 int flag; 1134{ 1135 1136 if (!ISSET(tp->t_state, TS_WOPEN) && ISSET(tp->t_cflag, MDMBUF)) { 1137 /* 1138 * MDMBUF: do flow control according to carrier flag 1139 */ 1140 if (flag) { 1141 CLR(tp->t_state, TS_TTSTOP); 1142 ttstart(tp); 1143 } else if (!ISSET(tp->t_state, TS_TTSTOP)) { 1144 SET(tp->t_state, TS_TTSTOP); 1145#ifdef sun4c /* XXX */ 1146 (*tp->t_stop)(tp, 0); 1147#else 1148 (*cdevsw[major(tp->t_dev)].d_stop)(tp, 0); 1149#endif 1150 } 1151 } else if (flag == 0) { 1152 /* 1153 * Lost carrier. 1154 */ 1155 CLR(tp->t_state, TS_CARR_ON); 1156 if (ISSET(tp->t_state, TS_ISOPEN) && 1157 !ISSET(tp->t_cflag, CLOCAL)) { 1158 if (tp->t_session && tp->t_session->s_leader) 1159 psignal(tp->t_session->s_leader, SIGHUP); 1160 ttyflush(tp, FREAD | FWRITE); 1161 return (0); 1162 } 1163 } else { 1164 /* 1165 * Carrier now on. 1166 */ 1167 SET(tp->t_state, TS_CARR_ON); 1168 ttwakeup(tp); 1169 } 1170 return (1); 1171} 1172 1173/* 1174 * Default modem control routine (for other line disciplines). 1175 * Return argument flag, to turn off device on carrier drop. 1176 */ 1177int 1178nullmodem(tp, flag) 1179 register struct tty *tp; 1180 int flag; 1181{ 1182 1183 if (flag) 1184 SET(tp->t_state, TS_CARR_ON); 1185 else { 1186 CLR(tp->t_state, TS_CARR_ON); 1187 if (!ISSET(tp->t_cflag, CLOCAL)) { 1188 if (tp->t_session && tp->t_session->s_leader) 1189 psignal(tp->t_session->s_leader, SIGHUP); 1190 return (0); 1191 } 1192 } 1193 return (1); 1194} 1195 1196/* 1197 * Reinput pending characters after state switch 1198 * call at spltty(). 1199 */ 1200void 1201ttypend(tp) 1202 register struct tty *tp; 1203{ 1204 struct clist tq; 1205 register c; 1206 1207 CLR(tp->t_lflag, PENDIN); 1208 SET(tp->t_state, TS_TYPEN); 1209 tq = tp->t_rawq; 1210 tp->t_rawq.c_cc = 0; 1211 tp->t_rawq.c_cf = tp->t_rawq.c_cl = 0; 1212 while ((c = getc(&tq)) >= 0) 1213 ttyinput(c, tp); 1214 CLR(tp->t_state, TS_TYPEN); 1215} 1216 1217/* 1218 * Process a read call on a tty device. 1219 */ 1220int 1221ttread(tp, uio, flag) 1222 register struct tty *tp; 1223 struct uio *uio; 1224 int flag; 1225{ 1226 register struct clist *qp; 1227 register int c; 1228 register tcflag_t lflag; 1229 register cc_t *cc = tp->t_cc; 1230 register struct proc *p = curproc; 1231 int s, first, error = 0, carrier; 1232 int has_stime = 0, last_cc = 0; 1233 long slp = 0; /* XXX this should be renamed `timo'. */ 1234 1235loop: 1236 s = spltty(); 1237 lflag = tp->t_lflag; 1238 /* 1239 * take pending input first 1240 */ 1241 if (ISSET(lflag, PENDIN)) { 1242 ttypend(tp); 1243 splx(s); /* reduce latency */ 1244 s = spltty(); 1245 lflag = tp->t_lflag; /* XXX ttypend() clobbers it */ 1246 } 1247 1248 /* 1249 * Hang process if it's in the background. 1250 */ 1251 if (isbackground(p, tp)) { 1252 splx(s); 1253 if ((p->p_sigignore & sigmask(SIGTTIN)) || 1254 (p->p_sigmask & sigmask(SIGTTIN)) || 1255 p->p_flag & P_PPWAIT || p->p_pgrp->pg_jobc == 0) 1256 return (EIO); 1257 pgsignal(p->p_pgrp, SIGTTIN, 1); 1258 error = ttysleep(tp, &lbolt, TTIPRI | PCATCH, ttybg, 0); 1259 if (error) 1260 return (error); 1261 goto loop; 1262 } 1263 1264 /* 1265 * If canonical, use the canonical queue, 1266 * else use the raw queue. 1267 * 1268 * (should get rid of clists...) 1269 */ 1270 qp = ISSET(lflag, ICANON) ? &tp->t_canq : &tp->t_rawq; 1271 1272 if (flag & IO_NDELAY) { 1273 if (qp->c_cc > 0) 1274 goto read; 1275 carrier = ISSET(tp->t_state, TS_CARR_ON) || 1276 ISSET(tp->t_cflag, CLOCAL); 1277 if (!carrier && ISSET(tp->t_state, TS_ISOPEN) || 1278 !ISSET(lflag, ICANON) && cc[VMIN] == 0) { 1279 splx(s); 1280 return (0); 1281 } 1282 splx(s); 1283 return (EWOULDBLOCK); 1284 } 1285 if (!ISSET(lflag, ICANON)) { 1286 int m = cc[VMIN]; 1287 long t = cc[VTIME]; 1288 struct timeval stime, timecopy; 1289 int x; 1290 1291 /* 1292 * Check each of the four combinations. 1293 * (m > 0 && t == 0) is the normal read case. 1294 * It should be fairly efficient, so we check that and its 1295 * companion case (m == 0 && t == 0) first. 1296 * For the other two cases, we compute the target sleep time 1297 * into slp. 1298 */ 1299 if (t == 0) { 1300 if (qp->c_cc < m) 1301 goto sleep; 1302 if (qp->c_cc > 0) 1303 goto read; 1304 1305 /* m, t and qp->c_cc are all 0. 0 is enough input. */ 1306 splx(s); 1307 return (0); 1308 } 1309 t *= 100000; /* time in us */ 1310#define diff(t1, t2) (((t1).tv_sec - (t2).tv_sec) * 1000000 + \ 1311 ((t1).tv_usec - (t2).tv_usec)) 1312 if (m > 0) { 1313 if (qp->c_cc <= 0) 1314 goto sleep; 1315 if (qp->c_cc >= m) 1316 goto read; 1317 x = splclock(); 1318 timecopy = time; 1319 splx(x); 1320 if (!has_stime) { 1321 /* first character, start timer */ 1322 has_stime = 1; 1323 stime = timecopy; 1324 slp = t; 1325 } else if (qp->c_cc > last_cc) { 1326 /* got a character, restart timer */ 1327 stime = timecopy; 1328 slp = t; 1329 } else { 1330 /* nothing, check expiration */ 1331 slp = t - diff(timecopy, stime); 1332 if (slp <= 0) 1333 goto read; 1334 } 1335 last_cc = qp->c_cc; 1336 } else { /* m == 0 */ 1337 if (qp->c_cc > 0) 1338 goto read; 1339 x = splclock(); 1340 timecopy = time; 1341 splx(x); 1342 if (!has_stime) { 1343 has_stime = 1; 1344 stime = timecopy; 1345 slp = t; 1346 } else { 1347 slp = t - diff(timecopy, stime); 1348 if (slp <= 0) { 1349 /* Timed out, but 0 is enough input. */ 1350 splx(s); 1351 return (0); 1352 } 1353 } 1354 } 1355#undef diff 1356 /* 1357 * Rounding down may make us wake up just short 1358 * of the target, so we round up. 1359 * The formula is ceiling(slp * hz/1000000). 1360 * 32-bit arithmetic is enough for hz < 169. 1361 * XXX see hzto() for how to avoid overflow if hz 1362 * is large (divide by `tick' and/or arrange to 1363 * use hzto() if hz is large). 1364 */ 1365 slp = (long) (((u_long)slp * hz) + 999999) / 1000000; 1366 goto sleep; 1367 } 1368 1369 /* 1370 * If there is no input, sleep on rawq 1371 * awaiting hardware receipt and notification. 1372 * If we have data, we don't need to check for carrier. 1373 */ 1374 if (qp->c_cc <= 0) { 1375sleep: 1376 carrier = ISSET(tp->t_state, TS_CARR_ON) || 1377 ISSET(tp->t_cflag, CLOCAL); 1378 if (!carrier && ISSET(tp->t_state, TS_ISOPEN)) { 1379 splx(s); 1380 return (0); /* EOF */ 1381 } 1382 error = ttysleep(tp, &tp->t_rawq, TTIPRI | PCATCH, 1383 carrier ? ttyin : ttopen, (int)slp); 1384 splx(s); 1385 if (error == EWOULDBLOCK) 1386 error = 0; 1387 else if (error) 1388 return (error); 1389 /* 1390 * XXX what happens if another process eats some input 1391 * while we are asleep (not just here)? It would be 1392 * safest to detect changes and reset our state variables 1393 * (has_stime and last_cc). 1394 */ 1395 slp = 0; 1396 goto loop; 1397 } 1398read: 1399 splx(s); 1400 /* 1401 * Input present, check for input mapping and processing. 1402 */ 1403 first = 1; 1404 while ((c = getc(qp)) >= 0) { 1405 /* 1406 * delayed suspend (^Y) 1407 */ 1408 if (CCEQ(cc[VDSUSP], c) && ISSET(lflag, ISIG)) { 1409 pgsignal(tp->t_pgrp, SIGTSTP, 1); 1410 if (first) { 1411 error = ttysleep(tp, 1412 &lbolt, TTIPRI | PCATCH, ttybg, 0); 1413 if (error) 1414 break; 1415 goto loop; 1416 } 1417 break; 1418 } 1419 /* 1420 * Interpret EOF only in canonical mode. 1421 */ 1422 if (CCEQ(cc[VEOF], c) && ISSET(lflag, ICANON)) 1423 break; 1424 /* 1425 * Give user character. 1426 */ 1427 error = ureadc(c, uio); 1428 if (error) 1429 break; 1430 if (uio->uio_resid == 0) 1431 break; 1432 /* 1433 * In canonical mode check for a "break character" 1434 * marking the end of a "line of input". 1435 */ 1436 if (ISSET(lflag, ICANON) && TTBREAKC(c)) 1437 break; 1438 first = 0; 1439 } 1440 /* 1441 * Look to unblock output now that (presumably) 1442 * the input queue has gone down. 1443 */ 1444 s = spltty(); 1445 if (ISSET(tp->t_state, TS_TBLOCK) && tp->t_rawq.c_cc < TTYHOG/5) { 1446 if (cc[VSTART] != _POSIX_VDISABLE && 1447 putc(cc[VSTART], &tp->t_outq) == 0) { 1448 CLR(tp->t_state, TS_TBLOCK); 1449 ttstart(tp); 1450 } 1451 } 1452 splx(s); 1453 return (error); 1454} 1455 1456/* 1457 * Check the output queue on tp for space for a kernel message (from uprintf 1458 * or tprintf). Allow some space over the normal hiwater mark so we don't 1459 * lose messages due to normal flow control, but don't let the tty run amok. 1460 * Sleeps here are not interruptible, but we return prematurely if new signals 1461 * arrive. 1462 */ 1463int 1464ttycheckoutq(tp, wait) 1465 register struct tty *tp; 1466 int wait; 1467{ 1468 int hiwat, s, oldsig; 1469 1470 hiwat = tp->t_hiwat; 1471 s = spltty(); 1472 oldsig = wait ? curproc->p_siglist : 0; 1473 if (tp->t_outq.c_cc > hiwat + 200) 1474 while (tp->t_outq.c_cc > hiwat) { 1475 ttstart(tp); 1476 if (wait == 0 || curproc->p_siglist != oldsig) { 1477 splx(s); 1478 return (0); 1479 } 1480 timeout((void (*)__P((void *)))wakeup, 1481 (void *)&tp->t_outq, hz); 1482 SET(tp->t_state, TS_ASLEEP); 1483 (void) tsleep((caddr_t)&tp->t_outq, PZERO - 1, "ttoutq", 0); 1484 } 1485 splx(s); 1486 return (1); 1487} 1488 1489/* 1490 * Process a write call on a tty device. 1491 */ 1492int 1493ttwrite(tp, uio, flag) 1494 register struct tty *tp; 1495 register struct uio *uio; 1496 int flag; 1497{ 1498 register char *cp = 0; 1499 register int cc, ce; 1500 register struct proc *p; 1501 int i, hiwat, cnt, error, s; 1502 char obuf[OBUFSIZ]; 1503 1504 hiwat = tp->t_hiwat; 1505 cnt = uio->uio_resid; 1506 error = 0; 1507 cc = 0; 1508loop: 1509 s = spltty(); 1510 if (!ISSET(tp->t_state, TS_CARR_ON) && 1511 !ISSET(tp->t_cflag, CLOCAL)) { 1512 if (ISSET(tp->t_state, TS_ISOPEN)) { 1513 splx(s); 1514 return (EIO); 1515 } else if (flag & IO_NDELAY) { 1516 splx(s); 1517 error = EWOULDBLOCK; 1518 goto out; 1519 } else { 1520 /* Sleep awaiting carrier. */ 1521 error = ttysleep(tp, 1522 &tp->t_rawq, TTIPRI | PCATCH,ttopen, 0); 1523 splx(s); 1524 if (error) 1525 goto out; 1526 goto loop; 1527 } 1528 } 1529 splx(s); 1530 /* 1531 * Hang the process if it's in the background. 1532 */ 1533 p = curproc; 1534 if (isbackground(p, tp) && 1535 ISSET(tp->t_lflag, TOSTOP) && (p->p_flag & P_PPWAIT) == 0 && 1536 (p->p_sigignore & sigmask(SIGTTOU)) == 0 && 1537 (p->p_sigmask & sigmask(SIGTTOU)) == 0 && 1538 p->p_pgrp->pg_jobc) { 1539 pgsignal(p->p_pgrp, SIGTTOU, 1); 1540 error = ttysleep(tp, &lbolt, TTIPRI | PCATCH, ttybg, 0); 1541 if (error) 1542 goto out; 1543 goto loop; 1544 } 1545 /* 1546 * Process the user's data in at most OBUFSIZ chunks. Perform any 1547 * output translation. Keep track of high water mark, sleep on 1548 * overflow awaiting device aid in acquiring new space. 1549 */ 1550 while (uio->uio_resid > 0 || cc > 0) { 1551 if (ISSET(tp->t_lflag, FLUSHO)) { 1552 uio->uio_resid = 0; 1553 return (0); 1554 } 1555 if (tp->t_outq.c_cc > hiwat) 1556 goto ovhiwat; 1557 /* 1558 * Grab a hunk of data from the user, unless we have some 1559 * leftover from last time. 1560 */ 1561 if (cc == 0) { 1562 cc = min(uio->uio_resid, OBUFSIZ); 1563 cp = obuf; 1564 error = uiomove(cp, cc, uio); 1565 if (error) { 1566 cc = 0; 1567 break; 1568 } 1569 } 1570 /* 1571 * If nothing fancy need be done, grab those characters we 1572 * can handle without any of ttyoutput's processing and 1573 * just transfer them to the output q. For those chars 1574 * which require special processing (as indicated by the 1575 * bits in char_type), call ttyoutput. After processing 1576 * a hunk of data, look for FLUSHO so ^O's will take effect 1577 * immediately. 1578 */ 1579 while (cc > 0) { 1580 if (!ISSET(tp->t_oflag, OPOST)) 1581 ce = cc; 1582 else { 1583 ce = cc - scanc((u_int)cc, (u_char *)cp, 1584 (u_char *)char_type, CCLASSMASK); 1585 /* 1586 * If ce is zero, then we're processing 1587 * a special character through ttyoutput. 1588 */ 1589 if (ce == 0) { 1590 tp->t_rocount = 0; 1591 if (ttyoutput(*cp, tp) >= 0) { 1592 /* No Clists, wait a bit. */ 1593 ttstart(tp); 1594 error = ttysleep(tp, &lbolt, 1595 TTOPRI | PCATCH, ttybuf, 0); 1596 if (error) 1597 break; 1598 goto loop; 1599 } 1600 cp++; 1601 cc--; 1602 if (ISSET(tp->t_lflag, FLUSHO) || 1603 tp->t_outq.c_cc > hiwat) 1604 goto ovhiwat; 1605 continue; 1606 } 1607 } 1608 /* 1609 * A bunch of normal characters have been found. 1610 * Transfer them en masse to the output queue and 1611 * continue processing at the top of the loop. 1612 * If there are any further characters in this 1613 * <= OBUFSIZ chunk, the first should be a character 1614 * requiring special handling by ttyoutput. 1615 */ 1616 tp->t_rocount = 0; 1617 i = b_to_q(cp, ce, &tp->t_outq); 1618 ce -= i; 1619 tp->t_column += ce; 1620 cp += ce, cc -= ce, tk_nout += ce; 1621 tp->t_outcc += ce; 1622 if (i > 0) { 1623 /* No Clists, wait a bit. */ 1624 ttstart(tp); 1625 error = ttysleep(tp, 1626 &lbolt, TTOPRI | PCATCH, ttybuf, 0); 1627 if (error) 1628 break; 1629 goto loop; 1630 } 1631 if (ISSET(tp->t_lflag, FLUSHO) || 1632 tp->t_outq.c_cc > hiwat) 1633 break; 1634 } 1635 ttstart(tp); 1636 } 1637out: 1638 /* 1639 * If cc is nonzero, we leave the uio structure inconsistent, as the 1640 * offset and iov pointers have moved forward, but it doesn't matter 1641 * (the call will either return short or restart with a new uio). 1642 */ 1643 uio->uio_resid += cc; 1644 return (error); 1645 1646ovhiwat: 1647 ttstart(tp); 1648 s = spltty(); 1649 /* 1650 * This can only occur if FLUSHO is set in t_lflag, 1651 * or if ttstart/oproc is synchronous (or very fast). 1652 */ 1653 if (tp->t_outq.c_cc <= hiwat) { 1654 splx(s); 1655 goto loop; 1656 } 1657 if (flag & IO_NDELAY) { 1658 splx(s); 1659 uio->uio_resid += cc; 1660 return (uio->uio_resid == cnt ? EWOULDBLOCK : 0); 1661 } 1662 if (tp->t_outq.c_cc || ISSET(tp->t_state, TS_BUSY)) { 1663 SET(tp->t_state, TS_ASLEEP); 1664 error = ttysleep(tp, &tp->t_outq, TTOPRI | PCATCH, ttyout, 0); 1665 } 1666 splx(s); 1667 if (error) 1668 goto out; 1669 goto loop; 1670} 1671 1672/* 1673 * Rubout one character from the rawq of tp 1674 * as cleanly as possible. 1675 */ 1676void 1677ttyrub(c, tp) 1678 register int c; 1679 register struct tty *tp; 1680{ 1681 register char *cp; 1682 register int savecol; 1683 int tabc, s; 1684 1685 if (!ISSET(tp->t_lflag, ECHO) || ISSET(tp->t_lflag, EXTPROC)) 1686 return; 1687 CLR(tp->t_lflag, FLUSHO); 1688 if (ISSET(tp->t_lflag, ECHOE)) { 1689 if (tp->t_rocount == 0) { 1690 /* 1691 * Screwed by ttwrite; retype 1692 */ 1693 ttyretype(tp); 1694 return; 1695 } 1696 if (c == ('\t' | TTY_QUOTE) || c == ('\n' | TTY_QUOTE)) 1697 ttyrubo(tp, 2); 1698 else { 1699 CLR(c, ~TTY_CHARMASK); 1700 switch (CCLASS(c)) { 1701 case ORDINARY: 1702 ttyrubo(tp, 1); 1703 break; 1704 case BACKSPACE: 1705 case CONTROL: 1706 case NEWLINE: 1707 case RETURN: 1708 case VTAB: 1709 if (ISSET(tp->t_lflag, ECHOCTL)) 1710 ttyrubo(tp, 2); 1711 break; 1712 case TAB: 1713 if (tp->t_rocount < tp->t_rawq.c_cc) { 1714 ttyretype(tp); 1715 return; 1716 } 1717 s = spltty(); 1718 savecol = tp->t_column; 1719 SET(tp->t_state, TS_CNTTB); 1720 SET(tp->t_lflag, FLUSHO); 1721 tp->t_column = tp->t_rocol; 1722 cp = tp->t_rawq.c_cf; 1723 if (cp) 1724 tabc = *cp; /* XXX FIX NEXTC */ 1725 for (; cp; cp = nextc(&tp->t_rawq, cp, &tabc)) 1726 ttyecho(tabc, tp); 1727 CLR(tp->t_lflag, FLUSHO); 1728 CLR(tp->t_state, TS_CNTTB); 1729 splx(s); 1730 1731 /* savecol will now be length of the tab. */ 1732 savecol -= tp->t_column; 1733 tp->t_column += savecol; 1734 if (savecol > 8) 1735 savecol = 8; /* overflow screw */ 1736 while (--savecol >= 0) 1737 (void)ttyoutput('\b', tp); 1738 break; 1739 default: /* XXX */ 1740#define PANICSTR "ttyrub: would panic c = %d, val = %d\n" 1741 (void)printf(PANICSTR, c, CCLASS(c)); 1742#ifdef notdef 1743 panic(PANICSTR, c, CCLASS(c)); 1744#endif 1745 } 1746 } 1747 } else if (ISSET(tp->t_lflag, ECHOPRT)) { 1748 if (!ISSET(tp->t_state, TS_ERASE)) { 1749 SET(tp->t_state, TS_ERASE); 1750 (void)ttyoutput('\\', tp); 1751 } 1752 ttyecho(c, tp); 1753 } else 1754 ttyecho(tp->t_cc[VERASE], tp); 1755 --tp->t_rocount; 1756} 1757 1758/* 1759 * Back over cnt characters, erasing them. 1760 */ 1761static void 1762ttyrubo(tp, cnt) 1763 register struct tty *tp; 1764 int cnt; 1765{ 1766 1767 while (cnt-- > 0) { 1768 (void)ttyoutput('\b', tp); 1769 (void)ttyoutput(' ', tp); 1770 (void)ttyoutput('\b', tp); 1771 } 1772} 1773 1774/* 1775 * ttyretype -- 1776 * Reprint the rawq line. Note, it is assumed that c_cc has already 1777 * been checked. 1778 */ 1779void 1780ttyretype(tp) 1781 register struct tty *tp; 1782{ 1783 register char *cp; 1784 int s, c; 1785 1786 /* Echo the reprint character. */ 1787 if (tp->t_cc[VREPRINT] != _POSIX_VDISABLE) 1788 ttyecho(tp->t_cc[VREPRINT], tp); 1789 1790 (void)ttyoutput('\n', tp); 1791 1792 /* 1793 * XXX 1794 * FIX: NEXTC IS BROKEN - DOESN'T CHECK QUOTE 1795 * BIT OF FIRST CHAR. 1796 */ 1797 s = spltty(); 1798 for (cp = tp->t_canq.c_cf, c = (cp != NULL ? *cp : 0); 1799 cp != NULL; cp = nextc(&tp->t_canq, cp, &c)) 1800 ttyecho(c, tp); 1801 for (cp = tp->t_rawq.c_cf, c = (cp != NULL ? *cp : 0); 1802 cp != NULL; cp = nextc(&tp->t_rawq, cp, &c)) 1803 ttyecho(c, tp); 1804 CLR(tp->t_state, TS_ERASE); 1805 splx(s); 1806 1807 tp->t_rocount = tp->t_rawq.c_cc; 1808 tp->t_rocol = 0; 1809} 1810 1811/* 1812 * Echo a typed character to the terminal. 1813 */ 1814static void 1815ttyecho(c, tp) 1816 register int c; 1817 register struct tty *tp; 1818{ 1819 1820 if (!ISSET(tp->t_state, TS_CNTTB)) 1821 CLR(tp->t_lflag, FLUSHO); 1822 if ((!ISSET(tp->t_lflag, ECHO) && 1823 (!ISSET(tp->t_lflag, ECHONL) || c == '\n')) || 1824 ISSET(tp->t_lflag, EXTPROC)) 1825 return; 1826 if (ISSET(tp->t_lflag, ECHOCTL) && 1827 ((ISSET(c, TTY_CHARMASK) <= 037 && c != '\t' && c != '\n') || 1828 ISSET(c, TTY_CHARMASK) == 0177)) { 1829 (void)ttyoutput('^', tp); 1830 CLR(c, ~TTY_CHARMASK); 1831 if (c == 0177) 1832 c = '?'; 1833 else 1834 c += 'A' - 1; 1835 } 1836 (void)ttyoutput(c, tp); 1837} 1838 1839/* 1840 * Wake up any readers on a tty. 1841 */ 1842void 1843ttwakeup(tp) 1844 register struct tty *tp; 1845{ 1846 1847 selwakeup(&tp->t_rsel); 1848 if (ISSET(tp->t_state, TS_ASYNC)) 1849 pgsignal(tp->t_pgrp, SIGIO, 1); 1850 wakeup((caddr_t)&tp->t_rawq); 1851} 1852 1853/* 1854 * Look up a code for a specified speed in a conversion table; 1855 * used by drivers to map software speed values to hardware parameters. 1856 */ 1857int 1858ttspeedtab(speed, table) 1859 int speed; 1860 register struct speedtab *table; 1861{ 1862 1863 for ( ; table->sp_speed != -1; table++) 1864 if (table->sp_speed == speed) 1865 return (table->sp_code); 1866 return (-1); 1867} 1868 1869/* 1870 * Set tty hi and low water marks. 1871 * 1872 * Try to arrange the dynamics so there's about one second 1873 * from hi to low water. 1874 * 1875 */ 1876void 1877ttsetwater(tp) 1878 struct tty *tp; 1879{ 1880 register int cps, x; 1881 1882#define CLAMP(x, h, l) ((x) > h ? h : ((x) < l) ? l : (x)) 1883 1884 cps = tp->t_ospeed / 10; 1885 tp->t_lowat = x = CLAMP(cps / 2, TTMAXLOWAT, TTMINLOWAT); 1886 x += cps; 1887 x = CLAMP(x, TTMAXHIWAT, TTMINHIWAT); 1888 tp->t_hiwat = roundup(x, CBSIZE); 1889#undef CLAMP 1890} 1891 1892/* 1893 * Report on state of foreground process group. 1894 */ 1895void 1896ttyinfo(tp) 1897 register struct tty *tp; 1898{ 1899 register struct proc *p, *pick; 1900 struct timeval utime, stime; 1901 int tmp; 1902 1903 if (ttycheckoutq(tp,0) == 0) 1904 return; 1905 1906 /* Print load average. */ 1907 tmp = (averunnable.ldavg[0] * 100 + FSCALE / 2) >> FSHIFT; 1908 ttyprintf(tp, "load: %d.%02d ", tmp / 100, tmp % 100); 1909 1910 if (tp->t_session == NULL) 1911 ttyprintf(tp, "not a controlling terminal\n"); 1912 else if (tp->t_pgrp == NULL) 1913 ttyprintf(tp, "no foreground process group\n"); 1914 else if ((p = tp->t_pgrp->pg_mem) == NULL) 1915 ttyprintf(tp, "empty foreground process group\n"); 1916 else { 1917 /* Pick interesting process. */ 1918 for (pick = NULL; p != NULL; p = p->p_pgrpnxt) 1919 if (proc_compare(pick, p)) 1920 pick = p; 1921 1922 ttyprintf(tp, " cmd: %s %d [%s] ", pick->p_comm, pick->p_pid, 1923 pick->p_stat == SRUN ? "running" : 1924 pick->p_wmesg ? pick->p_wmesg : "iowait"); 1925 1926 calcru(pick, &utime, &stime, NULL); 1927 1928 /* Print user time. */ 1929 ttyprintf(tp, "%d.%02du ", 1930 utime.tv_sec, (utime.tv_usec + 5000) / 10000); 1931 1932 /* Print system time. */ 1933 ttyprintf(tp, "%d.%02ds ", 1934 stime.tv_sec, (stime.tv_usec + 5000) / 10000); 1935 1936#define pgtok(a) (((a) * NBPG) / 1024) 1937 /* Print percentage cpu, resident set size. */ 1938 tmp = (pick->p_pctcpu * 10000 + FSCALE / 2) >> FSHIFT; 1939 ttyprintf(tp, "%d%% %dk\n", 1940 tmp / 100, 1941 pick->p_stat == SIDL || pick->p_stat == SZOMB ? 0 : 1942#ifdef pmap_resident_count 1943 pgtok(pmap_resident_count(&pick->p_vmspace->vm_pmap)) 1944#else 1945 pgtok(pick->p_vmspace->vm_rssize) 1946#endif 1947 ); 1948 } 1949 tp->t_rocount = 0; /* so pending input will be retyped if BS */ 1950} 1951 1952/* 1953 * Returns 1 if p2 is "better" than p1 1954 * 1955 * The algorithm for picking the "interesting" process is thus: 1956 * 1957 * 1) Only foreground processes are eligible - implied. 1958 * 2) Runnable processes are favored over anything else. The runner 1959 * with the highest cpu utilization is picked (p_estcpu). Ties are 1960 * broken by picking the highest pid. 1961 * 3) The sleeper with the shortest sleep time is next. With ties, 1962 * we pick out just "short-term" sleepers (P_SINTR == 0). 1963 * 4) Further ties are broken by picking the highest pid. 1964 */ 1965#define ISRUN(p) (((p)->p_stat == SRUN) || ((p)->p_stat == SIDL)) 1966#define TESTAB(a, b) ((a)<<1 | (b)) 1967#define ONLYA 2 1968#define ONLYB 1 1969#define BOTH 3 1970 1971static int 1972proc_compare(p1, p2) 1973 register struct proc *p1, *p2; 1974{ 1975 1976 if (p1 == NULL) 1977 return (1); 1978 /* 1979 * see if at least one of them is runnable 1980 */ 1981 switch (TESTAB(ISRUN(p1), ISRUN(p2))) { 1982 case ONLYA: 1983 return (0); 1984 case ONLYB: 1985 return (1); 1986 case BOTH: 1987 /* 1988 * tie - favor one with highest recent cpu utilization 1989 */ 1990 if (p2->p_estcpu > p1->p_estcpu) 1991 return (1); 1992 if (p1->p_estcpu > p2->p_estcpu) 1993 return (0); 1994 return (p2->p_pid > p1->p_pid); /* tie - return highest pid */ 1995 } 1996 /* 1997 * weed out zombies 1998 */ 1999 switch (TESTAB(p1->p_stat == SZOMB, p2->p_stat == SZOMB)) { 2000 case ONLYA: 2001 return (1); 2002 case ONLYB: 2003 return (0); 2004 case BOTH: 2005 return (p2->p_pid > p1->p_pid); /* tie - return highest pid */ 2006 } 2007 /* 2008 * pick the one with the smallest sleep time 2009 */ 2010 if (p2->p_slptime > p1->p_slptime) 2011 return (0); 2012 if (p1->p_slptime > p2->p_slptime) 2013 return (1); 2014 /* 2015 * favor one sleeping in a non-interruptible sleep 2016 */ 2017 if (p1->p_flag & P_SINTR && (p2->p_flag & P_SINTR) == 0) 2018 return (1); 2019 if (p2->p_flag & P_SINTR && (p1->p_flag & P_SINTR) == 0) 2020 return (0); 2021 return (p2->p_pid > p1->p_pid); /* tie - return highest pid */ 2022} 2023 2024/* 2025 * Output char to tty; console putchar style. 2026 */ 2027int 2028tputchar(c, tp) 2029 int c; 2030 struct tty *tp; 2031{ 2032 register int s; 2033 2034 s = spltty(); 2035 if (ISSET(tp->t_state, 2036 TS_CARR_ON | TS_ISOPEN) != (TS_CARR_ON | TS_ISOPEN)) { 2037 splx(s); 2038 return (-1); 2039 } 2040 if (c == '\n') 2041 (void)ttyoutput('\r', tp); 2042 (void)ttyoutput(c, tp); 2043 ttstart(tp); 2044 splx(s); 2045 return (0); 2046} 2047 2048/* 2049 * Sleep on chan, returning ERESTART if tty changed while we napped and 2050 * returning any errors (e.g. EINTR/ETIMEDOUT) reported by tsleep. If 2051 * the tty is revoked, restarting a pending call will redo validation done 2052 * at the start of the call. 2053 */ 2054int 2055ttysleep(tp, chan, pri, wmesg, timo) 2056 struct tty *tp; 2057 void *chan; 2058 int pri, timo; 2059 char *wmesg; 2060{ 2061 int error; 2062 short gen; 2063 2064 gen = tp->t_gen; 2065 error = tsleep(chan, pri, wmesg, timo); 2066 if (error) 2067 return (error); 2068 return (tp->t_gen == gen ? 0 : ERESTART); 2069} 2070