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