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