1 /* $NetBSD: tty.c,v 1.168 2004/05/25 04:30:32 atatat Exp $ */ 2 3 /*- 4 * Copyright (c) 1982, 1986, 1990, 1991, 1993 5 * The Regents of the University of California. All rights reserved. 6 * (c) UNIX System Laboratories, Inc. 7 * All or some portions of this file are derived from material licensed 8 * to the University of California by American Telephone and Telegraph 9 * Co. or Unix System Laboratories, Inc. and are reproduced herein with 10 * the permission of UNIX System Laboratories, Inc. 11 * 12 * Redistribution and use in source and binary forms, with or without 13 * modification, are permitted provided that the following conditions 14 * are met: 15 * 1. Redistributions of source code must retain the above copyright 16 * notice, this list of conditions and the following disclaimer. 17 * 2. Redistributions in binary form must reproduce the above copyright 18 * notice, this list of conditions and the following disclaimer in the 19 * documentation and/or other materials provided with the distribution. 20 * 3. Neither the name of the University nor the names of its contributors 21 * may be used to endorse or promote products derived from this software 22 * without specific prior written permission. 23 * 24 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 25 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 26 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 27 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 28 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 29 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 30 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 31 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 32 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 33 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 34 * SUCH DAMAGE. 35 * 36 * @(#)tty.c 8.13 (Berkeley) 1/9/95 37 */ 38 39 #include <sys/cdefs.h> 40 __KERNEL_RCSID(0, "$NetBSD: tty.c,v 1.168 2004/05/25 04:30:32 atatat Exp $"); 41 42 #include <sys/param.h> 43 #include <sys/systm.h> 44 #include <sys/ioctl.h> 45 #include <sys/proc.h> 46 #define TTYDEFCHARS 47 #include <sys/tty.h> 48 #undef TTYDEFCHARS 49 #include <sys/file.h> 50 #include <sys/conf.h> 51 #include <sys/dkstat.h> 52 #include <sys/uio.h> 53 #include <sys/kernel.h> 54 #include <sys/vnode.h> 55 #include <sys/syslog.h> 56 #include <sys/malloc.h> 57 #include <sys/pool.h> 58 #include <sys/signalvar.h> 59 #include <sys/resourcevar.h> 60 #include <sys/poll.h> 61 #include <sys/kprintf.h> 62 #include <sys/namei.h> 63 #include <sys/sysctl.h> 64 65 #include <machine/stdarg.h> 66 67 static int ttnread(struct tty *); 68 static void ttyblock(struct tty *); 69 static void ttyecho(int, struct tty *); 70 static void ttyrubo(struct tty *, int); 71 static void ttyprintf_nolock(struct tty *, const char *fmt, ...) 72 __attribute__((__format__(__printf__,2,3))); 73 static int proc_compare(struct proc *, struct proc *); 74 75 /* Symbolic sleep message strings. */ 76 const char ttclos[] = "ttycls"; 77 const char ttopen[] = "ttyopn"; 78 const char ttybg[] = "ttybg"; 79 const char ttyin[] = "ttyin"; 80 const char ttyout[] = "ttyout"; 81 82 /* 83 * Used to determine whether we still have a connection. This is true in 84 * one of 3 cases: 85 * 1) We have carrier. 86 * 2) It's a locally attached terminal, and we are therefore ignoring carrier. 87 * 3) We're using a flow control mechanism that overloads the carrier signal. 88 */ 89 #define CONNECTED(tp) (ISSET(tp->t_state, TS_CARR_ON) || \ 90 ISSET(tp->t_cflag, CLOCAL | MDMBUF)) 91 92 /* 93 * Table with character classes and parity. The 8th bit indicates parity, 94 * the 7th bit indicates the character is an alphameric or underscore (for 95 * ALTWERASE), and the low 6 bits indicate delay type. If the low 6 bits 96 * are 0 then the character needs no special processing on output; classes 97 * other than 0 might be translated or (not currently) require delays. 98 */ 99 #define E 0x00 /* Even parity. */ 100 #define O 0x80 /* Odd parity. */ 101 #define PARITY(c) (char_type[c] & O) 102 103 #define ALPHA 0x40 /* Alpha or underscore. */ 104 #define ISALPHA(c) (char_type[(c) & TTY_CHARMASK] & ALPHA) 105 106 #define CCLASSMASK 0x3f 107 #define CCLASS(c) (char_type[c] & CCLASSMASK) 108 109 #define BS BACKSPACE 110 #define CC CONTROL 111 #define CR RETURN 112 #define NA ORDINARY | ALPHA 113 #define NL NEWLINE 114 #define NO ORDINARY 115 #define TB TAB 116 #define VT VTAB 117 118 unsigned char const char_type[] = { 119 E|CC, O|CC, O|CC, E|CC, O|CC, E|CC, E|CC, O|CC, /* nul - bel */ 120 O|BS, E|TB, E|NL, O|CC, E|VT, O|CR, O|CC, E|CC, /* bs - si */ 121 O|CC, E|CC, E|CC, O|CC, E|CC, O|CC, O|CC, E|CC, /* dle - etb */ 122 E|CC, O|CC, O|CC, E|CC, O|CC, E|CC, E|CC, O|CC, /* can - us */ 123 O|NO, E|NO, E|NO, O|NO, E|NO, O|NO, O|NO, E|NO, /* sp - ' */ 124 E|NO, O|NO, O|NO, E|NO, O|NO, E|NO, E|NO, O|NO, /* ( - / */ 125 E|NA, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* 0 - 7 */ 126 O|NA, E|NA, E|NO, O|NO, E|NO, O|NO, O|NO, E|NO, /* 8 - ? */ 127 O|NO, E|NA, E|NA, O|NA, E|NA, O|NA, O|NA, E|NA, /* @ - G */ 128 E|NA, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* H - O */ 129 E|NA, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* P - W */ 130 O|NA, E|NA, E|NA, O|NO, E|NO, O|NO, O|NO, O|NA, /* X - _ */ 131 E|NO, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* ` - g */ 132 O|NA, E|NA, E|NA, O|NA, E|NA, O|NA, O|NA, E|NA, /* h - o */ 133 O|NA, E|NA, E|NA, O|NA, E|NA, O|NA, O|NA, E|NA, /* p - w */ 134 E|NA, O|NA, O|NA, E|NO, O|NO, E|NO, E|NO, O|CC, /* x - del */ 135 /* 136 * Meta chars; should be settable per character set; 137 * for now, treat them all as normal characters. 138 */ 139 NA, NA, NA, NA, NA, NA, NA, NA, 140 NA, NA, NA, NA, NA, NA, NA, NA, 141 NA, NA, NA, NA, NA, NA, NA, NA, 142 NA, NA, NA, NA, NA, NA, NA, NA, 143 NA, NA, NA, NA, NA, NA, NA, NA, 144 NA, NA, NA, NA, NA, NA, NA, NA, 145 NA, NA, NA, NA, NA, NA, NA, NA, 146 NA, NA, NA, NA, NA, NA, NA, NA, 147 NA, NA, NA, NA, NA, NA, NA, NA, 148 NA, NA, NA, NA, NA, NA, NA, NA, 149 NA, NA, NA, NA, NA, NA, NA, NA, 150 NA, NA, NA, NA, NA, NA, NA, NA, 151 NA, NA, NA, NA, NA, NA, NA, NA, 152 NA, NA, NA, NA, NA, NA, NA, NA, 153 NA, NA, NA, NA, NA, NA, NA, NA, 154 NA, NA, NA, NA, NA, NA, NA, NA, 155 }; 156 #undef BS 157 #undef CC 158 #undef CR 159 #undef NA 160 #undef NL 161 #undef NO 162 #undef TB 163 #undef VT 164 165 /* Macros to clear/set/test flags. */ 166 #define SET(t, f) (t) |= (f) 167 #define CLR(t, f) (t) &= ~((unsigned)(f)) 168 #define ISSET(t, f) ((t) & (f)) 169 170 struct simplelock ttylist_slock = SIMPLELOCK_INITIALIZER; 171 struct ttylist_head ttylist; /* TAILQ_HEAD */ 172 int tty_count; 173 174 POOL_INIT(tty_pool, sizeof(struct tty), 0, 0, 0, "ttypl", 175 &pool_allocator_nointr); 176 177 u_int64_t tk_cancc; 178 u_int64_t tk_nin; 179 u_int64_t tk_nout; 180 u_int64_t tk_rawcc; 181 182 SYSCTL_SETUP(sysctl_kern_tkstat_setup, "sysctl kern.tkstat subtree setup") 183 { 184 185 sysctl_createv(clog, 0, NULL, NULL, 186 CTLFLAG_PERMANENT, 187 CTLTYPE_NODE, "kern", NULL, 188 NULL, 0, NULL, 0, 189 CTL_KERN, CTL_EOL); 190 sysctl_createv(clog, 0, NULL, NULL, 191 CTLFLAG_PERMANENT, 192 CTLTYPE_NODE, "tkstat", 193 SYSCTL_DESCR("Number of characters sent and and " 194 "received on ttys"), 195 NULL, 0, NULL, 0, 196 CTL_KERN, KERN_TKSTAT, CTL_EOL); 197 198 sysctl_createv(clog, 0, NULL, NULL, 199 CTLFLAG_PERMANENT, 200 CTLTYPE_QUAD, "nin", 201 SYSCTL_DESCR("Total number of tty input characters"), 202 NULL, 0, &tk_nin, 0, 203 CTL_KERN, KERN_TKSTAT, KERN_TKSTAT_NIN, CTL_EOL); 204 sysctl_createv(clog, 0, NULL, NULL, 205 CTLFLAG_PERMANENT, 206 CTLTYPE_QUAD, "nout", 207 SYSCTL_DESCR("Total number of tty output characters"), 208 NULL, 0, &tk_nout, 0, 209 CTL_KERN, KERN_TKSTAT, KERN_TKSTAT_NOUT, CTL_EOL); 210 sysctl_createv(clog, 0, NULL, NULL, 211 CTLFLAG_PERMANENT, 212 CTLTYPE_QUAD, "cancc", 213 SYSCTL_DESCR("Number of canonical tty input characters"), 214 NULL, 0, &tk_cancc, 0, 215 CTL_KERN, KERN_TKSTAT, KERN_TKSTAT_CANCC, CTL_EOL); 216 sysctl_createv(clog, 0, NULL, NULL, 217 CTLFLAG_PERMANENT, 218 CTLTYPE_QUAD, "rawcc", 219 SYSCTL_DESCR("Number of raw tty input characters"), 220 NULL, 0, &tk_rawcc, 0, 221 CTL_KERN, KERN_TKSTAT, KERN_TKSTAT_RAWCC, CTL_EOL); 222 } 223 224 int 225 ttyopen(struct tty *tp, int dialout, int nonblock) 226 { 227 int s, error; 228 229 error = 0; 230 231 s = spltty(); 232 TTY_LOCK(tp); 233 234 if (dialout) { 235 /* 236 * If the device is already open for non-dialout, fail. 237 * Otherwise, set TS_DIALOUT to block any pending non-dialout 238 * opens. 239 */ 240 if (ISSET(tp->t_state, TS_ISOPEN) && 241 !ISSET(tp->t_state, TS_DIALOUT)) { 242 error = EBUSY; 243 goto out; 244 } 245 SET(tp->t_state, TS_DIALOUT); 246 } else { 247 if (!nonblock) { 248 /* 249 * Wait for carrier. Also wait for any dialout 250 * processes to close the tty first. 251 */ 252 while (ISSET(tp->t_state, TS_DIALOUT) || 253 !CONNECTED(tp)) { 254 tp->t_wopen++; 255 error = ttysleep(tp, &tp->t_rawq, 256 TTIPRI | PCATCH, ttopen, 0); 257 tp->t_wopen--; 258 if (error) 259 goto out; 260 } 261 } else { 262 /* 263 * Don't allow a non-blocking non-dialout open if the 264 * device is already open for dialout. 265 */ 266 if (ISSET(tp->t_state, TS_DIALOUT)) { 267 error = EBUSY; 268 goto out; 269 } 270 } 271 } 272 273 out: 274 TTY_UNLOCK(tp); 275 splx(s); 276 return (error); 277 } 278 279 /* 280 * Initial open of tty, or (re)entry to standard tty line discipline. 281 */ 282 int 283 ttylopen(dev_t device, struct tty *tp) 284 { 285 int s; 286 287 s = spltty(); 288 TTY_LOCK(tp); 289 tp->t_dev = device; 290 if (!ISSET(tp->t_state, TS_ISOPEN)) { 291 SET(tp->t_state, TS_ISOPEN); 292 memset(&tp->t_winsize, 0, sizeof(tp->t_winsize)); 293 #ifdef COMPAT_OLDTTY 294 tp->t_flags = 0; 295 #endif 296 } 297 TTY_UNLOCK(tp); 298 splx(s); 299 return (0); 300 } 301 302 /* 303 * Handle close() on a tty line: flush and set to initial state, 304 * bumping generation number so that pending read/write calls 305 * can detect recycling of the tty. 306 */ 307 int 308 ttyclose(struct tty *tp) 309 { 310 extern struct tty *constty; /* Temporary virtual console. */ 311 int s; 312 313 s = spltty(); 314 TTY_LOCK(tp); 315 316 if (constty == tp) 317 constty = NULL; 318 319 ttyflush(tp, FREAD | FWRITE); 320 321 tp->t_gen++; 322 tp->t_pgrp = NULL; 323 if (tp->t_session != NULL) { 324 SESSRELE(tp->t_session); 325 tp->t_session = NULL; 326 } 327 tp->t_state = 0; 328 329 TTY_UNLOCK(tp); 330 splx(s); 331 return (0); 332 } 333 334 #define FLUSHQ(q) { \ 335 if ((q)->c_cc) \ 336 ndflush(q, (q)->c_cc); \ 337 } 338 339 /* 340 * This macro is used in canonical mode input processing, where a read 341 * request shall not return unless a 'line delimiter' ('\n') or 'break' 342 * (EOF, EOL, EOL2) character (or a signal) has been received. As EOL2 343 * is an extension to the POSIX.1 defined set of special characters, 344 * recognize it only if IEXTEN is set in the set of local flags. 345 */ 346 #define TTBREAKC(c, lflg) \ 347 ((c) == '\n' || (((c) == cc[VEOF] || (c) == cc[VEOL] || \ 348 ((c) == cc[VEOL2] && ISSET(lflg, IEXTEN))) && (c) != _POSIX_VDISABLE)) 349 350 351 352 /* 353 * ttyinput() helper. 354 * Call at spltty() and with the tty slock held. 355 */ 356 static int 357 ttyinput_wlock(int c, struct tty *tp) 358 { 359 const struct cdevsw *cdev; 360 int iflag, lflag, i, error; 361 u_char *cc; 362 363 /* 364 * If input is pending take it first. 365 */ 366 lflag = tp->t_lflag; 367 if (ISSET(lflag, PENDIN)) 368 ttypend(tp); 369 /* 370 * Gather stats. 371 */ 372 if (ISSET(lflag, ICANON)) { 373 ++tk_cancc; 374 ++tp->t_cancc; 375 } else { 376 ++tk_rawcc; 377 ++tp->t_rawcc; 378 } 379 ++tk_nin; 380 381 cc = tp->t_cc; 382 383 /* 384 * Handle exceptional conditions (break, parity, framing). 385 */ 386 iflag = tp->t_iflag; 387 if ((error = (ISSET(c, TTY_ERRORMASK))) != 0) { 388 CLR(c, TTY_ERRORMASK); 389 if (ISSET(error, TTY_FE) && c == 0) { /* Break. */ 390 if (ISSET(iflag, IGNBRK)) 391 return (0); 392 else if (ISSET(iflag, BRKINT)) { 393 ttyflush(tp, FREAD | FWRITE); 394 pgsignal(tp->t_pgrp, SIGINT, 1); 395 return (0); 396 } else if (ISSET(iflag, PARMRK)) 397 goto parmrk; 398 } else if ((ISSET(error, TTY_PE) && ISSET(iflag, INPCK)) || 399 ISSET(error, TTY_FE)) { 400 if (ISSET(iflag, IGNPAR)) 401 return (0); 402 else if (ISSET(iflag, PARMRK)) { 403 parmrk: (void)putc(0377 | TTY_QUOTE, &tp->t_rawq); 404 (void)putc(0 | TTY_QUOTE, &tp->t_rawq); 405 (void)putc(c | TTY_QUOTE, &tp->t_rawq); 406 return (0); 407 } else 408 c = 0; 409 } 410 } else if (c == 0377 && 411 ISSET(iflag, ISTRIP|IGNPAR|INPCK|PARMRK) == (INPCK|PARMRK)) { 412 /* "Escape" a valid character of '\377'. */ 413 (void)putc(0377 | TTY_QUOTE, &tp->t_rawq); 414 (void)putc(0377 | TTY_QUOTE, &tp->t_rawq); 415 goto endcase; 416 } 417 418 /* 419 * In tandem mode, check high water mark. 420 */ 421 if (ISSET(iflag, IXOFF) || ISSET(tp->t_cflag, CHWFLOW)) 422 ttyblock(tp); 423 if (!ISSET(tp->t_state, TS_TYPEN) && ISSET(iflag, ISTRIP)) 424 CLR(c, 0x80); 425 if (!ISSET(lflag, EXTPROC)) { 426 /* 427 * Check for literal nexting very first 428 */ 429 if (ISSET(tp->t_state, TS_LNCH)) { 430 SET(c, TTY_QUOTE); 431 CLR(tp->t_state, TS_LNCH); 432 } 433 /* 434 * Scan for special characters. This code 435 * is really just a big case statement with 436 * non-constant cases. The bottom of the 437 * case statement is labeled ``endcase'', so goto 438 * it after a case match, or similar. 439 */ 440 441 /* 442 * Control chars which aren't controlled 443 * by ICANON, ISIG, or IXON. 444 */ 445 if (ISSET(lflag, IEXTEN)) { 446 if (CCEQ(cc[VLNEXT], c)) { 447 if (ISSET(lflag, ECHO)) { 448 if (ISSET(lflag, ECHOE)) { 449 (void)ttyoutput('^', tp); 450 (void)ttyoutput('\b', tp); 451 } else 452 ttyecho(c, tp); 453 } 454 SET(tp->t_state, TS_LNCH); 455 goto endcase; 456 } 457 if (CCEQ(cc[VDISCARD], c)) { 458 if (ISSET(lflag, FLUSHO)) 459 CLR(tp->t_lflag, FLUSHO); 460 else { 461 ttyflush(tp, FWRITE); 462 ttyecho(c, tp); 463 if (tp->t_rawq.c_cc + tp->t_canq.c_cc) 464 ttyretype(tp); 465 SET(tp->t_lflag, FLUSHO); 466 } 467 goto startoutput; 468 } 469 } 470 /* 471 * Signals. 472 */ 473 if (ISSET(lflag, ISIG)) { 474 if (CCEQ(cc[VINTR], c) || CCEQ(cc[VQUIT], c)) { 475 if (!ISSET(lflag, NOFLSH)) 476 ttyflush(tp, FREAD | FWRITE); 477 ttyecho(c, tp); 478 pgsignal(tp->t_pgrp, 479 CCEQ(cc[VINTR], c) ? SIGINT : SIGQUIT, 1); 480 goto endcase; 481 } 482 if (CCEQ(cc[VSUSP], c)) { 483 if (!ISSET(lflag, NOFLSH)) 484 ttyflush(tp, FREAD); 485 ttyecho(c, tp); 486 pgsignal(tp->t_pgrp, SIGTSTP, 1); 487 goto endcase; 488 } 489 } 490 /* 491 * Handle start/stop characters. 492 */ 493 if (ISSET(iflag, IXON)) { 494 if (CCEQ(cc[VSTOP], c)) { 495 if (!ISSET(tp->t_state, TS_TTSTOP)) { 496 SET(tp->t_state, TS_TTSTOP); 497 cdev = cdevsw_lookup(tp->t_dev); 498 if (cdev != NULL) 499 (*cdev->d_stop)(tp, 0); 500 return (0); 501 } 502 if (!CCEQ(cc[VSTART], c)) 503 return (0); 504 /* 505 * if VSTART == VSTOP then toggle 506 */ 507 goto endcase; 508 } 509 if (CCEQ(cc[VSTART], c)) 510 goto restartoutput; 511 } 512 /* 513 * IGNCR, ICRNL, & INLCR 514 */ 515 if (c == '\r') { 516 if (ISSET(iflag, IGNCR)) 517 goto endcase; 518 else if (ISSET(iflag, ICRNL)) 519 c = '\n'; 520 } else if (c == '\n' && ISSET(iflag, INLCR)) 521 c = '\r'; 522 } 523 if (!ISSET(lflag, EXTPROC) && ISSET(lflag, ICANON)) { 524 /* 525 * From here on down canonical mode character 526 * processing takes place. 527 */ 528 /* 529 * erase (^H / ^?) 530 */ 531 if (CCEQ(cc[VERASE], c)) { 532 if (tp->t_rawq.c_cc) 533 ttyrub(unputc(&tp->t_rawq), tp); 534 goto endcase; 535 } 536 /* 537 * kill (^U) 538 */ 539 if (CCEQ(cc[VKILL], c)) { 540 if (ISSET(lflag, ECHOKE) && 541 tp->t_rawq.c_cc == tp->t_rocount && 542 !ISSET(lflag, ECHOPRT)) 543 while (tp->t_rawq.c_cc) 544 ttyrub(unputc(&tp->t_rawq), tp); 545 else { 546 ttyecho(c, tp); 547 if (ISSET(lflag, ECHOK) || 548 ISSET(lflag, ECHOKE)) 549 ttyecho('\n', tp); 550 FLUSHQ(&tp->t_rawq); 551 tp->t_rocount = 0; 552 } 553 CLR(tp->t_state, TS_LOCAL); 554 goto endcase; 555 } 556 /* 557 * Extensions to the POSIX.1 GTI set of functions. 558 */ 559 if (ISSET(lflag, IEXTEN)) { 560 /* 561 * word erase (^W) 562 */ 563 if (CCEQ(cc[VWERASE], c)) { 564 int alt = ISSET(lflag, ALTWERASE); 565 int ctype; 566 567 /* 568 * erase whitespace 569 */ 570 while ((c = unputc(&tp->t_rawq)) == ' ' || 571 c == '\t') 572 ttyrub(c, tp); 573 if (c == -1) 574 goto endcase; 575 /* 576 * erase last char of word and remember the 577 * next chars type (for ALTWERASE) 578 */ 579 ttyrub(c, tp); 580 c = unputc(&tp->t_rawq); 581 if (c == -1) 582 goto endcase; 583 if (c == ' ' || c == '\t') { 584 (void)putc(c, &tp->t_rawq); 585 goto endcase; 586 } 587 ctype = ISALPHA(c); 588 /* 589 * erase rest of word 590 */ 591 do { 592 ttyrub(c, tp); 593 c = unputc(&tp->t_rawq); 594 if (c == -1) 595 goto endcase; 596 } while (c != ' ' && c != '\t' && 597 (alt == 0 || ISALPHA(c) == ctype)); 598 (void)putc(c, &tp->t_rawq); 599 goto endcase; 600 } 601 /* 602 * reprint line (^R) 603 */ 604 if (CCEQ(cc[VREPRINT], c)) { 605 ttyretype(tp); 606 goto endcase; 607 } 608 /* 609 * ^T - kernel info and generate SIGINFO 610 */ 611 if (CCEQ(cc[VSTATUS], c)) { 612 if (!ISSET(lflag, NOKERNINFO)) 613 ttyinfo(tp); 614 if (ISSET(lflag, ISIG)) 615 pgsignal(tp->t_pgrp, SIGINFO, 1); 616 goto endcase; 617 } 618 } 619 } 620 /* 621 * Check for input buffer overflow 622 */ 623 if (tp->t_rawq.c_cc + tp->t_canq.c_cc >= TTYHOG) { 624 if (ISSET(iflag, IMAXBEL)) { 625 if (tp->t_outq.c_cc < tp->t_hiwat) 626 (void)ttyoutput(CTRL('g'), tp); 627 } else 628 ttyflush(tp, FREAD | FWRITE); 629 goto endcase; 630 } 631 /* 632 * Put data char in q for user and 633 * wakeup on seeing a line delimiter. 634 */ 635 if (putc(c, &tp->t_rawq) >= 0) { 636 if (!ISSET(lflag, ICANON)) { 637 ttwakeup(tp); 638 ttyecho(c, tp); 639 goto endcase; 640 } 641 if (TTBREAKC(c, lflag)) { 642 tp->t_rocount = 0; 643 catq(&tp->t_rawq, &tp->t_canq); 644 ttwakeup(tp); 645 } else if (tp->t_rocount++ == 0) 646 tp->t_rocol = tp->t_column; 647 if (ISSET(tp->t_state, TS_ERASE)) { 648 /* 649 * end of prterase \.../ 650 */ 651 CLR(tp->t_state, TS_ERASE); 652 (void)ttyoutput('/', tp); 653 } 654 i = tp->t_column; 655 ttyecho(c, tp); 656 if (CCEQ(cc[VEOF], c) && ISSET(lflag, ECHO)) { 657 /* 658 * Place the cursor over the '^' of the ^D. 659 */ 660 i = min(2, tp->t_column - i); 661 while (i > 0) { 662 (void)ttyoutput('\b', tp); 663 i--; 664 } 665 } 666 } 667 endcase: 668 /* 669 * IXANY means allow any character to restart output. 670 */ 671 if (ISSET(tp->t_state, TS_TTSTOP) && 672 !ISSET(iflag, IXANY) && cc[VSTART] != cc[VSTOP]) { 673 return (0); 674 } 675 restartoutput: 676 CLR(tp->t_lflag, FLUSHO); 677 CLR(tp->t_state, TS_TTSTOP); 678 startoutput: 679 return (ttstart(tp)); 680 } 681 682 /* 683 * Process input of a single character received on a tty. 684 * Must be called at spltty(). 685 * 686 * XXX - this is a hack, all drivers must changed to acquire the 687 * lock before calling linesw->l_rint() 688 */ 689 int 690 ttyinput(int c, struct tty *tp) 691 { 692 int error; 693 int s; 694 695 /* 696 * Unless the receiver is enabled, drop incoming data. 697 */ 698 if (!ISSET(tp->t_cflag, CREAD)) 699 return (0); 700 701 s = spltty(); 702 TTY_LOCK(tp); 703 error = ttyinput_wlock(c, tp); 704 TTY_UNLOCK(tp); 705 splx(s); 706 return (error); 707 } 708 709 /* 710 * Output a single character on a tty, doing output processing 711 * as needed (expanding tabs, newline processing, etc.). 712 * Returns < 0 if succeeds, otherwise returns char to resend. 713 * Must be recursive. 714 * Call with tty slock held. 715 */ 716 int 717 ttyoutput(int c, struct tty *tp) 718 { 719 long oflag; 720 int col, notout, s; 721 722 oflag = tp->t_oflag; 723 if (!ISSET(oflag, OPOST)) { 724 tk_nout++; 725 tp->t_outcc++; 726 if (!ISSET(tp->t_lflag, FLUSHO) && putc(c, &tp->t_outq)) 727 return (c); 728 return (-1); 729 } 730 /* 731 * Do tab expansion if OXTABS is set. Special case if we do external 732 * processing, we don't do the tab expansion because we'll probably 733 * get it wrong. If tab expansion needs to be done, let it happen 734 * externally. 735 */ 736 CLR(c, ~TTY_CHARMASK); 737 if (c == '\t' && 738 ISSET(oflag, OXTABS) && !ISSET(tp->t_lflag, EXTPROC)) { 739 c = 8 - (tp->t_column & 7); 740 if (ISSET(tp->t_lflag, FLUSHO)) { 741 notout = 0; 742 } else { 743 s = spltty(); /* Don't interrupt tabs. */ 744 notout = b_to_q(" ", c, &tp->t_outq); 745 c -= notout; 746 tk_nout += c; 747 tp->t_outcc += c; 748 splx(s); 749 } 750 tp->t_column += c; 751 return (notout ? '\t' : -1); 752 } 753 if (c == CEOT && ISSET(oflag, ONOEOT)) 754 return (-1); 755 756 /* 757 * Newline translation: if ONLCR is set, 758 * translate newline into "\r\n". 759 */ 760 if (c == '\n' && ISSET(tp->t_oflag, ONLCR)) { 761 tk_nout++; 762 tp->t_outcc++; 763 if (!ISSET(tp->t_lflag, FLUSHO) && putc('\r', &tp->t_outq)) 764 return (c); 765 } 766 /* If OCRNL is set, translate "\r" into "\n". */ 767 else if (c == '\r' && ISSET(tp->t_oflag, OCRNL)) 768 c = '\n'; 769 /* If ONOCR is set, don't transmit CRs when on column 0. */ 770 else if (c == '\r' && ISSET(tp->t_oflag, ONOCR) && tp->t_column == 0) 771 return (-1); 772 773 tk_nout++; 774 tp->t_outcc++; 775 if (!ISSET(tp->t_lflag, FLUSHO) && putc(c, &tp->t_outq)) 776 return (c); 777 778 col = tp->t_column; 779 switch (CCLASS(c)) { 780 case BACKSPACE: 781 if (col > 0) 782 --col; 783 break; 784 case CONTROL: 785 break; 786 case NEWLINE: 787 if (ISSET(tp->t_oflag, ONLCR | ONLRET)) 788 col = 0; 789 break; 790 case RETURN: 791 col = 0; 792 break; 793 case ORDINARY: 794 ++col; 795 break; 796 case TAB: 797 col = (col + 8) & ~7; 798 break; 799 } 800 tp->t_column = col; 801 return (-1); 802 } 803 804 /* 805 * Ioctls for all tty devices. Called after line-discipline specific ioctl 806 * has been called to do discipline-specific functions and/or reject any 807 * of these ioctl commands. 808 */ 809 /* ARGSUSED */ 810 int 811 ttioctl(struct tty *tp, u_long cmd, caddr_t data, int flag, struct proc *p) 812 { 813 extern struct tty *constty; /* Temporary virtual console. */ 814 struct linesw *lp; 815 int s, error; 816 struct nameidata nd; 817 818 /* If the ioctl involves modification, hang if in the background. */ 819 switch (cmd) { 820 case TIOCFLUSH: 821 case TIOCDRAIN: 822 case TIOCSBRK: 823 case TIOCCBRK: 824 case TIOCSTART: 825 case TIOCSETA: 826 case TIOCSETD: 827 case TIOCSLINED: 828 case TIOCSETAF: 829 case TIOCSETAW: 830 #ifdef notdef 831 case TIOCSPGRP: 832 case FIOSETOWN: 833 #endif 834 case TIOCSTAT: 835 case TIOCSTI: 836 case TIOCSWINSZ: 837 #ifdef COMPAT_OLDTTY 838 case TIOCLBIC: 839 case TIOCLBIS: 840 case TIOCLSET: 841 case TIOCSETC: 842 case OTIOCSETD: 843 case TIOCSETN: 844 case TIOCSETP: 845 case TIOCSLTC: 846 #endif 847 while (isbackground(curproc, tp) && 848 p->p_pgrp->pg_jobc && (p->p_flag & P_PPWAIT) == 0 && 849 !sigismasked(p, SIGTTOU)) { 850 pgsignal(p->p_pgrp, SIGTTOU, 1); 851 s = spltty(); 852 TTY_LOCK(tp); 853 error = ttysleep(tp, &lbolt, 854 TTOPRI | PCATCH | PNORELOCK, ttybg, 0); 855 splx(s); 856 if (error) { 857 return (error); 858 } 859 } 860 break; 861 } 862 863 switch (cmd) { /* Process the ioctl. */ 864 case FIOASYNC: /* set/clear async i/o */ 865 s = spltty(); 866 TTY_LOCK(tp); 867 if (*(int *)data) 868 SET(tp->t_state, TS_ASYNC); 869 else 870 CLR(tp->t_state, TS_ASYNC); 871 TTY_UNLOCK(tp); 872 splx(s); 873 break; 874 case FIONBIO: /* set/clear non-blocking i/o */ 875 break; /* XXX: delete. */ 876 case FIONREAD: /* get # bytes to read */ 877 s = spltty(); 878 TTY_LOCK(tp); 879 *(int *)data = ttnread(tp); 880 TTY_UNLOCK(tp); 881 splx(s); 882 break; 883 case TIOCEXCL: /* set exclusive use of tty */ 884 s = spltty(); 885 TTY_LOCK(tp); 886 SET(tp->t_state, TS_XCLUDE); 887 splx(s); 888 TTY_UNLOCK(tp); 889 break; 890 case TIOCFLUSH: { /* flush buffers */ 891 int flags = *(int *)data; 892 893 if (flags == 0) 894 flags = FREAD | FWRITE; 895 else 896 flags &= FREAD | FWRITE; 897 s = spltty(); 898 TTY_LOCK(tp); 899 ttyflush(tp, flags); 900 TTY_UNLOCK(tp); 901 splx(s); 902 break; 903 } 904 case TIOCCONS: /* become virtual console */ 905 if (*(int *)data) { 906 if (constty && constty != tp && 907 ISSET(constty->t_state, TS_CARR_ON | TS_ISOPEN) == 908 (TS_CARR_ON | TS_ISOPEN)) 909 return EBUSY; 910 911 NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_SYSSPACE, 912 "/dev/console", p); 913 if ((error = namei(&nd)) != 0) 914 return error; 915 error = VOP_ACCESS(nd.ni_vp, VREAD, p->p_ucred, p); 916 vput(nd.ni_vp); 917 if (error) 918 return error; 919 920 constty = tp; 921 } else if (tp == constty) 922 constty = NULL; 923 break; 924 case TIOCDRAIN: /* wait till output drained */ 925 if ((error = ttywait(tp)) != 0) 926 return (error); 927 break; 928 case TIOCGETA: { /* get termios struct */ 929 struct termios *t = (struct termios *)data; 930 931 memcpy(t, &tp->t_termios, sizeof(struct termios)); 932 break; 933 } 934 case TIOCGETD: /* get line discipline */ 935 *(int *)data = tp->t_linesw->l_no; 936 break; 937 case TIOCGLINED: 938 (void)strncpy((char *)data, tp->t_linesw->l_name, 939 TTLINEDNAMELEN - 1); 940 break; 941 case TIOCGWINSZ: /* get window size */ 942 *(struct winsize *)data = tp->t_winsize; 943 break; 944 case FIOGETOWN: 945 if (!isctty(p, tp)) 946 return (ENOTTY); 947 *(int *)data = tp->t_pgrp ? -tp->t_pgrp->pg_id : 0; 948 break; 949 case TIOCGPGRP: /* get pgrp of tty */ 950 if (!isctty(p, tp)) 951 return (ENOTTY); 952 *(int *)data = tp->t_pgrp ? tp->t_pgrp->pg_id : NO_PGID; 953 break; 954 case TIOCGSID: /* get sid of tty */ 955 if (!isctty(p, tp)) 956 return (ENOTTY); 957 *(int *)data = tp->t_session->s_sid; 958 break; 959 #ifdef TIOCHPCL 960 case TIOCHPCL: /* hang up on last close */ 961 s = spltty(); 962 TTY_LOCK(tp); 963 SET(tp->t_cflag, HUPCL); 964 TTY_UNLOCK(tp); 965 splx(s); 966 break; 967 #endif 968 case TIOCNXCL: /* reset exclusive use of tty */ 969 s = spltty(); 970 TTY_LOCK(tp); 971 CLR(tp->t_state, TS_XCLUDE); 972 TTY_UNLOCK(tp); 973 splx(s); 974 break; 975 case TIOCOUTQ: /* output queue size */ 976 *(int *)data = tp->t_outq.c_cc; 977 break; 978 case TIOCSETA: /* set termios struct */ 979 case TIOCSETAW: /* drain output, set */ 980 case TIOCSETAF: { /* drn out, fls in, set */ 981 struct termios *t = (struct termios *)data; 982 983 if (cmd == TIOCSETAW || cmd == TIOCSETAF) { 984 if ((error = ttywait(tp)) != 0) 985 return (error); 986 987 if (cmd == TIOCSETAF) { 988 s = spltty(); 989 TTY_LOCK(tp); 990 ttyflush(tp, FREAD); 991 TTY_UNLOCK(tp); 992 splx(s); 993 } 994 } 995 996 s = spltty(); 997 /* 998 * XXXSMP - some drivers call back on us from t_param(), so 999 * don't take the tty spin lock here. 1000 * require t_param() to unlock upon callback? 1001 */ 1002 /* wanted here: TTY_LOCK(tp); */ 1003 if (!ISSET(t->c_cflag, CIGNORE)) { 1004 /* 1005 * Set device hardware. 1006 */ 1007 if (tp->t_param && (error = (*tp->t_param)(tp, t))) { 1008 /* wanted here: TTY_UNLOCK(tp); */ 1009 splx(s); 1010 return (error); 1011 } else { 1012 tp->t_cflag = t->c_cflag; 1013 tp->t_ispeed = t->c_ispeed; 1014 tp->t_ospeed = t->c_ospeed; 1015 if (t->c_ospeed == 0 && tp->t_session && 1016 tp->t_session->s_leader) 1017 psignal(tp->t_session->s_leader, 1018 SIGHUP); 1019 } 1020 ttsetwater(tp); 1021 } 1022 1023 /* delayed lock acquiring */TTY_LOCK(tp); 1024 if (cmd != TIOCSETAF) { 1025 if (ISSET(t->c_lflag, ICANON) != 1026 ISSET(tp->t_lflag, ICANON)) { 1027 if (ISSET(t->c_lflag, ICANON)) { 1028 SET(tp->t_lflag, PENDIN); 1029 ttwakeup(tp); 1030 } else { 1031 struct clist tq; 1032 1033 catq(&tp->t_rawq, &tp->t_canq); 1034 tq = tp->t_rawq; 1035 tp->t_rawq = tp->t_canq; 1036 tp->t_canq = tq; 1037 CLR(tp->t_lflag, PENDIN); 1038 } 1039 } 1040 } 1041 tp->t_iflag = t->c_iflag; 1042 tp->t_oflag = t->c_oflag; 1043 /* 1044 * Make the EXTPROC bit read only. 1045 */ 1046 if (ISSET(tp->t_lflag, EXTPROC)) 1047 SET(t->c_lflag, EXTPROC); 1048 else 1049 CLR(t->c_lflag, EXTPROC); 1050 tp->t_lflag = t->c_lflag | ISSET(tp->t_lflag, PENDIN); 1051 memcpy(tp->t_cc, t->c_cc, sizeof(t->c_cc)); 1052 TTY_UNLOCK(tp); 1053 splx(s); 1054 break; 1055 } 1056 case TIOCSETD: { /* set line discipline */ 1057 int t = *(int *)data; 1058 1059 if (t < 0) 1060 return (EINVAL); 1061 if (t >= nlinesw) 1062 return (ENXIO); 1063 lp = linesw[t]; 1064 goto setldisc; 1065 } 1066 case TIOCSLINED: { /* set line discipline */ 1067 char *name = (char *)data; 1068 dev_t device; 1069 1070 /* Null terminate to prevent buffer overflow */ 1071 name[TTLINEDNAMELEN - 1] = '\0'; 1072 lp = ttyldisc_lookup(name); 1073 1074 setldisc: 1075 if (lp == NULL) 1076 return (ENXIO); 1077 1078 if (lp != tp->t_linesw) { 1079 device = tp->t_dev; 1080 s = spltty(); 1081 (*tp->t_linesw->l_close)(tp, flag); 1082 error = (*lp->l_open)(device, tp); 1083 if (error) { 1084 (void)(*tp->t_linesw->l_open)(device, tp); 1085 splx(s); 1086 return (error); 1087 } 1088 tp->t_linesw = lp; 1089 splx(s); 1090 } 1091 break; 1092 } 1093 case TIOCSTART: /* start output, like ^Q */ 1094 s = spltty(); 1095 TTY_LOCK(tp); 1096 if (ISSET(tp->t_state, TS_TTSTOP) || 1097 ISSET(tp->t_lflag, FLUSHO)) { 1098 CLR(tp->t_lflag, FLUSHO); 1099 CLR(tp->t_state, TS_TTSTOP); 1100 ttstart(tp); 1101 } 1102 TTY_UNLOCK(tp); 1103 splx(s); 1104 break; 1105 case TIOCSTI: /* simulate terminal input */ 1106 if (p->p_ucred->cr_uid && (flag & FREAD) == 0) 1107 return (EPERM); 1108 if (p->p_ucred->cr_uid && !isctty(p, tp)) 1109 return (EACCES); 1110 (*tp->t_linesw->l_rint)(*(u_char *)data, tp); 1111 break; 1112 case TIOCSTOP: /* stop output, like ^S */ 1113 { 1114 const struct cdevsw *cdev; 1115 s = spltty(); 1116 TTY_LOCK(tp); 1117 if (!ISSET(tp->t_state, TS_TTSTOP)) { 1118 SET(tp->t_state, TS_TTSTOP); 1119 cdev = cdevsw_lookup(tp->t_dev); 1120 if (cdev != NULL) 1121 (*cdev->d_stop)(tp, 0); 1122 } 1123 TTY_UNLOCK(tp); 1124 splx(s); 1125 break; 1126 } 1127 case TIOCSCTTY: /* become controlling tty */ 1128 /* Session ctty vnode pointer set in vnode layer. */ 1129 if (!SESS_LEADER(p) || 1130 ((p->p_session->s_ttyvp || tp->t_session) && 1131 (tp->t_session != p->p_session))) 1132 return (EPERM); 1133 1134 /* 1135 * `p_session' acquires a reference. 1136 * But note that if `t_session' is set at this point, 1137 * it must equal `p_session', in which case the session 1138 * already has the correct reference count. 1139 */ 1140 if (tp->t_session == NULL) 1141 SESSHOLD(p->p_session); 1142 1143 tp->t_session = p->p_session; 1144 tp->t_pgrp = p->p_pgrp; 1145 p->p_session->s_ttyp = tp; 1146 p->p_flag |= P_CONTROLT; 1147 break; 1148 case FIOSETOWN: { /* set pgrp of tty */ 1149 pid_t pgid = *(int *)data; 1150 struct pgrp *pgrp; 1151 1152 if (!isctty(p, tp)) 1153 return (ENOTTY); 1154 1155 if (pgid < 0) 1156 pgrp = pgfind(-pgid); 1157 else { 1158 struct proc *p1 = pfind(pgid); 1159 if (!p1) 1160 return (ESRCH); 1161 pgrp = p1->p_pgrp; 1162 } 1163 1164 if (pgrp == NULL) 1165 return (EINVAL); 1166 else if (pgrp->pg_session != p->p_session) 1167 return (EPERM); 1168 tp->t_pgrp = pgrp; 1169 break; 1170 } 1171 case TIOCSPGRP: { /* set pgrp of tty */ 1172 struct pgrp *pgrp = pgfind(*(int *)data); 1173 1174 if (!isctty(p, tp)) 1175 return (ENOTTY); 1176 else if (pgrp == NULL) 1177 return (EINVAL); 1178 else if (pgrp->pg_session != p->p_session) 1179 return (EPERM); 1180 tp->t_pgrp = pgrp; 1181 break; 1182 } 1183 case TIOCSTAT: /* get load avg stats */ 1184 s = spltty(); 1185 TTY_LOCK(tp); 1186 ttyinfo(tp); 1187 TTY_UNLOCK(tp); 1188 splx(s); 1189 break; 1190 case TIOCSWINSZ: /* set window size */ 1191 if (memcmp((caddr_t)&tp->t_winsize, data, 1192 sizeof(struct winsize))) { 1193 tp->t_winsize = *(struct winsize *)data; 1194 pgsignal(tp->t_pgrp, SIGWINCH, 1); 1195 } 1196 break; 1197 default: 1198 #ifdef COMPAT_OLDTTY 1199 return (ttcompat(tp, cmd, data, flag, p)); 1200 #else 1201 return (EPASSTHROUGH); 1202 #endif 1203 } 1204 return (0); 1205 } 1206 1207 int 1208 ttpoll(struct tty *tp, int events, struct proc *p) 1209 { 1210 int revents, s; 1211 1212 revents = 0; 1213 s = spltty(); 1214 TTY_LOCK(tp); 1215 if (events & (POLLIN | POLLRDNORM)) 1216 if (ttnread(tp) > 0) 1217 revents |= events & (POLLIN | POLLRDNORM); 1218 1219 if (events & (POLLOUT | POLLWRNORM)) 1220 if (tp->t_outq.c_cc <= tp->t_lowat) 1221 revents |= events & (POLLOUT | POLLWRNORM); 1222 1223 if (events & POLLHUP) 1224 if (!CONNECTED(tp)) 1225 revents |= POLLHUP; 1226 1227 if (revents == 0) { 1228 if (events & (POLLIN | POLLHUP | POLLRDNORM)) 1229 selrecord(p, &tp->t_rsel); 1230 1231 if (events & (POLLOUT | POLLWRNORM)) 1232 selrecord(p, &tp->t_wsel); 1233 } 1234 1235 TTY_UNLOCK(tp); 1236 splx(s); 1237 return (revents); 1238 } 1239 1240 static void 1241 filt_ttyrdetach(struct knote *kn) 1242 { 1243 struct tty *tp; 1244 int s; 1245 1246 tp = kn->kn_hook; 1247 s = spltty(); 1248 SLIST_REMOVE(&tp->t_rsel.sel_klist, kn, knote, kn_selnext); 1249 splx(s); 1250 } 1251 1252 static int 1253 filt_ttyread(struct knote *kn, long hint) 1254 { 1255 struct tty *tp; 1256 int s; 1257 1258 tp = kn->kn_hook; 1259 s = spltty(); 1260 if ((hint & NOTE_SUBMIT) == 0) 1261 TTY_LOCK(tp); 1262 kn->kn_data = ttnread(tp); 1263 if ((hint & NOTE_SUBMIT) == 0) 1264 TTY_UNLOCK(tp); 1265 splx(s); 1266 return (kn->kn_data > 0); 1267 } 1268 1269 static void 1270 filt_ttywdetach(struct knote *kn) 1271 { 1272 struct tty *tp; 1273 int s; 1274 1275 tp = kn->kn_hook; 1276 s = spltty(); 1277 TTY_LOCK(tp); 1278 SLIST_REMOVE(&tp->t_wsel.sel_klist, kn, knote, kn_selnext); 1279 TTY_UNLOCK(tp); 1280 splx(s); 1281 } 1282 1283 static int 1284 filt_ttywrite(struct knote *kn, long hint) 1285 { 1286 struct tty *tp; 1287 int canwrite, s; 1288 1289 tp = kn->kn_hook; 1290 s = spltty(); 1291 if ((hint & NOTE_SUBMIT) == 0) 1292 TTY_LOCK(tp); 1293 kn->kn_data = tp->t_outq.c_cn - tp->t_outq.c_cc; 1294 canwrite = (tp->t_outq.c_cc <= tp->t_lowat) && CONNECTED(tp); 1295 if ((hint & NOTE_SUBMIT) == 0) 1296 TTY_UNLOCK(tp); 1297 splx(s); 1298 return (canwrite); 1299 } 1300 1301 static const struct filterops ttyread_filtops = 1302 { 1, NULL, filt_ttyrdetach, filt_ttyread }; 1303 static const struct filterops ttywrite_filtops = 1304 { 1, NULL, filt_ttywdetach, filt_ttywrite }; 1305 1306 int 1307 ttykqfilter(dev_t dev, struct knote *kn) 1308 { 1309 struct tty *tp; 1310 struct klist *klist; 1311 int s; 1312 const struct cdevsw *cdev; 1313 1314 if (((cdev = cdevsw_lookup(dev)) == NULL) || 1315 (cdev->d_tty == NULL) || 1316 ((tp = (*cdev->d_tty)(dev)) == NULL)) 1317 return (ENXIO); 1318 1319 switch (kn->kn_filter) { 1320 case EVFILT_READ: 1321 klist = &tp->t_rsel.sel_klist; 1322 kn->kn_fop = &ttyread_filtops; 1323 break; 1324 case EVFILT_WRITE: 1325 klist = &tp->t_wsel.sel_klist; 1326 kn->kn_fop = &ttywrite_filtops; 1327 break; 1328 default: 1329 return (1); 1330 } 1331 1332 kn->kn_hook = tp; 1333 1334 s = spltty(); 1335 TTY_LOCK(tp); 1336 SLIST_INSERT_HEAD(klist, kn, kn_selnext); 1337 TTY_UNLOCK(tp); 1338 splx(s); 1339 1340 return (0); 1341 } 1342 1343 /* 1344 * Find the number of chars ready to be read from this tty. 1345 * Call at spltty() and with the tty slock held. 1346 */ 1347 static int 1348 ttnread(struct tty *tp) 1349 { 1350 int nread; 1351 1352 if (ISSET(tp->t_lflag, PENDIN)) 1353 ttypend(tp); 1354 nread = tp->t_canq.c_cc; 1355 if (!ISSET(tp->t_lflag, ICANON)) { 1356 nread += tp->t_rawq.c_cc; 1357 if (nread < tp->t_cc[VMIN] && !tp->t_cc[VTIME]) 1358 nread = 0; 1359 } 1360 return (nread); 1361 } 1362 1363 /* 1364 * Wait for output to drain. 1365 */ 1366 int 1367 ttywait(struct tty *tp) 1368 { 1369 int error, s; 1370 1371 error = 0; 1372 s = spltty(); 1373 TTY_LOCK(tp); 1374 while ((tp->t_outq.c_cc || ISSET(tp->t_state, TS_BUSY)) && 1375 CONNECTED(tp) && tp->t_oproc) { 1376 (*tp->t_oproc)(tp); 1377 SET(tp->t_state, TS_ASLEEP); 1378 error = ttysleep(tp, &tp->t_outq, TTOPRI | PCATCH, ttyout, 0); 1379 if (error) 1380 break; 1381 } 1382 TTY_UNLOCK(tp); 1383 splx(s); 1384 return (error); 1385 } 1386 1387 /* 1388 * Flush if successfully wait. 1389 */ 1390 int 1391 ttywflush(struct tty *tp) 1392 { 1393 int error; 1394 int s; 1395 1396 if ((error = ttywait(tp)) == 0) { 1397 s = spltty(); 1398 TTY_LOCK(tp); 1399 ttyflush(tp, FREAD); 1400 TTY_UNLOCK(tp); 1401 splx(s); 1402 } 1403 return (error); 1404 } 1405 1406 /* 1407 * Flush tty read and/or write queues, notifying anyone waiting. 1408 * Call at spltty() and with the tty slock held. 1409 */ 1410 void 1411 ttyflush(struct tty *tp, int rw) 1412 { 1413 const struct cdevsw *cdev; 1414 1415 if (rw & FREAD) { 1416 FLUSHQ(&tp->t_canq); 1417 FLUSHQ(&tp->t_rawq); 1418 tp->t_rocount = 0; 1419 tp->t_rocol = 0; 1420 CLR(tp->t_state, TS_LOCAL); 1421 ttwakeup(tp); 1422 } 1423 if (rw & FWRITE) { 1424 CLR(tp->t_state, TS_TTSTOP); 1425 cdev = cdevsw_lookup(tp->t_dev); 1426 if (cdev != NULL) 1427 (*cdev->d_stop)(tp, rw); 1428 FLUSHQ(&tp->t_outq); 1429 wakeup((caddr_t)&tp->t_outq); 1430 selnotify(&tp->t_wsel, NOTE_SUBMIT); 1431 } 1432 } 1433 1434 /* 1435 * Copy in the default termios characters. 1436 */ 1437 void 1438 ttychars(struct tty *tp) 1439 { 1440 1441 memcpy(tp->t_cc, ttydefchars, sizeof(ttydefchars)); 1442 } 1443 1444 /* 1445 * Send stop character on input overflow. 1446 * Call at spltty() and with the tty slock held. 1447 */ 1448 static void 1449 ttyblock(struct tty *tp) 1450 { 1451 int total; 1452 1453 total = tp->t_rawq.c_cc + tp->t_canq.c_cc; 1454 if (tp->t_rawq.c_cc > TTYHOG) { 1455 ttyflush(tp, FREAD | FWRITE); 1456 CLR(tp->t_state, TS_TBLOCK); 1457 } 1458 /* 1459 * Block further input iff: current input > threshold 1460 * AND input is available to user program. 1461 */ 1462 if (total >= TTYHOG / 2 && 1463 !ISSET(tp->t_state, TS_TBLOCK) && 1464 (!ISSET(tp->t_lflag, ICANON) || tp->t_canq.c_cc > 0)) { 1465 if (ISSET(tp->t_iflag, IXOFF) && 1466 tp->t_cc[VSTOP] != _POSIX_VDISABLE && 1467 putc(tp->t_cc[VSTOP], &tp->t_outq) == 0) { 1468 SET(tp->t_state, TS_TBLOCK); 1469 ttstart(tp); 1470 } 1471 /* Try to block remote output via hardware flow control. */ 1472 if (ISSET(tp->t_cflag, CHWFLOW) && tp->t_hwiflow && 1473 (*tp->t_hwiflow)(tp, 1) != 0) 1474 SET(tp->t_state, TS_TBLOCK); 1475 } 1476 } 1477 1478 /* 1479 * Delayed line discipline output 1480 */ 1481 void 1482 ttrstrt(void *tp_arg) 1483 { 1484 struct tty *tp; 1485 int s; 1486 1487 #ifdef DIAGNOSTIC 1488 if (tp_arg == NULL) 1489 panic("ttrstrt"); 1490 #endif 1491 tp = tp_arg; 1492 s = spltty(); 1493 TTY_LOCK(tp); 1494 1495 CLR(tp->t_state, TS_TIMEOUT); 1496 ttstart(tp); /* XXX - Shouldn't this be tp->l_start(tp)? */ 1497 1498 TTY_UNLOCK(tp); 1499 splx(s); 1500 } 1501 1502 /* 1503 * start a line discipline 1504 * Always call at spltty() and with tty slock held? 1505 */ 1506 int 1507 ttstart(struct tty *tp) 1508 { 1509 1510 if (tp->t_oproc != NULL) /* XXX: Kludge for pty. */ 1511 (*tp->t_oproc)(tp); 1512 return (0); 1513 } 1514 1515 /* 1516 * "close" a line discipline 1517 */ 1518 int 1519 ttylclose(struct tty *tp, int flag) 1520 { 1521 int s; 1522 1523 if (flag & FNONBLOCK) { 1524 s = spltty(); 1525 TTY_LOCK(tp); 1526 ttyflush(tp, FREAD | FWRITE); 1527 TTY_UNLOCK(tp); 1528 splx(s); 1529 } else 1530 ttywflush(tp); 1531 return (0); 1532 } 1533 1534 /* 1535 * Handle modem control transition on a tty. 1536 * Flag indicates new state of carrier. 1537 * Returns 0 if the line should be turned off, otherwise 1. 1538 * 1539 * Must be called at spltty(). 1540 * XXX except that it is often isn't, which should be fixed. 1541 */ 1542 int 1543 ttymodem(struct tty *tp, int flag) 1544 { 1545 int s; 1546 1547 s = spltty(); 1548 TTY_LOCK(tp); 1549 if (flag == 0) { 1550 if (ISSET(tp->t_state, TS_CARR_ON)) { 1551 /* 1552 * Lost carrier. 1553 */ 1554 CLR(tp->t_state, TS_CARR_ON); 1555 if (ISSET(tp->t_state, TS_ISOPEN) && !CONNECTED(tp)) { 1556 if (tp->t_session && tp->t_session->s_leader) 1557 psignal(tp->t_session->s_leader, 1558 SIGHUP); 1559 ttyflush(tp, FREAD | FWRITE); 1560 TTY_UNLOCK(tp); 1561 splx(s); 1562 return (0); 1563 } 1564 } 1565 } else { 1566 if (!ISSET(tp->t_state, TS_CARR_ON)) { 1567 /* 1568 * Carrier now on. 1569 */ 1570 SET(tp->t_state, TS_CARR_ON); 1571 ttwakeup(tp); 1572 } 1573 } 1574 TTY_UNLOCK(tp); 1575 splx(s); 1576 return (1); 1577 } 1578 1579 /* 1580 * Default modem control routine (for other line disciplines). 1581 * Return argument flag, to turn off device on carrier drop. 1582 * 1583 * Must be called at spltty(). 1584 * XXX except that it is often isn't, which should be fixed. 1585 */ 1586 int 1587 nullmodem(struct tty *tp, int flag) 1588 { 1589 int s; 1590 1591 s = spltty(); 1592 TTY_LOCK(tp); 1593 if (flag) 1594 SET(tp->t_state, TS_CARR_ON); 1595 else { 1596 CLR(tp->t_state, TS_CARR_ON); 1597 if (!CONNECTED(tp)) { 1598 if (tp->t_session && tp->t_session->s_leader) 1599 psignal(tp->t_session->s_leader, SIGHUP); 1600 TTY_UNLOCK(tp); 1601 splx(s); 1602 return (0); 1603 } 1604 } 1605 TTY_UNLOCK(tp); 1606 splx(s); 1607 return (1); 1608 } 1609 1610 /* 1611 * Reinput pending characters after state switch. 1612 * Call at spltty() and with the tty slock held. 1613 */ 1614 void 1615 ttypend(struct tty *tp) 1616 { 1617 struct clist tq; 1618 int c; 1619 1620 CLR(tp->t_lflag, PENDIN); 1621 SET(tp->t_state, TS_TYPEN); 1622 tq = tp->t_rawq; 1623 tp->t_rawq.c_cc = 0; 1624 tp->t_rawq.c_cf = tp->t_rawq.c_cl = 0; 1625 while ((c = getc(&tq)) >= 0) 1626 ttyinput_wlock(c, tp); 1627 CLR(tp->t_state, TS_TYPEN); 1628 } 1629 1630 /* 1631 * Process a read call on a tty device. 1632 */ 1633 int 1634 ttread(struct tty *tp, struct uio *uio, int flag) 1635 { 1636 struct clist *qp; 1637 u_char *cc; 1638 struct proc *p; 1639 int c, s, first, error, has_stime, last_cc; 1640 long lflag, slp; 1641 struct timeval stime; 1642 1643 cc = tp->t_cc; 1644 p = curproc; 1645 error = 0; 1646 has_stime = 0; 1647 last_cc = 0; 1648 slp = 0; 1649 1650 loop: 1651 s = spltty(); 1652 TTY_LOCK(tp); 1653 lflag = tp->t_lflag; 1654 /* 1655 * take pending input first 1656 */ 1657 if (ISSET(lflag, PENDIN)) 1658 ttypend(tp); 1659 1660 /* 1661 * Hang process if it's in the background. 1662 */ 1663 if (isbackground(p, tp)) { 1664 if (sigismember(&p->p_sigctx.ps_sigignore, SIGTTIN) || 1665 sigismember(&p->p_sigctx.ps_sigmask, SIGTTIN) || 1666 p->p_flag & P_PPWAIT || p->p_pgrp->pg_jobc == 0) { 1667 TTY_UNLOCK(tp); 1668 splx(s); 1669 return (EIO); 1670 } 1671 pgsignal(p->p_pgrp, SIGTTIN, 1); 1672 error = ttysleep(tp, &lbolt, TTIPRI | PCATCH | PNORELOCK, ttybg, 0); 1673 splx(s); 1674 if (error) 1675 return (error); 1676 goto loop; 1677 } 1678 1679 if (!ISSET(lflag, ICANON)) { 1680 int m = cc[VMIN]; 1681 long t = cc[VTIME]; 1682 1683 qp = &tp->t_rawq; 1684 /* 1685 * Check each of the four combinations. 1686 * (m > 0 && t == 0) is the normal read case. 1687 * It should be fairly efficient, so we check that and its 1688 * companion case (m == 0 && t == 0) first. 1689 * For the other two cases, we compute the target sleep time 1690 * into slp. 1691 */ 1692 if (t == 0) { 1693 if (qp->c_cc < m) 1694 goto sleep; 1695 goto read; 1696 } 1697 t *= hz; /* time in deca-ticks */ 1698 /* 1699 * Time difference in deca-ticks, split division to avoid numeric overflow. 1700 * Ok for hz < ~200kHz 1701 */ 1702 #define diff(t1, t2) (((t1).tv_sec - (t2).tv_sec) * 10 * hz + \ 1703 ((t1).tv_usec - (t2).tv_usec) / 100 * hz / 1000) 1704 if (m > 0) { 1705 if (qp->c_cc <= 0) 1706 goto sleep; 1707 if (qp->c_cc >= m) 1708 goto read; 1709 if (!has_stime) { 1710 /* first character, start timer */ 1711 has_stime = 1; 1712 stime = time; 1713 slp = t; 1714 } else if (qp->c_cc > last_cc) { 1715 /* got a character, restart timer */ 1716 stime = time; 1717 slp = t; 1718 } else { 1719 /* nothing, check expiration */ 1720 slp = t - diff(time, stime); 1721 } 1722 } else { /* m == 0 */ 1723 if (qp->c_cc > 0) 1724 goto read; 1725 if (!has_stime) { 1726 has_stime = 1; 1727 stime = time; 1728 slp = t; 1729 } else 1730 slp = t - diff(time, stime); 1731 } 1732 last_cc = qp->c_cc; 1733 #undef diff 1734 if (slp > 0) { 1735 /* 1736 * Convert deca-ticks back to ticks. 1737 * Rounding down may make us wake up just short 1738 * of the target, so we round up. 1739 * Maybe we should do 'slp/10 + 1' because the 1740 * first tick maybe almost immediate. 1741 * However it is more useful for a program that sets 1742 * VTIME=10 to wakeup every second not every 1.01 1743 * seconds (if hz=100). 1744 */ 1745 slp = (slp + 9)/ 10; 1746 goto sleep; 1747 } 1748 } else if ((qp = &tp->t_canq)->c_cc <= 0) { 1749 int carrier; 1750 1751 sleep: 1752 /* 1753 * If there is no input, sleep on rawq 1754 * awaiting hardware receipt and notification. 1755 * If we have data, we don't need to check for carrier. 1756 */ 1757 carrier = CONNECTED(tp); 1758 if (!carrier && ISSET(tp->t_state, TS_ISOPEN)) { 1759 TTY_UNLOCK(tp); 1760 splx(s); 1761 return (0); /* EOF */ 1762 } 1763 if (flag & IO_NDELAY) { 1764 TTY_UNLOCK(tp); 1765 splx(s); 1766 return (EWOULDBLOCK); 1767 } 1768 error = ttysleep(tp, &tp->t_rawq, TTIPRI | PCATCH | PNORELOCK, 1769 carrier ? ttyin : ttopen, slp); 1770 splx(s); 1771 /* VMIN == 0: any quantity read satisfies */ 1772 if (cc[VMIN] == 0 && error == EWOULDBLOCK) 1773 return (0); 1774 if (error && error != EWOULDBLOCK) 1775 return (error); 1776 goto loop; 1777 } 1778 read: 1779 TTY_UNLOCK(tp); 1780 splx(s); 1781 1782 /* 1783 * Input present, check for input mapping and processing. 1784 */ 1785 first = 1; 1786 while ((c = getc(qp)) >= 0) { 1787 /* 1788 * delayed suspend (^Y) 1789 */ 1790 if (CCEQ(cc[VDSUSP], c) && 1791 ISSET(lflag, IEXTEN|ISIG) == (IEXTEN|ISIG)) { 1792 pgsignal(tp->t_pgrp, SIGTSTP, 1); 1793 if (first) { 1794 s = spltty(); 1795 TTY_LOCK(tp); 1796 error = ttysleep(tp, &lbolt, 1797 TTIPRI | PCATCH | PNORELOCK, ttybg, 0); 1798 splx(s); 1799 if (error) 1800 break; 1801 goto loop; 1802 } 1803 break; 1804 } 1805 /* 1806 * Interpret EOF only in canonical mode. 1807 */ 1808 if (CCEQ(cc[VEOF], c) && ISSET(lflag, ICANON)) 1809 break; 1810 /* 1811 * Give user character. 1812 */ 1813 error = ureadc(c, uio); 1814 if (error) 1815 break; 1816 if (uio->uio_resid == 0) 1817 break; 1818 /* 1819 * In canonical mode check for a "break character" 1820 * marking the end of a "line of input". 1821 */ 1822 if (ISSET(lflag, ICANON) && TTBREAKC(c, lflag)) 1823 break; 1824 first = 0; 1825 } 1826 /* 1827 * Look to unblock output now that (presumably) 1828 * the input queue has gone down. 1829 */ 1830 s = spltty(); 1831 TTY_LOCK(tp); 1832 if (ISSET(tp->t_state, TS_TBLOCK) && tp->t_rawq.c_cc < TTYHOG / 5) { 1833 if (ISSET(tp->t_iflag, IXOFF) && 1834 cc[VSTART] != _POSIX_VDISABLE && 1835 putc(cc[VSTART], &tp->t_outq) == 0) { 1836 CLR(tp->t_state, TS_TBLOCK); 1837 ttstart(tp); 1838 } 1839 /* Try to unblock remote output via hardware flow control. */ 1840 if (ISSET(tp->t_cflag, CHWFLOW) && tp->t_hwiflow && 1841 (*tp->t_hwiflow)(tp, 0) != 0) 1842 CLR(tp->t_state, TS_TBLOCK); 1843 } 1844 TTY_UNLOCK(tp); 1845 splx(s); 1846 return (error); 1847 } 1848 1849 /* 1850 * Check the output queue on tp for space for a kernel message (from uprintf 1851 * or tprintf). Allow some space over the normal hiwater mark so we don't 1852 * lose messages due to normal flow control, but don't let the tty run amok. 1853 * Sleeps here are not interruptible, but we return prematurely if new signals 1854 * arrive. 1855 * Call with tty slock held. 1856 */ 1857 static int 1858 ttycheckoutq_wlock(struct tty *tp, int wait) 1859 { 1860 int hiwat, s, error; 1861 1862 hiwat = tp->t_hiwat; 1863 s = spltty(); 1864 if (tp->t_outq.c_cc > hiwat + 200) 1865 while (tp->t_outq.c_cc > hiwat) { 1866 ttstart(tp); 1867 if (wait == 0) { 1868 splx(s); 1869 return (0); 1870 } 1871 SET(tp->t_state, TS_ASLEEP); 1872 error = ltsleep(&tp->t_outq, (PZERO - 1) | PCATCH, 1873 "ttckoutq", hz, &tp->t_slock); 1874 if (error == EINTR) 1875 wait = 0; 1876 } 1877 1878 splx(s); 1879 return (1); 1880 } 1881 1882 int 1883 ttycheckoutq(struct tty *tp, int wait) 1884 { 1885 int r, s; 1886 1887 s = spltty(); 1888 TTY_LOCK(tp); 1889 r = ttycheckoutq_wlock(tp, wait); 1890 TTY_UNLOCK(tp); 1891 splx(s); 1892 return (r); 1893 } 1894 1895 /* 1896 * Process a write call on a tty device. 1897 */ 1898 int 1899 ttwrite(struct tty *tp, struct uio *uio, int flag) 1900 { 1901 u_char *cp; 1902 struct proc *p; 1903 int cc, ce, i, hiwat, error, s; 1904 size_t cnt; 1905 u_char obuf[OBUFSIZ]; 1906 1907 cp = NULL; 1908 hiwat = tp->t_hiwat; 1909 cnt = uio->uio_resid; 1910 error = 0; 1911 cc = 0; 1912 loop: 1913 s = spltty(); 1914 TTY_LOCK(tp); 1915 if (!CONNECTED(tp)) { 1916 if (ISSET(tp->t_state, TS_ISOPEN)) { 1917 TTY_UNLOCK(tp); 1918 splx(s); 1919 return (EIO); 1920 } else if (flag & IO_NDELAY) { 1921 TTY_UNLOCK(tp); 1922 splx(s); 1923 error = EWOULDBLOCK; 1924 goto out; 1925 } else { 1926 /* Sleep awaiting carrier. */ 1927 error = ttysleep(tp, 1928 &tp->t_rawq, TTIPRI | PCATCH | PNORELOCK, ttopen, 0); 1929 splx(s); 1930 if (error) 1931 goto out; 1932 goto loop; 1933 } 1934 } 1935 TTY_UNLOCK(tp); 1936 splx(s); 1937 /* 1938 * Hang the process if it's in the background. 1939 */ 1940 p = curproc; 1941 if (isbackground(p, tp) && 1942 ISSET(tp->t_lflag, TOSTOP) && (p->p_flag & P_PPWAIT) == 0 && 1943 !sigismember(&p->p_sigctx.ps_sigignore, SIGTTOU) && 1944 !sigismember(&p->p_sigctx.ps_sigmask, SIGTTOU)) { 1945 if (p->p_pgrp->pg_jobc == 0) { 1946 error = EIO; 1947 goto out; 1948 } 1949 pgsignal(p->p_pgrp, SIGTTOU, 1); 1950 s = spltty(); 1951 TTY_LOCK(tp); 1952 error = ttysleep(tp, &lbolt, TTIPRI | PCATCH | PNORELOCK, ttybg, 0); 1953 splx(s); 1954 if (error) 1955 goto out; 1956 goto loop; 1957 } 1958 /* 1959 * Process the user's data in at most OBUFSIZ chunks. Perform any 1960 * output translation. Keep track of high water mark, sleep on 1961 * overflow awaiting device aid in acquiring new space. 1962 */ 1963 while (uio->uio_resid > 0 || cc > 0) { 1964 if (ISSET(tp->t_lflag, FLUSHO)) { 1965 TTY_UNLOCK(tp); 1966 uio->uio_resid = 0; 1967 return (0); 1968 } 1969 if (tp->t_outq.c_cc > hiwat) 1970 goto ovhiwat; 1971 /* 1972 * Grab a hunk of data from the user, unless we have some 1973 * leftover from last time. 1974 */ 1975 if (cc == 0) { 1976 cc = min(uio->uio_resid, OBUFSIZ); 1977 cp = obuf; 1978 error = uiomove(cp, cc, uio); 1979 if (error) { 1980 cc = 0; 1981 goto out; 1982 } 1983 } 1984 /* 1985 * If nothing fancy need be done, grab those characters we 1986 * can handle without any of ttyoutput's processing and 1987 * just transfer them to the output q. For those chars 1988 * which require special processing (as indicated by the 1989 * bits in char_type), call ttyoutput. After processing 1990 * a hunk of data, look for FLUSHO so ^O's will take effect 1991 * immediately. 1992 */ 1993 s = spltty(); 1994 TTY_LOCK(tp); 1995 while (cc > 0) { 1996 if (!ISSET(tp->t_oflag, OPOST)) 1997 ce = cc; 1998 else { 1999 ce = cc - scanc((u_int)cc, cp, char_type, 2000 CCLASSMASK); 2001 /* 2002 * If ce is zero, then we're processing 2003 * a special character through ttyoutput. 2004 */ 2005 if (ce == 0) { 2006 tp->t_rocount = 0; 2007 if (ttyoutput(*cp, tp) >= 0) { 2008 /* out of space */ 2009 TTY_UNLOCK(tp); 2010 splx(s); 2011 goto overfull; 2012 } 2013 cp++; 2014 cc--; 2015 if (ISSET(tp->t_lflag, FLUSHO) || 2016 tp->t_outq.c_cc > hiwat) { 2017 TTY_UNLOCK(tp); 2018 splx(s); 2019 goto ovhiwat; 2020 } 2021 continue; 2022 } 2023 } 2024 /* 2025 * A bunch of normal characters have been found. 2026 * Transfer them en masse to the output queue and 2027 * continue processing at the top of the loop. 2028 * If there are any further characters in this 2029 * <= OBUFSIZ chunk, the first should be a character 2030 * requiring special handling by ttyoutput. 2031 */ 2032 tp->t_rocount = 0; 2033 i = b_to_q(cp, ce, &tp->t_outq); 2034 ce -= i; 2035 tp->t_column += ce; 2036 cp += ce, cc -= ce, tk_nout += ce; 2037 tp->t_outcc += ce; 2038 if (i > 0) { 2039 /* out of space */ 2040 TTY_UNLOCK(tp); 2041 splx(s); 2042 goto overfull; 2043 } 2044 if (ISSET(tp->t_lflag, FLUSHO) || 2045 tp->t_outq.c_cc > hiwat) 2046 break; 2047 } 2048 TTY_UNLOCK(tp); 2049 splx(s); 2050 ttstart(tp); 2051 } 2052 2053 out: 2054 /* 2055 * If cc is nonzero, we leave the uio structure inconsistent, as the 2056 * offset and iov pointers have moved forward, but it doesn't matter 2057 * (the call will either return short or restart with a new uio). 2058 */ 2059 uio->uio_resid += cc; 2060 return (error); 2061 2062 overfull: 2063 /* 2064 * Since we are using ring buffers, if we can't insert any more into 2065 * the output queue, we can assume the ring is full and that someone 2066 * forgot to set the high water mark correctly. We set it and then 2067 * proceed as normal. 2068 */ 2069 hiwat = tp->t_outq.c_cc - 1; 2070 2071 ovhiwat: 2072 ttstart(tp); 2073 s = spltty(); 2074 TTY_LOCK(tp); 2075 /* 2076 * This can only occur if FLUSHO is set in t_lflag, 2077 * or if ttstart/oproc is synchronous (or very fast). 2078 */ 2079 if (tp->t_outq.c_cc <= hiwat) { 2080 TTY_UNLOCK(tp); 2081 splx(s); 2082 goto loop; 2083 } 2084 if (flag & IO_NDELAY) { 2085 TTY_UNLOCK(tp); 2086 splx(s); 2087 error = (uio->uio_resid == cnt) ? EWOULDBLOCK : 0; 2088 goto out; 2089 } 2090 SET(tp->t_state, TS_ASLEEP); 2091 error = ttysleep(tp, &tp->t_outq, TTOPRI | PCATCH | PNORELOCK, ttyout, 0); 2092 splx(s); 2093 if (error) 2094 goto out; 2095 goto loop; 2096 } 2097 2098 /* 2099 * Rubout one character from the rawq of tp 2100 * as cleanly as possible. 2101 * Called with tty slock held. 2102 */ 2103 void 2104 ttyrub(int c, struct tty *tp) 2105 { 2106 u_char *cp; 2107 int savecol, tabc, s; 2108 2109 if (!ISSET(tp->t_lflag, ECHO) || ISSET(tp->t_lflag, EXTPROC)) 2110 return; 2111 CLR(tp->t_lflag, FLUSHO); 2112 if (ISSET(tp->t_lflag, ECHOE)) { 2113 if (tp->t_rocount == 0) { 2114 /* 2115 * Screwed by ttwrite; retype 2116 */ 2117 ttyretype(tp); 2118 return; 2119 } 2120 if (c == ('\t' | TTY_QUOTE) || c == ('\n' | TTY_QUOTE)) 2121 ttyrubo(tp, 2); 2122 else { 2123 CLR(c, ~TTY_CHARMASK); 2124 switch (CCLASS(c)) { 2125 case ORDINARY: 2126 ttyrubo(tp, 1); 2127 break; 2128 case BACKSPACE: 2129 case CONTROL: 2130 case NEWLINE: 2131 case RETURN: 2132 case VTAB: 2133 if (ISSET(tp->t_lflag, ECHOCTL)) 2134 ttyrubo(tp, 2); 2135 break; 2136 case TAB: 2137 if (tp->t_rocount < tp->t_rawq.c_cc) { 2138 ttyretype(tp); 2139 return; 2140 } 2141 s = spltty(); 2142 savecol = tp->t_column; 2143 SET(tp->t_state, TS_CNTTB); 2144 SET(tp->t_lflag, FLUSHO); 2145 tp->t_column = tp->t_rocol; 2146 for (cp = firstc(&tp->t_rawq, &tabc); cp; 2147 cp = nextc(&tp->t_rawq, cp, &tabc)) 2148 ttyecho(tabc, tp); 2149 CLR(tp->t_lflag, FLUSHO); 2150 CLR(tp->t_state, TS_CNTTB); 2151 splx(s); 2152 2153 /* savecol will now be length of the tab. */ 2154 savecol -= tp->t_column; 2155 tp->t_column += savecol; 2156 if (savecol > 8) 2157 savecol = 8; /* overflow screw */ 2158 while (--savecol >= 0) 2159 (void)ttyoutput('\b', tp); 2160 break; 2161 default: /* XXX */ 2162 #define PANICSTR "ttyrub: would panic c = %d, val = %d\n" 2163 (void)printf(PANICSTR, c, CCLASS(c)); 2164 #ifdef notdef 2165 panic(PANICSTR, c, CCLASS(c)); 2166 #endif 2167 } 2168 } 2169 } else if (ISSET(tp->t_lflag, ECHOPRT)) { 2170 if (!ISSET(tp->t_state, TS_ERASE)) { 2171 SET(tp->t_state, TS_ERASE); 2172 (void)ttyoutput('\\', tp); 2173 } 2174 ttyecho(c, tp); 2175 } else 2176 ttyecho(tp->t_cc[VERASE], tp); 2177 --tp->t_rocount; 2178 } 2179 2180 /* 2181 * Back over cnt characters, erasing them. 2182 * Called with tty slock held. 2183 */ 2184 static void 2185 ttyrubo(struct tty *tp, int cnt) 2186 { 2187 2188 while (cnt-- > 0) { 2189 (void)ttyoutput('\b', tp); 2190 (void)ttyoutput(' ', tp); 2191 (void)ttyoutput('\b', tp); 2192 } 2193 } 2194 2195 /* 2196 * ttyretype -- 2197 * Reprint the rawq line. Note, it is assumed that c_cc has already 2198 * been checked. 2199 * 2200 * Called with tty slock held. 2201 */ 2202 void 2203 ttyretype(struct tty *tp) 2204 { 2205 u_char *cp; 2206 int s, c; 2207 2208 /* Echo the reprint character. */ 2209 if (tp->t_cc[VREPRINT] != _POSIX_VDISABLE) 2210 ttyecho(tp->t_cc[VREPRINT], tp); 2211 2212 (void)ttyoutput('\n', tp); 2213 2214 s = spltty(); 2215 for (cp = firstc(&tp->t_canq, &c); cp; cp = nextc(&tp->t_canq, cp, &c)) 2216 ttyecho(c, tp); 2217 for (cp = firstc(&tp->t_rawq, &c); cp; cp = nextc(&tp->t_rawq, cp, &c)) 2218 ttyecho(c, tp); 2219 CLR(tp->t_state, TS_ERASE); 2220 splx(s); 2221 2222 tp->t_rocount = tp->t_rawq.c_cc; 2223 tp->t_rocol = 0; 2224 } 2225 2226 /* 2227 * Echo a typed character to the terminal. 2228 * Called with tty slock held. 2229 */ 2230 static void 2231 ttyecho(int c, struct tty *tp) 2232 { 2233 2234 if (!ISSET(tp->t_state, TS_CNTTB)) 2235 CLR(tp->t_lflag, FLUSHO); 2236 if ((!ISSET(tp->t_lflag, ECHO) && 2237 (!ISSET(tp->t_lflag, ECHONL) || c != '\n')) || 2238 ISSET(tp->t_lflag, EXTPROC)) 2239 return; 2240 if (((ISSET(tp->t_lflag, ECHOCTL) && 2241 (ISSET(c, TTY_CHARMASK) <= 037 && c != '\t' && c != '\n')) || 2242 ISSET(c, TTY_CHARMASK) == 0177)) { 2243 (void)ttyoutput('^', tp); 2244 CLR(c, ~TTY_CHARMASK); 2245 if (c == 0177) 2246 c = '?'; 2247 else 2248 c += 'A' - 1; 2249 } 2250 (void)ttyoutput(c, tp); 2251 } 2252 2253 /* 2254 * Wake up any readers on a tty. 2255 * Called with tty slock held. 2256 */ 2257 void 2258 ttwakeup(struct tty *tp) 2259 { 2260 2261 selnotify(&tp->t_rsel, NOTE_SUBMIT); 2262 if (ISSET(tp->t_state, TS_ASYNC)) 2263 pgsignal(tp->t_pgrp, SIGIO, 1); 2264 wakeup((caddr_t)&tp->t_rawq); 2265 } 2266 2267 /* 2268 * Look up a code for a specified speed in a conversion table; 2269 * used by drivers to map software speed values to hardware parameters. 2270 */ 2271 int 2272 ttspeedtab(int speed, const struct speedtab *table) 2273 { 2274 2275 for (; table->sp_speed != -1; table++) 2276 if (table->sp_speed == speed) 2277 return (table->sp_code); 2278 return (-1); 2279 } 2280 2281 /* 2282 * Set tty hi and low water marks. 2283 * 2284 * Try to arrange the dynamics so there's about one second 2285 * from hi to low water. 2286 */ 2287 void 2288 ttsetwater(struct tty *tp) 2289 { 2290 int cps, x; 2291 2292 #define CLAMP(x, h, l) ((x) > h ? h : ((x) < l) ? l : (x)) 2293 2294 cps = tp->t_ospeed / 10; 2295 tp->t_lowat = x = CLAMP(cps / 2, TTMAXLOWAT, TTMINLOWAT); 2296 x += cps; 2297 x = CLAMP(x, TTMAXHIWAT, TTMINHIWAT); 2298 tp->t_hiwat = roundup(x, CBSIZE); 2299 #undef CLAMP 2300 } 2301 2302 /* 2303 * Report on state of foreground process group. 2304 * Call with tty slock held. 2305 */ 2306 void 2307 ttyinfo(struct tty *tp) 2308 { 2309 struct lwp *l; 2310 struct proc *p, *pick; 2311 struct timeval utime, stime; 2312 int tmp; 2313 2314 if (ttycheckoutq_wlock(tp, 0) == 0) 2315 return; 2316 2317 /* Print load average. */ 2318 tmp = (averunnable.ldavg[0] * 100 + FSCALE / 2) >> FSHIFT; 2319 ttyprintf_nolock(tp, "load: %d.%02d ", tmp / 100, tmp % 100); 2320 2321 if (tp->t_session == NULL) 2322 ttyprintf_nolock(tp, "not a controlling terminal\n"); 2323 else if (tp->t_pgrp == NULL) 2324 ttyprintf_nolock(tp, "no foreground process group\n"); 2325 else if ((p = LIST_FIRST(&tp->t_pgrp->pg_members)) == 0) 2326 ttyprintf_nolock(tp, "empty foreground process group\n"); 2327 else { 2328 /* Pick interesting process. */ 2329 for (pick = NULL; p != NULL; p = LIST_NEXT(p, p_pglist)) 2330 if (proc_compare(pick, p)) 2331 pick = p; 2332 2333 ttyprintf_nolock(tp, " cmd: %s %d [", pick->p_comm, pick->p_pid); 2334 LIST_FOREACH(l, &pick->p_lwps, l_sibling) 2335 ttyprintf_nolock(tp, "%s%s", 2336 l->l_stat == LSONPROC ? "running" : 2337 l->l_stat == LSRUN ? "runnable" : 2338 l->l_wmesg ? l->l_wmesg : "iowait", 2339 (LIST_NEXT(l, l_sibling) != NULL) ? " " : "] "); 2340 2341 calcru(pick, &utime, &stime, NULL); 2342 2343 /* Round up and print user time. */ 2344 utime.tv_usec += 5000; 2345 if (utime.tv_usec >= 1000000) { 2346 utime.tv_sec += 1; 2347 utime.tv_usec -= 1000000; 2348 } 2349 ttyprintf_nolock(tp, "%ld.%02ldu ", (long int)utime.tv_sec, 2350 (long int)utime.tv_usec / 10000); 2351 2352 /* Round up and print system time. */ 2353 stime.tv_usec += 5000; 2354 if (stime.tv_usec >= 1000000) { 2355 stime.tv_sec += 1; 2356 stime.tv_usec -= 1000000; 2357 } 2358 ttyprintf_nolock(tp, "%ld.%02lds ", (long int)stime.tv_sec, 2359 (long int)stime.tv_usec / 10000); 2360 2361 #define pgtok(a) (((u_long) ((a) * PAGE_SIZE) / 1024)) 2362 /* Print percentage CPU. */ 2363 tmp = (pick->p_pctcpu * 10000 + FSCALE / 2) >> FSHIFT; 2364 ttyprintf_nolock(tp, "%d%% ", tmp / 100); 2365 2366 /* Print resident set size. */ 2367 if (pick->p_stat == SIDL || P_ZOMBIE(pick)) 2368 tmp = 0; 2369 else { 2370 struct vmspace *vm = pick->p_vmspace; 2371 tmp = pgtok(vm_resident_count(vm)); 2372 } 2373 ttyprintf_nolock(tp, "%dk\n", tmp); 2374 } 2375 tp->t_rocount = 0; /* so pending input will be retyped if BS */ 2376 } 2377 2378 /* 2379 * Returns 1 if p2 is "better" than p1 2380 * 2381 * The algorithm for picking the "interesting" process is thus: 2382 * 2383 * 1) Only foreground processes are eligible - implied. 2384 * 2) Runnable processes are favored over anything else. The runner 2385 * with the highest CPU utilization is picked (p_estcpu). Ties are 2386 * broken by picking the highest pid. 2387 * 3) The sleeper with the shortest sleep time is next. With ties, 2388 * we pick out just "short-term" sleepers (P_SINTR == 0). 2389 * 4) Further ties are broken by picking the highest pid. 2390 */ 2391 #define ISRUN(p) ((p)->p_nrlwps > 0) 2392 #define TESTAB(a, b) ((a)<<1 | (b)) 2393 #define ONLYA 2 2394 #define ONLYB 1 2395 #define BOTH 3 2396 2397 static int 2398 proc_compare(struct proc *p1, struct proc *p2) 2399 { 2400 2401 if (p1 == NULL) 2402 return (1); 2403 /* 2404 * see if at least one of them is runnable 2405 */ 2406 switch (TESTAB(ISRUN(p1), ISRUN(p2))) { 2407 case ONLYA: 2408 return (0); 2409 case ONLYB: 2410 return (1); 2411 case BOTH: 2412 /* 2413 * tie - favor one with highest recent CPU utilization 2414 */ 2415 if (p2->p_estcpu > p1->p_estcpu) 2416 return (1); 2417 if (p1->p_estcpu > p2->p_estcpu) 2418 return (0); 2419 return (p2->p_pid > p1->p_pid); /* tie - return highest pid */ 2420 } 2421 /* 2422 * weed out zombies 2423 */ 2424 switch (TESTAB(P_ZOMBIE(p1), P_ZOMBIE(p2))) { 2425 case ONLYA: 2426 return (1); 2427 case ONLYB: 2428 return (0); 2429 case BOTH: 2430 return (p2->p_pid > p1->p_pid); /* tie - return highest pid */ 2431 } 2432 #if 0 /* XXX NJWLWP */ 2433 /* 2434 * pick the one with the smallest sleep time 2435 */ 2436 if (p2->p_slptime > p1->p_slptime) 2437 return (0); 2438 if (p1->p_slptime > p2->p_slptime) 2439 return (1); 2440 /* 2441 * favor one sleeping in a non-interruptible sleep 2442 */ 2443 if (p1->p_flag & P_SINTR && (p2->p_flag & P_SINTR) == 0) 2444 return (1); 2445 if (p2->p_flag & P_SINTR && (p1->p_flag & P_SINTR) == 0) 2446 return (0); 2447 #endif 2448 return (p2->p_pid > p1->p_pid); /* tie - return highest pid */ 2449 } 2450 2451 /* 2452 * Output char to tty; console putchar style. 2453 * Can be called with tty lock held through kprintf() machinery.. 2454 */ 2455 int 2456 tputchar(int c, int flags, struct tty *tp) 2457 { 2458 int s, r = 0; 2459 2460 s = spltty(); 2461 if ((flags & NOLOCK) == 0) 2462 simple_lock(&tp->t_slock); 2463 if (!CONNECTED(tp)) { 2464 r = -1; 2465 goto out; 2466 } 2467 if (c == '\n') 2468 (void)ttyoutput('\r', tp); 2469 (void)ttyoutput(c, tp); 2470 ttstart(tp); 2471 out: 2472 if ((flags & NOLOCK) == 0) 2473 TTY_UNLOCK(tp); 2474 splx(s); 2475 return (r); 2476 } 2477 2478 /* 2479 * Sleep on chan, returning ERESTART if tty changed while we napped and 2480 * returning any errors (e.g. EINTR/ETIMEDOUT) reported by tsleep. If 2481 * the tty is revoked, restarting a pending call will redo validation done 2482 * at the start of the call. 2483 * 2484 * Must be called with the tty slock held. 2485 */ 2486 int 2487 ttysleep(struct tty *tp, void *chan, int pri, const char *wmesg, int timo) 2488 { 2489 int error; 2490 short gen; 2491 2492 gen = tp->t_gen; 2493 if ((error = ltsleep(chan, pri, wmesg, timo, &tp->t_slock)) != 0) 2494 return (error); 2495 return (tp->t_gen == gen ? 0 : ERESTART); 2496 } 2497 2498 /* 2499 * Initialise the global tty list. 2500 */ 2501 void 2502 tty_init(void) 2503 { 2504 2505 ttyldisc_init(); 2506 2507 TAILQ_INIT(&ttylist); 2508 tty_count = 0; 2509 } 2510 2511 /* 2512 * Attach a tty to the tty list. 2513 * 2514 * This should be called ONLY once per real tty (including pty's). 2515 * eg, on the sparc, the keyboard and mouse have struct tty's that are 2516 * distinctly NOT usable as tty's, and thus should not be attached to 2517 * the ttylist. This is why this call is not done from ttymalloc(). 2518 * 2519 * Device drivers should attach tty's at a similar time that they are 2520 * ttymalloc()'ed, or, for the case of statically allocated struct tty's 2521 * either in the attach or (first) open routine. 2522 */ 2523 void 2524 tty_attach(struct tty *tp) 2525 { 2526 2527 simple_lock(&ttylist_slock); 2528 TAILQ_INSERT_TAIL(&ttylist, tp, tty_link); 2529 ++tty_count; 2530 simple_unlock(&ttylist_slock); 2531 } 2532 2533 /* 2534 * Remove a tty from the tty list. 2535 */ 2536 void 2537 tty_detach(struct tty *tp) 2538 { 2539 2540 simple_lock(&ttylist_slock); 2541 --tty_count; 2542 #ifdef DIAGNOSTIC 2543 if (tty_count < 0) 2544 panic("tty_detach: tty_count < 0"); 2545 #endif 2546 TAILQ_REMOVE(&ttylist, tp, tty_link); 2547 simple_unlock(&ttylist_slock); 2548 } 2549 2550 /* 2551 * Allocate a tty structure and its associated buffers. 2552 */ 2553 struct tty * 2554 ttymalloc(void) 2555 { 2556 struct tty *tp; 2557 2558 tp = pool_get(&tty_pool, PR_WAITOK); 2559 memset(tp, 0, sizeof(*tp)); 2560 simple_lock_init(&tp->t_slock); 2561 callout_init(&tp->t_rstrt_ch); 2562 /* XXX: default to 1024 chars for now */ 2563 clalloc(&tp->t_rawq, 1024, 1); 2564 clalloc(&tp->t_canq, 1024, 1); 2565 /* output queue doesn't need quoting */ 2566 clalloc(&tp->t_outq, 1024, 0); 2567 /* Set default line discipline. */ 2568 tp->t_linesw = linesw[0]; 2569 return (tp); 2570 } 2571 2572 /* 2573 * Free a tty structure and its buffers. 2574 * 2575 * Be sure to call tty_detach() for any tty that has been 2576 * tty_attach()ed. 2577 */ 2578 void 2579 ttyfree(struct tty *tp) 2580 { 2581 2582 callout_stop(&tp->t_rstrt_ch); 2583 clfree(&tp->t_rawq); 2584 clfree(&tp->t_canq); 2585 clfree(&tp->t_outq); 2586 pool_put(&tty_pool, tp); 2587 } 2588 2589 /* 2590 * ttyprintf_nolock: send a message to a specific tty, without locking. 2591 * 2592 * => should be used only by tty driver or anything that knows the 2593 * underlying tty will not be revoked(2)'d away. [otherwise, 2594 * use tprintf] 2595 */ 2596 static void 2597 ttyprintf_nolock(struct tty *tp, const char *fmt, ...) 2598 { 2599 va_list ap; 2600 2601 /* No mutex needed; going to process TTY. */ 2602 va_start(ap, fmt); 2603 kprintf(fmt, TOTTY|NOLOCK, tp, NULL, ap); 2604 va_end(ap); 2605 } 2606