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