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