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