1 /* $NetBSD: tty.c,v 1.170 2004/11/06 02:03:20 wrstuden 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.170 2004/11/06 02:03:20 wrstuden 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_INITIALIZER(ttylist); 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 FIONWRITE: /* get # bytes to written & unsent */ 884 s = spltty(); 885 TTY_LOCK(tp); 886 *(int *)data = tp->t_outq.c_cc; 887 TTY_UNLOCK(tp); 888 splx(s); 889 break; 890 case FIONSPACE: /* get # bytes to written & unsent */ 891 s = spltty(); 892 TTY_LOCK(tp); 893 *(int *)data = tp->t_outq.c_cn - tp->t_outq.c_cc; 894 TTY_UNLOCK(tp); 895 splx(s); 896 break; 897 case TIOCEXCL: /* set exclusive use of tty */ 898 s = spltty(); 899 TTY_LOCK(tp); 900 SET(tp->t_state, TS_XCLUDE); 901 splx(s); 902 TTY_UNLOCK(tp); 903 break; 904 case TIOCFLUSH: { /* flush buffers */ 905 int flags = *(int *)data; 906 907 if (flags == 0) 908 flags = FREAD | FWRITE; 909 else 910 flags &= FREAD | FWRITE; 911 s = spltty(); 912 TTY_LOCK(tp); 913 ttyflush(tp, flags); 914 TTY_UNLOCK(tp); 915 splx(s); 916 break; 917 } 918 case TIOCCONS: /* become virtual console */ 919 if (*(int *)data) { 920 if (constty && constty != tp && 921 ISSET(constty->t_state, TS_CARR_ON | TS_ISOPEN) == 922 (TS_CARR_ON | TS_ISOPEN)) 923 return EBUSY; 924 925 NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_SYSSPACE, 926 "/dev/console", p); 927 if ((error = namei(&nd)) != 0) 928 return error; 929 error = VOP_ACCESS(nd.ni_vp, VREAD, p->p_ucred, p); 930 vput(nd.ni_vp); 931 if (error) 932 return error; 933 934 constty = tp; 935 } else if (tp == constty) 936 constty = NULL; 937 break; 938 case TIOCDRAIN: /* wait till output drained */ 939 if ((error = ttywait(tp)) != 0) 940 return (error); 941 break; 942 case TIOCGETA: { /* get termios struct */ 943 struct termios *t = (struct termios *)data; 944 945 memcpy(t, &tp->t_termios, sizeof(struct termios)); 946 break; 947 } 948 case TIOCGETD: /* get line discipline */ 949 *(int *)data = tp->t_linesw->l_no; 950 break; 951 case TIOCGLINED: 952 (void)strncpy((char *)data, tp->t_linesw->l_name, 953 TTLINEDNAMELEN - 1); 954 break; 955 case TIOCGWINSZ: /* get window size */ 956 *(struct winsize *)data = tp->t_winsize; 957 break; 958 case FIOGETOWN: 959 if (!isctty(p, tp)) 960 return (ENOTTY); 961 *(int *)data = tp->t_pgrp ? -tp->t_pgrp->pg_id : 0; 962 break; 963 case TIOCGPGRP: /* get pgrp of tty */ 964 if (!isctty(p, tp)) 965 return (ENOTTY); 966 *(int *)data = tp->t_pgrp ? tp->t_pgrp->pg_id : NO_PGID; 967 break; 968 case TIOCGSID: /* get sid of tty */ 969 if (!isctty(p, tp)) 970 return (ENOTTY); 971 *(int *)data = tp->t_session->s_sid; 972 break; 973 #ifdef TIOCHPCL 974 case TIOCHPCL: /* hang up on last close */ 975 s = spltty(); 976 TTY_LOCK(tp); 977 SET(tp->t_cflag, HUPCL); 978 TTY_UNLOCK(tp); 979 splx(s); 980 break; 981 #endif 982 case TIOCNXCL: /* reset exclusive use of tty */ 983 s = spltty(); 984 TTY_LOCK(tp); 985 CLR(tp->t_state, TS_XCLUDE); 986 TTY_UNLOCK(tp); 987 splx(s); 988 break; 989 case TIOCOUTQ: /* output queue size */ 990 *(int *)data = tp->t_outq.c_cc; 991 break; 992 case TIOCSETA: /* set termios struct */ 993 case TIOCSETAW: /* drain output, set */ 994 case TIOCSETAF: { /* drn out, fls in, set */ 995 struct termios *t = (struct termios *)data; 996 997 if (cmd == TIOCSETAW || cmd == TIOCSETAF) { 998 if ((error = ttywait(tp)) != 0) 999 return (error); 1000 1001 if (cmd == TIOCSETAF) { 1002 s = spltty(); 1003 TTY_LOCK(tp); 1004 ttyflush(tp, FREAD); 1005 TTY_UNLOCK(tp); 1006 splx(s); 1007 } 1008 } 1009 1010 s = spltty(); 1011 /* 1012 * XXXSMP - some drivers call back on us from t_param(), so 1013 * don't take the tty spin lock here. 1014 * require t_param() to unlock upon callback? 1015 */ 1016 /* wanted here: TTY_LOCK(tp); */ 1017 if (!ISSET(t->c_cflag, CIGNORE)) { 1018 /* 1019 * Set device hardware. 1020 */ 1021 if (tp->t_param && (error = (*tp->t_param)(tp, t))) { 1022 /* wanted here: TTY_UNLOCK(tp); */ 1023 splx(s); 1024 return (error); 1025 } else { 1026 tp->t_cflag = t->c_cflag; 1027 tp->t_ispeed = t->c_ispeed; 1028 tp->t_ospeed = t->c_ospeed; 1029 if (t->c_ospeed == 0 && tp->t_session && 1030 tp->t_session->s_leader) 1031 psignal(tp->t_session->s_leader, 1032 SIGHUP); 1033 } 1034 ttsetwater(tp); 1035 } 1036 1037 /* delayed lock acquiring */TTY_LOCK(tp); 1038 if (cmd != TIOCSETAF) { 1039 if (ISSET(t->c_lflag, ICANON) != 1040 ISSET(tp->t_lflag, ICANON)) { 1041 if (ISSET(t->c_lflag, ICANON)) { 1042 SET(tp->t_lflag, PENDIN); 1043 ttwakeup(tp); 1044 } else { 1045 struct clist tq; 1046 1047 catq(&tp->t_rawq, &tp->t_canq); 1048 tq = tp->t_rawq; 1049 tp->t_rawq = tp->t_canq; 1050 tp->t_canq = tq; 1051 CLR(tp->t_lflag, PENDIN); 1052 } 1053 } 1054 } 1055 tp->t_iflag = t->c_iflag; 1056 tp->t_oflag = t->c_oflag; 1057 /* 1058 * Make the EXTPROC bit read only. 1059 */ 1060 if (ISSET(tp->t_lflag, EXTPROC)) 1061 SET(t->c_lflag, EXTPROC); 1062 else 1063 CLR(t->c_lflag, EXTPROC); 1064 tp->t_lflag = t->c_lflag | ISSET(tp->t_lflag, PENDIN); 1065 memcpy(tp->t_cc, t->c_cc, sizeof(t->c_cc)); 1066 TTY_UNLOCK(tp); 1067 splx(s); 1068 break; 1069 } 1070 case TIOCSETD: { /* set line discipline */ 1071 int t = *(int *)data; 1072 1073 if (t < 0) 1074 return (EINVAL); 1075 if (t >= nlinesw) 1076 return (ENXIO); 1077 lp = linesw[t]; 1078 goto setldisc; 1079 } 1080 case TIOCSLINED: { /* set line discipline */ 1081 char *name = (char *)data; 1082 dev_t device; 1083 1084 /* Null terminate to prevent buffer overflow */ 1085 name[TTLINEDNAMELEN - 1] = '\0'; 1086 lp = ttyldisc_lookup(name); 1087 1088 setldisc: 1089 if (lp == NULL) 1090 return (ENXIO); 1091 1092 if (lp != tp->t_linesw) { 1093 device = tp->t_dev; 1094 s = spltty(); 1095 (*tp->t_linesw->l_close)(tp, flag); 1096 error = (*lp->l_open)(device, tp); 1097 if (error) { 1098 (void)(*tp->t_linesw->l_open)(device, tp); 1099 splx(s); 1100 return (error); 1101 } 1102 tp->t_linesw = lp; 1103 splx(s); 1104 } 1105 break; 1106 } 1107 case TIOCSTART: /* start output, like ^Q */ 1108 s = spltty(); 1109 TTY_LOCK(tp); 1110 if (ISSET(tp->t_state, TS_TTSTOP) || 1111 ISSET(tp->t_lflag, FLUSHO)) { 1112 CLR(tp->t_lflag, FLUSHO); 1113 CLR(tp->t_state, TS_TTSTOP); 1114 ttstart(tp); 1115 } 1116 TTY_UNLOCK(tp); 1117 splx(s); 1118 break; 1119 case TIOCSTI: /* simulate terminal input */ 1120 if (p->p_ucred->cr_uid && (flag & FREAD) == 0) 1121 return (EPERM); 1122 if (p->p_ucred->cr_uid && !isctty(p, tp)) 1123 return (EACCES); 1124 (*tp->t_linesw->l_rint)(*(u_char *)data, tp); 1125 break; 1126 case TIOCSTOP: /* stop output, like ^S */ 1127 { 1128 const struct cdevsw *cdev; 1129 s = spltty(); 1130 TTY_LOCK(tp); 1131 if (!ISSET(tp->t_state, TS_TTSTOP)) { 1132 SET(tp->t_state, TS_TTSTOP); 1133 cdev = cdevsw_lookup(tp->t_dev); 1134 if (cdev != NULL) 1135 (*cdev->d_stop)(tp, 0); 1136 } 1137 TTY_UNLOCK(tp); 1138 splx(s); 1139 break; 1140 } 1141 case TIOCSCTTY: /* become controlling tty */ 1142 /* Session ctty vnode pointer set in vnode layer. */ 1143 if (!SESS_LEADER(p) || 1144 ((p->p_session->s_ttyvp || tp->t_session) && 1145 (tp->t_session != p->p_session))) 1146 return (EPERM); 1147 1148 /* 1149 * `p_session' acquires a reference. 1150 * But note that if `t_session' is set at this point, 1151 * it must equal `p_session', in which case the session 1152 * already has the correct reference count. 1153 */ 1154 if (tp->t_session == NULL) 1155 SESSHOLD(p->p_session); 1156 1157 tp->t_session = p->p_session; 1158 tp->t_pgrp = p->p_pgrp; 1159 p->p_session->s_ttyp = tp; 1160 p->p_flag |= P_CONTROLT; 1161 break; 1162 case FIOSETOWN: { /* set pgrp of tty */ 1163 pid_t pgid = *(int *)data; 1164 struct pgrp *pgrp; 1165 1166 if (!isctty(p, tp)) 1167 return (ENOTTY); 1168 1169 if (pgid < 0) 1170 pgrp = pgfind(-pgid); 1171 else { 1172 struct proc *p1 = pfind(pgid); 1173 if (!p1) 1174 return (ESRCH); 1175 pgrp = p1->p_pgrp; 1176 } 1177 1178 if (pgrp == NULL) 1179 return (EINVAL); 1180 else if (pgrp->pg_session != p->p_session) 1181 return (EPERM); 1182 tp->t_pgrp = pgrp; 1183 break; 1184 } 1185 case TIOCSPGRP: { /* set pgrp of tty */ 1186 struct pgrp *pgrp = pgfind(*(int *)data); 1187 1188 if (!isctty(p, tp)) 1189 return (ENOTTY); 1190 else if (pgrp == NULL) 1191 return (EINVAL); 1192 else if (pgrp->pg_session != p->p_session) 1193 return (EPERM); 1194 tp->t_pgrp = pgrp; 1195 break; 1196 } 1197 case TIOCSTAT: /* get load avg stats */ 1198 s = spltty(); 1199 TTY_LOCK(tp); 1200 ttyinfo(tp); 1201 TTY_UNLOCK(tp); 1202 splx(s); 1203 break; 1204 case TIOCSWINSZ: /* set window size */ 1205 if (memcmp((caddr_t)&tp->t_winsize, data, 1206 sizeof(struct winsize))) { 1207 tp->t_winsize = *(struct winsize *)data; 1208 pgsignal(tp->t_pgrp, SIGWINCH, 1); 1209 } 1210 break; 1211 default: 1212 #ifdef COMPAT_OLDTTY 1213 return (ttcompat(tp, cmd, data, flag, p)); 1214 #else 1215 return (EPASSTHROUGH); 1216 #endif 1217 } 1218 return (0); 1219 } 1220 1221 int 1222 ttpoll(struct tty *tp, int events, struct proc *p) 1223 { 1224 int revents, s; 1225 1226 revents = 0; 1227 s = spltty(); 1228 TTY_LOCK(tp); 1229 if (events & (POLLIN | POLLRDNORM)) 1230 if (ttnread(tp) > 0) 1231 revents |= events & (POLLIN | POLLRDNORM); 1232 1233 if (events & (POLLOUT | POLLWRNORM)) 1234 if (tp->t_outq.c_cc <= tp->t_lowat) 1235 revents |= events & (POLLOUT | POLLWRNORM); 1236 1237 if (events & POLLHUP) 1238 if (!CONNECTED(tp)) 1239 revents |= POLLHUP; 1240 1241 if (revents == 0) { 1242 if (events & (POLLIN | POLLHUP | POLLRDNORM)) 1243 selrecord(p, &tp->t_rsel); 1244 1245 if (events & (POLLOUT | POLLWRNORM)) 1246 selrecord(p, &tp->t_wsel); 1247 } 1248 1249 TTY_UNLOCK(tp); 1250 splx(s); 1251 return (revents); 1252 } 1253 1254 static void 1255 filt_ttyrdetach(struct knote *kn) 1256 { 1257 struct tty *tp; 1258 int s; 1259 1260 tp = kn->kn_hook; 1261 s = spltty(); 1262 SLIST_REMOVE(&tp->t_rsel.sel_klist, kn, knote, kn_selnext); 1263 splx(s); 1264 } 1265 1266 static int 1267 filt_ttyread(struct knote *kn, long hint) 1268 { 1269 struct tty *tp; 1270 int s; 1271 1272 tp = kn->kn_hook; 1273 s = spltty(); 1274 if ((hint & NOTE_SUBMIT) == 0) 1275 TTY_LOCK(tp); 1276 kn->kn_data = ttnread(tp); 1277 if ((hint & NOTE_SUBMIT) == 0) 1278 TTY_UNLOCK(tp); 1279 splx(s); 1280 return (kn->kn_data > 0); 1281 } 1282 1283 static void 1284 filt_ttywdetach(struct knote *kn) 1285 { 1286 struct tty *tp; 1287 int s; 1288 1289 tp = kn->kn_hook; 1290 s = spltty(); 1291 TTY_LOCK(tp); 1292 SLIST_REMOVE(&tp->t_wsel.sel_klist, kn, knote, kn_selnext); 1293 TTY_UNLOCK(tp); 1294 splx(s); 1295 } 1296 1297 static int 1298 filt_ttywrite(struct knote *kn, long hint) 1299 { 1300 struct tty *tp; 1301 int canwrite, s; 1302 1303 tp = kn->kn_hook; 1304 s = spltty(); 1305 if ((hint & NOTE_SUBMIT) == 0) 1306 TTY_LOCK(tp); 1307 kn->kn_data = tp->t_outq.c_cn - tp->t_outq.c_cc; 1308 canwrite = (tp->t_outq.c_cc <= tp->t_lowat) && CONNECTED(tp); 1309 if ((hint & NOTE_SUBMIT) == 0) 1310 TTY_UNLOCK(tp); 1311 splx(s); 1312 return (canwrite); 1313 } 1314 1315 static const struct filterops ttyread_filtops = 1316 { 1, NULL, filt_ttyrdetach, filt_ttyread }; 1317 static const struct filterops ttywrite_filtops = 1318 { 1, NULL, filt_ttywdetach, filt_ttywrite }; 1319 1320 int 1321 ttykqfilter(dev_t dev, struct knote *kn) 1322 { 1323 struct tty *tp; 1324 struct klist *klist; 1325 int s; 1326 const struct cdevsw *cdev; 1327 1328 if (((cdev = cdevsw_lookup(dev)) == NULL) || 1329 (cdev->d_tty == NULL) || 1330 ((tp = (*cdev->d_tty)(dev)) == NULL)) 1331 return (ENXIO); 1332 1333 switch (kn->kn_filter) { 1334 case EVFILT_READ: 1335 klist = &tp->t_rsel.sel_klist; 1336 kn->kn_fop = &ttyread_filtops; 1337 break; 1338 case EVFILT_WRITE: 1339 klist = &tp->t_wsel.sel_klist; 1340 kn->kn_fop = &ttywrite_filtops; 1341 break; 1342 default: 1343 return (1); 1344 } 1345 1346 kn->kn_hook = tp; 1347 1348 s = spltty(); 1349 TTY_LOCK(tp); 1350 SLIST_INSERT_HEAD(klist, kn, kn_selnext); 1351 TTY_UNLOCK(tp); 1352 splx(s); 1353 1354 return (0); 1355 } 1356 1357 /* 1358 * Find the number of chars ready to be read from this tty. 1359 * Call at spltty() and with the tty slock held. 1360 */ 1361 static int 1362 ttnread(struct tty *tp) 1363 { 1364 int nread; 1365 1366 if (ISSET(tp->t_lflag, PENDIN)) 1367 ttypend(tp); 1368 nread = tp->t_canq.c_cc; 1369 if (!ISSET(tp->t_lflag, ICANON)) { 1370 nread += tp->t_rawq.c_cc; 1371 if (nread < tp->t_cc[VMIN] && !tp->t_cc[VTIME]) 1372 nread = 0; 1373 } 1374 return (nread); 1375 } 1376 1377 /* 1378 * Wait for output to drain. 1379 */ 1380 int 1381 ttywait(struct tty *tp) 1382 { 1383 int error, s; 1384 1385 error = 0; 1386 s = spltty(); 1387 TTY_LOCK(tp); 1388 while ((tp->t_outq.c_cc || ISSET(tp->t_state, TS_BUSY)) && 1389 CONNECTED(tp) && tp->t_oproc) { 1390 (*tp->t_oproc)(tp); 1391 SET(tp->t_state, TS_ASLEEP); 1392 error = ttysleep(tp, &tp->t_outq, TTOPRI | PCATCH, ttyout, 0); 1393 if (error) 1394 break; 1395 } 1396 TTY_UNLOCK(tp); 1397 splx(s); 1398 return (error); 1399 } 1400 1401 /* 1402 * Flush if successfully wait. 1403 */ 1404 int 1405 ttywflush(struct tty *tp) 1406 { 1407 int error; 1408 int s; 1409 1410 if ((error = ttywait(tp)) == 0) { 1411 s = spltty(); 1412 TTY_LOCK(tp); 1413 ttyflush(tp, FREAD); 1414 TTY_UNLOCK(tp); 1415 splx(s); 1416 } 1417 return (error); 1418 } 1419 1420 /* 1421 * Flush tty read and/or write queues, notifying anyone waiting. 1422 * Call at spltty() and with the tty slock held. 1423 */ 1424 void 1425 ttyflush(struct tty *tp, int rw) 1426 { 1427 const struct cdevsw *cdev; 1428 1429 if (rw & FREAD) { 1430 FLUSHQ(&tp->t_canq); 1431 FLUSHQ(&tp->t_rawq); 1432 tp->t_rocount = 0; 1433 tp->t_rocol = 0; 1434 CLR(tp->t_state, TS_LOCAL); 1435 ttwakeup(tp); 1436 } 1437 if (rw & FWRITE) { 1438 CLR(tp->t_state, TS_TTSTOP); 1439 cdev = cdevsw_lookup(tp->t_dev); 1440 if (cdev != NULL) 1441 (*cdev->d_stop)(tp, rw); 1442 FLUSHQ(&tp->t_outq); 1443 wakeup((caddr_t)&tp->t_outq); 1444 selnotify(&tp->t_wsel, NOTE_SUBMIT); 1445 } 1446 } 1447 1448 /* 1449 * Copy in the default termios characters. 1450 */ 1451 void 1452 ttychars(struct tty *tp) 1453 { 1454 1455 memcpy(tp->t_cc, ttydefchars, sizeof(ttydefchars)); 1456 } 1457 1458 /* 1459 * Send stop character on input overflow. 1460 * Call at spltty() and with the tty slock held. 1461 */ 1462 static void 1463 ttyblock(struct tty *tp) 1464 { 1465 int total; 1466 1467 total = tp->t_rawq.c_cc + tp->t_canq.c_cc; 1468 if (tp->t_rawq.c_cc > TTYHOG) { 1469 ttyflush(tp, FREAD | FWRITE); 1470 CLR(tp->t_state, TS_TBLOCK); 1471 } 1472 /* 1473 * Block further input iff: current input > threshold 1474 * AND input is available to user program. 1475 */ 1476 if (total >= TTYHOG / 2 && 1477 !ISSET(tp->t_state, TS_TBLOCK) && 1478 (!ISSET(tp->t_lflag, ICANON) || tp->t_canq.c_cc > 0)) { 1479 if (ISSET(tp->t_iflag, IXOFF) && 1480 tp->t_cc[VSTOP] != _POSIX_VDISABLE && 1481 putc(tp->t_cc[VSTOP], &tp->t_outq) == 0) { 1482 SET(tp->t_state, TS_TBLOCK); 1483 ttstart(tp); 1484 } 1485 /* Try to block remote output via hardware flow control. */ 1486 if (ISSET(tp->t_cflag, CHWFLOW) && tp->t_hwiflow && 1487 (*tp->t_hwiflow)(tp, 1) != 0) 1488 SET(tp->t_state, TS_TBLOCK); 1489 } 1490 } 1491 1492 /* 1493 * Delayed line discipline output 1494 */ 1495 void 1496 ttrstrt(void *tp_arg) 1497 { 1498 struct tty *tp; 1499 int s; 1500 1501 #ifdef DIAGNOSTIC 1502 if (tp_arg == NULL) 1503 panic("ttrstrt"); 1504 #endif 1505 tp = tp_arg; 1506 s = spltty(); 1507 TTY_LOCK(tp); 1508 1509 CLR(tp->t_state, TS_TIMEOUT); 1510 ttstart(tp); /* XXX - Shouldn't this be tp->l_start(tp)? */ 1511 1512 TTY_UNLOCK(tp); 1513 splx(s); 1514 } 1515 1516 /* 1517 * start a line discipline 1518 * Always call at spltty() and with tty slock held? 1519 */ 1520 int 1521 ttstart(struct tty *tp) 1522 { 1523 1524 if (tp->t_oproc != NULL) /* XXX: Kludge for pty. */ 1525 (*tp->t_oproc)(tp); 1526 return (0); 1527 } 1528 1529 /* 1530 * "close" a line discipline 1531 */ 1532 int 1533 ttylclose(struct tty *tp, int flag) 1534 { 1535 int s; 1536 1537 if (flag & FNONBLOCK) { 1538 s = spltty(); 1539 TTY_LOCK(tp); 1540 ttyflush(tp, FREAD | FWRITE); 1541 TTY_UNLOCK(tp); 1542 splx(s); 1543 } else 1544 ttywflush(tp); 1545 return (0); 1546 } 1547 1548 /* 1549 * Handle modem control transition on a tty. 1550 * Flag indicates new state of carrier. 1551 * Returns 0 if the line should be turned off, otherwise 1. 1552 * 1553 * Must be called at spltty(). 1554 * XXX except that it is often isn't, which should be fixed. 1555 */ 1556 int 1557 ttymodem(struct tty *tp, int flag) 1558 { 1559 int s; 1560 1561 s = spltty(); 1562 TTY_LOCK(tp); 1563 if (flag == 0) { 1564 if (ISSET(tp->t_state, TS_CARR_ON)) { 1565 /* 1566 * Lost carrier. 1567 */ 1568 CLR(tp->t_state, TS_CARR_ON); 1569 if (ISSET(tp->t_state, TS_ISOPEN) && !CONNECTED(tp)) { 1570 if (tp->t_session && tp->t_session->s_leader) 1571 psignal(tp->t_session->s_leader, 1572 SIGHUP); 1573 ttyflush(tp, FREAD | FWRITE); 1574 TTY_UNLOCK(tp); 1575 splx(s); 1576 return (0); 1577 } 1578 } 1579 } else { 1580 if (!ISSET(tp->t_state, TS_CARR_ON)) { 1581 /* 1582 * Carrier now on. 1583 */ 1584 SET(tp->t_state, TS_CARR_ON); 1585 ttwakeup(tp); 1586 } 1587 } 1588 TTY_UNLOCK(tp); 1589 splx(s); 1590 return (1); 1591 } 1592 1593 /* 1594 * Default modem control routine (for other line disciplines). 1595 * Return argument flag, to turn off device on carrier drop. 1596 * 1597 * Must be called at spltty(). 1598 * XXX except that it is often isn't, which should be fixed. 1599 */ 1600 int 1601 nullmodem(struct tty *tp, int flag) 1602 { 1603 int s; 1604 1605 s = spltty(); 1606 TTY_LOCK(tp); 1607 if (flag) 1608 SET(tp->t_state, TS_CARR_ON); 1609 else { 1610 CLR(tp->t_state, TS_CARR_ON); 1611 if (!CONNECTED(tp)) { 1612 if (tp->t_session && tp->t_session->s_leader) 1613 psignal(tp->t_session->s_leader, SIGHUP); 1614 TTY_UNLOCK(tp); 1615 splx(s); 1616 return (0); 1617 } 1618 } 1619 TTY_UNLOCK(tp); 1620 splx(s); 1621 return (1); 1622 } 1623 1624 /* 1625 * Reinput pending characters after state switch. 1626 * Call at spltty() and with the tty slock held. 1627 */ 1628 void 1629 ttypend(struct tty *tp) 1630 { 1631 struct clist tq; 1632 int c; 1633 1634 CLR(tp->t_lflag, PENDIN); 1635 SET(tp->t_state, TS_TYPEN); 1636 tq = tp->t_rawq; 1637 tp->t_rawq.c_cc = 0; 1638 tp->t_rawq.c_cf = tp->t_rawq.c_cl = 0; 1639 while ((c = getc(&tq)) >= 0) 1640 ttyinput_wlock(c, tp); 1641 CLR(tp->t_state, TS_TYPEN); 1642 } 1643 1644 /* 1645 * Process a read call on a tty device. 1646 */ 1647 int 1648 ttread(struct tty *tp, struct uio *uio, int flag) 1649 { 1650 struct clist *qp; 1651 u_char *cc; 1652 struct proc *p; 1653 int c, s, first, error, has_stime, last_cc; 1654 long lflag, slp; 1655 struct timeval stime; 1656 1657 cc = tp->t_cc; 1658 p = curproc; 1659 error = 0; 1660 has_stime = 0; 1661 last_cc = 0; 1662 slp = 0; 1663 1664 loop: 1665 s = spltty(); 1666 TTY_LOCK(tp); 1667 lflag = tp->t_lflag; 1668 /* 1669 * take pending input first 1670 */ 1671 if (ISSET(lflag, PENDIN)) 1672 ttypend(tp); 1673 1674 /* 1675 * Hang process if it's in the background. 1676 */ 1677 if (isbackground(p, tp)) { 1678 if (sigismember(&p->p_sigctx.ps_sigignore, SIGTTIN) || 1679 sigismember(&p->p_sigctx.ps_sigmask, SIGTTIN) || 1680 p->p_flag & P_PPWAIT || p->p_pgrp->pg_jobc == 0) { 1681 TTY_UNLOCK(tp); 1682 splx(s); 1683 return (EIO); 1684 } 1685 pgsignal(p->p_pgrp, SIGTTIN, 1); 1686 error = ttysleep(tp, &lbolt, TTIPRI | PCATCH | PNORELOCK, ttybg, 0); 1687 splx(s); 1688 if (error) 1689 return (error); 1690 goto loop; 1691 } 1692 1693 if (!ISSET(lflag, ICANON)) { 1694 int m = cc[VMIN]; 1695 long t = cc[VTIME]; 1696 1697 qp = &tp->t_rawq; 1698 /* 1699 * Check each of the four combinations. 1700 * (m > 0 && t == 0) is the normal read case. 1701 * It should be fairly efficient, so we check that and its 1702 * companion case (m == 0 && t == 0) first. 1703 * For the other two cases, we compute the target sleep time 1704 * into slp. 1705 */ 1706 if (t == 0) { 1707 if (qp->c_cc < m) 1708 goto sleep; 1709 goto read; 1710 } 1711 t *= hz; /* time in deca-ticks */ 1712 /* 1713 * Time difference in deca-ticks, split division to avoid numeric overflow. 1714 * Ok for hz < ~200kHz 1715 */ 1716 #define diff(t1, t2) (((t1).tv_sec - (t2).tv_sec) * 10 * hz + \ 1717 ((t1).tv_usec - (t2).tv_usec) / 100 * hz / 1000) 1718 if (m > 0) { 1719 if (qp->c_cc <= 0) 1720 goto sleep; 1721 if (qp->c_cc >= m) 1722 goto read; 1723 if (!has_stime) { 1724 /* first character, start timer */ 1725 has_stime = 1; 1726 stime = time; 1727 slp = t; 1728 } else if (qp->c_cc > last_cc) { 1729 /* got a character, restart timer */ 1730 stime = time; 1731 slp = t; 1732 } else { 1733 /* nothing, check expiration */ 1734 slp = t - diff(time, stime); 1735 } 1736 } else { /* m == 0 */ 1737 if (qp->c_cc > 0) 1738 goto read; 1739 if (!has_stime) { 1740 has_stime = 1; 1741 stime = time; 1742 slp = t; 1743 } else 1744 slp = t - diff(time, stime); 1745 } 1746 last_cc = qp->c_cc; 1747 #undef diff 1748 if (slp > 0) { 1749 /* 1750 * Convert deca-ticks back to ticks. 1751 * Rounding down may make us wake up just short 1752 * of the target, so we round up. 1753 * Maybe we should do 'slp/10 + 1' because the 1754 * first tick maybe almost immediate. 1755 * However it is more useful for a program that sets 1756 * VTIME=10 to wakeup every second not every 1.01 1757 * seconds (if hz=100). 1758 */ 1759 slp = (slp + 9)/ 10; 1760 goto sleep; 1761 } 1762 } else if ((qp = &tp->t_canq)->c_cc <= 0) { 1763 int carrier; 1764 1765 sleep: 1766 /* 1767 * If there is no input, sleep on rawq 1768 * awaiting hardware receipt and notification. 1769 * If we have data, we don't need to check for carrier. 1770 */ 1771 carrier = CONNECTED(tp); 1772 if (!carrier && ISSET(tp->t_state, TS_ISOPEN)) { 1773 TTY_UNLOCK(tp); 1774 splx(s); 1775 return (0); /* EOF */ 1776 } 1777 if (flag & IO_NDELAY) { 1778 TTY_UNLOCK(tp); 1779 splx(s); 1780 return (EWOULDBLOCK); 1781 } 1782 error = ttysleep(tp, &tp->t_rawq, TTIPRI | PCATCH | PNORELOCK, 1783 carrier ? ttyin : ttopen, slp); 1784 splx(s); 1785 /* VMIN == 0: any quantity read satisfies */ 1786 if (cc[VMIN] == 0 && error == EWOULDBLOCK) 1787 return (0); 1788 if (error && error != EWOULDBLOCK) 1789 return (error); 1790 goto loop; 1791 } 1792 read: 1793 TTY_UNLOCK(tp); 1794 splx(s); 1795 1796 /* 1797 * Input present, check for input mapping and processing. 1798 */ 1799 first = 1; 1800 while ((c = getc(qp)) >= 0) { 1801 /* 1802 * delayed suspend (^Y) 1803 */ 1804 if (CCEQ(cc[VDSUSP], c) && 1805 ISSET(lflag, IEXTEN|ISIG) == (IEXTEN|ISIG)) { 1806 pgsignal(tp->t_pgrp, SIGTSTP, 1); 1807 if (first) { 1808 s = spltty(); 1809 TTY_LOCK(tp); 1810 error = ttysleep(tp, &lbolt, 1811 TTIPRI | PCATCH | PNORELOCK, ttybg, 0); 1812 splx(s); 1813 if (error) 1814 break; 1815 goto loop; 1816 } 1817 break; 1818 } 1819 /* 1820 * Interpret EOF only in canonical mode. 1821 */ 1822 if (CCEQ(cc[VEOF], c) && ISSET(lflag, ICANON)) 1823 break; 1824 /* 1825 * Give user character. 1826 */ 1827 error = ureadc(c, uio); 1828 if (error) 1829 break; 1830 if (uio->uio_resid == 0) 1831 break; 1832 /* 1833 * In canonical mode check for a "break character" 1834 * marking the end of a "line of input". 1835 */ 1836 if (ISSET(lflag, ICANON) && TTBREAKC(c, lflag)) 1837 break; 1838 first = 0; 1839 } 1840 /* 1841 * Look to unblock output now that (presumably) 1842 * the input queue has gone down. 1843 */ 1844 s = spltty(); 1845 TTY_LOCK(tp); 1846 if (ISSET(tp->t_state, TS_TBLOCK) && tp->t_rawq.c_cc < TTYHOG / 5) { 1847 if (ISSET(tp->t_iflag, IXOFF) && 1848 cc[VSTART] != _POSIX_VDISABLE && 1849 putc(cc[VSTART], &tp->t_outq) == 0) { 1850 CLR(tp->t_state, TS_TBLOCK); 1851 ttstart(tp); 1852 } 1853 /* Try to unblock remote output via hardware flow control. */ 1854 if (ISSET(tp->t_cflag, CHWFLOW) && tp->t_hwiflow && 1855 (*tp->t_hwiflow)(tp, 0) != 0) 1856 CLR(tp->t_state, TS_TBLOCK); 1857 } 1858 TTY_UNLOCK(tp); 1859 splx(s); 1860 return (error); 1861 } 1862 1863 /* 1864 * Check the output queue on tp for space for a kernel message (from uprintf 1865 * or tprintf). Allow some space over the normal hiwater mark so we don't 1866 * lose messages due to normal flow control, but don't let the tty run amok. 1867 * Sleeps here are not interruptible, but we return prematurely if new signals 1868 * arrive. 1869 * Call with tty slock held. 1870 */ 1871 static int 1872 ttycheckoutq_wlock(struct tty *tp, int wait) 1873 { 1874 int hiwat, s, error; 1875 1876 hiwat = tp->t_hiwat; 1877 s = spltty(); 1878 if (tp->t_outq.c_cc > hiwat + 200) 1879 while (tp->t_outq.c_cc > hiwat) { 1880 ttstart(tp); 1881 if (wait == 0) { 1882 splx(s); 1883 return (0); 1884 } 1885 SET(tp->t_state, TS_ASLEEP); 1886 error = ltsleep(&tp->t_outq, (PZERO - 1) | PCATCH, 1887 "ttckoutq", hz, &tp->t_slock); 1888 if (error == EINTR) 1889 wait = 0; 1890 } 1891 1892 splx(s); 1893 return (1); 1894 } 1895 1896 int 1897 ttycheckoutq(struct tty *tp, int wait) 1898 { 1899 int r, s; 1900 1901 s = spltty(); 1902 TTY_LOCK(tp); 1903 r = ttycheckoutq_wlock(tp, wait); 1904 TTY_UNLOCK(tp); 1905 splx(s); 1906 return (r); 1907 } 1908 1909 /* 1910 * Process a write call on a tty device. 1911 */ 1912 int 1913 ttwrite(struct tty *tp, struct uio *uio, int flag) 1914 { 1915 u_char *cp; 1916 struct proc *p; 1917 int cc, ce, i, hiwat, error, s; 1918 size_t cnt; 1919 u_char obuf[OBUFSIZ]; 1920 1921 cp = NULL; 1922 hiwat = tp->t_hiwat; 1923 cnt = uio->uio_resid; 1924 error = 0; 1925 cc = 0; 1926 loop: 1927 s = spltty(); 1928 TTY_LOCK(tp); 1929 if (!CONNECTED(tp)) { 1930 if (ISSET(tp->t_state, TS_ISOPEN)) { 1931 TTY_UNLOCK(tp); 1932 splx(s); 1933 return (EIO); 1934 } else if (flag & IO_NDELAY) { 1935 TTY_UNLOCK(tp); 1936 splx(s); 1937 error = EWOULDBLOCK; 1938 goto out; 1939 } else { 1940 /* Sleep awaiting carrier. */ 1941 error = ttysleep(tp, 1942 &tp->t_rawq, TTIPRI | PCATCH | PNORELOCK, ttopen, 0); 1943 splx(s); 1944 if (error) 1945 goto out; 1946 goto loop; 1947 } 1948 } 1949 TTY_UNLOCK(tp); 1950 splx(s); 1951 /* 1952 * Hang the process if it's in the background. 1953 */ 1954 p = curproc; 1955 if (isbackground(p, tp) && 1956 ISSET(tp->t_lflag, TOSTOP) && (p->p_flag & P_PPWAIT) == 0 && 1957 !sigismember(&p->p_sigctx.ps_sigignore, SIGTTOU) && 1958 !sigismember(&p->p_sigctx.ps_sigmask, SIGTTOU)) { 1959 if (p->p_pgrp->pg_jobc == 0) { 1960 error = EIO; 1961 goto out; 1962 } 1963 pgsignal(p->p_pgrp, SIGTTOU, 1); 1964 s = spltty(); 1965 TTY_LOCK(tp); 1966 error = ttysleep(tp, &lbolt, TTIPRI | PCATCH | PNORELOCK, ttybg, 0); 1967 splx(s); 1968 if (error) 1969 goto out; 1970 goto loop; 1971 } 1972 /* 1973 * Process the user's data in at most OBUFSIZ chunks. Perform any 1974 * output translation. Keep track of high water mark, sleep on 1975 * overflow awaiting device aid in acquiring new space. 1976 */ 1977 while (uio->uio_resid > 0 || cc > 0) { 1978 if (ISSET(tp->t_lflag, FLUSHO)) { 1979 TTY_UNLOCK(tp); 1980 uio->uio_resid = 0; 1981 return (0); 1982 } 1983 if (tp->t_outq.c_cc > hiwat) 1984 goto ovhiwat; 1985 /* 1986 * Grab a hunk of data from the user, unless we have some 1987 * leftover from last time. 1988 */ 1989 if (cc == 0) { 1990 cc = min(uio->uio_resid, OBUFSIZ); 1991 cp = obuf; 1992 error = uiomove(cp, cc, uio); 1993 if (error) { 1994 cc = 0; 1995 goto out; 1996 } 1997 } 1998 /* 1999 * If nothing fancy need be done, grab those characters we 2000 * can handle without any of ttyoutput's processing and 2001 * just transfer them to the output q. For those chars 2002 * which require special processing (as indicated by the 2003 * bits in char_type), call ttyoutput. After processing 2004 * a hunk of data, look for FLUSHO so ^O's will take effect 2005 * immediately. 2006 */ 2007 s = spltty(); 2008 TTY_LOCK(tp); 2009 while (cc > 0) { 2010 if (!ISSET(tp->t_oflag, OPOST)) 2011 ce = cc; 2012 else { 2013 ce = cc - scanc((u_int)cc, cp, char_type, 2014 CCLASSMASK); 2015 /* 2016 * If ce is zero, then we're processing 2017 * a special character through ttyoutput. 2018 */ 2019 if (ce == 0) { 2020 tp->t_rocount = 0; 2021 if (ttyoutput(*cp, tp) >= 0) { 2022 /* out of space */ 2023 TTY_UNLOCK(tp); 2024 splx(s); 2025 goto overfull; 2026 } 2027 cp++; 2028 cc--; 2029 if (ISSET(tp->t_lflag, FLUSHO) || 2030 tp->t_outq.c_cc > hiwat) { 2031 TTY_UNLOCK(tp); 2032 splx(s); 2033 goto ovhiwat; 2034 } 2035 continue; 2036 } 2037 } 2038 /* 2039 * A bunch of normal characters have been found. 2040 * Transfer them en masse to the output queue and 2041 * continue processing at the top of the loop. 2042 * If there are any further characters in this 2043 * <= OBUFSIZ chunk, the first should be a character 2044 * requiring special handling by ttyoutput. 2045 */ 2046 tp->t_rocount = 0; 2047 i = b_to_q(cp, ce, &tp->t_outq); 2048 ce -= i; 2049 tp->t_column += ce; 2050 cp += ce, cc -= ce, tk_nout += ce; 2051 tp->t_outcc += ce; 2052 if (i > 0) { 2053 /* out of space */ 2054 TTY_UNLOCK(tp); 2055 splx(s); 2056 goto overfull; 2057 } 2058 if (ISSET(tp->t_lflag, FLUSHO) || 2059 tp->t_outq.c_cc > hiwat) 2060 break; 2061 } 2062 TTY_UNLOCK(tp); 2063 splx(s); 2064 ttstart(tp); 2065 } 2066 2067 out: 2068 /* 2069 * If cc is nonzero, we leave the uio structure inconsistent, as the 2070 * offset and iov pointers have moved forward, but it doesn't matter 2071 * (the call will either return short or restart with a new uio). 2072 */ 2073 uio->uio_resid += cc; 2074 return (error); 2075 2076 overfull: 2077 /* 2078 * Since we are using ring buffers, if we can't insert any more into 2079 * the output queue, we can assume the ring is full and that someone 2080 * forgot to set the high water mark correctly. We set it and then 2081 * proceed as normal. 2082 */ 2083 hiwat = tp->t_outq.c_cc - 1; 2084 2085 ovhiwat: 2086 ttstart(tp); 2087 s = spltty(); 2088 TTY_LOCK(tp); 2089 /* 2090 * This can only occur if FLUSHO is set in t_lflag, 2091 * or if ttstart/oproc is synchronous (or very fast). 2092 */ 2093 if (tp->t_outq.c_cc <= hiwat) { 2094 TTY_UNLOCK(tp); 2095 splx(s); 2096 goto loop; 2097 } 2098 if (flag & IO_NDELAY) { 2099 TTY_UNLOCK(tp); 2100 splx(s); 2101 error = (uio->uio_resid == cnt) ? EWOULDBLOCK : 0; 2102 goto out; 2103 } 2104 SET(tp->t_state, TS_ASLEEP); 2105 error = ttysleep(tp, &tp->t_outq, TTOPRI | PCATCH | PNORELOCK, ttyout, 0); 2106 splx(s); 2107 if (error) 2108 goto out; 2109 goto loop; 2110 } 2111 2112 /* 2113 * Rubout one character from the rawq of tp 2114 * as cleanly as possible. 2115 * Called with tty slock held. 2116 */ 2117 void 2118 ttyrub(int c, struct tty *tp) 2119 { 2120 u_char *cp; 2121 int savecol, tabc, s; 2122 2123 if (!ISSET(tp->t_lflag, ECHO) || ISSET(tp->t_lflag, EXTPROC)) 2124 return; 2125 CLR(tp->t_lflag, FLUSHO); 2126 if (ISSET(tp->t_lflag, ECHOE)) { 2127 if (tp->t_rocount == 0) { 2128 /* 2129 * Screwed by ttwrite; retype 2130 */ 2131 ttyretype(tp); 2132 return; 2133 } 2134 if (c == ('\t' | TTY_QUOTE) || c == ('\n' | TTY_QUOTE)) 2135 ttyrubo(tp, 2); 2136 else { 2137 CLR(c, ~TTY_CHARMASK); 2138 switch (CCLASS(c)) { 2139 case ORDINARY: 2140 ttyrubo(tp, 1); 2141 break; 2142 case BACKSPACE: 2143 case CONTROL: 2144 case NEWLINE: 2145 case RETURN: 2146 case VTAB: 2147 if (ISSET(tp->t_lflag, ECHOCTL)) 2148 ttyrubo(tp, 2); 2149 break; 2150 case TAB: 2151 if (tp->t_rocount < tp->t_rawq.c_cc) { 2152 ttyretype(tp); 2153 return; 2154 } 2155 s = spltty(); 2156 savecol = tp->t_column; 2157 SET(tp->t_state, TS_CNTTB); 2158 SET(tp->t_lflag, FLUSHO); 2159 tp->t_column = tp->t_rocol; 2160 for (cp = firstc(&tp->t_rawq, &tabc); cp; 2161 cp = nextc(&tp->t_rawq, cp, &tabc)) 2162 ttyecho(tabc, tp); 2163 CLR(tp->t_lflag, FLUSHO); 2164 CLR(tp->t_state, TS_CNTTB); 2165 splx(s); 2166 2167 /* savecol will now be length of the tab. */ 2168 savecol -= tp->t_column; 2169 tp->t_column += savecol; 2170 if (savecol > 8) 2171 savecol = 8; /* overflow screw */ 2172 while (--savecol >= 0) 2173 (void)ttyoutput('\b', tp); 2174 break; 2175 default: /* XXX */ 2176 #define PANICSTR "ttyrub: would panic c = %d, val = %d\n" 2177 (void)printf(PANICSTR, c, CCLASS(c)); 2178 #ifdef notdef 2179 panic(PANICSTR, c, CCLASS(c)); 2180 #endif 2181 } 2182 } 2183 } else if (ISSET(tp->t_lflag, ECHOPRT)) { 2184 if (!ISSET(tp->t_state, TS_ERASE)) { 2185 SET(tp->t_state, TS_ERASE); 2186 (void)ttyoutput('\\', tp); 2187 } 2188 ttyecho(c, tp); 2189 } else 2190 ttyecho(tp->t_cc[VERASE], tp); 2191 --tp->t_rocount; 2192 } 2193 2194 /* 2195 * Back over cnt characters, erasing them. 2196 * Called with tty slock held. 2197 */ 2198 static void 2199 ttyrubo(struct tty *tp, int cnt) 2200 { 2201 2202 while (cnt-- > 0) { 2203 (void)ttyoutput('\b', tp); 2204 (void)ttyoutput(' ', tp); 2205 (void)ttyoutput('\b', tp); 2206 } 2207 } 2208 2209 /* 2210 * ttyretype -- 2211 * Reprint the rawq line. Note, it is assumed that c_cc has already 2212 * been checked. 2213 * 2214 * Called with tty slock held. 2215 */ 2216 void 2217 ttyretype(struct tty *tp) 2218 { 2219 u_char *cp; 2220 int s, c; 2221 2222 /* Echo the reprint character. */ 2223 if (tp->t_cc[VREPRINT] != _POSIX_VDISABLE) 2224 ttyecho(tp->t_cc[VREPRINT], tp); 2225 2226 (void)ttyoutput('\n', tp); 2227 2228 s = spltty(); 2229 for (cp = firstc(&tp->t_canq, &c); cp; cp = nextc(&tp->t_canq, cp, &c)) 2230 ttyecho(c, tp); 2231 for (cp = firstc(&tp->t_rawq, &c); cp; cp = nextc(&tp->t_rawq, cp, &c)) 2232 ttyecho(c, tp); 2233 CLR(tp->t_state, TS_ERASE); 2234 splx(s); 2235 2236 tp->t_rocount = tp->t_rawq.c_cc; 2237 tp->t_rocol = 0; 2238 } 2239 2240 /* 2241 * Echo a typed character to the terminal. 2242 * Called with tty slock held. 2243 */ 2244 static void 2245 ttyecho(int c, struct tty *tp) 2246 { 2247 2248 if (!ISSET(tp->t_state, TS_CNTTB)) 2249 CLR(tp->t_lflag, FLUSHO); 2250 if ((!ISSET(tp->t_lflag, ECHO) && 2251 (!ISSET(tp->t_lflag, ECHONL) || c != '\n')) || 2252 ISSET(tp->t_lflag, EXTPROC)) 2253 return; 2254 if (((ISSET(tp->t_lflag, ECHOCTL) && 2255 (ISSET(c, TTY_CHARMASK) <= 037 && c != '\t' && c != '\n')) || 2256 ISSET(c, TTY_CHARMASK) == 0177)) { 2257 (void)ttyoutput('^', tp); 2258 CLR(c, ~TTY_CHARMASK); 2259 if (c == 0177) 2260 c = '?'; 2261 else 2262 c += 'A' - 1; 2263 } 2264 (void)ttyoutput(c, tp); 2265 } 2266 2267 /* 2268 * Wake up any readers on a tty. 2269 * Called with tty slock held. 2270 */ 2271 void 2272 ttwakeup(struct tty *tp) 2273 { 2274 2275 selnotify(&tp->t_rsel, NOTE_SUBMIT); 2276 if (ISSET(tp->t_state, TS_ASYNC)) 2277 pgsignal(tp->t_pgrp, SIGIO, 1); 2278 wakeup((caddr_t)&tp->t_rawq); 2279 } 2280 2281 /* 2282 * Look up a code for a specified speed in a conversion table; 2283 * used by drivers to map software speed values to hardware parameters. 2284 */ 2285 int 2286 ttspeedtab(int speed, const struct speedtab *table) 2287 { 2288 2289 for (; table->sp_speed != -1; table++) 2290 if (table->sp_speed == speed) 2291 return (table->sp_code); 2292 return (-1); 2293 } 2294 2295 /* 2296 * Set tty hi and low water marks. 2297 * 2298 * Try to arrange the dynamics so there's about one second 2299 * from hi to low water. 2300 */ 2301 void 2302 ttsetwater(struct tty *tp) 2303 { 2304 int cps, x; 2305 2306 #define CLAMP(x, h, l) ((x) > h ? h : ((x) < l) ? l : (x)) 2307 2308 cps = tp->t_ospeed / 10; 2309 tp->t_lowat = x = CLAMP(cps / 2, TTMAXLOWAT, TTMINLOWAT); 2310 x += cps; 2311 x = CLAMP(x, TTMAXHIWAT, TTMINHIWAT); 2312 tp->t_hiwat = roundup(x, CBSIZE); 2313 #undef CLAMP 2314 } 2315 2316 /* 2317 * Report on state of foreground process group. 2318 * Call with tty slock held. 2319 */ 2320 void 2321 ttyinfo(struct tty *tp) 2322 { 2323 struct lwp *l; 2324 struct proc *p, *pick; 2325 struct timeval utime, stime; 2326 int tmp; 2327 2328 if (ttycheckoutq_wlock(tp, 0) == 0) 2329 return; 2330 2331 /* Print load average. */ 2332 tmp = (averunnable.ldavg[0] * 100 + FSCALE / 2) >> FSHIFT; 2333 ttyprintf_nolock(tp, "load: %d.%02d ", tmp / 100, tmp % 100); 2334 2335 if (tp->t_session == NULL) 2336 ttyprintf_nolock(tp, "not a controlling terminal\n"); 2337 else if (tp->t_pgrp == NULL) 2338 ttyprintf_nolock(tp, "no foreground process group\n"); 2339 else if ((p = LIST_FIRST(&tp->t_pgrp->pg_members)) == 0) 2340 ttyprintf_nolock(tp, "empty foreground process group\n"); 2341 else { 2342 /* Pick interesting process. */ 2343 for (pick = NULL; p != NULL; p = LIST_NEXT(p, p_pglist)) 2344 if (proc_compare(pick, p)) 2345 pick = p; 2346 2347 ttyprintf_nolock(tp, " cmd: %s %d [", pick->p_comm, pick->p_pid); 2348 LIST_FOREACH(l, &pick->p_lwps, l_sibling) 2349 ttyprintf_nolock(tp, "%s%s", 2350 l->l_stat == LSONPROC ? "running" : 2351 l->l_stat == LSRUN ? "runnable" : 2352 l->l_wmesg ? l->l_wmesg : "iowait", 2353 (LIST_NEXT(l, l_sibling) != NULL) ? " " : "] "); 2354 2355 calcru(pick, &utime, &stime, NULL); 2356 2357 /* Round up and print user time. */ 2358 utime.tv_usec += 5000; 2359 if (utime.tv_usec >= 1000000) { 2360 utime.tv_sec += 1; 2361 utime.tv_usec -= 1000000; 2362 } 2363 ttyprintf_nolock(tp, "%ld.%02ldu ", (long int)utime.tv_sec, 2364 (long int)utime.tv_usec / 10000); 2365 2366 /* Round up and print system time. */ 2367 stime.tv_usec += 5000; 2368 if (stime.tv_usec >= 1000000) { 2369 stime.tv_sec += 1; 2370 stime.tv_usec -= 1000000; 2371 } 2372 ttyprintf_nolock(tp, "%ld.%02lds ", (long int)stime.tv_sec, 2373 (long int)stime.tv_usec / 10000); 2374 2375 #define pgtok(a) (((u_long) ((a) * PAGE_SIZE) / 1024)) 2376 /* Print percentage CPU. */ 2377 tmp = (pick->p_pctcpu * 10000 + FSCALE / 2) >> FSHIFT; 2378 ttyprintf_nolock(tp, "%d%% ", tmp / 100); 2379 2380 /* Print resident set size. */ 2381 if (pick->p_stat == SIDL || P_ZOMBIE(pick)) 2382 tmp = 0; 2383 else { 2384 struct vmspace *vm = pick->p_vmspace; 2385 tmp = pgtok(vm_resident_count(vm)); 2386 } 2387 ttyprintf_nolock(tp, "%dk\n", tmp); 2388 } 2389 tp->t_rocount = 0; /* so pending input will be retyped if BS */ 2390 } 2391 2392 /* 2393 * Returns 1 if p2 is "better" than p1 2394 * 2395 * The algorithm for picking the "interesting" process is thus: 2396 * 2397 * 1) Only foreground processes are eligible - implied. 2398 * 2) Runnable processes are favored over anything else. The runner 2399 * with the highest CPU utilization is picked (p_estcpu). Ties are 2400 * broken by picking the highest pid. 2401 * 3) The sleeper with the shortest sleep time is next. With ties, 2402 * we pick out just "short-term" sleepers (P_SINTR == 0). 2403 * 4) Further ties are broken by picking the highest pid. 2404 */ 2405 #define ISRUN(p) ((p)->p_nrlwps > 0) 2406 #define TESTAB(a, b) ((a)<<1 | (b)) 2407 #define ONLYA 2 2408 #define ONLYB 1 2409 #define BOTH 3 2410 2411 static int 2412 proc_compare(struct proc *p1, struct proc *p2) 2413 { 2414 2415 if (p1 == NULL) 2416 return (1); 2417 /* 2418 * see if at least one of them is runnable 2419 */ 2420 switch (TESTAB(ISRUN(p1), ISRUN(p2))) { 2421 case ONLYA: 2422 return (0); 2423 case ONLYB: 2424 return (1); 2425 case BOTH: 2426 /* 2427 * tie - favor one with highest recent CPU utilization 2428 */ 2429 if (p2->p_estcpu > p1->p_estcpu) 2430 return (1); 2431 if (p1->p_estcpu > p2->p_estcpu) 2432 return (0); 2433 return (p2->p_pid > p1->p_pid); /* tie - return highest pid */ 2434 } 2435 /* 2436 * weed out zombies 2437 */ 2438 switch (TESTAB(P_ZOMBIE(p1), P_ZOMBIE(p2))) { 2439 case ONLYA: 2440 return (1); 2441 case ONLYB: 2442 return (0); 2443 case BOTH: 2444 return (p2->p_pid > p1->p_pid); /* tie - return highest pid */ 2445 } 2446 #if 0 /* XXX NJWLWP */ 2447 /* 2448 * pick the one with the smallest sleep time 2449 */ 2450 if (p2->p_slptime > p1->p_slptime) 2451 return (0); 2452 if (p1->p_slptime > p2->p_slptime) 2453 return (1); 2454 /* 2455 * favor one sleeping in a non-interruptible sleep 2456 */ 2457 if (p1->p_flag & P_SINTR && (p2->p_flag & P_SINTR) == 0) 2458 return (1); 2459 if (p2->p_flag & P_SINTR && (p1->p_flag & P_SINTR) == 0) 2460 return (0); 2461 #endif 2462 return (p2->p_pid > p1->p_pid); /* tie - return highest pid */ 2463 } 2464 2465 /* 2466 * Output char to tty; console putchar style. 2467 * Can be called with tty lock held through kprintf() machinery.. 2468 */ 2469 int 2470 tputchar(int c, int flags, struct tty *tp) 2471 { 2472 int s, r = 0; 2473 2474 s = spltty(); 2475 if ((flags & NOLOCK) == 0) 2476 simple_lock(&tp->t_slock); 2477 if (!CONNECTED(tp)) { 2478 r = -1; 2479 goto out; 2480 } 2481 if (c == '\n') 2482 (void)ttyoutput('\r', tp); 2483 (void)ttyoutput(c, tp); 2484 ttstart(tp); 2485 out: 2486 if ((flags & NOLOCK) == 0) 2487 TTY_UNLOCK(tp); 2488 splx(s); 2489 return (r); 2490 } 2491 2492 /* 2493 * Sleep on chan, returning ERESTART if tty changed while we napped and 2494 * returning any errors (e.g. EINTR/ETIMEDOUT) reported by tsleep. If 2495 * the tty is revoked, restarting a pending call will redo validation done 2496 * at the start of the call. 2497 * 2498 * Must be called with the tty slock held. 2499 */ 2500 int 2501 ttysleep(struct tty *tp, void *chan, int pri, const char *wmesg, int timo) 2502 { 2503 int error; 2504 short gen; 2505 2506 gen = tp->t_gen; 2507 if ((error = ltsleep(chan, pri, wmesg, timo, &tp->t_slock)) != 0) 2508 return (error); 2509 return (tp->t_gen == gen ? 0 : ERESTART); 2510 } 2511 2512 /* 2513 * Initialise the global tty list. 2514 */ 2515 void 2516 tty_init(void) 2517 { 2518 2519 ttyldisc_init(); 2520 } 2521 2522 /* 2523 * Attach a tty to the tty list. 2524 * 2525 * This should be called ONLY once per real tty (including pty's). 2526 * eg, on the sparc, the keyboard and mouse have struct tty's that are 2527 * distinctly NOT usable as tty's, and thus should not be attached to 2528 * the ttylist. This is why this call is not done from ttymalloc(). 2529 * 2530 * Device drivers should attach tty's at a similar time that they are 2531 * ttymalloc()'ed, or, for the case of statically allocated struct tty's 2532 * either in the attach or (first) open routine. 2533 */ 2534 void 2535 tty_attach(struct tty *tp) 2536 { 2537 2538 simple_lock(&ttylist_slock); 2539 TAILQ_INSERT_TAIL(&ttylist, tp, tty_link); 2540 ++tty_count; 2541 simple_unlock(&ttylist_slock); 2542 } 2543 2544 /* 2545 * Remove a tty from the tty list. 2546 */ 2547 void 2548 tty_detach(struct tty *tp) 2549 { 2550 2551 simple_lock(&ttylist_slock); 2552 --tty_count; 2553 #ifdef DIAGNOSTIC 2554 if (tty_count < 0) 2555 panic("tty_detach: tty_count < 0"); 2556 #endif 2557 TAILQ_REMOVE(&ttylist, tp, tty_link); 2558 simple_unlock(&ttylist_slock); 2559 } 2560 2561 /* 2562 * Allocate a tty structure and its associated buffers. 2563 */ 2564 struct tty * 2565 ttymalloc(void) 2566 { 2567 struct tty *tp; 2568 2569 tp = pool_get(&tty_pool, PR_WAITOK); 2570 memset(tp, 0, sizeof(*tp)); 2571 simple_lock_init(&tp->t_slock); 2572 callout_init(&tp->t_rstrt_ch); 2573 /* XXX: default to 1024 chars for now */ 2574 clalloc(&tp->t_rawq, 1024, 1); 2575 clalloc(&tp->t_canq, 1024, 1); 2576 /* output queue doesn't need quoting */ 2577 clalloc(&tp->t_outq, 1024, 0); 2578 /* Set default line discipline. */ 2579 tp->t_linesw = linesw[0]; 2580 return (tp); 2581 } 2582 2583 /* 2584 * Free a tty structure and its buffers. 2585 * 2586 * Be sure to call tty_detach() for any tty that has been 2587 * tty_attach()ed. 2588 */ 2589 void 2590 ttyfree(struct tty *tp) 2591 { 2592 2593 callout_stop(&tp->t_rstrt_ch); 2594 clfree(&tp->t_rawq); 2595 clfree(&tp->t_canq); 2596 clfree(&tp->t_outq); 2597 pool_put(&tty_pool, tp); 2598 } 2599 2600 /* 2601 * ttyprintf_nolock: send a message to a specific tty, without locking. 2602 * 2603 * => should be used only by tty driver or anything that knows the 2604 * underlying tty will not be revoked(2)'d away. [otherwise, 2605 * use tprintf] 2606 */ 2607 static void 2608 ttyprintf_nolock(struct tty *tp, const char *fmt, ...) 2609 { 2610 va_list ap; 2611 2612 /* No mutex needed; going to process TTY. */ 2613 va_start(ap, fmt); 2614 kprintf(fmt, TOTTY|NOLOCK, tp, NULL, ap); 2615 va_end(ap); 2616 } 2617