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