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