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.35 2007/01/01 22:51:17 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 proc *p = td->td_proc; 764 int error; 765 766 KKASSERT(p); 767 768 /* If the ioctl involves modification, hang if in the background. */ 769 switch (cmd) { 770 case TIOCCBRK: 771 case TIOCCONS: 772 case TIOCDRAIN: 773 case TIOCEXCL: 774 case TIOCFLUSH: 775 #ifdef TIOCHPCL 776 case TIOCHPCL: 777 #endif 778 case TIOCNXCL: 779 case TIOCSBRK: 780 case TIOCSCTTY: 781 case TIOCSDRAINWAIT: 782 case TIOCSETA: 783 case TIOCSETAF: 784 case TIOCSETAW: 785 case TIOCSETD: 786 case TIOCSPGRP: 787 case TIOCSTART: 788 case TIOCSTAT: 789 case TIOCSTI: 790 case TIOCSTOP: 791 case TIOCSWINSZ: 792 #if defined(COMPAT_43) || defined(COMPAT_SUNOS) 793 case TIOCLBIC: 794 case TIOCLBIS: 795 case TIOCLSET: 796 case TIOCSETC: 797 case OTIOCSETD: 798 case TIOCSETN: 799 case TIOCSETP: 800 case TIOCSLTC: 801 #endif 802 while (isbackground(p, tp) && !(p->p_flag & P_PPWAIT) && 803 !SIGISMEMBER(p->p_sigignore, SIGTTOU) && 804 !SIGISMEMBER(p->p_sigmask, SIGTTOU)) { 805 if (p->p_pgrp->pg_jobc == 0) 806 return (EIO); 807 pgsignal(p->p_pgrp, SIGTTOU, 1); 808 error = ttysleep(tp, &lbolt, PCATCH, "ttybg1", 809 0); 810 if (error) 811 return (error); 812 } 813 break; 814 } 815 816 switch (cmd) { /* Process the ioctl. */ 817 case FIOASYNC: /* set/clear async i/o */ 818 crit_enter(); 819 if (*(int *)data) 820 SET(tp->t_state, TS_ASYNC); 821 else 822 CLR(tp->t_state, TS_ASYNC); 823 crit_exit(); 824 break; 825 case FIONREAD: /* get # bytes to read */ 826 crit_enter(); 827 *(int *)data = ttnread(tp); 828 crit_exit(); 829 break; 830 831 case FIOSETOWN: 832 /* 833 * Policy -- Don't allow FIOSETOWN on someone else's 834 * controlling tty 835 */ 836 if (tp->t_session != NULL && !isctty(p, tp)) 837 return (ENOTTY); 838 839 error = fsetown(*(int *)data, &tp->t_sigio); 840 if (error) 841 return (error); 842 break; 843 case FIOGETOWN: 844 if (tp->t_session != NULL && !isctty(p, tp)) 845 return (ENOTTY); 846 *(int *)data = fgetown(tp->t_sigio); 847 break; 848 849 case TIOCEXCL: /* set exclusive use of tty */ 850 crit_enter(); 851 SET(tp->t_state, TS_XCLUDE); 852 crit_exit(); 853 break; 854 case TIOCFLUSH: { /* flush buffers */ 855 int flags = *(int *)data; 856 857 if (flags == 0) 858 flags = FREAD | FWRITE; 859 else 860 flags &= FREAD | FWRITE; 861 ttyflush(tp, flags); 862 break; 863 } 864 case TIOCCONS: /* become virtual console */ 865 if (*(int *)data) { 866 if (constty && constty != tp && 867 ISSET(constty->t_state, TS_CONNECTED)) 868 return (EBUSY); 869 #ifndef UCONSOLE 870 if ((error = suser(td)) != 0) 871 return (error); 872 #endif 873 constty = tp; 874 } else if (tp == constty) 875 constty = NULL; 876 break; 877 case TIOCDRAIN: /* wait till output drained */ 878 error = ttywait(tp); 879 if (error) 880 return (error); 881 break; 882 case TIOCGETA: { /* get termios struct */ 883 struct termios *t = (struct termios *)data; 884 885 bcopy(&tp->t_termios, t, sizeof(struct termios)); 886 break; 887 } 888 case TIOCGETD: /* get line discipline */ 889 *(int *)data = tp->t_line; 890 break; 891 case TIOCGWINSZ: /* get window size */ 892 *(struct winsize *)data = tp->t_winsize; 893 break; 894 case TIOCGPGRP: /* get pgrp of tty */ 895 if (!isctty(p, tp)) 896 return (ENOTTY); 897 *(int *)data = tp->t_pgrp ? tp->t_pgrp->pg_id : NO_PID; 898 break; 899 #ifdef TIOCHPCL 900 case TIOCHPCL: /* hang up on last close */ 901 crit_enter(); 902 SET(tp->t_cflag, HUPCL); 903 crit_exit(); 904 break; 905 #endif 906 case TIOCNXCL: /* reset exclusive use of tty */ 907 crit_enter(); 908 CLR(tp->t_state, TS_XCLUDE); 909 crit_exit(); 910 break; 911 case TIOCOUTQ: /* output queue size */ 912 *(int *)data = tp->t_outq.c_cc; 913 break; 914 case TIOCSETA: /* set termios struct */ 915 case TIOCSETAW: /* drain output, set */ 916 case TIOCSETAF: { /* drn out, fls in, set */ 917 struct termios *t = (struct termios *)data; 918 919 if (t->c_ispeed == 0) 920 t->c_ispeed = t->c_ospeed; 921 if (t->c_ispeed == 0) 922 t->c_ispeed = tp->t_ospeed; 923 if (t->c_ispeed == 0) 924 return (EINVAL); 925 crit_enter(); 926 if (cmd == TIOCSETAW || cmd == TIOCSETAF) { 927 error = ttywait(tp); 928 if (error) { 929 crit_exit(); 930 return (error); 931 } 932 if (cmd == TIOCSETAF) 933 ttyflush(tp, FREAD); 934 } 935 if (!ISSET(t->c_cflag, CIGNORE)) { 936 /* 937 * Set device hardware. 938 */ 939 if (tp->t_param && (error = (*tp->t_param)(tp, t))) { 940 crit_exit(); 941 return (error); 942 } 943 if (ISSET(t->c_cflag, CLOCAL) && 944 !ISSET(tp->t_cflag, CLOCAL)) { 945 /* 946 * XXX disconnections would be too hard to 947 * get rid of without this kludge. The only 948 * way to get rid of controlling terminals 949 * is to exit from the session leader. 950 */ 951 CLR(tp->t_state, TS_ZOMBIE); 952 953 wakeup(TSA_CARR_ON(tp)); 954 ttwakeup(tp); 955 ttwwakeup(tp); 956 } 957 if ((ISSET(tp->t_state, TS_CARR_ON) || 958 ISSET(t->c_cflag, CLOCAL)) && 959 !ISSET(tp->t_state, TS_ZOMBIE)) 960 SET(tp->t_state, TS_CONNECTED); 961 else 962 CLR(tp->t_state, TS_CONNECTED); 963 tp->t_cflag = t->c_cflag; 964 tp->t_ispeed = t->c_ispeed; 965 if (t->c_ospeed != 0) 966 tp->t_ospeed = t->c_ospeed; 967 ttsetwater(tp); 968 } 969 if (ISSET(t->c_lflag, ICANON) != ISSET(tp->t_lflag, ICANON) && 970 cmd != TIOCSETAF) { 971 if (ISSET(t->c_lflag, ICANON)) 972 SET(tp->t_lflag, PENDIN); 973 else { 974 /* 975 * XXX we really shouldn't allow toggling 976 * ICANON while we're in a non-termios line 977 * discipline. Now we have to worry about 978 * panicing for a null queue. 979 */ 980 if (tp->t_canq.c_cbreserved > 0 && 981 tp->t_rawq.c_cbreserved > 0) { 982 catq(&tp->t_rawq, &tp->t_canq); 983 /* 984 * XXX the queue limits may be 985 * different, so the old queue 986 * swapping method no longer works. 987 */ 988 catq(&tp->t_canq, &tp->t_rawq); 989 } 990 CLR(tp->t_lflag, PENDIN); 991 } 992 ttwakeup(tp); 993 } 994 tp->t_iflag = t->c_iflag; 995 tp->t_oflag = t->c_oflag; 996 /* 997 * Make the EXTPROC bit read only. 998 */ 999 if (ISSET(tp->t_lflag, EXTPROC)) 1000 SET(t->c_lflag, EXTPROC); 1001 else 1002 CLR(t->c_lflag, EXTPROC); 1003 tp->t_lflag = t->c_lflag | ISSET(tp->t_lflag, PENDIN); 1004 if (t->c_cc[VMIN] != tp->t_cc[VMIN] || 1005 t->c_cc[VTIME] != tp->t_cc[VTIME]) 1006 ttwakeup(tp); 1007 bcopy(t->c_cc, tp->t_cc, sizeof(t->c_cc)); 1008 crit_exit(); 1009 break; 1010 } 1011 case TIOCSETD: { /* set line discipline */ 1012 int t = *(int *)data; 1013 cdev_t device = tp->t_dev; 1014 1015 if ((u_int)t >= nlinesw) 1016 return (ENXIO); 1017 if (t != tp->t_line) { 1018 crit_enter(); 1019 (*linesw[tp->t_line].l_close)(tp, flag); 1020 error = (*linesw[t].l_open)(device, tp); 1021 if (error) { 1022 (void)(*linesw[tp->t_line].l_open)(device, tp); 1023 crit_exit(); 1024 return (error); 1025 } 1026 tp->t_line = t; 1027 crit_exit(); 1028 } 1029 break; 1030 } 1031 case TIOCSTART: /* start output, like ^Q */ 1032 crit_enter(); 1033 if (ISSET(tp->t_state, TS_TTSTOP) || 1034 ISSET(tp->t_lflag, FLUSHO)) { 1035 CLR(tp->t_lflag, FLUSHO); 1036 CLR(tp->t_state, TS_TTSTOP); 1037 ttstart(tp); 1038 } 1039 crit_exit(); 1040 break; 1041 case TIOCSTI: /* simulate terminal input */ 1042 if ((flag & FREAD) == 0 && suser(td)) 1043 return (EPERM); 1044 if (!isctty(p, tp) && suser(td)) 1045 return (EACCES); 1046 crit_enter(); 1047 (*linesw[tp->t_line].l_rint)(*(u_char *)data, tp); 1048 crit_exit(); 1049 break; 1050 case TIOCSTOP: /* stop output, like ^S */ 1051 crit_enter(); 1052 if (!ISSET(tp->t_state, TS_TTSTOP)) { 1053 SET(tp->t_state, TS_TTSTOP); 1054 (*tp->t_stop)(tp, 0); 1055 } 1056 crit_exit(); 1057 break; 1058 case TIOCSCTTY: /* become controlling tty */ 1059 /* Session ctty vnode pointer set in vnode layer. */ 1060 if (!SESS_LEADER(p) || 1061 ((p->p_session->s_ttyvp || tp->t_session) && 1062 (tp->t_session != p->p_session))) 1063 return (EPERM); 1064 tp->t_session = p->p_session; 1065 tp->t_pgrp = p->p_pgrp; 1066 p->p_session->s_ttyp = tp; 1067 p->p_flag |= P_CONTROLT; 1068 break; 1069 case TIOCSPGRP: { /* set pgrp of tty */ 1070 struct pgrp *pgrp = pgfind(*(int *)data); 1071 1072 if (!isctty(p, tp)) 1073 return (ENOTTY); 1074 else if (pgrp == NULL || pgrp->pg_session != p->p_session) 1075 return (EPERM); 1076 tp->t_pgrp = pgrp; 1077 break; 1078 } 1079 case TIOCSTAT: /* simulate control-T */ 1080 crit_enter(); 1081 ttyinfo(tp); 1082 crit_exit(); 1083 break; 1084 case TIOCSWINSZ: /* set window size */ 1085 if (bcmp((caddr_t)&tp->t_winsize, data, 1086 sizeof (struct winsize))) { 1087 tp->t_winsize = *(struct winsize *)data; 1088 pgsignal(tp->t_pgrp, SIGWINCH, 1); 1089 } 1090 break; 1091 case TIOCSDRAINWAIT: 1092 error = suser(td); 1093 if (error) 1094 return (error); 1095 tp->t_timeout = *(int *)data * hz; 1096 wakeup(TSA_OCOMPLETE(tp)); 1097 wakeup(TSA_OLOWAT(tp)); 1098 break; 1099 case TIOCGDRAINWAIT: 1100 *(int *)data = tp->t_timeout / hz; 1101 break; 1102 default: 1103 #if defined(COMPAT_43) || defined(COMPAT_SUNOS) 1104 return (ttcompat(tp, cmd, data, flag)); 1105 #else 1106 return (ENOIOCTL); 1107 #endif 1108 } 1109 return (0); 1110 } 1111 1112 int 1113 ttypoll(struct dev_poll_args *ap) 1114 { 1115 cdev_t dev = ap->a_head.a_dev; 1116 int events = ap->a_events; 1117 int revents = 0; 1118 struct tty *tp; 1119 1120 tp = dev->si_tty; 1121 /* XXX used to return ENXIO, but that means true! */ 1122 if (tp == NULL) { 1123 ap->a_events = (events & (POLLIN | POLLOUT | POLLRDNORM | 1124 POLLWRNORM)) | POLLHUP; 1125 return(0); 1126 } 1127 1128 crit_enter(); 1129 if (events & (POLLIN | POLLRDNORM)) { 1130 if (ttnread(tp) > 0 || ISSET(tp->t_state, TS_ZOMBIE)) 1131 revents |= events & (POLLIN | POLLRDNORM); 1132 else 1133 selrecord(curthread, &tp->t_rsel); 1134 } 1135 if (events & (POLLOUT | POLLWRNORM)) { 1136 if ((tp->t_outq.c_cc <= tp->t_olowat && 1137 ISSET(tp->t_state, TS_CONNECTED)) 1138 || ISSET(tp->t_state, TS_ZOMBIE)) 1139 revents |= events & (POLLOUT | POLLWRNORM); 1140 else 1141 selrecord(curthread, &tp->t_wsel); 1142 } 1143 crit_exit(); 1144 ap->a_events = revents; 1145 return (0); 1146 } 1147 1148 static struct filterops ttyread_filtops = 1149 { 1, NULL, filt_ttyrdetach, filt_ttyread }; 1150 static struct filterops ttywrite_filtops = 1151 { 1, NULL, filt_ttywdetach, filt_ttywrite }; 1152 1153 int 1154 ttykqfilter(struct dev_kqfilter_args *ap) 1155 { 1156 cdev_t dev = ap->a_head.a_dev; 1157 struct knote *kn = ap->a_kn; 1158 struct tty *tp = dev->si_tty; 1159 struct klist *klist; 1160 1161 ap->a_result = 0; 1162 switch (kn->kn_filter) { 1163 case EVFILT_READ: 1164 klist = &tp->t_rsel.si_note; 1165 kn->kn_fop = &ttyread_filtops; 1166 break; 1167 case EVFILT_WRITE: 1168 klist = &tp->t_wsel.si_note; 1169 kn->kn_fop = &ttywrite_filtops; 1170 break; 1171 default: 1172 ap->a_result = 1; 1173 return (0); 1174 } 1175 1176 kn->kn_hook = (caddr_t)dev; 1177 1178 crit_enter(); 1179 SLIST_INSERT_HEAD(klist, kn, kn_selnext); 1180 crit_exit(); 1181 1182 return (0); 1183 } 1184 1185 static void 1186 filt_ttyrdetach(struct knote *kn) 1187 { 1188 struct tty *tp = ((cdev_t)kn->kn_hook)->si_tty; 1189 1190 crit_enter(); 1191 SLIST_REMOVE(&tp->t_rsel.si_note, kn, knote, kn_selnext); 1192 crit_exit(); 1193 } 1194 1195 static int 1196 filt_ttyread(struct knote *kn, long hint) 1197 { 1198 struct tty *tp = ((cdev_t)kn->kn_hook)->si_tty; 1199 1200 kn->kn_data = ttnread(tp); 1201 if (ISSET(tp->t_state, TS_ZOMBIE)) { 1202 kn->kn_flags |= EV_EOF; 1203 return (1); 1204 } 1205 return (kn->kn_data > 0); 1206 } 1207 1208 static void 1209 filt_ttywdetach(struct knote *kn) 1210 { 1211 struct tty *tp = ((cdev_t)kn->kn_hook)->si_tty; 1212 1213 crit_enter(); 1214 SLIST_REMOVE(&tp->t_wsel.si_note, kn, knote, kn_selnext); 1215 crit_exit(); 1216 } 1217 1218 static int 1219 filt_ttywrite(struct knote *kn, long hint) 1220 { 1221 struct tty *tp = ((cdev_t)kn->kn_hook)->si_tty; 1222 1223 kn->kn_data = tp->t_outq.c_cc; 1224 if (ISSET(tp->t_state, TS_ZOMBIE)) 1225 return (1); 1226 return (kn->kn_data <= tp->t_olowat && 1227 ISSET(tp->t_state, TS_CONNECTED)); 1228 } 1229 1230 /* 1231 * Must be called while in a critical section. 1232 */ 1233 static int 1234 ttnread(struct tty *tp) 1235 { 1236 int nread; 1237 1238 if (ISSET(tp->t_lflag, PENDIN)) 1239 ttypend(tp); 1240 nread = tp->t_canq.c_cc; 1241 if (!ISSET(tp->t_lflag, ICANON)) { 1242 nread += tp->t_rawq.c_cc; 1243 if (nread < tp->t_cc[VMIN] && tp->t_cc[VTIME] == 0) 1244 nread = 0; 1245 } 1246 return (nread); 1247 } 1248 1249 /* 1250 * Wait for output to drain. 1251 */ 1252 int 1253 ttywait(struct tty *tp) 1254 { 1255 int error; 1256 1257 error = 0; 1258 crit_enter(); 1259 while ((tp->t_outq.c_cc || ISSET(tp->t_state, TS_BUSY)) && 1260 ISSET(tp->t_state, TS_CONNECTED) && tp->t_oproc) { 1261 (*tp->t_oproc)(tp); 1262 if ((tp->t_outq.c_cc || ISSET(tp->t_state, TS_BUSY)) && 1263 ISSET(tp->t_state, TS_CONNECTED)) { 1264 SET(tp->t_state, TS_SO_OCOMPLETE); 1265 error = ttysleep(tp, TSA_OCOMPLETE(tp), 1266 PCATCH, "ttywai", 1267 tp->t_timeout); 1268 if (error) { 1269 if (error == EWOULDBLOCK) 1270 error = EIO; 1271 break; 1272 } 1273 } else 1274 break; 1275 } 1276 if (!error && (tp->t_outq.c_cc || ISSET(tp->t_state, TS_BUSY))) 1277 error = EIO; 1278 crit_exit(); 1279 return (error); 1280 } 1281 1282 /* 1283 * Flush if successfully wait. 1284 */ 1285 static int 1286 ttywflush(struct tty *tp) 1287 { 1288 int error; 1289 1290 if ((error = ttywait(tp)) == 0) 1291 ttyflush(tp, FREAD); 1292 return (error); 1293 } 1294 1295 /* 1296 * Flush tty read and/or write queues, notifying anyone waiting. 1297 */ 1298 void 1299 ttyflush(struct tty *tp, int rw) 1300 { 1301 crit_enter(); 1302 #if 0 1303 again: 1304 #endif 1305 if (rw & FWRITE) { 1306 FLUSHQ(&tp->t_outq); 1307 CLR(tp->t_state, TS_TTSTOP); 1308 } 1309 (*tp->t_stop)(tp, rw); 1310 if (rw & FREAD) { 1311 FLUSHQ(&tp->t_canq); 1312 FLUSHQ(&tp->t_rawq); 1313 CLR(tp->t_lflag, PENDIN); 1314 tp->t_rocount = 0; 1315 tp->t_rocol = 0; 1316 CLR(tp->t_state, TS_LOCAL); 1317 ttwakeup(tp); 1318 if (ISSET(tp->t_state, TS_TBLOCK)) { 1319 if (rw & FWRITE) 1320 FLUSHQ(&tp->t_outq); 1321 ttyunblock(tp); 1322 1323 /* 1324 * Don't let leave any state that might clobber the 1325 * next line discipline (although we should do more 1326 * to send the START char). Not clearing the state 1327 * may have caused the "putc to a clist with no 1328 * reserved cblocks" panic/kprintf. 1329 */ 1330 CLR(tp->t_state, TS_TBLOCK); 1331 1332 #if 0 /* forget it, sleeping isn't always safe and we don't know when it is */ 1333 if (ISSET(tp->t_iflag, IXOFF)) { 1334 /* 1335 * XXX wait a bit in the hope that the stop 1336 * character (if any) will go out. Waiting 1337 * isn't good since it allows races. This 1338 * will be fixed when the stop character is 1339 * put in a special queue. Don't bother with 1340 * the checks in ttywait() since the timeout 1341 * will save us. 1342 */ 1343 SET(tp->t_state, TS_SO_OCOMPLETE); 1344 ttysleep(tp, TSA_OCOMPLETE(tp), 0, 1345 "ttyfls", hz / 10); 1346 /* 1347 * Don't try sending the stop character again. 1348 */ 1349 CLR(tp->t_state, TS_TBLOCK); 1350 goto again; 1351 } 1352 #endif 1353 } 1354 } 1355 if (rw & FWRITE) { 1356 FLUSHQ(&tp->t_outq); 1357 ttwwakeup(tp); 1358 } 1359 crit_exit(); 1360 } 1361 1362 /* 1363 * Copy in the default termios characters. 1364 */ 1365 void 1366 termioschars(struct termios *t) 1367 { 1368 1369 bcopy(ttydefchars, t->c_cc, sizeof t->c_cc); 1370 } 1371 1372 /* 1373 * Old interface. 1374 */ 1375 void 1376 ttychars(struct tty *tp) 1377 { 1378 1379 termioschars(&tp->t_termios); 1380 } 1381 1382 /* 1383 * Handle input high water. Send stop character for the IXOFF case. Turn 1384 * on our input flow control bit and propagate the changes to the driver. 1385 * XXX the stop character should be put in a special high priority queue. 1386 */ 1387 void 1388 ttyblock(struct tty *tp) 1389 { 1390 1391 SET(tp->t_state, TS_TBLOCK); 1392 if (ISSET(tp->t_iflag, IXOFF) && tp->t_cc[VSTOP] != _POSIX_VDISABLE && 1393 clist_putc(tp->t_cc[VSTOP], &tp->t_outq) != 0) 1394 CLR(tp->t_state, TS_TBLOCK); /* try again later */ 1395 ttstart(tp); 1396 } 1397 1398 /* 1399 * Handle input low water. Send start character for the IXOFF case. Turn 1400 * off our input flow control bit and propagate the changes to the driver. 1401 * XXX the start character should be put in a special high priority queue. 1402 */ 1403 static void 1404 ttyunblock(struct tty *tp) 1405 { 1406 1407 CLR(tp->t_state, TS_TBLOCK); 1408 if (ISSET(tp->t_iflag, IXOFF) && tp->t_cc[VSTART] != _POSIX_VDISABLE && 1409 clist_putc(tp->t_cc[VSTART], &tp->t_outq) != 0) 1410 SET(tp->t_state, TS_TBLOCK); /* try again later */ 1411 ttstart(tp); 1412 } 1413 1414 #ifdef notyet 1415 /* Not used by any current (i386) drivers. */ 1416 /* 1417 * Restart after an inter-char delay. 1418 */ 1419 void 1420 ttrstrt(void *tp_arg) 1421 { 1422 struct tty *tp; 1423 1424 KASSERT(tp_arg != NULL, ("ttrstrt")); 1425 1426 tp = tp_arg; 1427 crit_enter(); 1428 CLR(tp->t_state, TS_TIMEOUT); 1429 ttstart(tp); 1430 crit_exit(); 1431 } 1432 #endif 1433 1434 int 1435 ttstart(struct tty *tp) 1436 { 1437 1438 if (tp->t_oproc != NULL) /* XXX: Kludge for pty. */ 1439 (*tp->t_oproc)(tp); 1440 return (0); 1441 } 1442 1443 /* 1444 * "close" a line discipline 1445 */ 1446 int 1447 ttylclose(struct tty *tp, int flag) 1448 { 1449 1450 if (flag & FNONBLOCK || ttywflush(tp)) 1451 ttyflush(tp, FREAD | FWRITE); 1452 return (0); 1453 } 1454 1455 /* 1456 * Handle modem control transition on a tty. 1457 * Flag indicates new state of carrier. 1458 * Returns 0 if the line should be turned off, otherwise 1. 1459 */ 1460 int 1461 ttymodem(struct tty *tp, int flag) 1462 { 1463 1464 if (ISSET(tp->t_state, TS_CARR_ON) && ISSET(tp->t_cflag, MDMBUF)) { 1465 /* 1466 * MDMBUF: do flow control according to carrier flag 1467 * XXX TS_CAR_OFLOW doesn't do anything yet. TS_TTSTOP 1468 * works if IXON and IXANY are clear. 1469 */ 1470 if (flag) { 1471 CLR(tp->t_state, TS_CAR_OFLOW); 1472 CLR(tp->t_state, TS_TTSTOP); 1473 ttstart(tp); 1474 } else if (!ISSET(tp->t_state, TS_CAR_OFLOW)) { 1475 SET(tp->t_state, TS_CAR_OFLOW); 1476 SET(tp->t_state, TS_TTSTOP); 1477 (*tp->t_stop)(tp, 0); 1478 } 1479 } else if (flag == 0) { 1480 /* 1481 * Lost carrier. 1482 */ 1483 CLR(tp->t_state, TS_CARR_ON); 1484 if (ISSET(tp->t_state, TS_ISOPEN) && 1485 !ISSET(tp->t_cflag, CLOCAL)) { 1486 SET(tp->t_state, TS_ZOMBIE); 1487 CLR(tp->t_state, TS_CONNECTED); 1488 if (tp->t_session && tp->t_session->s_leader) 1489 ksignal(tp->t_session->s_leader, SIGHUP); 1490 ttyflush(tp, FREAD | FWRITE); 1491 return (0); 1492 } 1493 } else { 1494 /* 1495 * Carrier now on. 1496 */ 1497 SET(tp->t_state, TS_CARR_ON); 1498 if (!ISSET(tp->t_state, TS_ZOMBIE)) 1499 SET(tp->t_state, TS_CONNECTED); 1500 wakeup(TSA_CARR_ON(tp)); 1501 ttwakeup(tp); 1502 ttwwakeup(tp); 1503 } 1504 return (1); 1505 } 1506 1507 /* 1508 * Reinput pending characters after state switch 1509 * call from a critical section. 1510 */ 1511 static void 1512 ttypend(struct tty *tp) 1513 { 1514 struct clist tq; 1515 int c; 1516 1517 CLR(tp->t_lflag, PENDIN); 1518 SET(tp->t_state, TS_TYPEN); 1519 /* 1520 * XXX this assumes too much about clist internals. It may even 1521 * fail if the cblock slush pool is empty. We can't allocate more 1522 * cblocks here because we are called from an interrupt handler 1523 * and clist_alloc_cblocks() can wait. 1524 */ 1525 tq = tp->t_rawq; 1526 bzero(&tp->t_rawq, sizeof tp->t_rawq); 1527 tp->t_rawq.c_cbmax = tq.c_cbmax; 1528 tp->t_rawq.c_cbreserved = tq.c_cbreserved; 1529 while ((c = clist_getc(&tq)) >= 0) 1530 ttyinput(c, tp); 1531 CLR(tp->t_state, TS_TYPEN); 1532 } 1533 1534 /* 1535 * Process a read call on a tty device. 1536 */ 1537 int 1538 ttread(struct tty *tp, struct uio *uio, int flag) 1539 { 1540 struct clist *qp; 1541 int c; 1542 tcflag_t lflag; 1543 cc_t *cc = tp->t_cc; 1544 struct proc *pp; 1545 int first, error = 0; 1546 int has_stime = 0, last_cc = 0; 1547 long slp = 0; /* XXX this should be renamed `timo'. */ 1548 struct timeval stime; 1549 1550 loop: 1551 crit_enter(); 1552 lflag = tp->t_lflag; 1553 /* 1554 * take pending input first 1555 */ 1556 if (ISSET(lflag, PENDIN)) { 1557 ttypend(tp); 1558 splz(); /* reduce latency */ 1559 lflag = tp->t_lflag; /* XXX ttypend() clobbers it */ 1560 } 1561 1562 /* 1563 * Hang process if it's in the background. 1564 */ 1565 if ((pp = curproc) && isbackground(pp, tp)) { 1566 crit_exit(); 1567 if (SIGISMEMBER(pp->p_sigignore, SIGTTIN) || 1568 SIGISMEMBER(pp->p_sigmask, SIGTTIN) || 1569 (pp->p_flag & P_PPWAIT) || pp->p_pgrp->pg_jobc == 0) 1570 return (EIO); 1571 pgsignal(pp->p_pgrp, SIGTTIN, 1); 1572 error = ttysleep(tp, &lbolt, PCATCH, "ttybg2", 0); 1573 if (error) 1574 return (error); 1575 goto loop; 1576 } 1577 1578 if (ISSET(tp->t_state, TS_ZOMBIE)) { 1579 crit_exit(); 1580 return (0); /* EOF */ 1581 } 1582 1583 /* 1584 * If canonical, use the canonical queue, 1585 * else use the raw queue. 1586 * 1587 * (should get rid of clists...) 1588 */ 1589 qp = ISSET(lflag, ICANON) ? &tp->t_canq : &tp->t_rawq; 1590 1591 if (flag & IO_NDELAY) { 1592 if (qp->c_cc > 0) 1593 goto read; 1594 if (!ISSET(lflag, ICANON) && cc[VMIN] == 0) { 1595 crit_exit(); 1596 return (0); 1597 } 1598 crit_exit(); 1599 return (EWOULDBLOCK); 1600 } 1601 if (!ISSET(lflag, ICANON)) { 1602 int m = cc[VMIN]; 1603 long t = cc[VTIME]; 1604 struct timeval timecopy; 1605 1606 /* 1607 * Check each of the four combinations. 1608 * (m > 0 && t == 0) is the normal read case. 1609 * It should be fairly efficient, so we check that and its 1610 * companion case (m == 0 && t == 0) first. 1611 * For the other two cases, we compute the target sleep time 1612 * into slp. 1613 */ 1614 if (t == 0) { 1615 if (qp->c_cc < m) 1616 goto sleep; 1617 if (qp->c_cc > 0) 1618 goto read; 1619 1620 /* m, t and qp->c_cc are all 0. 0 is enough input. */ 1621 crit_exit(); 1622 return (0); 1623 } 1624 t *= 100000; /* time in us */ 1625 #define diff(t1, t2) (((t1).tv_sec - (t2).tv_sec) * 1000000 + \ 1626 ((t1).tv_usec - (t2).tv_usec)) 1627 if (m > 0) { 1628 if (qp->c_cc <= 0) 1629 goto sleep; 1630 if (qp->c_cc >= m) 1631 goto read; 1632 getmicrotime(&timecopy); 1633 if (!has_stime) { 1634 /* first character, start timer */ 1635 has_stime = 1; 1636 stime = timecopy; 1637 slp = t; 1638 } else if (qp->c_cc > last_cc) { 1639 /* got a character, restart timer */ 1640 stime = timecopy; 1641 slp = t; 1642 } else { 1643 /* nothing, check expiration */ 1644 slp = t - diff(timecopy, stime); 1645 if (slp <= 0) 1646 goto read; 1647 } 1648 last_cc = qp->c_cc; 1649 } else { /* m == 0 */ 1650 if (qp->c_cc > 0) 1651 goto read; 1652 getmicrotime(&timecopy); 1653 if (!has_stime) { 1654 has_stime = 1; 1655 stime = timecopy; 1656 slp = t; 1657 } else { 1658 slp = t - diff(timecopy, stime); 1659 if (slp <= 0) { 1660 /* Timed out, but 0 is enough input. */ 1661 crit_exit(); 1662 return (0); 1663 } 1664 } 1665 } 1666 #undef diff 1667 /* 1668 * Rounding down may make us wake up just short 1669 * of the target, so we round up. 1670 * The formula is ceiling(slp * hz/1000000). 1671 * 32-bit arithmetic is enough for hz < 169. 1672 * XXX see tvtohz() for how to avoid overflow if hz 1673 * is large (divide by `tick' and/or arrange to 1674 * use tvtohz() if hz is large). 1675 */ 1676 slp = (long) (((u_long)slp * hz) + 999999) / 1000000; 1677 goto sleep; 1678 } 1679 if (qp->c_cc <= 0) { 1680 sleep: 1681 /* 1682 * There is no input, or not enough input and we can block. 1683 */ 1684 error = ttysleep(tp, TSA_HUP_OR_INPUT(tp), PCATCH, 1685 ISSET(tp->t_state, TS_CONNECTED) ? 1686 "ttyin" : "ttyhup", (int)slp); 1687 crit_exit(); 1688 if (error == EWOULDBLOCK) 1689 error = 0; 1690 else if (error) 1691 return (error); 1692 /* 1693 * XXX what happens if another process eats some input 1694 * while we are asleep (not just here)? It would be 1695 * safest to detect changes and reset our state variables 1696 * (has_stime and last_cc). 1697 */ 1698 slp = 0; 1699 goto loop; 1700 } 1701 read: 1702 crit_exit(); 1703 /* 1704 * Input present, check for input mapping and processing. 1705 */ 1706 first = 1; 1707 if (ISSET(lflag, ICANON | ISIG)) 1708 goto slowcase; 1709 for (;;) { 1710 char ibuf[IBUFSIZ]; 1711 int icc; 1712 1713 icc = imin(uio->uio_resid, IBUFSIZ); 1714 icc = q_to_b(qp, ibuf, icc); 1715 if (icc <= 0) { 1716 if (first) 1717 goto loop; 1718 break; 1719 } 1720 error = uiomove(ibuf, icc, uio); 1721 /* 1722 * XXX if there was an error then we should ungetc() the 1723 * unmoved chars and reduce icc here. 1724 */ 1725 if (error) 1726 break; 1727 if (uio->uio_resid == 0) 1728 break; 1729 first = 0; 1730 } 1731 goto out; 1732 slowcase: 1733 for (;;) { 1734 c = clist_getc(qp); 1735 if (c < 0) { 1736 if (first) 1737 goto loop; 1738 break; 1739 } 1740 /* 1741 * delayed suspend (^Y) 1742 */ 1743 if (CCEQ(cc[VDSUSP], c) && 1744 ISSET(lflag, IEXTEN | ISIG) == (IEXTEN | ISIG)) { 1745 pgsignal(tp->t_pgrp, SIGTSTP, 1); 1746 if (first) { 1747 error = ttysleep(tp, &lbolt, PCATCH, 1748 "ttybg3", 0); 1749 if (error) 1750 break; 1751 goto loop; 1752 } 1753 break; 1754 } 1755 /* 1756 * Interpret EOF only in canonical mode. 1757 */ 1758 if (CCEQ(cc[VEOF], c) && ISSET(lflag, ICANON)) 1759 break; 1760 /* 1761 * Give user character. 1762 */ 1763 error = ureadc(c, uio); 1764 if (error) 1765 /* XXX should ungetc(c, qp). */ 1766 break; 1767 if (uio->uio_resid == 0) 1768 break; 1769 /* 1770 * In canonical mode check for a "break character" 1771 * marking the end of a "line of input". 1772 */ 1773 if (ISSET(lflag, ICANON) && TTBREAKC(c, lflag)) 1774 break; 1775 first = 0; 1776 } 1777 1778 out: 1779 /* 1780 * Look to unblock input now that (presumably) 1781 * the input queue has gone down. 1782 */ 1783 crit_enter(); 1784 if (ISSET(tp->t_state, TS_TBLOCK) && 1785 tp->t_rawq.c_cc + tp->t_canq.c_cc <= tp->t_ilowat) 1786 ttyunblock(tp); 1787 crit_exit(); 1788 1789 return (error); 1790 } 1791 1792 /* 1793 * Check the output queue on tp for space for a kernel message (from uprintf 1794 * or tprintf). Allow some space over the normal hiwater mark so we don't 1795 * lose messages due to normal flow control, but don't let the tty run amok. 1796 * Sleeps here are not interruptible, but we return prematurely if new signals 1797 * arrive. 1798 */ 1799 int 1800 ttycheckoutq(struct tty *tp, int wait) 1801 { 1802 int hiwat; 1803 sigset_t oldmask; 1804 1805 hiwat = tp->t_ohiwat; 1806 SIGEMPTYSET(oldmask); 1807 crit_enter(); 1808 if (wait) 1809 oldmask = curproc->p_siglist; 1810 if (tp->t_outq.c_cc > hiwat + OBUFSIZ + 100) { 1811 while (tp->t_outq.c_cc > hiwat) { 1812 ttstart(tp); 1813 if (tp->t_outq.c_cc <= hiwat) 1814 break; 1815 if (!(wait && SIGSETEQ(curproc->p_siglist, oldmask))) { 1816 crit_exit(); 1817 return (0); 1818 } 1819 SET(tp->t_state, TS_SO_OLOWAT); 1820 tsleep(TSA_OLOWAT(tp), 0, "ttoutq", hz); 1821 } 1822 } 1823 crit_exit(); 1824 return (1); 1825 } 1826 1827 /* 1828 * Process a write call on a tty device. 1829 */ 1830 int 1831 ttwrite(struct tty *tp, struct uio *uio, int flag) 1832 { 1833 char *cp = NULL; 1834 int cc, ce; 1835 struct proc *pp; 1836 int i, hiwat, cnt, error; 1837 char obuf[OBUFSIZ]; 1838 1839 hiwat = tp->t_ohiwat; 1840 cnt = uio->uio_resid; 1841 error = 0; 1842 cc = 0; 1843 loop: 1844 crit_enter(); 1845 if (ISSET(tp->t_state, TS_ZOMBIE)) { 1846 crit_exit(); 1847 if (uio->uio_resid == cnt) 1848 error = EIO; 1849 goto out; 1850 } 1851 if (!ISSET(tp->t_state, TS_CONNECTED)) { 1852 if (flag & IO_NDELAY) { 1853 crit_exit(); 1854 error = EWOULDBLOCK; 1855 goto out; 1856 } 1857 error = ttysleep(tp, TSA_CARR_ON(tp), PCATCH, "ttydcd", 0); 1858 crit_exit(); 1859 if (error) 1860 goto out; 1861 goto loop; 1862 } 1863 crit_exit(); 1864 1865 /* 1866 * Hang the process if it's in the background. 1867 */ 1868 if ((pp = curproc) && isbackground(pp, tp) && 1869 ISSET(tp->t_lflag, TOSTOP) && !(pp->p_flag & P_PPWAIT) && 1870 !SIGISMEMBER(pp->p_sigignore, SIGTTOU) && 1871 !SIGISMEMBER(pp->p_sigmask, SIGTTOU)) { 1872 if (pp->p_pgrp->pg_jobc == 0) { 1873 error = EIO; 1874 goto out; 1875 } 1876 pgsignal(pp->p_pgrp, SIGTTOU, 1); 1877 error = ttysleep(tp, &lbolt, PCATCH, "ttybg4", 0); 1878 if (error) 1879 goto out; 1880 goto loop; 1881 } 1882 /* 1883 * Process the user's data in at most OBUFSIZ chunks. Perform any 1884 * output translation. Keep track of high water mark, sleep on 1885 * overflow awaiting device aid in acquiring new space. 1886 */ 1887 while (uio->uio_resid > 0 || cc > 0) { 1888 if (ISSET(tp->t_lflag, FLUSHO)) { 1889 uio->uio_resid = 0; 1890 return (0); 1891 } 1892 if (tp->t_outq.c_cc > hiwat) 1893 goto ovhiwat; 1894 /* 1895 * Grab a hunk of data from the user, unless we have some 1896 * leftover from last time. 1897 */ 1898 if (cc == 0) { 1899 cc = imin(uio->uio_resid, OBUFSIZ); 1900 cp = obuf; 1901 error = uiomove(cp, cc, uio); 1902 if (error) { 1903 cc = 0; 1904 break; 1905 } 1906 } 1907 /* 1908 * If nothing fancy need be done, grab those characters we 1909 * can handle without any of ttyoutput's processing and 1910 * just transfer them to the output q. For those chars 1911 * which require special processing (as indicated by the 1912 * bits in char_type), call ttyoutput. After processing 1913 * a hunk of data, look for FLUSHO so ^O's will take effect 1914 * immediately. 1915 */ 1916 while (cc > 0) { 1917 if (!ISSET(tp->t_oflag, OPOST)) 1918 ce = cc; 1919 else { 1920 ce = cc - scanc((u_int)cc, (u_char *)cp, 1921 char_type, CCLASSMASK); 1922 /* 1923 * If ce is zero, then we're processing 1924 * a special character through ttyoutput. 1925 */ 1926 if (ce == 0) { 1927 tp->t_rocount = 0; 1928 if (ttyoutput(*cp, tp) >= 0) { 1929 /* No Clists, wait a bit. */ 1930 ttstart(tp); 1931 if (flag & IO_NDELAY) { 1932 error = EWOULDBLOCK; 1933 goto out; 1934 } 1935 error = ttysleep(tp, &lbolt, 1936 PCATCH, 1937 "ttybf1", 0); 1938 if (error) 1939 goto out; 1940 goto loop; 1941 } 1942 cp++; 1943 cc--; 1944 if (ISSET(tp->t_lflag, FLUSHO) || 1945 tp->t_outq.c_cc > hiwat) 1946 goto ovhiwat; 1947 continue; 1948 } 1949 } 1950 /* 1951 * A bunch of normal characters have been found. 1952 * Transfer them en masse to the output queue and 1953 * continue processing at the top of the loop. 1954 * If there are any further characters in this 1955 * <= OBUFSIZ chunk, the first should be a character 1956 * requiring special handling by ttyoutput. 1957 */ 1958 tp->t_rocount = 0; 1959 i = b_to_q(cp, ce, &tp->t_outq); 1960 ce -= i; 1961 tp->t_column += ce; 1962 cp += ce, cc -= ce, tk_nout += ce; 1963 tp->t_outcc += ce; 1964 if (i > 0) { 1965 /* No Clists, wait a bit. */ 1966 ttstart(tp); 1967 if (flag & IO_NDELAY) { 1968 error = EWOULDBLOCK; 1969 goto out; 1970 } 1971 error = ttysleep(tp, &lbolt, PCATCH, 1972 "ttybf2", 0); 1973 if (error) 1974 goto out; 1975 goto loop; 1976 } 1977 if (ISSET(tp->t_lflag, FLUSHO) || 1978 tp->t_outq.c_cc > hiwat) 1979 break; 1980 } 1981 ttstart(tp); 1982 } 1983 out: 1984 /* 1985 * If cc is nonzero, we leave the uio structure inconsistent, as the 1986 * offset and iov pointers have moved forward, but it doesn't matter 1987 * (the call will either return short or restart with a new uio). 1988 */ 1989 uio->uio_resid += cc; 1990 return (error); 1991 1992 ovhiwat: 1993 ttstart(tp); 1994 crit_enter(); 1995 /* 1996 * This can only occur if FLUSHO is set in t_lflag, 1997 * or if ttstart/oproc is synchronous (or very fast). 1998 */ 1999 if (tp->t_outq.c_cc <= hiwat) { 2000 crit_exit(); 2001 goto loop; 2002 } 2003 if (flag & IO_NDELAY) { 2004 crit_exit(); 2005 uio->uio_resid += cc; 2006 return (uio->uio_resid == cnt ? EWOULDBLOCK : 0); 2007 } 2008 SET(tp->t_state, TS_SO_OLOWAT); 2009 error = ttysleep(tp, TSA_OLOWAT(tp), PCATCH, "ttywri", tp->t_timeout); 2010 crit_exit(); 2011 if (error == EWOULDBLOCK) 2012 error = EIO; 2013 if (error) 2014 goto out; 2015 goto loop; 2016 } 2017 2018 /* 2019 * Rubout one character from the rawq of tp 2020 * as cleanly as possible. 2021 */ 2022 static void 2023 ttyrub(int c, struct tty *tp) 2024 { 2025 char *cp; 2026 int savecol; 2027 int tabc; 2028 2029 if (!ISSET(tp->t_lflag, ECHO) || ISSET(tp->t_lflag, EXTPROC)) 2030 return; 2031 CLR(tp->t_lflag, FLUSHO); 2032 if (ISSET(tp->t_lflag, ECHOE)) { 2033 if (tp->t_rocount == 0) { 2034 /* 2035 * Screwed by ttwrite; retype 2036 */ 2037 ttyretype(tp); 2038 return; 2039 } 2040 if (c == ('\t' | TTY_QUOTE) || c == ('\n' | TTY_QUOTE)) 2041 ttyrubo(tp, 2); 2042 else { 2043 CLR(c, ~TTY_CHARMASK); 2044 switch (CCLASS(c)) { 2045 case ORDINARY: 2046 ttyrubo(tp, 1); 2047 break; 2048 case BACKSPACE: 2049 case CONTROL: 2050 case NEWLINE: 2051 case RETURN: 2052 case VTAB: 2053 if (ISSET(tp->t_lflag, ECHOCTL)) 2054 ttyrubo(tp, 2); 2055 break; 2056 case TAB: 2057 if (tp->t_rocount < tp->t_rawq.c_cc) { 2058 ttyretype(tp); 2059 return; 2060 } 2061 crit_enter(); 2062 savecol = tp->t_column; 2063 SET(tp->t_state, TS_CNTTB); 2064 SET(tp->t_lflag, FLUSHO); 2065 tp->t_column = tp->t_rocol; 2066 cp = tp->t_rawq.c_cf; 2067 if (cp) 2068 tabc = *cp; /* XXX FIX NEXTC */ 2069 for (; cp; cp = nextc(&tp->t_rawq, cp, &tabc)) 2070 ttyecho(tabc, tp); 2071 CLR(tp->t_lflag, FLUSHO); 2072 CLR(tp->t_state, TS_CNTTB); 2073 crit_exit(); 2074 2075 /* savecol will now be length of the tab. */ 2076 savecol -= tp->t_column; 2077 tp->t_column += savecol; 2078 if (savecol > 8) 2079 savecol = 8; /* overflow screw */ 2080 while (--savecol >= 0) 2081 (void)ttyoutput('\b', tp); 2082 break; 2083 default: /* XXX */ 2084 #define PANICSTR "ttyrub: would panic c = %d, val = %d\n" 2085 (void)kprintf(PANICSTR, c, CCLASS(c)); 2086 #ifdef notdef 2087 panic(PANICSTR, c, CCLASS(c)); 2088 #endif 2089 } 2090 } 2091 } else if (ISSET(tp->t_lflag, ECHOPRT)) { 2092 if (!ISSET(tp->t_state, TS_ERASE)) { 2093 SET(tp->t_state, TS_ERASE); 2094 (void)ttyoutput('\\', tp); 2095 } 2096 ttyecho(c, tp); 2097 } else { 2098 ttyecho(tp->t_cc[VERASE], tp); 2099 /* 2100 * This code may be executed not only when an ERASE key 2101 * is pressed, but also when ^U (KILL) or ^W (WERASE) are. 2102 * So, I didn't think it was worthwhile to pass the extra 2103 * information (which would need an extra parameter, 2104 * changing every call) needed to distinguish the ERASE2 2105 * case from the ERASE. 2106 */ 2107 } 2108 --tp->t_rocount; 2109 } 2110 2111 /* 2112 * Back over cnt characters, erasing them. 2113 */ 2114 static void 2115 ttyrubo(struct tty *tp, int cnt) 2116 { 2117 2118 while (cnt-- > 0) { 2119 (void)ttyoutput('\b', tp); 2120 (void)ttyoutput(' ', tp); 2121 (void)ttyoutput('\b', tp); 2122 } 2123 } 2124 2125 /* 2126 * ttyretype -- 2127 * Reprint the rawq line. Note, it is assumed that c_cc has already 2128 * been checked. 2129 */ 2130 static void 2131 ttyretype(struct tty *tp) 2132 { 2133 char *cp; 2134 int c; 2135 2136 /* Echo the reprint character. */ 2137 if (tp->t_cc[VREPRINT] != _POSIX_VDISABLE) 2138 ttyecho(tp->t_cc[VREPRINT], tp); 2139 2140 (void)ttyoutput('\n', tp); 2141 2142 /* 2143 * XXX 2144 * FIX: NEXTC IS BROKEN - DOESN'T CHECK QUOTE 2145 * BIT OF FIRST CHAR. 2146 */ 2147 crit_enter(); 2148 for (cp = tp->t_canq.c_cf, c = (cp != NULL ? *cp : 0); 2149 cp != NULL; cp = nextc(&tp->t_canq, cp, &c)) 2150 ttyecho(c, tp); 2151 for (cp = tp->t_rawq.c_cf, c = (cp != NULL ? *cp : 0); 2152 cp != NULL; cp = nextc(&tp->t_rawq, cp, &c)) 2153 ttyecho(c, tp); 2154 CLR(tp->t_state, TS_ERASE); 2155 crit_exit(); 2156 2157 tp->t_rocount = tp->t_rawq.c_cc; 2158 tp->t_rocol = 0; 2159 } 2160 2161 /* 2162 * Echo a typed character to the terminal. 2163 */ 2164 static void 2165 ttyecho(int c, struct tty *tp) 2166 { 2167 2168 if (!ISSET(tp->t_state, TS_CNTTB)) 2169 CLR(tp->t_lflag, FLUSHO); 2170 if ((!ISSET(tp->t_lflag, ECHO) && 2171 (c != '\n' || !ISSET(tp->t_lflag, ECHONL))) || 2172 ISSET(tp->t_lflag, EXTPROC)) 2173 return; 2174 if (ISSET(tp->t_lflag, ECHOCTL) && 2175 ((ISSET(c, TTY_CHARMASK) <= 037 && c != '\t' && c != '\n') || 2176 ISSET(c, TTY_CHARMASK) == 0177)) { 2177 (void)ttyoutput('^', tp); 2178 CLR(c, ~TTY_CHARMASK); 2179 if (c == 0177) 2180 c = '?'; 2181 else 2182 c += 'A' - 1; 2183 } 2184 (void)ttyoutput(c, tp); 2185 } 2186 2187 /* 2188 * Wake up any readers on a tty. 2189 */ 2190 void 2191 ttwakeup(struct tty *tp) 2192 { 2193 2194 if (tp->t_rsel.si_pid != 0) 2195 selwakeup(&tp->t_rsel); 2196 if (ISSET(tp->t_state, TS_ASYNC) && tp->t_sigio != NULL) 2197 pgsigio(tp->t_sigio, SIGIO, (tp->t_session != NULL)); 2198 wakeup(TSA_HUP_OR_INPUT(tp)); 2199 KNOTE(&tp->t_rsel.si_note, 0); 2200 } 2201 2202 /* 2203 * Wake up any writers on a tty. 2204 */ 2205 void 2206 ttwwakeup(struct tty *tp) 2207 { 2208 2209 if (tp->t_wsel.si_pid != 0 && tp->t_outq.c_cc <= tp->t_olowat) 2210 selwakeup(&tp->t_wsel); 2211 if (ISSET(tp->t_state, TS_ASYNC) && tp->t_sigio != NULL) 2212 pgsigio(tp->t_sigio, SIGIO, (tp->t_session != NULL)); 2213 if (ISSET(tp->t_state, TS_BUSY | TS_SO_OCOMPLETE) == 2214 TS_SO_OCOMPLETE && tp->t_outq.c_cc == 0) { 2215 CLR(tp->t_state, TS_SO_OCOMPLETE); 2216 wakeup(TSA_OCOMPLETE(tp)); 2217 } 2218 if (ISSET(tp->t_state, TS_SO_OLOWAT) && 2219 tp->t_outq.c_cc <= tp->t_olowat) { 2220 CLR(tp->t_state, TS_SO_OLOWAT); 2221 wakeup(TSA_OLOWAT(tp)); 2222 } 2223 KNOTE(&tp->t_wsel.si_note, 0); 2224 } 2225 2226 /* 2227 * Look up a code for a specified speed in a conversion table; 2228 * used by drivers to map software speed values to hardware parameters. 2229 */ 2230 int 2231 ttspeedtab(int speed, struct speedtab *table) 2232 { 2233 2234 for ( ; table->sp_speed != -1; table++) 2235 if (table->sp_speed == speed) 2236 return (table->sp_code); 2237 return (-1); 2238 } 2239 2240 /* 2241 * Set input and output watermarks and buffer sizes. For input, the 2242 * high watermark is about one second's worth of input above empty, the 2243 * low watermark is slightly below high water, and the buffer size is a 2244 * driver-dependent amount above high water. For output, the watermarks 2245 * are near the ends of the buffer, with about 1 second's worth of input 2246 * between them. All this only applies to the standard line discipline. 2247 */ 2248 void 2249 ttsetwater(struct tty *tp) 2250 { 2251 int cps, ttmaxhiwat, x; 2252 2253 /* Input. */ 2254 clist_alloc_cblocks(&tp->t_canq, TTYHOG, 512); 2255 switch (tp->t_ispeedwat) { 2256 case (speed_t)-1: 2257 cps = tp->t_ispeed / 10; 2258 break; 2259 case 0: 2260 /* 2261 * This case is for old drivers that don't know about 2262 * t_ispeedwat. Arrange for them to get the old buffer 2263 * sizes and watermarks. 2264 */ 2265 cps = TTYHOG - 2 * 256; 2266 tp->t_ififosize = 2 * 256; 2267 break; 2268 default: 2269 cps = tp->t_ispeedwat / 10; 2270 break; 2271 } 2272 tp->t_ihiwat = cps; 2273 tp->t_ilowat = 7 * cps / 8; 2274 x = cps + tp->t_ififosize; 2275 clist_alloc_cblocks(&tp->t_rawq, x, x); 2276 2277 /* Output. */ 2278 switch (tp->t_ospeedwat) { 2279 case (speed_t)-1: 2280 cps = tp->t_ospeed / 10; 2281 ttmaxhiwat = 2 * TTMAXHIWAT; 2282 break; 2283 case 0: 2284 cps = tp->t_ospeed / 10; 2285 ttmaxhiwat = TTMAXHIWAT; 2286 break; 2287 default: 2288 cps = tp->t_ospeedwat / 10; 2289 ttmaxhiwat = 8 * TTMAXHIWAT; 2290 break; 2291 } 2292 #define CLAMP(x, h, l) ((x) > h ? h : ((x) < l) ? l : (x)) 2293 tp->t_olowat = x = CLAMP(cps / 2, TTMAXLOWAT, TTMINLOWAT); 2294 x += cps; 2295 x = CLAMP(x, ttmaxhiwat, TTMINHIWAT); /* XXX clamps are too magic */ 2296 tp->t_ohiwat = roundup(x, CBSIZE); /* XXX for compat */ 2297 x = imax(tp->t_ohiwat, TTMAXHIWAT); /* XXX for compat/safety */ 2298 x += OBUFSIZ + 100; 2299 clist_alloc_cblocks(&tp->t_outq, x, x); 2300 #undef CLAMP 2301 } 2302 2303 /* 2304 * Report on state of foreground process group. 2305 */ 2306 void 2307 ttyinfo(struct tty *tp) 2308 { 2309 struct proc *p, *pick; 2310 struct rusage ru; 2311 int tmp; 2312 2313 if (ttycheckoutq(tp,0) == 0) 2314 return; 2315 2316 /* 2317 * We always print the load average, then figure out what else to 2318 * print based on the state of the current process group. 2319 */ 2320 tmp = (averunnable.ldavg[0] * 100 + FSCALE / 2) >> FSHIFT; 2321 ttyprintf(tp, "load: %d.%02d ", tmp / 100, tmp % 100); 2322 2323 if (tp->t_session == NULL) { 2324 ttyprintf(tp, "not a controlling terminal\n"); 2325 } else if (tp->t_pgrp == NULL) { 2326 ttyprintf(tp, "no foreground process group\n"); 2327 } else if ((p = LIST_FIRST(&tp->t_pgrp->pg_members)) == 0) { 2328 ttyprintf(tp, "empty foreground process group\n"); 2329 } else { 2330 /* 2331 * Pick an interesting process. Note that certain elements, 2332 * in particular the wmesg, require a critical section for 2333 * safe access (YYY and we are still not MP safe). 2334 * 2335 * NOTE: p_wmesg is p_thread->td_wmesg, and p_comm is 2336 * p_thread->td_comm. 2337 */ 2338 char buf[64]; 2339 const char *str; 2340 int isinmem; 2341 long vmsz; 2342 int pctcpu; 2343 2344 crit_enter(); 2345 2346 /* XXX lwp should compare lwps */ 2347 2348 for (pick = NULL; p != 0; p = LIST_NEXT(p, p_pglist)) { 2349 if (proc_compare(pick, p)) 2350 pick = p; 2351 } 2352 2353 /* 2354 * Figure out what wait/process-state message, and command 2355 * buffer to present 2356 */ 2357 if (pick->p_flag & P_WEXIT) 2358 str = "exiting"; 2359 else if (pick->p_stat == SRUN) 2360 str = "running"; 2361 else if (pick->p_stat == SIDL) 2362 str = "spawning"; 2363 else if (pick->p_wmesg) /* p_thread must not be NULL */ 2364 str = pick->p_wmesg; 2365 else 2366 str = "iowait"; 2367 2368 ksnprintf(buf, sizeof(buf), "cmd: %s %d [%s]", 2369 pick->p_comm, pick->p_pid, str); 2370 2371 /* 2372 * Calculate cpu usage, percent cpu, and cmsz. Note that 2373 * 'pick' becomes invalid the moment we exit the critical 2374 * section. 2375 */ 2376 if (pick->p_thread && (pick->p_flag & P_SWAPPEDOUT) == 0) { 2377 calcru_proc(pick, &ru); 2378 isinmem = 1; 2379 } else { 2380 isinmem = 0; 2381 } 2382 2383 pctcpu = (pick->p_pctcpu * 10000 + FSCALE / 2) >> FSHIFT; 2384 2385 if (pick->p_stat == SIDL || (pick->p_flag & P_ZOMBIE)) 2386 vmsz = 0; 2387 else 2388 vmsz = pgtok(vmspace_resident_count(pick->p_vmspace)); 2389 2390 crit_exit(); 2391 2392 /* 2393 * Dump the output 2394 */ 2395 ttyprintf(tp, " %s ", buf); 2396 ttyprintf(tp, "%ld.%02ldu ", 2397 ru.ru_utime.tv_sec, ru.ru_utime.tv_usec / 10000); 2398 ttyprintf(tp, "%ld.%02lds ", 2399 ru.ru_stime.tv_sec, ru.ru_stime.tv_usec / 10000); 2400 ttyprintf(tp, "%d%% %ldk\n", pctcpu / 100, vmsz); 2401 } 2402 tp->t_rocount = 0; /* so pending input will be retyped if BS */ 2403 } 2404 2405 /* 2406 * Returns 1 if p2 is "better" than p1 2407 * 2408 * The algorithm for picking the "interesting" process is thus: 2409 * 2410 * 1) Only foreground processes are eligible - implied. 2411 * 2) Runnable processes are favored over anything else. The runner 2412 * with the highest cpu utilization is picked (p_cpticks). Ties are 2413 * broken by picking the highest pid. 2414 * 3) The sleeper with the shortest sleep time is next. With ties, 2415 * we pick out just "short-term" sleepers (P_SINTR == 0). 2416 * 4) Further ties are broken by picking the highest pid. 2417 */ 2418 #define ISRUN(p) (((p)->p_stat == SRUN) || ((p)->p_stat == SIDL)) 2419 #define TESTAB(a, b) ((a)<<1 | (b)) 2420 #define ONLYA 2 2421 #define ONLYB 1 2422 #define BOTH 3 2423 2424 static int 2425 proc_compare(struct proc *p1, struct proc *p2) 2426 { 2427 2428 if (p1 == NULL) 2429 return (1); 2430 /* 2431 * see if at least one of them is runnable 2432 */ 2433 switch (TESTAB(ISRUN(p1), ISRUN(p2))) { 2434 case ONLYA: 2435 return (0); 2436 case ONLYB: 2437 return (1); 2438 case BOTH: 2439 /* 2440 * tie - favor one with highest recent cpu utilization 2441 */ 2442 if (p2->p_cpticks > p1->p_cpticks) 2443 return (1); 2444 if (p1->p_cpticks > p2->p_cpticks) 2445 return (0); 2446 return (p2->p_pid > p1->p_pid); /* tie - return highest pid */ 2447 } 2448 /* 2449 * weed out zombies 2450 */ 2451 switch (TESTAB((p1->p_flag & P_ZOMBIE), (p2->p_flag & P_ZOMBIE))) { 2452 case ONLYA: 2453 return (1); 2454 case ONLYB: 2455 return (0); 2456 case BOTH: 2457 return (p2->p_pid > p1->p_pid); /* tie - return highest pid */ 2458 } 2459 /* 2460 * pick the one with the smallest sleep time 2461 */ 2462 if (p2->p_slptime > p1->p_slptime) 2463 return (0); 2464 if (p1->p_slptime > p2->p_slptime) 2465 return (1); 2466 /* 2467 * favor one sleeping in a non-interruptible sleep 2468 */ 2469 if (p1->p_flag & P_SINTR && (p2->p_flag & P_SINTR) == 0) 2470 return (1); 2471 if (p2->p_flag & P_SINTR && (p1->p_flag & P_SINTR) == 0) 2472 return (0); 2473 return (p2->p_pid > p1->p_pid); /* tie - return highest pid */ 2474 } 2475 2476 /* 2477 * Output char to tty; console putchar style. 2478 */ 2479 int 2480 tputchar(int c, struct tty *tp) 2481 { 2482 crit_enter(); 2483 if (!ISSET(tp->t_state, TS_CONNECTED)) { 2484 crit_exit(); 2485 return (-1); 2486 } 2487 if (c == '\n') 2488 (void)ttyoutput('\r', tp); 2489 (void)ttyoutput(c, tp); 2490 ttstart(tp); 2491 crit_exit(); 2492 return (0); 2493 } 2494 2495 /* 2496 * Sleep on chan, returning ERESTART if tty changed while we napped and 2497 * returning any errors (e.g. EINTR/EWOULDBLOCK) reported by tsleep. If 2498 * the tty is revoked, restarting a pending call will redo validation done 2499 * at the start of the call. 2500 */ 2501 int 2502 ttysleep(struct tty *tp, void *chan, int slpflags, char *wmesg, int timo) 2503 { 2504 int error; 2505 int gen; 2506 2507 gen = tp->t_gen; 2508 error = tsleep(chan, slpflags, wmesg, timo); 2509 if (error) 2510 return (error); 2511 return (tp->t_gen == gen ? 0 : ERESTART); 2512 } 2513 2514 /* 2515 * Allocate a tty struct. Clists in the struct will be allocated by 2516 * ttyopen(). 2517 */ 2518 struct tty * 2519 ttymalloc(struct tty *tp) 2520 { 2521 2522 if (tp) 2523 return(tp); 2524 tp = kmalloc(sizeof *tp, M_TTYS, M_WAITOK|M_ZERO); 2525 ttyregister(tp); 2526 return (tp); 2527 } 2528 2529 #if 0 2530 /* 2531 * Free a tty struct. Clists in the struct should have been freed by 2532 * ttyclose(). 2533 * 2534 * XXX not yet usable: since we support a half-closed state and do not 2535 * ref count the tty reference from the session, it is possible for a 2536 * session to hold a ref on the tty. See TTY_DO_FULL_CLOSE. 2537 */ 2538 void 2539 ttyfree(struct tty *tp) 2540 { 2541 kfree(tp, M_TTYS); 2542 } 2543 #endif /* 0 */ 2544 2545 void 2546 ttyregister(struct tty *tp) 2547 { 2548 SLIST_INSERT_HEAD(&tty_list, tp, t_list); 2549 } 2550 2551 static int 2552 sysctl_kern_ttys(SYSCTL_HANDLER_ARGS) 2553 { 2554 int error; 2555 struct tty *tp, t; 2556 SLIST_FOREACH(tp, &tty_list, t_list) { 2557 t = *tp; 2558 if (t.t_dev) 2559 t.t_dev = (cdev_t)dev2udev(t.t_dev); 2560 error = SYSCTL_OUT(req, (caddr_t)&t, sizeof(t)); 2561 if (error) 2562 return (error); 2563 } 2564 return (0); 2565 } 2566 2567 SYSCTL_PROC(_kern, OID_AUTO, ttys, CTLTYPE_OPAQUE|CTLFLAG_RD, 2568 0, 0, sysctl_kern_ttys, "S,tty", "All struct ttys"); 2569 2570 void 2571 nottystop(struct tty *tp, int rw) 2572 { 2573 2574 return; 2575 } 2576 2577 int 2578 ttyread(struct dev_read_args *ap) 2579 { 2580 struct tty *tp; 2581 2582 tp = ap->a_head.a_dev->si_tty; 2583 if (tp == NULL) 2584 return (ENODEV); 2585 return ((*linesw[tp->t_line].l_read)(tp, ap->a_uio, ap->a_ioflag)); 2586 } 2587 2588 int 2589 ttywrite(struct dev_write_args *ap) 2590 { 2591 struct tty *tp; 2592 2593 tp = ap->a_head.a_dev->si_tty; 2594 if (tp == NULL) 2595 return (ENODEV); 2596 return ((*linesw[tp->t_line].l_write)(tp, ap->a_uio, ap->a_ioflag)); 2597 } 2598