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