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