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