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