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