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