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