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