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