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