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