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