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