tty.c revision 1.292
1 /* $NetBSD: tty.c,v 1.292 2020/10/10 15:59:41 christos Exp $ */ 2 3 /*- 4 * Copyright (c) 2008, 2020 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.292 2020/10/10 15:59:41 christos 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 if (newsize <= 0) 230 return EINVAL; 231 232 newsize = 1 << ilog2(newsize); /* Make it a power of two */ 233 234 if (newsize < TTY_MINQSIZE || newsize > TTY_MAXQSIZE) 235 return EINVAL; 236 237 *qsize = newsize; 238 return 0; 239 } 240 241 static int 242 tty_set_qsize(struct tty *tp, int newsize) 243 { 244 struct clist rawq, canq, outq; 245 struct clist orawq, ocanq, ooutq; 246 247 clalloc(&rawq, newsize, 1); 248 clalloc(&canq, newsize, 1); 249 clalloc(&outq, newsize, 0); 250 251 mutex_spin_enter(&tty_lock); 252 253 if (tp->t_outq.c_cc != 0) { 254 mutex_spin_exit(&tty_lock); 255 clfree(&rawq); 256 clfree(&canq); 257 clfree(&outq); 258 return EBUSY; 259 } 260 261 orawq = tp->t_rawq; 262 ocanq = tp->t_canq; 263 ooutq = tp->t_outq; 264 265 tp->t_qsize = newsize; 266 tp->t_rawq = rawq; 267 tp->t_canq = canq; 268 tp->t_outq = outq; 269 270 ttsetwater(tp); 271 272 mutex_spin_exit(&tty_lock); 273 274 clfree(&orawq); 275 clfree(&ocanq); 276 clfree(&ooutq); 277 278 return 0; 279 } 280 281 static int 282 sysctl_kern_tty_qsize(SYSCTLFN_ARGS) 283 { 284 int newsize; 285 int error; 286 struct sysctlnode node; 287 node = *rnode; 288 node.sysctl_data = &newsize; 289 290 newsize = tty_qsize; 291 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 292 if (error || newp == NULL) 293 return error; 294 295 296 return tty_get_qsize(&tty_qsize, newsize); 297 } 298 299 static void 300 sysctl_kern_tty_setup(void) 301 { 302 const struct sysctlnode *rnode, *cnode; 303 304 sysctl_createv(NULL, 0, NULL, NULL, 305 CTLFLAG_PERMANENT, 306 CTLTYPE_NODE, "tkstat", 307 SYSCTL_DESCR("Number of characters sent and received " 308 "on ttys"), 309 NULL, 0, NULL, 0, 310 CTL_KERN, KERN_TKSTAT, CTL_EOL); 311 312 sysctl_createv(NULL, 0, NULL, NULL, 313 CTLFLAG_PERMANENT, 314 CTLTYPE_QUAD, "nin", 315 SYSCTL_DESCR("Total number of tty input characters"), 316 NULL, 0, &tk_nin, 0, 317 CTL_KERN, KERN_TKSTAT, KERN_TKSTAT_NIN, CTL_EOL); 318 sysctl_createv(NULL, 0, NULL, NULL, 319 CTLFLAG_PERMANENT, 320 CTLTYPE_QUAD, "nout", 321 SYSCTL_DESCR("Total number of tty output characters"), 322 NULL, 0, &tk_nout, 0, 323 CTL_KERN, KERN_TKSTAT, KERN_TKSTAT_NOUT, CTL_EOL); 324 sysctl_createv(NULL, 0, NULL, NULL, 325 CTLFLAG_PERMANENT, 326 CTLTYPE_QUAD, "cancc", 327 SYSCTL_DESCR("Number of canonical tty input characters"), 328 NULL, 0, &tk_cancc, 0, 329 CTL_KERN, KERN_TKSTAT, KERN_TKSTAT_CANCC, CTL_EOL); 330 sysctl_createv(NULL, 0, NULL, NULL, 331 CTLFLAG_PERMANENT, 332 CTLTYPE_QUAD, "rawcc", 333 SYSCTL_DESCR("Number of raw tty input characters"), 334 NULL, 0, &tk_rawcc, 0, 335 CTL_KERN, KERN_TKSTAT, KERN_TKSTAT_RAWCC, CTL_EOL); 336 337 sysctl_createv(NULL, 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(NULL, 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 case TIOCGSID: 1381 mutex_enter(&proc_lock); 1382 if (tp->t_session == NULL) { 1383 mutex_exit(&proc_lock); 1384 return ENOTTY; 1385 } 1386 if (tp->t_session->s_leader == NULL) { 1387 mutex_exit(&proc_lock); 1388 return ENOTTY; 1389 } 1390 *(int *) data = tp->t_session->s_leader->p_pid; 1391 mutex_exit(&proc_lock); 1392 break; 1393 1394 case TIOCSBRK: 1395 case TIOCCBRK: 1396 case TIOCSDTR: 1397 case TIOCCDTR: 1398 case TIOCSFLAGS: 1399 case TIOCGFLAGS: 1400 case TIOCMSET: 1401 case TIOCMGET: 1402 case TIOCMBIS: 1403 case TIOCMBIC: 1404 /* Handled by the driver layer */ 1405 return EPASSTHROUGH; 1406 1407 case TIOCEXT: 1408 case TIOCPTSNAME: 1409 case TIOCGRANTPT: 1410 case TIOCPKT: 1411 case TIOCUCNTL: 1412 case TIOCREMOTE: 1413 case TIOCSIG: 1414 /* for ptys */ 1415 return EPASSTHROUGH; 1416 1417 default: 1418 /* Pass through various console ioctls */ 1419 switch (IOCGROUP(cmd)) { 1420 case 'c': /* syscons console */ 1421 case 'v': /* usl console, video - where one letter */ 1422 case 'K': /* usl console, keyboard - aint enough */ 1423 case 'V': /* pcvt compat */ 1424 case 'W': /* wscons console */ 1425 return EPASSTHROUGH; 1426 default: 1427 break; 1428 } 1429 1430 /* We may have to load the compat_60 module for this. */ 1431 (void)module_autoload("compat_60", MODULE_CLASS_EXEC); 1432 MODULE_HOOK_CALL(tty_ttioctl_60_hook, 1433 (tp, cmd, data, flag, l), enosys(), error); 1434 if (error != EPASSTHROUGH) 1435 return error; 1436 1437 /* We may have to load the compat_43 module for this. */ 1438 (void)module_autoload("compat_43", MODULE_CLASS_EXEC); 1439 MODULE_HOOK_CALL(tty_ttioctl_43_hook, 1440 (tp, cmd, data, flag, l), enosys(), error); 1441 return error; 1442 } 1443 return (0); 1444 } 1445 1446 int 1447 ttpoll(struct tty *tp, int events, struct lwp *l) 1448 { 1449 int revents; 1450 1451 revents = 0; 1452 mutex_spin_enter(&tty_lock); 1453 if (events & (POLLIN | POLLRDNORM)) 1454 if (ttnread(tp) > 0) 1455 revents |= events & (POLLIN | POLLRDNORM); 1456 1457 if (events & (POLLOUT | POLLWRNORM)) 1458 if (tp->t_outq.c_cc <= tp->t_lowat) 1459 revents |= events & (POLLOUT | POLLWRNORM); 1460 1461 if (events & POLLHUP) 1462 if (!CONNECTED(tp)) 1463 revents |= POLLHUP; 1464 1465 if (revents == 0) { 1466 if (events & (POLLIN | POLLHUP | POLLRDNORM)) 1467 selrecord(l, &tp->t_rsel); 1468 1469 if (events & (POLLOUT | POLLWRNORM)) 1470 selrecord(l, &tp->t_wsel); 1471 } 1472 1473 mutex_spin_exit(&tty_lock); 1474 1475 return (revents); 1476 } 1477 1478 static void 1479 filt_ttyrdetach(struct knote *kn) 1480 { 1481 struct tty *tp; 1482 1483 tp = kn->kn_hook; 1484 mutex_spin_enter(&tty_lock); 1485 SLIST_REMOVE(&tp->t_rsel.sel_klist, kn, knote, kn_selnext); 1486 mutex_spin_exit(&tty_lock); 1487 } 1488 1489 static int 1490 filt_ttyread(struct knote *kn, long hint) 1491 { 1492 struct tty *tp; 1493 1494 tp = kn->kn_hook; 1495 if ((hint & NOTE_SUBMIT) == 0) 1496 mutex_spin_enter(&tty_lock); 1497 kn->kn_data = ttnread(tp); 1498 if ((hint & NOTE_SUBMIT) == 0) 1499 mutex_spin_exit(&tty_lock); 1500 return (kn->kn_data > 0); 1501 } 1502 1503 static void 1504 filt_ttywdetach(struct knote *kn) 1505 { 1506 struct tty *tp; 1507 1508 tp = kn->kn_hook; 1509 mutex_spin_enter(&tty_lock); 1510 SLIST_REMOVE(&tp->t_wsel.sel_klist, kn, knote, kn_selnext); 1511 mutex_spin_exit(&tty_lock); 1512 } 1513 1514 static int 1515 filt_ttywrite(struct knote *kn, long hint) 1516 { 1517 struct tty *tp; 1518 int canwrite; 1519 1520 tp = kn->kn_hook; 1521 if ((hint & NOTE_SUBMIT) == 0) 1522 mutex_spin_enter(&tty_lock); 1523 kn->kn_data = tp->t_outq.c_cn - tp->t_outq.c_cc; 1524 canwrite = (tp->t_outq.c_cc <= tp->t_lowat) && CONNECTED(tp); 1525 if ((hint & NOTE_SUBMIT) == 0) 1526 mutex_spin_exit(&tty_lock); 1527 return (canwrite); 1528 } 1529 1530 static const struct filterops ttyread_filtops = { 1531 .f_isfd = 1, 1532 .f_attach = NULL, 1533 .f_detach = filt_ttyrdetach, 1534 .f_event = filt_ttyread, 1535 }; 1536 1537 static const struct filterops ttywrite_filtops = { 1538 .f_isfd = 1, 1539 .f_attach = NULL, 1540 .f_detach = filt_ttywdetach, 1541 .f_event = filt_ttywrite, 1542 }; 1543 1544 int 1545 ttykqfilter(dev_t dev, struct knote *kn) 1546 { 1547 struct tty *tp; 1548 struct klist *klist; 1549 1550 if ((tp = cdev_tty(dev)) == NULL) 1551 return (ENXIO); 1552 1553 switch (kn->kn_filter) { 1554 case EVFILT_READ: 1555 klist = &tp->t_rsel.sel_klist; 1556 kn->kn_fop = &ttyread_filtops; 1557 break; 1558 case EVFILT_WRITE: 1559 klist = &tp->t_wsel.sel_klist; 1560 kn->kn_fop = &ttywrite_filtops; 1561 break; 1562 default: 1563 return EINVAL; 1564 } 1565 1566 kn->kn_hook = tp; 1567 1568 mutex_spin_enter(&tty_lock); 1569 SLIST_INSERT_HEAD(klist, kn, kn_selnext); 1570 mutex_spin_exit(&tty_lock); 1571 1572 return (0); 1573 } 1574 1575 /* 1576 * Find the number of chars ready to be read from this tty. 1577 * Call with the tty lock held. 1578 */ 1579 static int 1580 ttnread(struct tty *tp) 1581 { 1582 int nread; 1583 1584 KASSERT(mutex_owned(&tty_lock)); 1585 1586 if (ISSET(tp->t_lflag, PENDIN)) 1587 ttypend(tp); 1588 nread = tp->t_canq.c_cc; 1589 if (!ISSET(tp->t_lflag, ICANON)) { 1590 nread += tp->t_rawq.c_cc; 1591 if (nread < tp->t_cc[VMIN] && !tp->t_cc[VTIME]) 1592 nread = 0; 1593 } 1594 return (nread); 1595 } 1596 1597 /* 1598 * Wait for output to drain, or if this times out, flush it. 1599 */ 1600 static int 1601 ttywait_timo(struct tty *tp, int timo) 1602 { 1603 int error; 1604 1605 error = 0; 1606 1607 mutex_spin_enter(&tty_lock); 1608 while ((tp->t_outq.c_cc || ISSET(tp->t_state, TS_BUSY)) && 1609 CONNECTED(tp) && tp->t_oproc) { 1610 (*tp->t_oproc)(tp); 1611 error = ttysleep(tp, &tp->t_outcv, true, timo); 1612 if (error == EWOULDBLOCK) 1613 ttyflush(tp, FWRITE); 1614 if (error) 1615 break; 1616 } 1617 mutex_spin_exit(&tty_lock); 1618 1619 return (error); 1620 } 1621 1622 /* 1623 * Wait for output to drain. 1624 */ 1625 int 1626 ttywait(struct tty *tp) 1627 { 1628 return ttywait_timo(tp, 0); 1629 } 1630 1631 /* 1632 * Flush if successfully wait. 1633 */ 1634 int 1635 ttywflush(struct tty *tp) 1636 { 1637 int error; 1638 1639 error = ttywait_timo(tp, 5 * hz); 1640 if (error == 0 || error == EWOULDBLOCK) { 1641 mutex_spin_enter(&tty_lock); 1642 ttyflush(tp, FREAD); 1643 mutex_spin_exit(&tty_lock); 1644 } 1645 return (error); 1646 } 1647 1648 /* 1649 * Flush tty read and/or write queues, notifying anyone waiting. 1650 * Call with the tty lock held. 1651 */ 1652 void 1653 ttyflush(struct tty *tp, int rw) 1654 { 1655 1656 KASSERT(mutex_owned(&tty_lock)); 1657 1658 if (rw & FREAD) { 1659 FLUSHQ(&tp->t_canq); 1660 FLUSHQ(&tp->t_rawq); 1661 tp->t_rocount = 0; 1662 tp->t_rocol = 0; 1663 CLR(tp->t_state, TS_LOCAL); 1664 ttwakeup(tp); 1665 } 1666 if (rw & FWRITE) { 1667 CLR(tp->t_state, TS_TTSTOP); 1668 cdev_stop(tp, rw); 1669 FLUSHQ(&tp->t_outq); 1670 cv_broadcast(&tp->t_outcv); 1671 selnotify(&tp->t_wsel, 0, NOTE_SUBMIT); 1672 } 1673 } 1674 1675 /* 1676 * Copy in the default termios characters. 1677 */ 1678 void 1679 ttychars(struct tty *tp) 1680 { 1681 1682 memcpy(tp->t_cc, ttydefchars, sizeof(ttydefchars)); 1683 } 1684 1685 /* 1686 * Send stop character on input overflow. 1687 * Call with the tty lock held. 1688 */ 1689 static void 1690 ttyblock(struct tty *tp) 1691 { 1692 int total; 1693 1694 KASSERT(mutex_owned(&tty_lock)); 1695 1696 total = tp->t_rawq.c_cc + tp->t_canq.c_cc; 1697 if (tp->t_rawq.c_cc > TTYHOG) { 1698 ttyflush(tp, FREAD | FWRITE); 1699 CLR(tp->t_state, TS_TBLOCK); 1700 } 1701 /* 1702 * Block further input iff: current input > threshold 1703 * AND input is available to user program. 1704 */ 1705 if (total >= TTYHOG / 2 && 1706 !ISSET(tp->t_state, TS_TBLOCK) && 1707 (!ISSET(tp->t_lflag, ICANON) || tp->t_canq.c_cc > 0)) { 1708 if (ISSET(tp->t_iflag, IXOFF) && 1709 tp->t_cc[VSTOP] != _POSIX_VDISABLE && 1710 putc(tp->t_cc[VSTOP], &tp->t_outq) == 0) { 1711 SET(tp->t_state, TS_TBLOCK); 1712 ttstart(tp); 1713 } 1714 /* Try to block remote output via hardware flow control. */ 1715 if (ISSET(tp->t_cflag, CHWFLOW) && tp->t_hwiflow && 1716 (*tp->t_hwiflow)(tp, 1) != 0) 1717 SET(tp->t_state, TS_TBLOCK); 1718 } 1719 } 1720 1721 /* 1722 * Delayed line discipline output 1723 */ 1724 void 1725 ttrstrt(void *tp_arg) 1726 { 1727 struct tty *tp; 1728 1729 #ifdef DIAGNOSTIC 1730 if (tp_arg == NULL) 1731 panic("ttrstrt"); 1732 #endif 1733 tp = tp_arg; 1734 mutex_spin_enter(&tty_lock); 1735 1736 CLR(tp->t_state, TS_TIMEOUT); 1737 ttstart(tp); /* XXX - Shouldn't this be tp->l_start(tp)? */ 1738 1739 mutex_spin_exit(&tty_lock); 1740 } 1741 1742 /* 1743 * start a line discipline 1744 * Always call with tty lock held? 1745 */ 1746 int 1747 ttstart(struct tty *tp) 1748 { 1749 1750 if (tp->t_oproc != NULL) /* XXX: Kludge for pty. */ 1751 (*tp->t_oproc)(tp); 1752 return (0); 1753 } 1754 1755 /* 1756 * "close" a line discipline 1757 */ 1758 int 1759 ttylclose(struct tty *tp, int flag) 1760 { 1761 1762 if (flag & FNONBLOCK) { 1763 mutex_spin_enter(&tty_lock); 1764 ttyflush(tp, FREAD | FWRITE); 1765 mutex_spin_exit(&tty_lock); 1766 } else 1767 ttywflush(tp); 1768 return (0); 1769 } 1770 1771 /* 1772 * Handle modem control transition on a tty. 1773 * Flag indicates new state of carrier. 1774 * Returns 0 if the line should be turned off, otherwise 1. 1775 */ 1776 int 1777 ttymodem(struct tty *tp, int flag) 1778 { 1779 1780 mutex_spin_enter(&tty_lock); 1781 if (flag == 0) { 1782 if (ISSET(tp->t_state, TS_CARR_ON)) { 1783 /* 1784 * Lost carrier. 1785 */ 1786 CLR(tp->t_state, TS_CARR_ON); 1787 if (ISSET(tp->t_state, TS_ISOPEN) && !CONNECTED(tp)) { 1788 ttysig(tp, TTYSIG_LEADER, SIGHUP); 1789 ttyflush(tp, FREAD | FWRITE); 1790 mutex_spin_exit(&tty_lock); 1791 return (0); 1792 } 1793 } 1794 } else { 1795 if (!ISSET(tp->t_state, TS_CARR_ON)) { 1796 /* 1797 * Carrier now on. 1798 */ 1799 SET(tp->t_state, TS_CARR_ON); 1800 ttwakeup(tp); 1801 } 1802 } 1803 mutex_spin_exit(&tty_lock); 1804 1805 return (1); 1806 } 1807 1808 /* 1809 * Default modem control routine (for other line disciplines). 1810 * Return argument flag, to turn off device on carrier drop. 1811 */ 1812 int 1813 nullmodem(struct tty *tp, int flag) 1814 { 1815 1816 mutex_spin_enter(&tty_lock); 1817 if (flag) 1818 SET(tp->t_state, TS_CARR_ON); 1819 else { 1820 CLR(tp->t_state, TS_CARR_ON); 1821 if (!CONNECTED(tp)) { 1822 ttysig(tp, TTYSIG_LEADER, SIGHUP); 1823 mutex_spin_exit(&tty_lock); 1824 return (0); 1825 } 1826 } 1827 mutex_spin_exit(&tty_lock); 1828 1829 return (1); 1830 } 1831 1832 /* 1833 * Reinput pending characters after state switch. 1834 */ 1835 void 1836 ttypend(struct tty *tp) 1837 { 1838 struct clist tq; 1839 int c; 1840 1841 KASSERT(mutex_owned(&tty_lock)); 1842 1843 CLR(tp->t_lflag, PENDIN); 1844 SET(tp->t_state, TS_TYPEN); 1845 tq = tp->t_rawq; 1846 tp->t_rawq.c_cc = 0; 1847 tp->t_rawq.c_cf = tp->t_rawq.c_cl = 0; 1848 while ((c = getc(&tq)) >= 0) 1849 ttyinput_wlock(c, tp); 1850 CLR(tp->t_state, TS_TYPEN); 1851 } 1852 1853 /* 1854 * Process a read call on a tty device. 1855 */ 1856 int 1857 ttread(struct tty *tp, struct uio *uio, int flag) 1858 { 1859 struct clist *qp; 1860 u_char *cc; 1861 struct proc *p; 1862 int c, first, error, has_stime, last_cc; 1863 long lflag, slp; 1864 struct timeval now, stime; 1865 1866 if (uio->uio_resid == 0) 1867 return 0; 1868 1869 stime.tv_usec = 0; /* XXX gcc */ 1870 stime.tv_sec = 0; /* XXX gcc */ 1871 1872 cc = tp->t_cc; 1873 p = curproc; 1874 error = 0; 1875 has_stime = 0; 1876 last_cc = 0; 1877 slp = 0; 1878 1879 loop: 1880 mutex_spin_enter(&tty_lock); 1881 lflag = tp->t_lflag; 1882 /* 1883 * take pending input first 1884 */ 1885 if (ISSET(lflag, PENDIN)) 1886 ttypend(tp); 1887 1888 /* 1889 * Hang process if it's in the background. 1890 */ 1891 if (isbackground(p, tp)) { 1892 if (sigismasked(curlwp, SIGTTIN) || 1893 p->p_lflag & PL_PPWAIT || p->p_pgrp->pg_jobc == 0) { 1894 mutex_spin_exit(&tty_lock); 1895 return (EIO); 1896 } 1897 mutex_spin_exit(&tty_lock); 1898 1899 mutex_enter(&proc_lock); 1900 pgsignal(p->p_pgrp, SIGTTIN, 1); 1901 mutex_exit(&proc_lock); 1902 1903 mutex_spin_enter(&tty_lock); 1904 error = ttypause(tp, hz); 1905 mutex_spin_exit(&tty_lock); 1906 if (error) 1907 return (error); 1908 goto loop; 1909 } 1910 1911 if (!ISSET(lflag, ICANON)) { 1912 int m = cc[VMIN]; 1913 long t = cc[VTIME]; 1914 1915 qp = &tp->t_rawq; 1916 /* 1917 * Check each of the four combinations. 1918 * (m > 0 && t == 0) is the normal read case. 1919 * It should be fairly efficient, so we check that and its 1920 * companion case (m == 0 && t == 0) first. 1921 * For the other two cases, we compute the target sleep time 1922 * into slp. 1923 */ 1924 if (t == 0) { 1925 if (qp->c_cc < m) 1926 goto sleep; 1927 goto read; 1928 } 1929 t *= hz; /* time in deca-ticks */ 1930 /* 1931 * Time difference in deca-ticks, split division to avoid numeric overflow. 1932 * Ok for hz < ~200kHz 1933 */ 1934 #define diff(t1, t2) (((t1).tv_sec - (t2).tv_sec) * 10 * hz + \ 1935 ((t1).tv_usec - (t2).tv_usec) / 100 * hz / 1000) 1936 if (m > 0) { 1937 if (qp->c_cc <= 0) 1938 goto sleep; 1939 if (qp->c_cc >= m) 1940 goto read; 1941 if (!has_stime) { 1942 /* first character, start timer */ 1943 has_stime = 1; 1944 getmicrotime(&stime); 1945 slp = t; 1946 } else if (qp->c_cc > last_cc) { 1947 /* got a character, restart timer */ 1948 getmicrotime(&stime); 1949 slp = t; 1950 } else { 1951 /* nothing, check expiration */ 1952 getmicrotime(&now); 1953 slp = t - diff(now, stime); 1954 } 1955 } else { /* m == 0 */ 1956 if (qp->c_cc > 0) 1957 goto read; 1958 if (!has_stime) { 1959 has_stime = 1; 1960 getmicrotime(&stime); 1961 slp = t; 1962 } else { 1963 getmicrotime(&now); 1964 slp = t - diff(now, stime); 1965 } 1966 } 1967 last_cc = qp->c_cc; 1968 #undef diff 1969 if (slp > 0) { 1970 /* 1971 * Convert deca-ticks back to ticks. 1972 * Rounding down may make us wake up just short 1973 * of the target, so we round up. 1974 * Maybe we should do 'slp/10 + 1' because the 1975 * first tick maybe almost immediate. 1976 * However it is more useful for a program that sets 1977 * VTIME=10 to wakeup every second not every 1.01 1978 * seconds (if hz=100). 1979 */ 1980 slp = (slp + 9)/ 10; 1981 goto sleep; 1982 } 1983 } else if ((qp = &tp->t_canq)->c_cc <= 0) { 1984 int carrier; 1985 1986 sleep: 1987 /* 1988 * If there is no input, sleep on rawq 1989 * awaiting hardware receipt and notification. 1990 * If we have data, we don't need to check for carrier. 1991 */ 1992 carrier = CONNECTED(tp); 1993 if (!carrier && ISSET(tp->t_state, TS_ISOPEN)) { 1994 mutex_spin_exit(&tty_lock); 1995 return (0); /* EOF */ 1996 } 1997 if (!has_stime || slp <= 0) { 1998 if (flag & IO_NDELAY) { 1999 mutex_spin_exit(&tty_lock); 2000 return (EWOULDBLOCK); 2001 } 2002 } 2003 error = ttysleep(tp, &tp->t_rawcv, true, slp); 2004 mutex_spin_exit(&tty_lock); 2005 /* VMIN == 0: any quantity read satisfies */ 2006 if (cc[VMIN] == 0 && error == EWOULDBLOCK) 2007 return (0); 2008 if (error && error != EWOULDBLOCK) 2009 return (error); 2010 goto loop; 2011 } 2012 read: 2013 2014 /* 2015 * Input present, check for input mapping and processing. 2016 */ 2017 first = 1; 2018 while ((c = getc(qp)) >= 0) { 2019 /* 2020 * delayed suspend (^Y) 2021 */ 2022 if (CCEQ(cc[VDSUSP], c) && 2023 ISSET(lflag, IEXTEN|ISIG) == (IEXTEN|ISIG)) { 2024 ttysig(tp, TTYSIG_PG1, SIGTSTP); 2025 if (first) { 2026 error = ttypause(tp, hz); 2027 if (error) 2028 break; 2029 mutex_spin_exit(&tty_lock); 2030 goto loop; 2031 } 2032 break; 2033 } 2034 /* 2035 * Interpret EOF only in canonical mode. 2036 */ 2037 if (CCEQ(cc[VEOF], c) && ISSET(lflag, ICANON)) 2038 break; 2039 /* 2040 * Give user character. 2041 */ 2042 mutex_spin_exit(&tty_lock); 2043 error = ureadc(c, uio); 2044 mutex_spin_enter(&tty_lock); 2045 if (error) 2046 break; 2047 if (uio->uio_resid == 0) 2048 break; 2049 /* 2050 * In canonical mode check for a "break character" 2051 * marking the end of a "line of input". 2052 */ 2053 if (ISSET(lflag, ICANON) && TTBREAKC(c, lflag)) 2054 break; 2055 first = 0; 2056 } 2057 2058 /* 2059 * Look to unblock output now that (presumably) 2060 * the input queue has gone down. 2061 */ 2062 if (ISSET(tp->t_state, TS_TBLOCK) && tp->t_rawq.c_cc < TTYHOG / 5) { 2063 if (ISSET(tp->t_iflag, IXOFF) && 2064 cc[VSTART] != _POSIX_VDISABLE && 2065 putc(cc[VSTART], &tp->t_outq) == 0) { 2066 CLR(tp->t_state, TS_TBLOCK); 2067 ttstart(tp); 2068 } 2069 /* Try to unblock remote output via hardware flow control. */ 2070 if (ISSET(tp->t_cflag, CHWFLOW) && tp->t_hwiflow && 2071 (*tp->t_hwiflow)(tp, 0) != 0) 2072 CLR(tp->t_state, TS_TBLOCK); 2073 } 2074 mutex_spin_exit(&tty_lock); 2075 2076 return (error); 2077 } 2078 2079 /* 2080 * Check the output queue on tp for space for a kernel message (from uprintf 2081 * or tprintf). Allow some space over the normal hiwater mark so we don't 2082 * lose messages due to normal flow control, but don't let the tty run amok. 2083 * Sleeps here are not interruptible, but we return prematurely if new signals 2084 * arrive. 2085 * Call with tty lock held. 2086 */ 2087 static int 2088 ttycheckoutq_wlock(struct tty *tp, int wait) 2089 { 2090 int hiwat, error; 2091 2092 KASSERT(mutex_owned(&tty_lock)); 2093 2094 hiwat = tp->t_hiwat; 2095 if (tp->t_outq.c_cc > hiwat + 200) 2096 while (tp->t_outq.c_cc > hiwat) { 2097 ttstart(tp); 2098 if (wait == 0) 2099 return (0); 2100 error = ttysleep(tp, &tp->t_outcv, true, hz); 2101 if (error == EINTR) 2102 wait = 0; 2103 } 2104 2105 return (1); 2106 } 2107 2108 int 2109 ttycheckoutq(struct tty *tp, int wait) 2110 { 2111 int r; 2112 2113 mutex_spin_enter(&tty_lock); 2114 r = ttycheckoutq_wlock(tp, wait); 2115 mutex_spin_exit(&tty_lock); 2116 2117 return (r); 2118 } 2119 2120 /* 2121 * Process a write call on a tty device. 2122 */ 2123 int 2124 ttwrite(struct tty *tp, struct uio *uio, int flag) 2125 { 2126 u_char *cp; 2127 struct proc *p; 2128 int cc, ce, i, hiwat, error; 2129 u_char obuf[OBUFSIZ]; 2130 2131 cp = NULL; 2132 hiwat = tp->t_hiwat; 2133 error = 0; 2134 cc = 0; 2135 loop: 2136 mutex_spin_enter(&tty_lock); 2137 if (!CONNECTED(tp)) { 2138 if (ISSET(tp->t_state, TS_ISOPEN)) { 2139 mutex_spin_exit(&tty_lock); 2140 return (EIO); 2141 } else if (flag & IO_NDELAY) { 2142 mutex_spin_exit(&tty_lock); 2143 error = EWOULDBLOCK; 2144 goto out; 2145 } else { 2146 /* Sleep awaiting carrier. */ 2147 error = ttysleep(tp, &tp->t_rawcv, true, 0); 2148 mutex_spin_exit(&tty_lock); 2149 if (error) 2150 goto out; 2151 goto loop; 2152 } 2153 } 2154 2155 /* 2156 * Hang the process if it's in the background. 2157 */ 2158 p = curproc; 2159 if (isbackground(p, tp) && 2160 ISSET(tp->t_lflag, TOSTOP) && (p->p_lflag & PL_PPWAIT) == 0 && 2161 !sigismasked(curlwp, SIGTTOU)) { 2162 if (p->p_pgrp->pg_jobc == 0) { 2163 error = EIO; 2164 mutex_spin_exit(&tty_lock); 2165 goto out; 2166 } 2167 mutex_spin_exit(&tty_lock); 2168 2169 mutex_enter(&proc_lock); 2170 pgsignal(p->p_pgrp, SIGTTOU, 1); 2171 mutex_exit(&proc_lock); 2172 2173 mutex_spin_enter(&tty_lock); 2174 error = ttypause(tp, hz); 2175 mutex_spin_exit(&tty_lock); 2176 if (error) 2177 goto out; 2178 goto loop; 2179 } 2180 mutex_spin_exit(&tty_lock); 2181 2182 /* 2183 * Process the user's data in at most OBUFSIZ chunks. Perform any 2184 * output translation. Keep track of high water mark, sleep on 2185 * overflow awaiting device aid in acquiring new space. 2186 */ 2187 while (uio->uio_resid > 0 || cc > 0) { 2188 if (ISSET(tp->t_lflag, FLUSHO)) { 2189 uio->uio_resid = 0; 2190 return (0); 2191 } 2192 if (tp->t_outq.c_cc > hiwat) 2193 goto ovhiwat; 2194 /* 2195 * Grab a hunk of data from the user, unless we have some 2196 * leftover from last time. 2197 */ 2198 if (cc == 0) { 2199 cc = uimin(uio->uio_resid, OBUFSIZ); 2200 cp = obuf; 2201 error = uiomove(cp, cc, uio); 2202 if (error) { 2203 cc = 0; 2204 goto out; 2205 } 2206 } 2207 /* 2208 * If nothing fancy need be done, grab those characters we 2209 * can handle without any of ttyoutput's processing and 2210 * just transfer them to the output q. For those chars 2211 * which require special processing (as indicated by the 2212 * bits in char_type), call ttyoutput. After processing 2213 * a hunk of data, look for FLUSHO so ^O's will take effect 2214 * immediately. 2215 */ 2216 mutex_spin_enter(&tty_lock); 2217 while (cc > 0) { 2218 if (!ISSET(tp->t_oflag, OPOST)) 2219 ce = cc; 2220 else { 2221 ce = cc - scanc((u_int)cc, cp, char_type, 2222 CCLASSMASK); 2223 /* 2224 * If ce is zero, then we're processing 2225 * a special character through ttyoutput. 2226 */ 2227 if (ce == 0) { 2228 tp->t_rocount = 0; 2229 if (ttyoutput(*cp, tp) >= 0) { 2230 /* out of space */ 2231 mutex_spin_exit(&tty_lock); 2232 goto overfull; 2233 } 2234 cp++; 2235 cc--; 2236 if (ISSET(tp->t_lflag, FLUSHO) || 2237 tp->t_outq.c_cc > hiwat) { 2238 mutex_spin_exit(&tty_lock); 2239 goto ovhiwat; 2240 } 2241 continue; 2242 } 2243 } 2244 /* 2245 * A bunch of normal characters have been found. 2246 * Transfer them en masse to the output queue and 2247 * continue processing at the top of the loop. 2248 * If there are any further characters in this 2249 * <= OBUFSIZ chunk, the first should be a character 2250 * requiring special handling by ttyoutput. 2251 */ 2252 tp->t_rocount = 0; 2253 i = b_to_q(cp, ce, &tp->t_outq); 2254 ce -= i; 2255 tp->t_column += ce; 2256 cp += ce, cc -= ce, tk_nout += ce; 2257 tp->t_outcc += ce; 2258 if (i > 0) { 2259 /* out of space */ 2260 mutex_spin_exit(&tty_lock); 2261 goto overfull; 2262 } 2263 if (ISSET(tp->t_lflag, FLUSHO) || 2264 tp->t_outq.c_cc > hiwat) 2265 break; 2266 } 2267 ttstart(tp); 2268 mutex_spin_exit(&tty_lock); 2269 } 2270 2271 out: 2272 /* 2273 * If cc is nonzero, we leave the uio structure inconsistent, as the 2274 * offset and iov pointers have moved forward, but it doesn't matter 2275 * (the call will either return short or restart with a new uio). 2276 */ 2277 uio->uio_resid += cc; 2278 return (error); 2279 2280 overfull: 2281 /* 2282 * Since we are using ring buffers, if we can't insert any more into 2283 * the output queue, we can assume the ring is full and that someone 2284 * forgot to set the high water mark correctly. We set it and then 2285 * proceed as normal. 2286 */ 2287 hiwat = tp->t_outq.c_cc - 1; 2288 2289 ovhiwat: 2290 mutex_spin_enter(&tty_lock); 2291 ttstart(tp); 2292 /* 2293 * This can only occur if FLUSHO is set in t_lflag, 2294 * or if ttstart/oproc is synchronous (or very fast). 2295 */ 2296 if (tp->t_outq.c_cc <= hiwat) { 2297 mutex_spin_exit(&tty_lock); 2298 goto loop; 2299 } 2300 if (flag & IO_NDELAY) { 2301 mutex_spin_exit(&tty_lock); 2302 error = EWOULDBLOCK; 2303 goto out; 2304 } 2305 error = ttysleep(tp, &tp->t_outcv, true, 0); 2306 mutex_spin_exit(&tty_lock); 2307 if (error) 2308 goto out; 2309 goto loop; 2310 } 2311 2312 /* 2313 * Try to pull more output from the producer. Return non-zero if 2314 * there is output ready to be sent. 2315 */ 2316 bool 2317 ttypull(struct tty *tp) 2318 { 2319 2320 /* XXXSMP not yet KASSERT(mutex_owned(&tty_lock)); */ 2321 2322 if (tp->t_outq.c_cc <= tp->t_lowat) { 2323 cv_broadcast(&tp->t_outcv); 2324 selnotify(&tp->t_wsel, 0, NOTE_SUBMIT); 2325 } 2326 return tp->t_outq.c_cc != 0; 2327 } 2328 2329 /* 2330 * Rubout one character from the rawq of tp 2331 * as cleanly as possible. 2332 * Called with tty lock held. 2333 */ 2334 void 2335 ttyrub(int c, struct tty *tp) 2336 { 2337 u_char *cp; 2338 int savecol, tabc; 2339 2340 KASSERT(mutex_owned(&tty_lock)); 2341 2342 if (!ISSET(tp->t_lflag, ECHO) || ISSET(tp->t_lflag, EXTPROC)) 2343 return; 2344 CLR(tp->t_lflag, FLUSHO); 2345 if (ISSET(tp->t_lflag, ECHOE)) { 2346 if (tp->t_rocount == 0) { 2347 /* 2348 * Screwed by ttwrite; retype 2349 */ 2350 ttyretype(tp); 2351 return; 2352 } 2353 if (c == ('\t' | TTY_QUOTE) || c == ('\n' | TTY_QUOTE)) 2354 ttyrubo(tp, 2); 2355 else { 2356 CLR(c, ~TTY_CHARMASK); 2357 switch (CCLASS(c)) { 2358 case ORDINARY: 2359 ttyrubo(tp, 1); 2360 break; 2361 case BACKSPACE: 2362 case CONTROL: 2363 case NEWLINE: 2364 case RETURN: 2365 case VTAB: 2366 if (ISSET(tp->t_lflag, ECHOCTL)) 2367 ttyrubo(tp, 2); 2368 break; 2369 case TAB: 2370 if (tp->t_rocount < tp->t_rawq.c_cc) { 2371 ttyretype(tp); 2372 return; 2373 } 2374 savecol = tp->t_column; 2375 SET(tp->t_state, TS_CNTTB); 2376 SET(tp->t_lflag, FLUSHO); 2377 tp->t_column = tp->t_rocol; 2378 for (cp = firstc(&tp->t_rawq, &tabc); cp; 2379 cp = nextc(&tp->t_rawq, cp, &tabc)) 2380 ttyecho(tabc, tp); 2381 CLR(tp->t_lflag, FLUSHO); 2382 CLR(tp->t_state, TS_CNTTB); 2383 2384 /* savecol will now be length of the tab. */ 2385 savecol -= tp->t_column; 2386 tp->t_column += savecol; 2387 if (savecol > 8) 2388 savecol = 8; /* overflow screw */ 2389 while (--savecol >= 0) 2390 (void)ttyoutput('\b', tp); 2391 break; 2392 default: /* XXX */ 2393 (void)printf("ttyrub: would panic c = %d, " 2394 "val = %d\n", c, CCLASS(c)); 2395 } 2396 } 2397 } else if (ISSET(tp->t_lflag, ECHOPRT)) { 2398 if (!ISSET(tp->t_state, TS_ERASE)) { 2399 SET(tp->t_state, TS_ERASE); 2400 (void)ttyoutput('\\', tp); 2401 } 2402 ttyecho(c, tp); 2403 } else 2404 ttyecho(tp->t_cc[VERASE], tp); 2405 --tp->t_rocount; 2406 } 2407 2408 /* 2409 * Back over cnt characters, erasing them. 2410 * Called with tty lock held. 2411 */ 2412 static void 2413 ttyrubo(struct tty *tp, int cnt) 2414 { 2415 2416 KASSERT(mutex_owned(&tty_lock)); 2417 2418 while (cnt-- > 0) { 2419 (void)ttyoutput('\b', tp); 2420 (void)ttyoutput(' ', tp); 2421 (void)ttyoutput('\b', tp); 2422 } 2423 } 2424 2425 /* 2426 * ttyretype -- 2427 * Reprint the rawq line. Note, it is assumed that c_cc has already 2428 * been checked. 2429 * 2430 * Called with tty lock held. 2431 */ 2432 void 2433 ttyretype(struct tty *tp) 2434 { 2435 u_char *cp; 2436 int c; 2437 2438 KASSERT(mutex_owned(&tty_lock)); 2439 2440 /* Echo the reprint character. */ 2441 if (tp->t_cc[VREPRINT] != _POSIX_VDISABLE) 2442 ttyecho(tp->t_cc[VREPRINT], tp); 2443 2444 (void)ttyoutput('\n', tp); 2445 2446 for (cp = firstc(&tp->t_canq, &c); cp; cp = nextc(&tp->t_canq, cp, &c)) 2447 ttyecho(c, tp); 2448 for (cp = firstc(&tp->t_rawq, &c); cp; cp = nextc(&tp->t_rawq, cp, &c)) 2449 ttyecho(c, tp); 2450 CLR(tp->t_state, TS_ERASE); 2451 2452 tp->t_rocount = tp->t_rawq.c_cc; 2453 tp->t_rocol = 0; 2454 } 2455 2456 /* 2457 * Echo a typed character to the terminal. 2458 * Called with tty lock held. 2459 */ 2460 static void 2461 ttyecho(int c, struct tty *tp) 2462 { 2463 2464 KASSERT(mutex_owned(&tty_lock)); 2465 2466 if (!ISSET(tp->t_state, TS_CNTTB)) 2467 CLR(tp->t_lflag, FLUSHO); 2468 if ((!ISSET(tp->t_lflag, ECHO) && 2469 (!ISSET(tp->t_lflag, ECHONL) || c != '\n')) || 2470 ISSET(tp->t_lflag, EXTPROC)) 2471 return; 2472 if (((ISSET(tp->t_lflag, ECHOCTL) && 2473 (ISSET(c, TTY_CHARMASK) <= 037 && c != '\t' && c != '\n')) || 2474 ISSET(c, TTY_CHARMASK) == 0177)) { 2475 (void)ttyoutput('^', tp); 2476 CLR(c, ~TTY_CHARMASK); 2477 if (c == 0177) 2478 c = '?'; 2479 else 2480 c += 'A' - 1; 2481 } 2482 (void)ttyoutput(c, tp); 2483 } 2484 2485 /* 2486 * Wake up any readers on a tty. 2487 * Called with tty lock held. 2488 */ 2489 void 2490 ttwakeup(struct tty *tp) 2491 { 2492 2493 KASSERT(mutex_owned(&tty_lock)); 2494 2495 selnotify(&tp->t_rsel, 0, NOTE_SUBMIT); 2496 if (ISSET(tp->t_state, TS_ASYNC)) 2497 ttysig(tp, TTYSIG_PG2, SIGIO); 2498 cv_broadcast(&tp->t_rawcv); 2499 } 2500 2501 /* 2502 * Look up a code for a specified speed in a conversion table; 2503 * used by drivers to map software speed values to hardware parameters. 2504 */ 2505 int 2506 ttspeedtab(int speed, const struct speedtab *table) 2507 { 2508 2509 for (; table->sp_speed != -1; table++) 2510 if (table->sp_speed == speed) 2511 return (table->sp_code); 2512 return (-1); 2513 } 2514 2515 /* 2516 * Set tty hi and low water marks. 2517 * 2518 * Try to arrange the dynamics so there's about one second 2519 * from hi to low water. 2520 */ 2521 void 2522 ttsetwater(struct tty *tp) 2523 { 2524 int cps, x; 2525 2526 /* XXX not yet KASSERT(mutex_owned(&tty_lock)); */ 2527 2528 #define CLAMP(x, h, l) ((x) > h ? h : ((x) < l) ? l : (x)) 2529 2530 cps = tp->t_ospeed / 10; 2531 tp->t_lowat = x = CLAMP(cps / 2, TTMAXLOWAT, TTMINLOWAT); 2532 x += cps; 2533 x = CLAMP(x, TTMAXHIWAT, TTMINHIWAT); 2534 tp->t_hiwat = roundup(x, TTROUND); 2535 #undef CLAMP 2536 } 2537 2538 /* 2539 * Prepare report on state of foreground process group. 2540 * Call with &proc_lock held. 2541 */ 2542 void 2543 ttygetinfo(struct tty *tp, int fromsig, char *buf, size_t bufsz) 2544 { 2545 struct lwp *l; 2546 struct proc *p, *pick = NULL; 2547 struct timeval utime, stime; 2548 int tmp; 2549 fixpt_t pctcpu = 0; 2550 const char *msg = NULL; 2551 char lmsg[100]; 2552 long rss; 2553 bool again = false; 2554 2555 KASSERT(mutex_owned(&proc_lock)); 2556 2557 *buf = '\0'; 2558 2559 retry: 2560 if (tp->t_session == NULL) 2561 msg = "not a controlling terminal\n"; 2562 else if (tp->t_pgrp == NULL) 2563 msg = "no foreground process group\n"; 2564 else if ((p = LIST_FIRST(&tp->t_pgrp->pg_members)) == NULL) 2565 msg = "empty foreground process group\n"; 2566 else { 2567 /* Pick interesting process. */ 2568 for (; p != NULL; p = LIST_NEXT(p, p_pglist)) { 2569 struct proc *oldpick; 2570 2571 if (pick == NULL) { 2572 pick = p; 2573 continue; 2574 } 2575 if (pick->p_lock < p->p_lock) { 2576 mutex_enter(pick->p_lock); 2577 mutex_enter(p->p_lock); 2578 } else if (pick->p_lock > p->p_lock) { 2579 mutex_enter(p->p_lock); 2580 mutex_enter(pick->p_lock); 2581 } else 2582 mutex_enter(p->p_lock); 2583 oldpick = pick; 2584 if (proc_compare_wrapper(pick, p)) 2585 pick = p; 2586 mutex_exit(p->p_lock); 2587 if (p->p_lock != oldpick->p_lock) 2588 mutex_exit(oldpick->p_lock); 2589 } 2590 2591 if (pick != NULL) { 2592 mutex_enter(pick->p_lock); 2593 if (P_ZOMBIE(pick)) { 2594 mutex_exit(pick->p_lock); 2595 pick = NULL; 2596 if (!again) { 2597 again = true; 2598 goto retry; 2599 } 2600 msg = "found only zombie processes\n"; 2601 } 2602 if (pick && fromsig && 2603 (SIGACTION_PS(pick->p_sigacts, SIGINFO).sa_flags & 2604 SA_NOKERNINFO)) { 2605 mutex_exit(pick->p_lock); 2606 return; 2607 } 2608 } 2609 } 2610 2611 /* Print load average. */ 2612 tmp = (averunnable.ldavg[0] * 100 + FSCALE / 2) >> FSHIFT; 2613 snprintf(lmsg, sizeof(lmsg), "load: %d.%02d ", tmp / 100, tmp % 100); 2614 strlcat(buf, lmsg, bufsz); 2615 2616 if (pick == NULL) { 2617 strlcat(buf, msg, bufsz); 2618 return; 2619 } 2620 2621 snprintf(lmsg, sizeof(lmsg), " cmd: %s %d [", pick->p_comm, 2622 pick->p_pid); 2623 strlcat(buf, lmsg, bufsz); 2624 2625 KASSERT(mutex_owned(pick->p_lock)); 2626 LIST_FOREACH(l, &pick->p_lwps, l_sibling) { 2627 const char *lp; 2628 lwp_lock(l); 2629 #ifdef LWP_PC 2630 #define FMT_RUN "%#"PRIxVADDR 2631 #define VAL_RUNNING (vaddr_t)LWP_PC(l) 2632 #define VAL_RUNABLE (vaddr_t)LWP_PC(l) 2633 #else 2634 #define FMT_RUN "%s" 2635 #define VAL_RUNNING "running" 2636 #define VAL_RUNABLE "runnable" 2637 #endif 2638 switch (l->l_stat) { 2639 case LSONPROC: 2640 snprintf(lmsg, sizeof(lmsg), FMT_RUN"/%d", VAL_RUNNING, 2641 cpu_index(l->l_cpu)); 2642 lp = lmsg; 2643 break; 2644 case LSRUN: 2645 snprintf(lmsg, sizeof(lmsg), FMT_RUN, VAL_RUNABLE); 2646 lp = lmsg; 2647 break; 2648 default: 2649 lp = l->l_wchan ? l->l_wmesg : "iowait"; 2650 break; 2651 } 2652 strlcat(buf, lp, bufsz); 2653 strlcat(buf, LIST_NEXT(l, l_sibling) != NULL ? " " : "] ", 2654 bufsz); 2655 pctcpu += l->l_pctcpu; 2656 lwp_unlock(l); 2657 } 2658 pctcpu += pick->p_pctcpu; 2659 calcru(pick, &utime, &stime, NULL, NULL); 2660 mutex_exit(pick->p_lock); 2661 2662 /* Round up and print user+system time, %CPU and RSS. */ 2663 utime.tv_usec += 5000; 2664 if (utime.tv_usec >= 1000000) { 2665 utime.tv_sec += 1; 2666 utime.tv_usec -= 1000000; 2667 } 2668 stime.tv_usec += 5000; 2669 if (stime.tv_usec >= 1000000) { 2670 stime.tv_sec += 1; 2671 stime.tv_usec -= 1000000; 2672 } 2673 #define pgtok(a) (((u_long) ((a) * PAGE_SIZE) / 1024)) 2674 tmp = (pctcpu * 10000 + FSCALE / 2) >> FSHIFT; 2675 if (pick->p_stat == SIDL || P_ZOMBIE(pick)) 2676 rss = 0; 2677 else 2678 rss = pgtok(vm_resident_count(pick->p_vmspace)); 2679 2680 snprintf(lmsg, sizeof(lmsg), "%ld.%02ldu %ld.%02lds %d%% %ldk", 2681 (long)utime.tv_sec, (long)utime.tv_usec / 10000, 2682 (long)stime.tv_sec, (long)stime.tv_usec / 10000, 2683 tmp / 100, rss); 2684 strlcat(buf, lmsg, bufsz); 2685 } 2686 2687 /* 2688 * Print report on state of foreground process group. 2689 * Call with tty_lock held. 2690 */ 2691 void 2692 ttyputinfo(struct tty *tp, char *buf) 2693 { 2694 2695 KASSERT(mutex_owned(&tty_lock)); 2696 2697 if (ttycheckoutq_wlock(tp, 0) == 0) 2698 return; 2699 ttyprintf_nolock(tp, "%s\n", buf); 2700 tp->t_rocount = 0; /* so pending input will be retyped if BS */ 2701 } 2702 2703 /* 2704 * Returns 1 if p2 has a better chance being the active foreground process 2705 * in a terminal instead of p1. 2706 */ 2707 static int 2708 proc_compare_wrapper(struct proc *p1, struct proc *p2) 2709 { 2710 lwp_t *l1, *l2; 2711 2712 KASSERT(mutex_owned(p1->p_lock)); 2713 KASSERT(mutex_owned(p2->p_lock)); 2714 2715 l1 = LIST_FIRST(&p1->p_lwps); 2716 l2 = LIST_FIRST(&p2->p_lwps); 2717 2718 return proc_compare(p1, l1, p2, l2); 2719 } 2720 2721 /* 2722 * Output char to tty; console putchar style. 2723 * Can be called with tty lock held through kprintf() machinery.. 2724 */ 2725 int 2726 tputchar(int c, int flags, struct tty *tp) 2727 { 2728 int r = 0; 2729 2730 if ((flags & NOLOCK) == 0) 2731 mutex_spin_enter(&tty_lock); 2732 if (!CONNECTED(tp)) { 2733 r = -1; 2734 goto out; 2735 } 2736 if (c == '\n') 2737 (void)ttyoutput('\r', tp); 2738 (void)ttyoutput(c, tp); 2739 ttstart(tp); 2740 out: 2741 if ((flags & NOLOCK) == 0) 2742 mutex_spin_exit(&tty_lock); 2743 return (r); 2744 } 2745 2746 /* 2747 * Sleep on chan, returning ERESTART if tty changed while we napped and 2748 * returning any errors (e.g. EINTR/EWOULDBLOCK) reported by 2749 * cv_timedwait(_sig). 2750 * If the tty is revoked, restarting a pending call will redo validation done 2751 * at the start of the call. 2752 * 2753 * Must be called with the tty lock held. 2754 */ 2755 int 2756 ttysleep(struct tty *tp, kcondvar_t *cv, bool catch_p, int timo) 2757 { 2758 int error; 2759 short gen; 2760 2761 KASSERT(mutex_owned(&tty_lock)); 2762 2763 gen = tp->t_gen; 2764 if (cv == NULL) 2765 error = kpause("ttypause", catch_p, timo, &tty_lock); 2766 else if (catch_p) 2767 error = cv_timedwait_sig(cv, &tty_lock, timo); 2768 else 2769 error = cv_timedwait(cv, &tty_lock, timo); 2770 if (error != 0) 2771 return (error); 2772 return (tp->t_gen == gen ? 0 : ERESTART); 2773 } 2774 2775 int 2776 ttypause(struct tty *tp, int timo) 2777 { 2778 int error; 2779 2780 error = ttysleep(tp, NULL, true, timo); 2781 if (error == EWOULDBLOCK) 2782 error = 0; 2783 return error; 2784 } 2785 2786 /* 2787 * Attach a tty to the tty list. 2788 * 2789 * This should be called ONLY once per real tty (including pty's). 2790 * eg, on the sparc, the keyboard and mouse have struct tty's that are 2791 * distinctly NOT usable as tty's, and thus should not be attached to 2792 * the ttylist. This is why this call is not done from tty_alloc(). 2793 * 2794 * Device drivers should attach tty's at a similar time that they are 2795 * allocated, or, for the case of statically allocated struct tty's 2796 * either in the attach or (first) open routine. 2797 */ 2798 void 2799 tty_attach(struct tty *tp) 2800 { 2801 2802 mutex_spin_enter(&tty_lock); 2803 TAILQ_INSERT_TAIL(&ttylist, tp, tty_link); 2804 ++tty_count; 2805 mutex_spin_exit(&tty_lock); 2806 } 2807 2808 /* 2809 * Remove a tty from the tty list. 2810 */ 2811 void 2812 tty_detach(struct tty *tp) 2813 { 2814 2815 mutex_spin_enter(&tty_lock); 2816 --tty_count; 2817 #ifdef DIAGNOSTIC 2818 if (tty_count < 0) 2819 panic("tty_detach: tty_count < 0"); 2820 #endif 2821 TAILQ_REMOVE(&ttylist, tp, tty_link); 2822 mutex_spin_exit(&tty_lock); 2823 } 2824 2825 /* 2826 * Allocate a tty structure and its associated buffers. 2827 */ 2828 struct tty * 2829 tty_alloc(void) 2830 { 2831 struct tty *tp; 2832 int i; 2833 2834 tp = kmem_zalloc(sizeof(*tp), KM_SLEEP); 2835 callout_init(&tp->t_rstrt_ch, 0); 2836 callout_setfunc(&tp->t_rstrt_ch, ttrstrt, tp); 2837 tp->t_qsize = tty_qsize; 2838 clalloc(&tp->t_rawq, tp->t_qsize, 1); 2839 cv_init(&tp->t_rawcv, "ttyraw"); 2840 cv_init(&tp->t_rawcvf, "ttyrawf"); 2841 clalloc(&tp->t_canq, tp->t_qsize, 1); 2842 cv_init(&tp->t_cancv, "ttycan"); 2843 cv_init(&tp->t_cancvf, "ttycanf"); 2844 /* output queue doesn't need quoting */ 2845 clalloc(&tp->t_outq, tp->t_qsize, 0); 2846 cv_init(&tp->t_outcv, "ttyout"); 2847 cv_init(&tp->t_outcvf, "ttyoutf"); 2848 /* Set default line discipline. */ 2849 tp->t_linesw = ttyldisc_default(); 2850 tp->t_dev = NODEV; 2851 selinit(&tp->t_rsel); 2852 selinit(&tp->t_wsel); 2853 for (i = 0; i < TTYSIG_COUNT; i++) { 2854 sigemptyset(&tp->t_sigs[i]); 2855 } 2856 2857 return tp; 2858 } 2859 2860 /* 2861 * Free a tty structure and its buffers. 2862 * 2863 * Be sure to call tty_detach() for any tty that has been 2864 * tty_attach()ed. 2865 */ 2866 void 2867 tty_free(struct tty *tp) 2868 { 2869 int i; 2870 2871 mutex_enter(&proc_lock); 2872 mutex_enter(&tty_lock); 2873 for (i = 0; i < TTYSIG_COUNT; i++) 2874 sigemptyset(&tp->t_sigs[i]); 2875 if (tp->t_sigcount != 0) 2876 TAILQ_REMOVE(&tty_sigqueue, tp, t_sigqueue); 2877 mutex_exit(&tty_lock); 2878 mutex_exit(&proc_lock); 2879 2880 callout_halt(&tp->t_rstrt_ch, NULL); 2881 callout_destroy(&tp->t_rstrt_ch); 2882 ttyldisc_release(tp->t_linesw); 2883 clfree(&tp->t_rawq); 2884 clfree(&tp->t_canq); 2885 clfree(&tp->t_outq); 2886 cv_destroy(&tp->t_rawcv); 2887 cv_destroy(&tp->t_rawcvf); 2888 cv_destroy(&tp->t_cancv); 2889 cv_destroy(&tp->t_cancvf); 2890 cv_destroy(&tp->t_outcv); 2891 cv_destroy(&tp->t_outcvf); 2892 seldestroy(&tp->t_rsel); 2893 seldestroy(&tp->t_wsel); 2894 kmem_free(tp, sizeof(*tp)); 2895 } 2896 2897 /* 2898 * ttyprintf_nolock: send a message to a specific tty, without locking. 2899 * 2900 * => should be used only by tty driver or anything that knows the 2901 * underlying tty will not be revoked(2)'d away. [otherwise, 2902 * use tprintf] 2903 */ 2904 static void 2905 ttyprintf_nolock(struct tty *tp, const char *fmt, ...) 2906 { 2907 va_list ap; 2908 2909 /* No mutex needed; going to process TTY. */ 2910 va_start(ap, fmt); 2911 kprintf(fmt, TOTTY|NOLOCK, tp, NULL, ap); 2912 va_end(ap); 2913 } 2914 2915 static int 2916 tty_listener_cb(kauth_cred_t cred, kauth_action_t action, void *cookie, 2917 void *arg0, void *arg1, void *arg2, void *arg3) 2918 { 2919 struct tty *tty; 2920 int result; 2921 2922 result = KAUTH_RESULT_DEFER; 2923 2924 if (action != KAUTH_DEVICE_TTY_OPEN) 2925 return result; 2926 2927 tty = arg0; 2928 2929 /* If it's not opened, we allow. */ 2930 if ((tty->t_state & TS_ISOPEN) == 0) 2931 result = KAUTH_RESULT_ALLOW; 2932 else { 2933 /* 2934 * If it's opened, we can only allow if it's not exclusively 2935 * opened; otherwise, that's a privileged operation and we 2936 * let the secmodel handle it. 2937 */ 2938 if ((tty->t_state & TS_XCLUDE) == 0) 2939 result = KAUTH_RESULT_ALLOW; 2940 } 2941 2942 return result; 2943 } 2944 2945 /* 2946 * Initialize the tty subsystem. 2947 */ 2948 void 2949 tty_init(void) 2950 { 2951 2952 mutex_init(&tty_lock, MUTEX_DEFAULT, IPL_VM); 2953 tty_sigsih = softint_establish(SOFTINT_CLOCK, ttysigintr, NULL); 2954 KASSERT(tty_sigsih != NULL); 2955 2956 tty_listener = kauth_listen_scope(KAUTH_SCOPE_DEVICE, 2957 tty_listener_cb, NULL); 2958 2959 sysctl_kern_tty_setup(); 2960 } 2961 2962 /* 2963 * Send a signal from a tty to its process group or session leader. 2964 * Handoff to the target is deferred to a soft interrupt. 2965 */ 2966 void 2967 ttysig(struct tty *tp, enum ttysigtype st, int sig) 2968 { 2969 sigset_t *sp; 2970 2971 /* XXXSMP not yet KASSERT(mutex_owned(&tty_lock)); */ 2972 2973 sp = &tp->t_sigs[st]; 2974 if (sigismember(sp, sig)) 2975 return; 2976 sigaddset(sp, sig); 2977 if (tp->t_sigcount++ == 0) 2978 TAILQ_INSERT_TAIL(&tty_sigqueue, tp, t_sigqueue); 2979 softint_schedule(tty_sigsih); 2980 } 2981 2982 /* 2983 * Deliver deferred signals from ttys. Note that the process groups 2984 * and sessions associated with the ttys may have changed from when 2985 * the signal was originally sent, but in practice it should not matter. 2986 * For signals produced as a result of a syscall, the soft interrupt 2987 * will fire before the syscall returns to the user. 2988 */ 2989 static void 2990 ttysigintr(void *cookie) 2991 { 2992 struct tty *tp; 2993 enum ttysigtype st; 2994 struct pgrp *pgrp; 2995 struct session *sess; 2996 int sig, lflag; 2997 char infobuf[200]; 2998 2999 mutex_enter(&proc_lock); 3000 mutex_spin_enter(&tty_lock); 3001 while ((tp = TAILQ_FIRST(&tty_sigqueue)) != NULL) { 3002 KASSERT(tp->t_sigcount > 0); 3003 for (st = TTYSIG_PG1; st < TTYSIG_COUNT; st++) { 3004 if ((sig = firstsig(&tp->t_sigs[st])) != 0) 3005 break; 3006 } 3007 KASSERT(st < TTYSIG_COUNT); 3008 sigdelset(&tp->t_sigs[st], sig); 3009 if (--tp->t_sigcount == 0) 3010 TAILQ_REMOVE(&tty_sigqueue, tp, t_sigqueue); 3011 pgrp = tp->t_pgrp; 3012 sess = tp->t_session; 3013 lflag = tp->t_lflag; 3014 if (sig == SIGINFO) { 3015 if (ISSET(tp->t_state, TS_SIGINFO)) { 3016 /* Via ioctl: ignore tty option. */ 3017 tp->t_state &= ~TS_SIGINFO; 3018 lflag |= ISIG; 3019 } 3020 if (!ISSET(lflag, NOKERNINFO)) { 3021 mutex_spin_exit(&tty_lock); 3022 ttygetinfo(tp, 1, infobuf, sizeof(infobuf)); 3023 mutex_spin_enter(&tty_lock); 3024 ttyputinfo(tp, infobuf); 3025 } 3026 if (!ISSET(lflag, ISIG)) 3027 continue; 3028 } 3029 mutex_spin_exit(&tty_lock); 3030 KASSERT(sig != 0); 3031 switch (st) { 3032 case TTYSIG_PG1: 3033 if (pgrp != NULL) 3034 pgsignal(pgrp, sig, 1); 3035 break; 3036 case TTYSIG_PG2: 3037 if (pgrp != NULL) 3038 pgsignal(pgrp, sig, sess != NULL); 3039 break; 3040 case TTYSIG_LEADER: 3041 if (sess != NULL && sess->s_leader != NULL) 3042 psignal(sess->s_leader, sig); 3043 break; 3044 default: 3045 /* NOTREACHED */ 3046 break; 3047 } 3048 mutex_spin_enter(&tty_lock); 3049 } 3050 mutex_spin_exit(&tty_lock); 3051 mutex_exit(&proc_lock); 3052 } 3053 3054 unsigned char 3055 tty_getctrlchar(struct tty *tp, unsigned which) 3056 { 3057 KASSERT(which < NCCS); 3058 return tp->t_cc[which]; 3059 } 3060 3061 void 3062 tty_setctrlchar(struct tty *tp, unsigned which, unsigned char val) 3063 { 3064 KASSERT(which < NCCS); 3065 tp->t_cc[which] = val; 3066 } 3067 3068 int 3069 tty_try_xonxoff(struct tty *tp, unsigned char c) 3070 { 3071 const struct cdevsw *cdev; 3072 3073 if (tp->t_iflag & IXON) { 3074 if (c == tp->t_cc[VSTOP] && tp->t_cc[VSTOP] != _POSIX_VDISABLE) { 3075 if ((tp->t_state & TS_TTSTOP) == 0) { 3076 tp->t_state |= TS_TTSTOP; 3077 cdev = cdevsw_lookup(tp->t_dev); 3078 if (cdev != NULL) 3079 (*cdev->d_stop)(tp, 0); 3080 } 3081 return 0; 3082 } 3083 if (c == tp->t_cc[VSTART] && tp->t_cc[VSTART] != _POSIX_VDISABLE) { 3084 tp->t_state &= ~TS_TTSTOP; 3085 if (tp->t_oproc != NULL) { 3086 mutex_spin_enter(&tty_lock); /* XXX */ 3087 (*tp->t_oproc)(tp); 3088 mutex_spin_exit(&tty_lock); /* XXX */ 3089 } 3090 return 0; 3091 } 3092 } 3093 return EAGAIN; 3094 } 3095
Indexes created Tue Sep 30 10:09:55 GMT 2025