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