1 /*- 2 * (MPSAFE) 3 * 4 * Copyright (c) 1982, 1986, 1990, 1991, 1993 5 * The Regents of the University of California. All rights reserved. 6 * (c) UNIX System Laboratories, Inc. 7 * All or some portions of this file are derived from material licensed 8 * to the University of California by American Telephone and Telegraph 9 * Co. or Unix System Laboratories, Inc. and are reproduced herein with 10 * the permission of UNIX System Laboratories, Inc. 11 * 12 * Redistribution and use in source and binary forms, with or without 13 * modification, are permitted provided that the following conditions 14 * are met: 15 * 1. Redistributions of source code must retain the above copyright 16 * notice, this list of conditions and the following disclaimer. 17 * 2. Redistributions in binary form must reproduce the above copyright 18 * notice, this list of conditions and the following disclaimer in the 19 * documentation and/or other materials provided with the distribution. 20 * 3. All advertising materials mentioning features or use of this software 21 * must display the following acknowledgement: 22 * This product includes software developed by the University of 23 * California, Berkeley and its contributors. 24 * 4. Neither the name of the University nor the names of its contributors 25 * may be used to endorse or promote products derived from this software 26 * without specific prior written permission. 27 * 28 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 29 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 30 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 31 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 32 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 33 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 34 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 35 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 36 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 37 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 38 * SUCH DAMAGE. 39 * 40 * @(#)tty.c 8.8 (Berkeley) 1/21/94 41 * $FreeBSD: src/sys/kern/tty.c,v 1.129.2.5 2002/03/11 01:32:31 dd Exp $ 42 */ 43 44 /* 45 * MPSAFE NOTE: 46 * Almost all functions in this file are acquiring the tty token due to their 47 * access and modifications of the 'tp' (struct tty) objects. 48 */ 49 50 /*- 51 * TODO: 52 * o Fix races for sending the start char in ttyflush(). 53 * o Handle inter-byte timeout for "MIN > 0, TIME > 0" in ttyselect(). 54 * With luck, there will be MIN chars before select() returns(). 55 * o Handle CLOCAL consistently for ptys. Perhaps disallow setting it. 56 * o Don't allow input in TS_ZOMBIE case. It would be visible through 57 * FIONREAD. 58 * o Do the new sio locking stuff here and use it to avoid special 59 * case for EXTPROC? 60 * o Lock PENDIN too? 61 * o Move EXTPROC and/or PENDIN to t_state? 62 * o Wrap most of ttioctl in spltty/splx. 63 * o Implement TIOCNOTTY or remove it from <sys/ioctl.h>. 64 * o Send STOP if IXOFF is toggled off while TS_TBLOCK is set. 65 * o Don't allow certain termios flags to affect disciplines other 66 * than TTYDISC. Cancel their effects before switch disciplines 67 * and ignore them if they are set while we are in another 68 * discipline. 69 * o Now that historical speed conversions are handled here, don't 70 * do them in drivers. 71 * o Check for TS_CARR_ON being set while everything is closed and not 72 * waiting for carrier. TS_CARR_ON isn't cleared if nothing is open, 73 * so it would live until the next open even if carrier drops. 74 * o Restore TS_WOPEN since it is useful in pstat. It must be cleared 75 * only when _all_ openers leave open(). 76 */ 77 78 #include "opt_compat.h" 79 #include "opt_uconsole.h" 80 81 #include <sys/param.h> 82 #include <sys/systm.h> 83 #include <sys/filio.h> 84 #if defined(COMPAT_43) 85 #include <sys/ioctl_compat.h> 86 #endif 87 #include <sys/proc.h> 88 #include <sys/priv.h> 89 #define TTYDEFCHARS 90 #include <sys/tty.h> 91 #include <sys/clist.h> 92 #undef TTYDEFCHARS 93 #include <sys/fcntl.h> 94 #include <sys/conf.h> 95 #include <sys/dkstat.h> 96 #include <sys/kernel.h> 97 #include <sys/vnode.h> 98 #include <sys/signalvar.h> 99 #include <sys/signal2.h> 100 #include <sys/resourcevar.h> 101 #include <sys/malloc.h> 102 #include <sys/filedesc.h> 103 #include <sys/sysctl.h> 104 #include <sys/thread2.h> 105 106 #include <vm/vm.h> 107 #include <sys/lock.h> 108 #include <vm/pmap.h> 109 #include <vm/vm_map.h> 110 #include <vm/vm_extern.h> 111 112 MALLOC_DEFINE(M_TTYS, "ttys", "tty data structures"); 113 114 static int proc_compare (struct proc *p1, struct proc *p2); 115 static int ttnread (struct tty *tp); 116 static void ttyecho (int c, struct tty *tp); 117 static int ttyoutput (int c, struct tty *tp); 118 static void ttypend (struct tty *tp); 119 static void ttyretype (struct tty *tp); 120 static void ttyrub (int c, struct tty *tp); 121 static void ttyrubo (struct tty *tp, int cnt); 122 static void ttyunblock (struct tty *tp); 123 static int ttywflush (struct tty *tp); 124 static int filt_ttyread (struct knote *kn, long hint); 125 static void filt_ttyrdetach (struct knote *kn); 126 static int filt_ttywrite (struct knote *kn, long hint); 127 static void filt_ttywdetach (struct knote *kn); 128 129 /* 130 * Table with character classes and parity. The 8th bit indicates parity, 131 * the 7th bit indicates the character is an alphameric or underscore (for 132 * ALTWERASE), and the low 6 bits indicate delay type. If the low 6 bits 133 * are 0 then the character needs no special processing on output; classes 134 * other than 0 might be translated or (not currently) require delays. 135 */ 136 #define E 0x00 /* Even parity. */ 137 #define O 0x80 /* Odd parity. */ 138 #define PARITY(c) (char_type[c] & O) 139 140 #define ALPHA 0x40 /* Alpha or underscore. */ 141 #define ISALPHA(c) (char_type[(c) & TTY_CHARMASK] & ALPHA) 142 143 #define CCLASSMASK 0x3f 144 #define CCLASS(c) (char_type[c] & CCLASSMASK) 145 146 #define BS BACKSPACE 147 #define CC CONTROL 148 #define CR RETURN 149 #define NA ORDINARY | ALPHA 150 #define NL NEWLINE 151 #define NO ORDINARY 152 #define TB TAB 153 #define VT VTAB 154 155 static u_char const char_type[] = { 156 E|CC, O|CC, O|CC, E|CC, O|CC, E|CC, E|CC, O|CC, /* nul - bel */ 157 O|BS, E|TB, E|NL, O|CC, E|VT, O|CR, O|CC, E|CC, /* bs - si */ 158 O|CC, E|CC, E|CC, O|CC, E|CC, O|CC, O|CC, E|CC, /* dle - etb */ 159 E|CC, O|CC, O|CC, E|CC, O|CC, E|CC, E|CC, O|CC, /* can - us */ 160 O|NO, E|NO, E|NO, O|NO, E|NO, O|NO, O|NO, E|NO, /* sp - ' */ 161 E|NO, O|NO, O|NO, E|NO, O|NO, E|NO, E|NO, O|NO, /* ( - / */ 162 E|NA, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* 0 - 7 */ 163 O|NA, E|NA, E|NO, O|NO, E|NO, O|NO, O|NO, E|NO, /* 8 - ? */ 164 O|NO, E|NA, E|NA, O|NA, E|NA, O|NA, O|NA, E|NA, /* @ - G */ 165 E|NA, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* H - O */ 166 E|NA, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* P - W */ 167 O|NA, E|NA, E|NA, O|NO, E|NO, O|NO, O|NO, O|NA, /* X - _ */ 168 E|NO, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* ` - g */ 169 O|NA, E|NA, E|NA, O|NA, E|NA, O|NA, O|NA, E|NA, /* h - o */ 170 O|NA, E|NA, E|NA, O|NA, E|NA, O|NA, O|NA, E|NA, /* p - w */ 171 E|NA, O|NA, O|NA, E|NO, O|NO, E|NO, E|NO, O|CC, /* x - del */ 172 /* 173 * Meta chars; should be settable per character set; 174 * for now, treat them all as normal characters. 175 */ 176 NA, NA, NA, NA, NA, NA, NA, NA, 177 NA, NA, NA, NA, NA, NA, NA, NA, 178 NA, NA, NA, NA, NA, NA, NA, NA, 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 }; 193 #undef BS 194 #undef CC 195 #undef CR 196 #undef NA 197 #undef NL 198 #undef NO 199 #undef TB 200 #undef VT 201 202 /* Macros to clear/set/test flags. */ 203 #define SET(t, f) (t) |= (f) 204 #define CLR(t, f) (t) &= ~(f) 205 #define ISSET(t, f) ((t) & (f)) 206 207 #undef MAX_INPUT /* XXX wrong in <sys/syslimits.h> */ 208 #define MAX_INPUT TTYHOG /* XXX limit is usually larger for !ICANON */ 209 210 uint64_t tk_nin; 211 SYSCTL_OPAQUE(_kern, OID_AUTO, tk_nin, CTLFLAG_RD, &tk_nin, sizeof(tk_nin), 212 "LU", "TTY input statistic"); 213 uint64_t tk_nout; 214 SYSCTL_OPAQUE(_kern, OID_AUTO, tk_nout, CTLFLAG_RD, &tk_nout, sizeof(tk_nout), 215 "LU", "TTY output statistic"); 216 uint64_t tk_rawcc; 217 218 /* 219 * list of struct tty where pstat(8) can pick it up with sysctl 220 */ 221 static TAILQ_HEAD(, tty) tty_list = TAILQ_HEAD_INITIALIZER(tty_list); 222 223 /* 224 * Initial open of tty, or (re)entry to standard tty line discipline. 225 */ 226 int 227 ttyopen(cdev_t device, struct tty *tp) 228 { 229 crit_enter(); 230 lwkt_gettoken(&tty_token); 231 tp->t_dev = device; 232 if (!ISSET(tp->t_state, TS_ISOPEN)) { 233 SET(tp->t_state, TS_ISOPEN); 234 if (ISSET(tp->t_cflag, CLOCAL)) { 235 SET(tp->t_state, TS_CONNECTED); 236 } 237 bzero(&tp->t_winsize, sizeof(tp->t_winsize)); 238 } 239 ttsetwater(tp); 240 lwkt_reltoken(&tty_token); 241 crit_exit(); 242 return (0); 243 } 244 245 /* 246 * Handle close() on a tty line: flush and set to initial state, 247 * bumping generation number so that pending read/write calls 248 * can detect recycling of the tty. 249 * 250 * XXX our caller should have done `spltty(); l_close(); ttyclose();' 251 * and l_close() should have flushed, but we repeat the spltty() and 252 * the flush in case there are buggy callers. 253 */ 254 int 255 ttyclose(struct tty *tp) 256 { 257 crit_enter(); 258 lwkt_gettoken(&tty_token); 259 funsetown(&tp->t_sigio); 260 if (constty == tp) 261 constty = NULL; 262 263 ttyflush(tp, FREAD | FWRITE); 264 clist_free_cblocks(&tp->t_canq); 265 clist_free_cblocks(&tp->t_outq); 266 clist_free_cblocks(&tp->t_rawq); 267 268 tp->t_gen++; 269 tp->t_line = TTYDISC; 270 ttyclearsession(tp); 271 tp->t_state &= TS_REGISTERED; /* clear all bits except */ 272 lwkt_reltoken(&tty_token); 273 crit_exit(); 274 return (0); 275 } 276 277 /* 278 * Disassociate the tty from its session. Traditionally this has only been 279 * a half-close, meaning that the session was still allowed to point at the 280 * tty (resulting in the tty in the ps command showing something like 'p0-'), 281 * even though the tty is no longer pointing at the session. 282 * 283 * The half close seems to be useful only for 'ps' output but there is as 284 * yet no reason to remove the feature. The full-close code is currently 285 * #if 0'd out. See also sess_rele() in kern/kern_proc.c. 286 */ 287 void 288 ttyclearsession(struct tty *tp) 289 { 290 struct session *sp; 291 struct pgrp *opgrp; 292 293 lwkt_gettoken(&tty_token); 294 opgrp = tp->t_pgrp; 295 tp->t_pgrp = NULL; 296 if (opgrp) { 297 pgrel(opgrp); 298 opgrp = NULL; 299 } 300 301 if ((sp = tp->t_session) != NULL) { 302 tp->t_session = NULL; 303 #ifdef TTY_DO_FULL_CLOSE 304 /* FULL CLOSE (not yet) */ 305 if (sp->s_ttyp == tp) { 306 sp->s_ttyp = NULL; 307 ttyunhold(tp); 308 } else { 309 kprintf("ttyclearsession: warning: sp->s_ttyp != tp " 310 "%p/%p\n", sp->s_ttyp, tp); 311 } 312 #endif 313 } 314 lwkt_reltoken(&tty_token); 315 } 316 317 /* 318 * Release the tty vnode association for a session. This is the 319 * 'other half' of the close. Because multiple opens of /dev/tty 320 * only generate a single open to the actual tty, the file modes 321 * are locked to FREAD|FWRITE. 322 * 323 * If dorevoke is non-zero, the session is also revoked. We have to 324 * close the vnode if VCTTYISOPEN is set. 325 */ 326 void 327 ttyclosesession(struct session *sp, int dorevoke) 328 { 329 struct vnode *vp; 330 331 lwkt_gettoken(&tty_token); 332 retry: 333 /* 334 * There may not be a controlling terminal or it may have been closed 335 * out from under us. 336 */ 337 if ((vp = sp->s_ttyvp) == NULL) { 338 lwkt_reltoken(&tty_token); 339 return; 340 } 341 342 /* 343 * We need a lock if we have to close or revoke. 344 */ 345 if ((vp->v_flag & VCTTYISOPEN) || dorevoke) { 346 vhold(vp); 347 if (vn_lock(vp, LK_EXCLUSIVE|LK_RETRY)) { 348 vdrop(vp); 349 goto retry; 350 } 351 352 /* 353 * Retry if the vnode was ripped out from under us 354 */ 355 if (vp != sp->s_ttyvp) { 356 vn_unlock(vp); 357 vdrop(vp); 358 goto retry; 359 } 360 361 /* 362 * Close and revoke as needed 363 */ 364 sp->s_ttyvp = NULL; 365 if (vp->v_flag & VCTTYISOPEN) { 366 vclrflags(vp, VCTTYISOPEN); 367 VOP_CLOSE(vp, FREAD|FWRITE); 368 } 369 vn_unlock(vp); 370 if (dorevoke) 371 vrevoke(vp, proc0.p_ucred); 372 vdrop(vp); 373 } else { 374 sp->s_ttyvp = NULL; 375 } 376 vrele(vp); 377 lwkt_reltoken(&tty_token); 378 } 379 380 #define FLUSHQ(q) { \ 381 if ((q)->c_cc) \ 382 ndflush(q, (q)->c_cc); \ 383 } 384 385 /* Is 'c' a line delimiter ("break" character)? */ 386 #define TTBREAKC(c, lflag) \ 387 ((c) == '\n' || (((c) == cc[VEOF] || \ 388 (c) == cc[VEOL] || ((c) == cc[VEOL2] && lflag & IEXTEN)) && \ 389 (c) != _POSIX_VDISABLE)) 390 391 /* 392 * Process input of a single character received on a tty. 393 */ 394 int 395 ttyinput(int c, struct tty *tp) 396 { 397 tcflag_t iflag, lflag; 398 cc_t *cc; 399 int i, err; 400 401 lwkt_gettoken(&tty_token); 402 /* 403 * If input is pending take it first. 404 */ 405 lflag = tp->t_lflag; 406 if (ISSET(lflag, PENDIN)) 407 ttypend(tp); 408 /* 409 * Gather stats. 410 */ 411 if (ISSET(lflag, ICANON)) 412 ++tp->t_cancc; 413 else 414 ++tp->t_rawcc; 415 ++tk_nin; 416 417 /* 418 * Block further input iff: 419 * current input > threshold AND input is available to user program 420 * AND input flow control is enabled and not yet invoked. 421 * The 3 is slop for PARMRK. 422 */ 423 iflag = tp->t_iflag; 424 if (tp->t_rawq.c_cc + tp->t_canq.c_cc > tp->t_ihiwat - 3 && 425 (!ISSET(lflag, ICANON) || tp->t_canq.c_cc != 0) && 426 (ISSET(tp->t_cflag, CRTS_IFLOW) || ISSET(iflag, IXOFF)) && 427 !ISSET(tp->t_state, TS_TBLOCK)) 428 ttyblock(tp); 429 430 /* Handle exceptional conditions (break, parity, framing). */ 431 cc = tp->t_cc; 432 err = (ISSET(c, TTY_ERRORMASK)); 433 if (err) { 434 CLR(c, TTY_ERRORMASK); 435 if (ISSET(err, TTY_BI)) { 436 if (ISSET(iflag, IGNBRK)) { 437 lwkt_reltoken(&tty_token); 438 return (0); 439 } 440 if (ISSET(iflag, BRKINT)) { 441 ttyflush(tp, FREAD | FWRITE); 442 pgsignal(tp->t_pgrp, SIGINT, 1); 443 goto endcase; 444 } 445 if (ISSET(iflag, PARMRK)) 446 goto parmrk; 447 } else if ((ISSET(err, TTY_PE) && ISSET(iflag, INPCK)) 448 || ISSET(err, TTY_FE)) { 449 if (ISSET(iflag, IGNPAR)) { 450 lwkt_reltoken(&tty_token); 451 return (0); 452 } 453 else if (ISSET(iflag, PARMRK)) { 454 parmrk: 455 if (tp->t_rawq.c_cc + tp->t_canq.c_cc > 456 MAX_INPUT - 3) 457 goto input_overflow; 458 clist_putc(0377 | TTY_QUOTE, &tp->t_rawq); 459 clist_putc(0 | TTY_QUOTE, &tp->t_rawq); 460 clist_putc(c | TTY_QUOTE, &tp->t_rawq); 461 goto endcase; 462 } else 463 c = 0; 464 } 465 } 466 467 if (!ISSET(tp->t_state, TS_TYPEN) && ISSET(iflag, ISTRIP)) 468 CLR(c, 0x80); 469 if (!ISSET(lflag, EXTPROC)) { 470 /* 471 * Check for literal nexting very first 472 */ 473 if (ISSET(tp->t_state, TS_LNCH)) { 474 SET(c, TTY_QUOTE); 475 CLR(tp->t_state, TS_LNCH); 476 } 477 /* 478 * Scan for special characters. This code 479 * is really just a big case statement with 480 * non-constant cases. The bottom of the 481 * case statement is labeled ``endcase'', so goto 482 * it after a case match, or similar. 483 */ 484 485 /* 486 * Control chars which aren't controlled 487 * by ICANON, ISIG, or IXON. 488 */ 489 if (ISSET(lflag, IEXTEN)) { 490 if (CCEQ(cc[VLNEXT], c)) { 491 if (ISSET(lflag, ECHO)) { 492 if (ISSET(lflag, ECHOE)) { 493 (void)ttyoutput('^', tp); 494 (void)ttyoutput('\b', tp); 495 } else 496 ttyecho(c, tp); 497 } 498 SET(tp->t_state, TS_LNCH); 499 goto endcase; 500 } 501 if (CCEQ(cc[VDISCARD], c)) { 502 if (ISSET(lflag, FLUSHO)) 503 CLR(tp->t_lflag, FLUSHO); 504 else { 505 ttyflush(tp, FWRITE); 506 ttyecho(c, tp); 507 if (tp->t_rawq.c_cc + tp->t_canq.c_cc) 508 ttyretype(tp); 509 SET(tp->t_lflag, FLUSHO); 510 } 511 goto startoutput; 512 } 513 } 514 /* 515 * Signals. 516 */ 517 if (ISSET(lflag, ISIG)) { 518 if (CCEQ(cc[VINTR], c) || CCEQ(cc[VQUIT], c)) { 519 if (!ISSET(lflag, NOFLSH)) 520 ttyflush(tp, FREAD | FWRITE); 521 ttyecho(c, tp); 522 pgsignal(tp->t_pgrp, 523 CCEQ(cc[VINTR], c) ? SIGINT : SIGQUIT, 1); 524 goto endcase; 525 } 526 if (CCEQ(cc[VSUSP], c)) { 527 if (!ISSET(lflag, NOFLSH)) 528 ttyflush(tp, FREAD); 529 ttyecho(c, tp); 530 pgsignal(tp->t_pgrp, SIGTSTP, 1); 531 goto endcase; 532 } 533 } 534 /* 535 * Handle start/stop characters. 536 */ 537 if (ISSET(iflag, IXON)) { 538 if (CCEQ(cc[VSTOP], c)) { 539 if (!ISSET(tp->t_state, TS_TTSTOP)) { 540 SET(tp->t_state, TS_TTSTOP); 541 (*tp->t_stop)(tp, 0); 542 lwkt_reltoken(&tty_token); 543 return (0); 544 } 545 if (!CCEQ(cc[VSTART], c)) { 546 lwkt_reltoken(&tty_token); 547 return (0); 548 } 549 /* 550 * if VSTART == VSTOP then toggle 551 */ 552 goto endcase; 553 } 554 if (CCEQ(cc[VSTART], c)) 555 goto restartoutput; 556 } 557 /* 558 * IGNCR, ICRNL, & INLCR 559 */ 560 if (c == '\r') { 561 if (ISSET(iflag, IGNCR)) { 562 lwkt_reltoken(&tty_token); 563 return (0); 564 } 565 else if (ISSET(iflag, ICRNL)) 566 c = '\n'; 567 } else if (c == '\n' && ISSET(iflag, INLCR)) 568 c = '\r'; 569 } 570 if (!ISSET(tp->t_lflag, EXTPROC) && ISSET(lflag, ICANON)) { 571 /* 572 * From here on down canonical mode character 573 * processing takes place. 574 */ 575 /* 576 * erase or erase2 (^H / ^?) 577 */ 578 if (CCEQ(cc[VERASE], c) || CCEQ(cc[VERASE2], c) ) { 579 if (tp->t_rawq.c_cc) 580 ttyrub(clist_unputc(&tp->t_rawq), tp); 581 goto endcase; 582 } 583 /* 584 * kill (^U) 585 */ 586 if (CCEQ(cc[VKILL], c)) { 587 if (ISSET(lflag, ECHOKE) && 588 tp->t_rawq.c_cc == tp->t_rocount && 589 !ISSET(lflag, ECHOPRT)) 590 while (tp->t_rawq.c_cc) 591 ttyrub(clist_unputc(&tp->t_rawq), tp); 592 else { 593 ttyecho(c, tp); 594 if (ISSET(lflag, ECHOK) || 595 ISSET(lflag, ECHOKE)) 596 ttyecho('\n', tp); 597 FLUSHQ(&tp->t_rawq); 598 tp->t_rocount = 0; 599 } 600 CLR(tp->t_state, TS_LOCAL); 601 goto endcase; 602 } 603 /* 604 * word erase (^W) 605 */ 606 if (CCEQ(cc[VWERASE], c) && ISSET(lflag, IEXTEN)) { 607 int ctype; 608 609 /* 610 * erase whitespace 611 */ 612 while ((c = clist_unputc(&tp->t_rawq)) == ' ' || c == '\t') 613 ttyrub(c, tp); 614 if (c == -1) 615 goto endcase; 616 /* 617 * erase last char of word and remember the 618 * next chars type (for ALTWERASE) 619 */ 620 ttyrub(c, tp); 621 c = clist_unputc(&tp->t_rawq); 622 if (c == -1) 623 goto endcase; 624 if (c == ' ' || c == '\t') { 625 clist_putc(c, &tp->t_rawq); 626 goto endcase; 627 } 628 ctype = ISALPHA(c); 629 /* 630 * erase rest of word 631 */ 632 do { 633 ttyrub(c, tp); 634 c = clist_unputc(&tp->t_rawq); 635 if (c == -1) 636 goto endcase; 637 } while (c != ' ' && c != '\t' && 638 (!ISSET(lflag, ALTWERASE) || ISALPHA(c) == ctype)); 639 clist_putc(c, &tp->t_rawq); 640 goto endcase; 641 } 642 /* 643 * reprint line (^R) 644 */ 645 if (CCEQ(cc[VREPRINT], c) && ISSET(lflag, IEXTEN)) { 646 ttyretype(tp); 647 goto endcase; 648 } 649 /* 650 * ^T - kernel info and generate SIGINFO 651 */ 652 if (CCEQ(cc[VSTATUS], c) && ISSET(lflag, IEXTEN)) { 653 if (ISSET(lflag, ISIG)) 654 pgsignal(tp->t_pgrp, SIGINFO, 1); 655 if (!ISSET(lflag, NOKERNINFO)) 656 ttyinfo(tp); 657 goto endcase; 658 } 659 if (CCEQ(cc[VCHECKPT], c) && ISSET(lflag, IEXTEN)) { 660 if (ISSET(lflag, ISIG)) 661 pgsignal(tp->t_pgrp, SIGCKPT, 1); 662 goto endcase; 663 } 664 } 665 /* 666 * Check for input buffer overflow 667 */ 668 if (tp->t_rawq.c_cc + tp->t_canq.c_cc >= MAX_INPUT) { 669 input_overflow: 670 if (ISSET(iflag, IMAXBEL)) { 671 if (tp->t_outq.c_cc < tp->t_ohiwat) 672 (void)ttyoutput(CTRL('g'), tp); 673 } 674 goto endcase; 675 } 676 677 if ( c == 0377 && ISSET(iflag, PARMRK) && !ISSET(iflag, ISTRIP) 678 && ISSET(iflag, IGNBRK|IGNPAR) != (IGNBRK|IGNPAR)) 679 clist_putc(0377 | TTY_QUOTE, &tp->t_rawq); 680 681 /* 682 * Put data char in q for user and 683 * wakeup on seeing a line delimiter. 684 */ 685 if (clist_putc(c, &tp->t_rawq) >= 0) { 686 if (!ISSET(lflag, ICANON)) { 687 ttwakeup(tp); 688 ttyecho(c, tp); 689 goto endcase; 690 } 691 if (TTBREAKC(c, lflag)) { 692 tp->t_rocount = 0; 693 catq(&tp->t_rawq, &tp->t_canq); 694 ttwakeup(tp); 695 } else if (tp->t_rocount++ == 0) 696 tp->t_rocol = tp->t_column; 697 if (ISSET(tp->t_state, TS_ERASE)) { 698 /* 699 * end of prterase \.../ 700 */ 701 CLR(tp->t_state, TS_ERASE); 702 (void)ttyoutput('/', tp); 703 } 704 i = tp->t_column; 705 ttyecho(c, tp); 706 if (CCEQ(cc[VEOF], c) && ISSET(lflag, ECHO)) { 707 /* 708 * Place the cursor over the '^' of the ^D. 709 */ 710 i = imin(2, tp->t_column - i); 711 while (i > 0) { 712 (void)ttyoutput('\b', tp); 713 i--; 714 } 715 } 716 } 717 endcase: 718 /* 719 * IXANY means allow any character to restart output. 720 */ 721 if (ISSET(tp->t_state, TS_TTSTOP) && 722 !ISSET(iflag, IXANY) && cc[VSTART] != cc[VSTOP]) { 723 lwkt_reltoken(&tty_token); 724 return (0); 725 } 726 restartoutput: 727 CLR(tp->t_lflag, FLUSHO); 728 CLR(tp->t_state, TS_TTSTOP); 729 startoutput: 730 lwkt_reltoken(&tty_token); 731 return (ttstart(tp)); 732 } 733 734 /* 735 * Output a single character on a tty, doing output processing 736 * as needed (expanding tabs, newline processing, etc.). 737 * Returns < 0 if succeeds, otherwise returns char to resend. 738 * Must be recursive. 739 */ 740 static int 741 ttyoutput(int c, struct tty *tp) 742 { 743 tcflag_t oflag; 744 int col; 745 746 lwkt_gettoken(&tty_token); 747 oflag = tp->t_oflag; 748 if (!ISSET(oflag, OPOST)) { 749 if (ISSET(tp->t_lflag, FLUSHO)) { 750 lwkt_reltoken(&tty_token); 751 return (-1); 752 } 753 if (clist_putc(c, &tp->t_outq)) { 754 lwkt_reltoken(&tty_token); 755 return (c); 756 } 757 tk_nout++; 758 tp->t_outcc++; 759 lwkt_reltoken(&tty_token); 760 return (-1); 761 } 762 /* 763 * Do tab expansion if OXTABS is set. Special case if we external 764 * processing, we don't do the tab expansion because we'll probably 765 * get it wrong. If tab expansion needs to be done, let it happen 766 * externally. 767 */ 768 CLR(c, ~TTY_CHARMASK); 769 if (c == '\t' && 770 ISSET(oflag, OXTABS) && !ISSET(tp->t_lflag, EXTPROC)) { 771 c = 8 - (tp->t_column & 7); 772 if (!ISSET(tp->t_lflag, FLUSHO)) { 773 crit_enter(); /* Don't interrupt tabs. */ 774 c -= b_to_q(" ", c, &tp->t_outq); 775 tk_nout += c; 776 tp->t_outcc += c; 777 crit_exit(); 778 } 779 tp->t_column += c; 780 lwkt_reltoken(&tty_token); 781 return (c ? -1 : '\t'); 782 } 783 if (c == CEOT && ISSET(oflag, ONOEOT)) { 784 lwkt_reltoken(&tty_token); 785 return (-1); 786 } 787 788 /* 789 * Newline translation: if ONLCR is set, 790 * translate newline into "\r\n". 791 */ 792 if (c == '\n' && ISSET(tp->t_oflag, ONLCR)) { 793 tk_nout++; 794 tp->t_outcc++; 795 if (!ISSET(tp->t_lflag, FLUSHO) && clist_putc('\r', &tp->t_outq)) { 796 lwkt_reltoken(&tty_token); 797 return (c); 798 } 799 } 800 /* If OCRNL is set, translate "\r" into "\n". */ 801 else if (c == '\r' && ISSET(tp->t_oflag, OCRNL)) 802 c = '\n'; 803 /* If ONOCR is set, don't transmit CRs when on column 0. */ 804 else if (c == '\r' && ISSET(tp->t_oflag, ONOCR) && tp->t_column == 0) { 805 lwkt_reltoken(&tty_token); 806 return (-1); 807 } 808 809 tk_nout++; 810 tp->t_outcc++; 811 if (!ISSET(tp->t_lflag, FLUSHO) && clist_putc(c, &tp->t_outq)) { 812 lwkt_reltoken(&tty_token); 813 return (c); 814 } 815 816 col = tp->t_column; 817 switch (CCLASS(c)) { 818 case BACKSPACE: 819 if (col > 0) 820 --col; 821 break; 822 case CONTROL: 823 break; 824 case NEWLINE: 825 if (ISSET(tp->t_oflag, ONLCR | ONLRET)) 826 col = 0; 827 break; 828 case RETURN: 829 col = 0; 830 break; 831 case ORDINARY: 832 ++col; 833 break; 834 case TAB: 835 col = (col + 8) & ~7; 836 break; 837 } 838 tp->t_column = col; 839 lwkt_reltoken(&tty_token); 840 return (-1); 841 } 842 843 /* 844 * Ioctls for all tty devices. Called after line-discipline specific ioctl 845 * has been called to do discipline-specific functions and/or reject any 846 * of these ioctl commands. 847 */ 848 /* ARGSUSED */ 849 int 850 ttioctl(struct tty *tp, u_long cmd, void *data, int flag) 851 { 852 struct thread *td = curthread; 853 struct lwp *lp = td->td_lwp; 854 struct proc *p = td->td_proc; 855 struct pgrp *opgrp; 856 struct tty *otp; 857 int error; 858 859 KKASSERT(p); 860 lwkt_gettoken(&tty_token); 861 lwkt_gettoken(&proc_token); 862 lwkt_gettoken(&p->p_token); 863 864 /* If the ioctl involves modification, hang if in the background. */ 865 switch (cmd) { 866 case TIOCCBRK: 867 case TIOCCONS: 868 case TIOCDRAIN: 869 case TIOCEXCL: 870 case TIOCFLUSH: 871 #ifdef TIOCHPCL 872 case TIOCHPCL: 873 #endif 874 case TIOCNXCL: 875 case TIOCSBRK: 876 case TIOCSCTTY: 877 case TIOCSDRAINWAIT: 878 case TIOCSETA: 879 case TIOCSETAF: 880 case TIOCSETAW: 881 case TIOCSETD: 882 case TIOCSPGRP: 883 case TIOCSTART: 884 case TIOCSTAT: 885 case TIOCSTI: 886 case TIOCSTOP: 887 case TIOCSWINSZ: 888 #if defined(COMPAT_43) 889 case TIOCLBIC: 890 case TIOCLBIS: 891 case TIOCLSET: 892 case TIOCSETC: 893 case OTIOCSETD: 894 case TIOCSETN: 895 case TIOCSETP: 896 case TIOCSLTC: 897 #endif 898 while (isbackground(p, tp) && !(p->p_flags & P_PPWAIT) && 899 !SIGISMEMBER(p->p_sigignore, SIGTTOU) && 900 !SIGISMEMBER(lp->lwp_sigmask, SIGTTOU)) { 901 if (p->p_pgrp->pg_jobc == 0) { 902 lwkt_reltoken(&p->p_token); 903 lwkt_reltoken(&proc_token); 904 lwkt_reltoken(&tty_token); 905 return (EIO); 906 } 907 pgsignal(p->p_pgrp, SIGTTOU, 1); 908 error = ttysleep(tp, &lbolt, PCATCH, "ttybg1", 909 0); 910 if (error) { 911 lwkt_reltoken(&p->p_token); 912 lwkt_reltoken(&proc_token); 913 lwkt_reltoken(&tty_token); 914 return (error); 915 } 916 } 917 break; 918 } 919 920 switch (cmd) { /* Process the ioctl. */ 921 case FIOASYNC: /* set/clear async i/o */ 922 crit_enter(); 923 if (*(int *)data) 924 SET(tp->t_state, TS_ASYNC); 925 else 926 CLR(tp->t_state, TS_ASYNC); 927 crit_exit(); 928 break; 929 case FIONREAD: /* get # bytes to read */ 930 crit_enter(); 931 *(int *)data = ttnread(tp); 932 crit_exit(); 933 break; 934 935 case FIOSETOWN: 936 /* 937 * Policy -- Don't allow FIOSETOWN on someone else's 938 * controlling tty 939 */ 940 if (tp->t_session != NULL && !isctty(p, tp)) { 941 lwkt_reltoken(&p->p_token); 942 lwkt_reltoken(&proc_token); 943 lwkt_reltoken(&tty_token); 944 return (ENOTTY); 945 } 946 947 error = fsetown(*(int *)data, &tp->t_sigio); 948 if (error) { 949 lwkt_reltoken(&p->p_token); 950 lwkt_reltoken(&proc_token); 951 lwkt_reltoken(&tty_token); 952 return (error); 953 } 954 break; 955 case FIOGETOWN: 956 if (tp->t_session != NULL && !isctty(p, tp)) { 957 lwkt_reltoken(&p->p_token); 958 lwkt_reltoken(&proc_token); 959 lwkt_reltoken(&tty_token); 960 return (ENOTTY); 961 } 962 *(int *)data = fgetown(&tp->t_sigio); 963 break; 964 965 case TIOCEXCL: /* set exclusive use of tty */ 966 crit_enter(); 967 SET(tp->t_state, TS_XCLUDE); 968 crit_exit(); 969 break; 970 case TIOCFLUSH: { /* flush buffers */ 971 int flags = *(int *)data; 972 973 if (flags == 0) 974 flags = FREAD | FWRITE; 975 else 976 flags &= FREAD | FWRITE; 977 ttyflush(tp, flags); 978 break; 979 } 980 case TIOCCONS: /* become virtual console */ 981 if (*(int *)data) { 982 if (constty && constty != tp && 983 ISSET(constty->t_state, TS_CONNECTED)) { 984 lwkt_reltoken(&p->p_token); 985 lwkt_reltoken(&proc_token); 986 lwkt_reltoken(&tty_token); 987 return (EBUSY); 988 } 989 #ifndef UCONSOLE 990 if ((error = priv_check(td, PRIV_ROOT)) != 0) { 991 lwkt_reltoken(&p->p_token); 992 lwkt_reltoken(&proc_token); 993 lwkt_reltoken(&tty_token); 994 return (error); 995 } 996 #endif 997 constty = tp; 998 } else if (tp == constty) 999 constty = NULL; 1000 break; 1001 case TIOCDRAIN: /* wait till output drained */ 1002 error = ttywait(tp); 1003 if (error) { 1004 lwkt_reltoken(&p->p_token); 1005 lwkt_reltoken(&proc_token); 1006 lwkt_reltoken(&tty_token); 1007 return (error); 1008 } 1009 break; 1010 case TIOCGETA: { /* get termios struct */ 1011 struct termios *t = (struct termios *)data; 1012 1013 bcopy(&tp->t_termios, t, sizeof(struct termios)); 1014 break; 1015 } 1016 case TIOCGETD: /* get line discipline */ 1017 *(int *)data = tp->t_line; 1018 break; 1019 case TIOCGWINSZ: /* get window size */ 1020 *(struct winsize *)data = tp->t_winsize; 1021 break; 1022 case TIOCGPGRP: /* get pgrp of tty */ 1023 if (!isctty(p, tp)) { 1024 lwkt_reltoken(&p->p_token); 1025 lwkt_reltoken(&proc_token); 1026 lwkt_reltoken(&tty_token); 1027 return (ENOTTY); 1028 } 1029 *(int *)data = tp->t_pgrp ? tp->t_pgrp->pg_id : NO_PID; 1030 break; 1031 case TIOCGSID: /* get sid of tty */ 1032 if (!isctty(p, tp)) { 1033 lwkt_reltoken(&p->p_token); 1034 lwkt_reltoken(&proc_token); 1035 lwkt_reltoken(&tty_token); 1036 return (ENOTTY); 1037 } 1038 *(int *)data = tp->t_session->s_sid; 1039 break; 1040 #ifdef TIOCHPCL 1041 case TIOCHPCL: /* hang up on last close */ 1042 crit_enter(); 1043 SET(tp->t_cflag, HUPCL); 1044 crit_exit(); 1045 break; 1046 #endif 1047 case TIOCNXCL: /* reset exclusive use of tty */ 1048 crit_enter(); 1049 CLR(tp->t_state, TS_XCLUDE); 1050 crit_exit(); 1051 break; 1052 case TIOCOUTQ: /* output queue size */ 1053 *(int *)data = tp->t_outq.c_cc; 1054 break; 1055 case TIOCSETA: /* set termios struct */ 1056 case TIOCSETAW: /* drain output, set */ 1057 case TIOCSETAF: { /* drn out, fls in, set */ 1058 struct termios *t = (struct termios *)data; 1059 1060 if (t->c_ispeed == 0) 1061 t->c_ispeed = t->c_ospeed; 1062 if (t->c_ispeed == 0) 1063 t->c_ispeed = tp->t_ospeed; 1064 if (t->c_ispeed == 0) { 1065 lwkt_reltoken(&p->p_token); 1066 lwkt_reltoken(&proc_token); 1067 lwkt_reltoken(&tty_token); 1068 return (EINVAL); 1069 } 1070 crit_enter(); 1071 if (cmd == TIOCSETAW || cmd == TIOCSETAF) { 1072 error = ttywait(tp); 1073 if (error) { 1074 crit_exit(); 1075 lwkt_reltoken(&p->p_token); 1076 lwkt_reltoken(&proc_token); 1077 lwkt_reltoken(&tty_token); 1078 return (error); 1079 } 1080 if (cmd == TIOCSETAF) 1081 ttyflush(tp, FREAD); 1082 } 1083 if (!ISSET(t->c_cflag, CIGNORE)) { 1084 /* 1085 * Set device hardware. 1086 */ 1087 if (tp->t_param && (error = (*tp->t_param)(tp, t))) { 1088 crit_exit(); 1089 lwkt_reltoken(&p->p_token); 1090 lwkt_reltoken(&proc_token); 1091 lwkt_reltoken(&tty_token); 1092 return (error); 1093 } 1094 if (ISSET(t->c_cflag, CLOCAL) && 1095 !ISSET(tp->t_cflag, CLOCAL)) { 1096 /* 1097 * XXX disconnections would be too hard to 1098 * get rid of without this kludge. The only 1099 * way to get rid of controlling terminals 1100 * is to exit from the session leader. 1101 */ 1102 CLR(tp->t_state, TS_ZOMBIE); 1103 1104 wakeup(TSA_CARR_ON(tp)); 1105 ttwakeup(tp); 1106 ttwwakeup(tp); 1107 } 1108 if ((ISSET(tp->t_state, TS_CARR_ON) || 1109 ISSET(t->c_cflag, CLOCAL)) && 1110 !ISSET(tp->t_state, TS_ZOMBIE)) 1111 SET(tp->t_state, TS_CONNECTED); 1112 else 1113 CLR(tp->t_state, TS_CONNECTED); 1114 tp->t_cflag = t->c_cflag; 1115 tp->t_ispeed = t->c_ispeed; 1116 if (t->c_ospeed != 0) 1117 tp->t_ospeed = t->c_ospeed; 1118 ttsetwater(tp); 1119 } 1120 if (ISSET(t->c_lflag, ICANON) != ISSET(tp->t_lflag, ICANON) && 1121 cmd != TIOCSETAF) { 1122 if (ISSET(t->c_lflag, ICANON)) 1123 SET(tp->t_lflag, PENDIN); 1124 else { 1125 /* 1126 * XXX we really shouldn't allow toggling 1127 * ICANON while we're in a non-termios line 1128 * discipline. Now we have to worry about 1129 * panicing for a null queue. 1130 */ 1131 if (tp->t_canq.c_cbreserved > 0 && 1132 tp->t_rawq.c_cbreserved > 0) { 1133 catq(&tp->t_rawq, &tp->t_canq); 1134 /* 1135 * XXX the queue limits may be 1136 * different, so the old queue 1137 * swapping method no longer works. 1138 */ 1139 catq(&tp->t_canq, &tp->t_rawq); 1140 } 1141 CLR(tp->t_lflag, PENDIN); 1142 } 1143 ttwakeup(tp); 1144 } 1145 tp->t_iflag = t->c_iflag; 1146 tp->t_oflag = t->c_oflag; 1147 /* 1148 * Make the EXTPROC bit read only. 1149 */ 1150 if (ISSET(tp->t_lflag, EXTPROC)) 1151 SET(t->c_lflag, EXTPROC); 1152 else 1153 CLR(t->c_lflag, EXTPROC); 1154 tp->t_lflag = t->c_lflag | ISSET(tp->t_lflag, PENDIN); 1155 if (t->c_cc[VMIN] != tp->t_cc[VMIN] || 1156 t->c_cc[VTIME] != tp->t_cc[VTIME]) 1157 ttwakeup(tp); 1158 bcopy(t->c_cc, tp->t_cc, sizeof(t->c_cc)); 1159 crit_exit(); 1160 break; 1161 } 1162 case TIOCSETD: { /* set line discipline */ 1163 int t = *(int *)data; 1164 cdev_t device = tp->t_dev; 1165 1166 if ((u_int)t >= nlinesw) { 1167 lwkt_reltoken(&p->p_token); 1168 lwkt_reltoken(&proc_token); 1169 lwkt_reltoken(&tty_token); 1170 return (ENXIO); 1171 } 1172 if (t != tp->t_line) { 1173 crit_enter(); 1174 (*linesw[tp->t_line].l_close)(tp, flag); 1175 error = (*linesw[t].l_open)(device, tp); 1176 if (error) { 1177 (void)(*linesw[tp->t_line].l_open)(device, tp); 1178 crit_exit(); 1179 lwkt_reltoken(&p->p_token); 1180 lwkt_reltoken(&proc_token); 1181 lwkt_reltoken(&tty_token); 1182 return (error); 1183 } 1184 tp->t_line = t; 1185 crit_exit(); 1186 } 1187 break; 1188 } 1189 case TIOCSTART: /* start output, like ^Q */ 1190 crit_enter(); 1191 if (ISSET(tp->t_state, TS_TTSTOP) || 1192 ISSET(tp->t_lflag, FLUSHO)) { 1193 CLR(tp->t_lflag, FLUSHO); 1194 CLR(tp->t_state, TS_TTSTOP); 1195 ttstart(tp); 1196 } 1197 crit_exit(); 1198 break; 1199 case TIOCSTI: /* simulate terminal input */ 1200 if ((flag & FREAD) == 0 && priv_check(td, PRIV_ROOT)) { 1201 lwkt_reltoken(&p->p_token); 1202 lwkt_reltoken(&proc_token); 1203 lwkt_reltoken(&tty_token); 1204 return (EPERM); 1205 } 1206 if (!isctty(p, tp) && priv_check(td, PRIV_ROOT)) { 1207 lwkt_reltoken(&p->p_token); 1208 lwkt_reltoken(&proc_token); 1209 lwkt_reltoken(&tty_token); 1210 return (EACCES); 1211 } 1212 crit_enter(); 1213 (*linesw[tp->t_line].l_rint)(*(u_char *)data, tp); 1214 crit_exit(); 1215 break; 1216 case TIOCSTOP: /* stop output, like ^S */ 1217 crit_enter(); 1218 if (!ISSET(tp->t_state, TS_TTSTOP)) { 1219 SET(tp->t_state, TS_TTSTOP); 1220 (*tp->t_stop)(tp, 0); 1221 } 1222 crit_exit(); 1223 break; 1224 case TIOCSCTTY: /* become controlling tty */ 1225 /* Session ctty vnode pointer set in vnode layer. */ 1226 if (!SESS_LEADER(p) || 1227 ((p->p_session->s_ttyvp || tp->t_session) && 1228 (tp->t_session != p->p_session))) { 1229 lwkt_reltoken(&p->p_token); 1230 lwkt_reltoken(&proc_token); 1231 lwkt_reltoken(&tty_token); 1232 return (EPERM); 1233 } 1234 ttyhold(tp); 1235 tp->t_session = p->p_session; 1236 opgrp = tp->t_pgrp; 1237 pgref(p->p_pgrp); 1238 tp->t_pgrp = p->p_pgrp; 1239 otp = p->p_session->s_ttyp; 1240 p->p_session->s_ttyp = tp; 1241 p->p_flags |= P_CONTROLT; 1242 if (otp) 1243 ttyunhold(otp); 1244 if (opgrp) { 1245 pgrel(opgrp); 1246 opgrp = NULL; 1247 } 1248 break; 1249 case TIOCSPGRP: { /* set pgrp of tty */ 1250 pid_t pgid = *(int *)data; 1251 1252 if (!isctty(p, tp)) { 1253 lwkt_reltoken(&p->p_token); 1254 lwkt_reltoken(&proc_token); 1255 lwkt_reltoken(&tty_token); 1256 return (ENOTTY); 1257 } 1258 else if (pgid < 1 || pgid > PID_MAX) { 1259 lwkt_reltoken(&p->p_token); 1260 lwkt_reltoken(&proc_token); 1261 lwkt_reltoken(&tty_token); 1262 return (EINVAL); 1263 } else { 1264 struct pgrp *pgrp = pgfind(pgid); 1265 if (pgrp == NULL || pgrp->pg_session != p->p_session) { 1266 if (pgrp) 1267 pgrel(pgrp); 1268 lwkt_reltoken(&p->p_token); 1269 lwkt_reltoken(&proc_token); 1270 lwkt_reltoken(&tty_token); 1271 return (EPERM); 1272 } 1273 opgrp = tp->t_pgrp; 1274 tp->t_pgrp = pgrp; 1275 if (opgrp) { 1276 pgrel(opgrp); 1277 opgrp = NULL; 1278 } 1279 } 1280 break; 1281 } 1282 case TIOCSTAT: /* simulate control-T */ 1283 crit_enter(); 1284 ttyinfo(tp); 1285 crit_exit(); 1286 break; 1287 case TIOCSWINSZ: /* set window size */ 1288 if (bcmp((caddr_t)&tp->t_winsize, data, 1289 sizeof (struct winsize))) { 1290 tp->t_winsize = *(struct winsize *)data; 1291 pgsignal(tp->t_pgrp, SIGWINCH, 1); 1292 } 1293 break; 1294 case TIOCSDRAINWAIT: 1295 error = priv_check(td, PRIV_ROOT); 1296 if (error) { 1297 lwkt_reltoken(&p->p_token); 1298 lwkt_reltoken(&proc_token); 1299 lwkt_reltoken(&tty_token); 1300 return (error); 1301 } 1302 tp->t_timeout = *(int *)data * hz; 1303 wakeup(TSA_OCOMPLETE(tp)); 1304 wakeup(TSA_OLOWAT(tp)); 1305 break; 1306 case TIOCGDRAINWAIT: 1307 *(int *)data = tp->t_timeout / hz; 1308 break; 1309 default: 1310 lwkt_reltoken(&p->p_token); 1311 lwkt_reltoken(&proc_token); 1312 lwkt_reltoken(&tty_token); 1313 #if defined(COMPAT_43) 1314 return (ttcompat(tp, cmd, data, flag)); 1315 #else 1316 return (ENOIOCTL); 1317 #endif 1318 } 1319 lwkt_reltoken(&p->p_token); 1320 lwkt_reltoken(&proc_token); 1321 lwkt_reltoken(&tty_token); 1322 return (0); 1323 } 1324 1325 static struct filterops ttyread_filtops = 1326 { FILTEROP_ISFD|FILTEROP_MPSAFE, NULL, filt_ttyrdetach, filt_ttyread }; 1327 static struct filterops ttywrite_filtops = 1328 { FILTEROP_ISFD|FILTEROP_MPSAFE, NULL, filt_ttywdetach, filt_ttywrite }; 1329 1330 int 1331 ttykqfilter(struct dev_kqfilter_args *ap) 1332 { 1333 cdev_t dev = ap->a_head.a_dev; 1334 struct knote *kn = ap->a_kn; 1335 struct tty *tp = dev->si_tty; 1336 struct klist *klist; 1337 1338 ap->a_result = 0; 1339 1340 lwkt_gettoken(&tty_token); 1341 switch (kn->kn_filter) { 1342 case EVFILT_READ: 1343 klist = &tp->t_rkq.ki_note; 1344 kn->kn_fop = &ttyread_filtops; 1345 break; 1346 case EVFILT_WRITE: 1347 klist = &tp->t_wkq.ki_note; 1348 kn->kn_fop = &ttywrite_filtops; 1349 break; 1350 default: 1351 ap->a_result = EOPNOTSUPP; 1352 lwkt_reltoken(&tty_token); 1353 return (0); 1354 } 1355 lwkt_reltoken(&tty_token); 1356 kn->kn_hook = (caddr_t)dev; 1357 knote_insert(klist, kn); 1358 1359 return (0); 1360 } 1361 1362 static void 1363 filt_ttyrdetach(struct knote *kn) 1364 { 1365 struct tty *tp = ((cdev_t)kn->kn_hook)->si_tty; 1366 1367 lwkt_gettoken(&tty_token); 1368 knote_remove(&tp->t_rkq.ki_note, kn); 1369 lwkt_reltoken(&tty_token); 1370 } 1371 1372 static int 1373 filt_ttyread(struct knote *kn, long hint) 1374 { 1375 struct tty *tp = ((cdev_t)kn->kn_hook)->si_tty; 1376 1377 lwkt_gettoken(&tty_token); 1378 kn->kn_data = ttnread(tp); 1379 if (ISSET(tp->t_state, TS_ZOMBIE)) { 1380 kn->kn_flags |= (EV_EOF | EV_NODATA); 1381 lwkt_reltoken(&tty_token); 1382 return (1); 1383 } 1384 lwkt_reltoken(&tty_token); 1385 return (kn->kn_data > 0); 1386 } 1387 1388 static void 1389 filt_ttywdetach(struct knote *kn) 1390 { 1391 struct tty *tp = ((cdev_t)kn->kn_hook)->si_tty; 1392 1393 lwkt_gettoken(&tty_token); 1394 knote_remove(&tp->t_wkq.ki_note, kn); 1395 lwkt_reltoken(&tty_token); 1396 } 1397 1398 static int 1399 filt_ttywrite(struct knote *kn, long hint) 1400 { 1401 struct tty *tp = ((cdev_t)kn->kn_hook)->si_tty; 1402 int ret; 1403 1404 lwkt_gettoken(&tty_token); 1405 kn->kn_data = tp->t_outq.c_cc; 1406 if (ISSET(tp->t_state, TS_ZOMBIE)) { 1407 lwkt_reltoken(&tty_token); 1408 return (1); 1409 } 1410 ret = (kn->kn_data <= tp->t_olowat && 1411 ISSET(tp->t_state, TS_CONNECTED)); 1412 lwkt_reltoken(&tty_token); 1413 return ret; 1414 } 1415 1416 /* 1417 * Must be called while in a critical section. 1418 * NOTE: tty_token must be held. 1419 */ 1420 static int 1421 ttnread(struct tty *tp) 1422 { 1423 int nread; 1424 1425 ASSERT_LWKT_TOKEN_HELD(&tty_token); 1426 if (ISSET(tp->t_lflag, PENDIN)) 1427 ttypend(tp); 1428 nread = tp->t_canq.c_cc; 1429 if (!ISSET(tp->t_lflag, ICANON)) { 1430 nread += tp->t_rawq.c_cc; 1431 if (nread < tp->t_cc[VMIN] && tp->t_cc[VTIME] == 0) 1432 nread = 0; 1433 } 1434 return (nread); 1435 } 1436 1437 /* 1438 * Wait for output to drain. 1439 */ 1440 int 1441 ttywait(struct tty *tp) 1442 { 1443 int error; 1444 1445 error = 0; 1446 crit_enter(); 1447 lwkt_gettoken(&tty_token); 1448 while ((tp->t_outq.c_cc || ISSET(tp->t_state, TS_BUSY)) && 1449 ISSET(tp->t_state, TS_CONNECTED) && tp->t_oproc) { 1450 (*tp->t_oproc)(tp); 1451 if ((tp->t_outq.c_cc || ISSET(tp->t_state, TS_BUSY)) && 1452 ISSET(tp->t_state, TS_CONNECTED)) { 1453 SET(tp->t_state, TS_SO_OCOMPLETE); 1454 error = ttysleep(tp, TSA_OCOMPLETE(tp), 1455 PCATCH, "ttywai", 1456 tp->t_timeout); 1457 if (error) { 1458 if (error == EWOULDBLOCK) 1459 error = EIO; 1460 break; 1461 } 1462 } else 1463 break; 1464 } 1465 if (!error && (tp->t_outq.c_cc || ISSET(tp->t_state, TS_BUSY))) 1466 error = EIO; 1467 lwkt_reltoken(&tty_token); 1468 crit_exit(); 1469 return (error); 1470 } 1471 1472 /* 1473 * Flush if successfully wait. 1474 */ 1475 static int 1476 ttywflush(struct tty *tp) 1477 { 1478 int error; 1479 1480 if ((error = ttywait(tp)) == 0) 1481 ttyflush(tp, FREAD); 1482 return (error); 1483 } 1484 1485 /* 1486 * Flush tty read and/or write queues, notifying anyone waiting. 1487 */ 1488 void 1489 ttyflush(struct tty *tp, int rw) 1490 { 1491 crit_enter(); 1492 lwkt_gettoken(&tty_token); 1493 #if 0 1494 again: 1495 #endif 1496 if (rw & FWRITE) { 1497 FLUSHQ(&tp->t_outq); 1498 CLR(tp->t_state, TS_TTSTOP); 1499 } 1500 (*tp->t_stop)(tp, rw); 1501 if (rw & FREAD) { 1502 FLUSHQ(&tp->t_canq); 1503 FLUSHQ(&tp->t_rawq); 1504 CLR(tp->t_lflag, PENDIN); 1505 tp->t_rocount = 0; 1506 tp->t_rocol = 0; 1507 CLR(tp->t_state, TS_LOCAL); 1508 ttwakeup(tp); 1509 if (ISSET(tp->t_state, TS_TBLOCK)) { 1510 if (rw & FWRITE) 1511 FLUSHQ(&tp->t_outq); 1512 ttyunblock(tp); 1513 1514 /* 1515 * Don't let leave any state that might clobber the 1516 * next line discipline (although we should do more 1517 * to send the START char). Not clearing the state 1518 * may have caused the "putc to a clist with no 1519 * reserved cblocks" panic/kprintf. 1520 */ 1521 CLR(tp->t_state, TS_TBLOCK); 1522 1523 #if 0 /* forget it, sleeping isn't always safe and we don't know when it is */ 1524 if (ISSET(tp->t_iflag, IXOFF)) { 1525 /* 1526 * XXX wait a bit in the hope that the stop 1527 * character (if any) will go out. Waiting 1528 * isn't good since it allows races. This 1529 * will be fixed when the stop character is 1530 * put in a special queue. Don't bother with 1531 * the checks in ttywait() since the timeout 1532 * will save us. 1533 */ 1534 SET(tp->t_state, TS_SO_OCOMPLETE); 1535 ttysleep(tp, TSA_OCOMPLETE(tp), 0, 1536 "ttyfls", hz / 10); 1537 /* 1538 * Don't try sending the stop character again. 1539 */ 1540 CLR(tp->t_state, TS_TBLOCK); 1541 goto again; 1542 } 1543 #endif 1544 } 1545 } 1546 if (rw & FWRITE) { 1547 FLUSHQ(&tp->t_outq); 1548 ttwwakeup(tp); 1549 } 1550 lwkt_reltoken(&tty_token); 1551 crit_exit(); 1552 } 1553 1554 /* 1555 * Copy in the default termios characters. 1556 */ 1557 void 1558 termioschars(struct termios *t) 1559 { 1560 lwkt_gettoken(&tty_token); 1561 bcopy(ttydefchars, t->c_cc, sizeof t->c_cc); 1562 lwkt_reltoken(&tty_token); 1563 } 1564 1565 /* 1566 * Old interface. 1567 */ 1568 void 1569 ttychars(struct tty *tp) 1570 { 1571 lwkt_gettoken(&tty_token); 1572 termioschars(&tp->t_termios); 1573 lwkt_reltoken(&tty_token); 1574 } 1575 1576 /* 1577 * Handle input high water. Send stop character for the IXOFF case. Turn 1578 * on our input flow control bit and propagate the changes to the driver. 1579 * XXX the stop character should be put in a special high priority queue. 1580 */ 1581 void 1582 ttyblock(struct tty *tp) 1583 { 1584 lwkt_gettoken(&tty_token); 1585 SET(tp->t_state, TS_TBLOCK); 1586 if (ISSET(tp->t_iflag, IXOFF) && tp->t_cc[VSTOP] != _POSIX_VDISABLE && 1587 clist_putc(tp->t_cc[VSTOP], &tp->t_outq) != 0) 1588 CLR(tp->t_state, TS_TBLOCK); /* try again later */ 1589 ttstart(tp); 1590 lwkt_reltoken(&tty_token); 1591 } 1592 1593 /* 1594 * Handle input low water. Send start character for the IXOFF case. Turn 1595 * off our input flow control bit and propagate the changes to the driver. 1596 * XXX the start character should be put in a special high priority queue. 1597 */ 1598 static void 1599 ttyunblock(struct tty *tp) 1600 { 1601 lwkt_gettoken(&tty_token); 1602 CLR(tp->t_state, TS_TBLOCK); 1603 if (ISSET(tp->t_iflag, IXOFF) && tp->t_cc[VSTART] != _POSIX_VDISABLE && 1604 clist_putc(tp->t_cc[VSTART], &tp->t_outq) != 0) 1605 SET(tp->t_state, TS_TBLOCK); /* try again later */ 1606 ttstart(tp); 1607 lwkt_reltoken(&tty_token); 1608 } 1609 1610 #ifdef notyet 1611 /* Not used by any current (i386) drivers. */ 1612 /* 1613 * Restart after an inter-char delay. 1614 */ 1615 void 1616 ttrstrt(void *tp_arg) 1617 { 1618 struct tty *tp; 1619 1620 KASSERT(tp_arg != NULL, ("ttrstrt")); 1621 1622 tp = tp_arg; 1623 crit_enter(); 1624 lwkt_gettoken(&tty_token); 1625 CLR(tp->t_state, TS_TIMEOUT); 1626 ttstart(tp); 1627 lwkt_reltoken(&tty_token); 1628 crit_exit(); 1629 } 1630 #endif 1631 1632 int 1633 ttstart(struct tty *tp) 1634 { 1635 lwkt_gettoken(&tty_token); 1636 if (tp->t_oproc != NULL) /* XXX: Kludge for pty. */ 1637 (*tp->t_oproc)(tp); 1638 lwkt_reltoken(&tty_token); 1639 return (0); 1640 } 1641 1642 /* 1643 * "close" a line discipline 1644 */ 1645 int 1646 ttylclose(struct tty *tp, int flag) 1647 { 1648 lwkt_gettoken(&tty_token); 1649 if (flag & FNONBLOCK || ttywflush(tp)) 1650 ttyflush(tp, FREAD | FWRITE); 1651 lwkt_reltoken(&tty_token); 1652 return (0); 1653 } 1654 1655 void 1656 ttyhold(struct tty *tp) 1657 { 1658 ++tp->t_refs; 1659 } 1660 1661 void 1662 ttyunhold(struct tty *tp) 1663 { 1664 if (tp->t_unhold) 1665 tp->t_unhold(tp); 1666 else 1667 --tp->t_refs; 1668 } 1669 1670 /* 1671 * Handle modem control transition on a tty. 1672 * Flag indicates new state of carrier. 1673 * Returns 0 if the line should be turned off, otherwise 1. 1674 */ 1675 int 1676 ttymodem(struct tty *tp, int flag) 1677 { 1678 lwkt_gettoken(&tty_token); 1679 if (ISSET(tp->t_state, TS_CARR_ON) && ISSET(tp->t_cflag, MDMBUF)) { 1680 /* 1681 * MDMBUF: do flow control according to carrier flag 1682 * XXX TS_CAR_OFLOW doesn't do anything yet. TS_TTSTOP 1683 * works if IXON and IXANY are clear. 1684 */ 1685 if (flag) { 1686 CLR(tp->t_state, TS_CAR_OFLOW); 1687 CLR(tp->t_state, TS_TTSTOP); 1688 ttstart(tp); 1689 } else if (!ISSET(tp->t_state, TS_CAR_OFLOW)) { 1690 SET(tp->t_state, TS_CAR_OFLOW); 1691 SET(tp->t_state, TS_TTSTOP); 1692 (*tp->t_stop)(tp, 0); 1693 } 1694 } else if (flag == 0) { 1695 /* 1696 * Lost carrier. 1697 */ 1698 CLR(tp->t_state, TS_CARR_ON); 1699 if (ISSET(tp->t_state, TS_ISOPEN) && 1700 !ISSET(tp->t_cflag, CLOCAL)) { 1701 SET(tp->t_state, TS_ZOMBIE); 1702 CLR(tp->t_state, TS_CONNECTED); 1703 if (tp->t_session && tp->t_session->s_leader) 1704 ksignal(tp->t_session->s_leader, SIGHUP); 1705 ttyflush(tp, FREAD | FWRITE); 1706 lwkt_reltoken(&tty_token); 1707 return (0); 1708 } 1709 } else { 1710 /* 1711 * Carrier now on. 1712 */ 1713 SET(tp->t_state, TS_CARR_ON); 1714 if (!ISSET(tp->t_state, TS_ZOMBIE)) 1715 SET(tp->t_state, TS_CONNECTED); 1716 wakeup(TSA_CARR_ON(tp)); 1717 ttwakeup(tp); 1718 ttwwakeup(tp); 1719 } 1720 lwkt_reltoken(&tty_token); 1721 return (1); 1722 } 1723 1724 /* 1725 * Reinput pending characters after state switch 1726 * call from a critical section. 1727 */ 1728 static void 1729 ttypend(struct tty *tp) 1730 { 1731 struct clist tq; 1732 int c; 1733 1734 lwkt_gettoken(&tty_token); 1735 CLR(tp->t_lflag, PENDIN); 1736 SET(tp->t_state, TS_TYPEN); 1737 /* 1738 * XXX this assumes too much about clist internals. It may even 1739 * fail if the cblock slush pool is empty. We can't allocate more 1740 * cblocks here because we are called from an interrupt handler 1741 * and clist_alloc_cblocks() can wait. 1742 */ 1743 tq = tp->t_rawq; 1744 bzero(&tp->t_rawq, sizeof tp->t_rawq); 1745 tp->t_rawq.c_cbmax = tq.c_cbmax; 1746 tp->t_rawq.c_cbreserved = tq.c_cbreserved; 1747 while ((c = clist_getc(&tq)) >= 0) 1748 ttyinput(c, tp); 1749 CLR(tp->t_state, TS_TYPEN); 1750 lwkt_reltoken(&tty_token); 1751 } 1752 1753 /* 1754 * Process a read call on a tty device. 1755 */ 1756 int 1757 ttread(struct tty *tp, struct uio *uio, int flag) 1758 { 1759 struct clist *qp; 1760 int c; 1761 tcflag_t lflag; 1762 cc_t *cc = tp->t_cc; 1763 struct proc *pp; 1764 struct lwp *lp; 1765 int first, error = 0; 1766 int has_stime = 0, last_cc = 0; 1767 long slp = 0; /* XXX this should be renamed `timo'. */ 1768 struct timeval stime; 1769 1770 lp = curthread->td_lwp; 1771 stime.tv_sec = 0; /* fix compiler warnings */ 1772 stime.tv_usec = 0; 1773 1774 lwkt_gettoken(&tty_token); 1775 loop: 1776 crit_enter(); 1777 lflag = tp->t_lflag; 1778 /* 1779 * take pending input first 1780 */ 1781 if (ISSET(lflag, PENDIN)) { 1782 ttypend(tp); 1783 splz(); /* reduce latency */ 1784 lflag = tp->t_lflag; /* XXX ttypend() clobbers it */ 1785 } 1786 1787 /* 1788 * Hang process if it's in the background. 1789 */ 1790 lwkt_gettoken(&proc_token); 1791 if ((pp = curproc) && isbackground(pp, tp)) { 1792 crit_exit(); 1793 if (SIGISMEMBER(pp->p_sigignore, SIGTTIN) || 1794 SIGISMEMBER(lp->lwp_sigmask, SIGTTIN) || 1795 (pp->p_flags & P_PPWAIT) || pp->p_pgrp->pg_jobc == 0) { 1796 lwkt_reltoken(&proc_token); 1797 lwkt_reltoken(&tty_token); 1798 return (EIO); 1799 } 1800 pgsignal(pp->p_pgrp, SIGTTIN, 1); 1801 error = ttysleep(tp, &lbolt, PCATCH, "ttybg2", 0); 1802 if (error) { 1803 lwkt_reltoken(&proc_token); 1804 lwkt_reltoken(&tty_token); 1805 return (error); 1806 } 1807 lwkt_reltoken(&proc_token); 1808 goto loop; 1809 } 1810 lwkt_reltoken(&proc_token); 1811 1812 if (ISSET(tp->t_state, TS_ZOMBIE)) { 1813 crit_exit(); 1814 lwkt_reltoken(&tty_token); 1815 return (0); /* EOF */ 1816 } 1817 1818 /* 1819 * If canonical, use the canonical queue, 1820 * else use the raw queue. 1821 * 1822 * (should get rid of clists...) 1823 */ 1824 qp = ISSET(lflag, ICANON) ? &tp->t_canq : &tp->t_rawq; 1825 1826 if (flag & IO_NDELAY) { 1827 if (qp->c_cc > 0) 1828 goto read; 1829 if (!ISSET(lflag, ICANON) && cc[VMIN] == 0) { 1830 crit_exit(); 1831 lwkt_reltoken(&tty_token); 1832 return (0); 1833 } 1834 crit_exit(); 1835 lwkt_reltoken(&tty_token); 1836 return (EWOULDBLOCK); 1837 } 1838 if (!ISSET(lflag, ICANON)) { 1839 int m = cc[VMIN]; 1840 long t = cc[VTIME]; 1841 struct timeval timecopy; 1842 1843 /* 1844 * Check each of the four combinations. 1845 * (m > 0 && t == 0) is the normal read case. 1846 * It should be fairly efficient, so we check that and its 1847 * companion case (m == 0 && t == 0) first. 1848 * For the other two cases, we compute the target sleep time 1849 * into slp. 1850 */ 1851 if (t == 0) { 1852 if (qp->c_cc < m) 1853 goto sleep; 1854 if (qp->c_cc > 0) 1855 goto read; 1856 1857 /* m, t and qp->c_cc are all 0. 0 is enough input. */ 1858 crit_exit(); 1859 lwkt_reltoken(&tty_token); 1860 return (0); 1861 } 1862 t *= 100000; /* time in us */ 1863 #define diff(t1, t2) (((t1).tv_sec - (t2).tv_sec) * 1000000 + \ 1864 ((t1).tv_usec - (t2).tv_usec)) 1865 if (m > 0) { 1866 if (qp->c_cc <= 0) 1867 goto sleep; 1868 if (qp->c_cc >= m) 1869 goto read; 1870 getmicrotime(&timecopy); 1871 if (has_stime == 0) { 1872 /* first character, start timer */ 1873 has_stime = 1; 1874 stime = timecopy; 1875 slp = t; 1876 } else if (qp->c_cc > last_cc) { 1877 /* got a character, restart timer */ 1878 stime = timecopy; 1879 slp = t; 1880 } else { 1881 /* nothing, check expiration */ 1882 slp = t - diff(timecopy, stime); 1883 if (slp <= 0) 1884 goto read; 1885 } 1886 last_cc = qp->c_cc; 1887 } else { /* m == 0 */ 1888 if (qp->c_cc > 0) 1889 goto read; 1890 getmicrotime(&timecopy); 1891 if (has_stime == 0) { 1892 has_stime = 1; 1893 stime = timecopy; 1894 slp = t; 1895 } else { 1896 slp = t - diff(timecopy, stime); 1897 if (slp <= 0) { 1898 /* Timed out, but 0 is enough input. */ 1899 crit_exit(); 1900 lwkt_reltoken(&tty_token); 1901 return (0); 1902 } 1903 } 1904 } 1905 #undef diff 1906 /* 1907 * Rounding down may make us wake up just short 1908 * of the target, so we round up. 1909 * The formula is ceiling(slp * hz/1000000). 1910 * 32-bit arithmetic is enough for hz < 169. 1911 * XXX see tvtohz() for how to avoid overflow if hz 1912 * is large (divide by `tick' and/or arrange to 1913 * use tvtohz() if hz is large). 1914 */ 1915 slp = (long) (((u_long)slp * hz) + 999999) / 1000000; 1916 goto sleep; 1917 } 1918 if (qp->c_cc <= 0) { 1919 sleep: 1920 /* 1921 * There is no input, or not enough input and we can block. 1922 */ 1923 error = ttysleep(tp, TSA_HUP_OR_INPUT(tp), PCATCH, 1924 ISSET(tp->t_state, TS_CONNECTED) ? 1925 "ttyin" : "ttyhup", (int)slp); 1926 crit_exit(); 1927 if (error == EWOULDBLOCK) 1928 error = 0; 1929 else if (error) { 1930 lwkt_reltoken(&tty_token); 1931 return (error); 1932 } 1933 /* 1934 * XXX what happens if another process eats some input 1935 * while we are asleep (not just here)? It would be 1936 * safest to detect changes and reset our state variables 1937 * (has_stime and last_cc). 1938 */ 1939 slp = 0; 1940 goto loop; 1941 } 1942 read: 1943 crit_exit(); 1944 /* 1945 * Input present, check for input mapping and processing. 1946 */ 1947 first = 1; 1948 if (ISSET(lflag, ICANON | ISIG)) 1949 goto slowcase; 1950 for (;;) { 1951 char ibuf[IBUFSIZ]; 1952 int icc; 1953 1954 icc = (int)szmin(uio->uio_resid, IBUFSIZ); 1955 icc = q_to_b(qp, ibuf, icc); 1956 if (icc <= 0) { 1957 if (first) 1958 goto loop; 1959 break; 1960 } 1961 error = uiomove(ibuf, (size_t)icc, uio); 1962 /* 1963 * XXX if there was an error then we should ungetc() the 1964 * unmoved chars and reduce icc here. 1965 */ 1966 if (error) 1967 break; 1968 if (uio->uio_resid == 0) 1969 break; 1970 first = 0; 1971 } 1972 goto out; 1973 slowcase: 1974 for (;;) { 1975 c = clist_getc(qp); 1976 if (c < 0) { 1977 if (first) 1978 goto loop; 1979 break; 1980 } 1981 /* 1982 * delayed suspend (^Y) 1983 */ 1984 if (CCEQ(cc[VDSUSP], c) && 1985 ISSET(lflag, IEXTEN | ISIG) == (IEXTEN | ISIG)) { 1986 pgsignal(tp->t_pgrp, SIGTSTP, 1); 1987 if (first) { 1988 error = ttysleep(tp, &lbolt, PCATCH, 1989 "ttybg3", 0); 1990 if (error) 1991 break; 1992 goto loop; 1993 } 1994 break; 1995 } 1996 /* 1997 * Interpret EOF only in canonical mode. 1998 */ 1999 if (CCEQ(cc[VEOF], c) && ISSET(lflag, ICANON)) 2000 break; 2001 /* 2002 * Give user character. 2003 */ 2004 error = ureadc(c, uio); 2005 if (error) 2006 /* XXX should ungetc(c, qp). */ 2007 break; 2008 if (uio->uio_resid == 0) 2009 break; 2010 /* 2011 * In canonical mode check for a "break character" 2012 * marking the end of a "line of input". 2013 */ 2014 if (ISSET(lflag, ICANON) && TTBREAKC(c, lflag)) 2015 break; 2016 first = 0; 2017 } 2018 2019 out: 2020 /* 2021 * Look to unblock input now that (presumably) 2022 * the input queue has gone down. 2023 */ 2024 crit_enter(); 2025 if (ISSET(tp->t_state, TS_TBLOCK) && 2026 tp->t_rawq.c_cc + tp->t_canq.c_cc <= tp->t_ilowat) 2027 ttyunblock(tp); 2028 crit_exit(); 2029 2030 lwkt_reltoken(&tty_token); 2031 return (error); 2032 } 2033 2034 /* 2035 * Check the output queue on tp for space for a kernel message (from uprintf 2036 * or tprintf). Allow some space over the normal hiwater mark so we don't 2037 * lose messages due to normal flow control, but don't let the tty run amok. 2038 * Sleeps here are not interruptible, but we return prematurely if new signals 2039 * arrive. 2040 */ 2041 int 2042 ttycheckoutq(struct tty *tp, int wait) 2043 { 2044 struct lwp *lp = curthread->td_lwp; 2045 int hiwat; 2046 sigset_t oldset, newset; 2047 2048 lwkt_gettoken(&tty_token); 2049 hiwat = tp->t_ohiwat; 2050 SIGEMPTYSET(oldset); 2051 SIGEMPTYSET(newset); 2052 crit_enter(); 2053 if (wait) 2054 oldset = lwp_sigpend(lp); 2055 if (tp->t_outq.c_cc > hiwat + OBUFSIZ + 100) { 2056 while (tp->t_outq.c_cc > hiwat) { 2057 ttstart(tp); 2058 if (tp->t_outq.c_cc <= hiwat) 2059 break; 2060 if (wait) 2061 newset = lwp_sigpend(lp); 2062 if (!wait || SIGSETNEQ(oldset, newset)) { 2063 crit_exit(); 2064 lwkt_reltoken(&tty_token); 2065 return (0); 2066 } 2067 SET(tp->t_state, TS_SO_OLOWAT); 2068 tsleep(TSA_OLOWAT(tp), 0, "ttoutq", hz); 2069 } 2070 } 2071 crit_exit(); 2072 lwkt_reltoken(&tty_token); 2073 return (1); 2074 } 2075 2076 /* 2077 * Process a write call on a tty device. 2078 */ 2079 int 2080 ttwrite(struct tty *tp, struct uio *uio, int flag) 2081 { 2082 char *cp = NULL; 2083 int cc, ce; 2084 struct proc *pp; 2085 struct lwp *lp; 2086 int i, hiwat, error; 2087 size_t cnt; 2088 2089 char obuf[OBUFSIZ]; 2090 2091 lwkt_gettoken(&tty_token); 2092 lp = curthread->td_lwp; 2093 hiwat = tp->t_ohiwat; 2094 cnt = uio->uio_resid; 2095 error = 0; 2096 cc = 0; 2097 loop: 2098 crit_enter(); 2099 if (ISSET(tp->t_state, TS_ZOMBIE)) { 2100 crit_exit(); 2101 if (uio->uio_resid == cnt) 2102 error = EIO; 2103 goto out; 2104 } 2105 if (!ISSET(tp->t_state, TS_CONNECTED)) { 2106 if (flag & IO_NDELAY) { 2107 crit_exit(); 2108 error = EWOULDBLOCK; 2109 goto out; 2110 } 2111 error = ttysleep(tp, TSA_CARR_ON(tp), PCATCH, "ttydcd", 0); 2112 crit_exit(); 2113 if (error) 2114 goto out; 2115 goto loop; 2116 } 2117 crit_exit(); 2118 2119 /* 2120 * Hang the process if it's in the background. 2121 */ 2122 lwkt_gettoken(&proc_token); 2123 if ((pp = curproc) && isbackground(pp, tp) && 2124 ISSET(tp->t_lflag, TOSTOP) && !(pp->p_flags & P_PPWAIT) && 2125 !SIGISMEMBER(pp->p_sigignore, SIGTTOU) && 2126 !SIGISMEMBER(lp->lwp_sigmask, SIGTTOU)) { 2127 if (pp->p_pgrp->pg_jobc == 0) { 2128 error = EIO; 2129 lwkt_reltoken(&proc_token); 2130 goto out; 2131 } 2132 pgsignal(pp->p_pgrp, SIGTTOU, 1); 2133 lwkt_reltoken(&proc_token); 2134 error = ttysleep(tp, &lbolt, PCATCH, "ttybg4", 0); 2135 if (error) 2136 goto out; 2137 goto loop; 2138 } 2139 lwkt_reltoken(&proc_token); 2140 /* 2141 * Process the user's data in at most OBUFSIZ chunks. Perform any 2142 * output translation. Keep track of high water mark, sleep on 2143 * overflow awaiting device aid in acquiring new space. 2144 */ 2145 while (uio->uio_resid > 0 || cc > 0) { 2146 if (ISSET(tp->t_lflag, FLUSHO)) { 2147 uio->uio_resid = 0; 2148 lwkt_reltoken(&tty_token); 2149 return (0); 2150 } 2151 if (tp->t_outq.c_cc > hiwat) 2152 goto ovhiwat; 2153 /* 2154 * Grab a hunk of data from the user, unless we have some 2155 * leftover from last time. 2156 */ 2157 if (cc == 0) { 2158 cc = szmin(uio->uio_resid, OBUFSIZ); 2159 cp = obuf; 2160 error = uiomove(cp, (size_t)cc, uio); 2161 if (error) { 2162 cc = 0; 2163 break; 2164 } 2165 } 2166 /* 2167 * If nothing fancy need be done, grab those characters we 2168 * can handle without any of ttyoutput's processing and 2169 * just transfer them to the output q. For those chars 2170 * which require special processing (as indicated by the 2171 * bits in char_type), call ttyoutput. After processing 2172 * a hunk of data, look for FLUSHO so ^O's will take effect 2173 * immediately. 2174 */ 2175 while (cc > 0) { 2176 if (!ISSET(tp->t_oflag, OPOST)) 2177 ce = cc; 2178 else { 2179 ce = cc - scanc((u_int)cc, (u_char *)cp, 2180 char_type, CCLASSMASK); 2181 /* 2182 * If ce is zero, then we're processing 2183 * a special character through ttyoutput. 2184 */ 2185 if (ce == 0) { 2186 tp->t_rocount = 0; 2187 if (ttyoutput(*cp, tp) >= 0) { 2188 /* No Clists, wait a bit. */ 2189 ttstart(tp); 2190 if (flag & IO_NDELAY) { 2191 error = EWOULDBLOCK; 2192 goto out; 2193 } 2194 error = ttysleep(tp, &lbolt, 2195 PCATCH, 2196 "ttybf1", 0); 2197 if (error) 2198 goto out; 2199 goto loop; 2200 } 2201 cp++; 2202 cc--; 2203 if (ISSET(tp->t_lflag, FLUSHO) || 2204 tp->t_outq.c_cc > hiwat) 2205 goto ovhiwat; 2206 continue; 2207 } 2208 } 2209 /* 2210 * A bunch of normal characters have been found. 2211 * Transfer them en masse to the output queue and 2212 * continue processing at the top of the loop. 2213 * If there are any further characters in this 2214 * <= OBUFSIZ chunk, the first should be a character 2215 * requiring special handling by ttyoutput. 2216 */ 2217 tp->t_rocount = 0; 2218 i = b_to_q(cp, ce, &tp->t_outq); 2219 ce -= i; 2220 tp->t_column += ce; 2221 cp += ce, cc -= ce, tk_nout += ce; 2222 tp->t_outcc += ce; 2223 if (i > 0) { 2224 /* No Clists, wait a bit. */ 2225 ttstart(tp); 2226 if (flag & IO_NDELAY) { 2227 error = EWOULDBLOCK; 2228 goto out; 2229 } 2230 error = ttysleep(tp, &lbolt, PCATCH, 2231 "ttybf2", 0); 2232 if (error) 2233 goto out; 2234 goto loop; 2235 } 2236 if (ISSET(tp->t_lflag, FLUSHO) || 2237 tp->t_outq.c_cc > hiwat) 2238 break; 2239 } 2240 ttstart(tp); 2241 } 2242 out: 2243 /* 2244 * If cc is nonzero, we leave the uio structure inconsistent, as the 2245 * offset and iov pointers have moved forward, but it doesn't matter 2246 * (the call will either return short or restart with a new uio). 2247 */ 2248 uio->uio_resid += cc; 2249 lwkt_reltoken(&tty_token); 2250 return (error); 2251 2252 ovhiwat: 2253 ttstart(tp); 2254 crit_enter(); 2255 /* 2256 * This can only occur if FLUSHO is set in t_lflag, 2257 * or if ttstart/oproc is synchronous (or very fast). 2258 */ 2259 if (tp->t_outq.c_cc <= hiwat) { 2260 crit_exit(); 2261 goto loop; 2262 } 2263 if (flag & IO_NDELAY) { 2264 crit_exit(); 2265 uio->uio_resid += cc; 2266 lwkt_reltoken(&tty_token); 2267 return (uio->uio_resid == cnt ? EWOULDBLOCK : 0); 2268 } 2269 SET(tp->t_state, TS_SO_OLOWAT); 2270 error = ttysleep(tp, TSA_OLOWAT(tp), PCATCH, "ttywri", tp->t_timeout); 2271 crit_exit(); 2272 if (error == EWOULDBLOCK) 2273 error = EIO; 2274 if (error) 2275 goto out; 2276 goto loop; 2277 } 2278 2279 /* 2280 * Rubout one character from the rawq of tp 2281 * as cleanly as possible. 2282 * NOTE: Must be called with tty_token held 2283 */ 2284 static void 2285 ttyrub(int c, struct tty *tp) 2286 { 2287 char *cp; 2288 int savecol; 2289 int tabc; 2290 2291 ASSERT_LWKT_TOKEN_HELD(&tty_token); 2292 if (!ISSET(tp->t_lflag, ECHO) || ISSET(tp->t_lflag, EXTPROC)) 2293 return; 2294 CLR(tp->t_lflag, FLUSHO); 2295 if (ISSET(tp->t_lflag, ECHOE)) { 2296 if (tp->t_rocount == 0) { 2297 /* 2298 * Screwed by ttwrite; retype 2299 */ 2300 ttyretype(tp); 2301 return; 2302 } 2303 if (c == ('\t' | TTY_QUOTE) || c == ('\n' | TTY_QUOTE)) 2304 ttyrubo(tp, 2); 2305 else { 2306 CLR(c, ~TTY_CHARMASK); 2307 switch (CCLASS(c)) { 2308 case ORDINARY: 2309 ttyrubo(tp, 1); 2310 break; 2311 case BACKSPACE: 2312 case CONTROL: 2313 case NEWLINE: 2314 case RETURN: 2315 case VTAB: 2316 if (ISSET(tp->t_lflag, ECHOCTL)) 2317 ttyrubo(tp, 2); 2318 break; 2319 case TAB: 2320 if (tp->t_rocount < tp->t_rawq.c_cc) { 2321 ttyretype(tp); 2322 return; 2323 } 2324 crit_enter(); 2325 savecol = tp->t_column; 2326 SET(tp->t_state, TS_CNTTB); 2327 SET(tp->t_lflag, FLUSHO); 2328 tp->t_column = tp->t_rocol; 2329 cp = tp->t_rawq.c_cf; 2330 if (cp) 2331 tabc = *cp; /* XXX FIX NEXTC */ 2332 for (; cp; cp = nextc(&tp->t_rawq, cp, &tabc)) 2333 ttyecho(tabc, tp); 2334 CLR(tp->t_lflag, FLUSHO); 2335 CLR(tp->t_state, TS_CNTTB); 2336 crit_exit(); 2337 2338 /* savecol will now be length of the tab. */ 2339 savecol -= tp->t_column; 2340 tp->t_column += savecol; 2341 if (savecol > 8) 2342 savecol = 8; /* overflow screw */ 2343 while (--savecol >= 0) 2344 (void)ttyoutput('\b', tp); 2345 break; 2346 default: /* XXX */ 2347 #define PANICSTR "ttyrub: would panic c = %d, val = %d\n" 2348 (void)kprintf(PANICSTR, c, CCLASS(c)); 2349 #ifdef notdef 2350 panic(PANICSTR, c, CCLASS(c)); 2351 #endif 2352 } 2353 } 2354 } else if (ISSET(tp->t_lflag, ECHOPRT)) { 2355 if (!ISSET(tp->t_state, TS_ERASE)) { 2356 SET(tp->t_state, TS_ERASE); 2357 (void)ttyoutput('\\', tp); 2358 } 2359 ttyecho(c, tp); 2360 } else { 2361 ttyecho(tp->t_cc[VERASE], tp); 2362 /* 2363 * This code may be executed not only when an ERASE key 2364 * is pressed, but also when ^U (KILL) or ^W (WERASE) are. 2365 * So, I didn't think it was worthwhile to pass the extra 2366 * information (which would need an extra parameter, 2367 * changing every call) needed to distinguish the ERASE2 2368 * case from the ERASE. 2369 */ 2370 } 2371 --tp->t_rocount; 2372 } 2373 2374 /* 2375 * Back over cnt characters, erasing them. 2376 * NOTE: Must be called with tty_token held 2377 */ 2378 static void 2379 ttyrubo(struct tty *tp, int cnt) 2380 { 2381 ASSERT_LWKT_TOKEN_HELD(&tty_token); 2382 while (cnt-- > 0) { 2383 (void)ttyoutput('\b', tp); 2384 (void)ttyoutput(' ', tp); 2385 (void)ttyoutput('\b', tp); 2386 } 2387 } 2388 2389 /* 2390 * ttyretype -- 2391 * Reprint the rawq line. Note, it is assumed that c_cc has already 2392 * been checked. 2393 * NOTE: Must be called with tty_token held 2394 */ 2395 static void 2396 ttyretype(struct tty *tp) 2397 { 2398 char *cp; 2399 int c; 2400 2401 ASSERT_LWKT_TOKEN_HELD(&tty_token); 2402 /* Echo the reprint character. */ 2403 if (tp->t_cc[VREPRINT] != _POSIX_VDISABLE) 2404 ttyecho(tp->t_cc[VREPRINT], tp); 2405 2406 (void)ttyoutput('\n', tp); 2407 2408 /* 2409 * XXX 2410 * FIX: NEXTC IS BROKEN - DOESN'T CHECK QUOTE 2411 * BIT OF FIRST CHAR. 2412 */ 2413 crit_enter(); 2414 for (cp = tp->t_canq.c_cf, c = (cp != NULL ? *cp : 0); 2415 cp != NULL; cp = nextc(&tp->t_canq, cp, &c)) 2416 ttyecho(c, tp); 2417 for (cp = tp->t_rawq.c_cf, c = (cp != NULL ? *cp : 0); 2418 cp != NULL; cp = nextc(&tp->t_rawq, cp, &c)) 2419 ttyecho(c, tp); 2420 CLR(tp->t_state, TS_ERASE); 2421 crit_exit(); 2422 2423 tp->t_rocount = tp->t_rawq.c_cc; 2424 tp->t_rocol = 0; 2425 } 2426 2427 /* 2428 * Echo a typed character to the terminal. 2429 * NOTE: Must be called with tty_token held 2430 */ 2431 static void 2432 ttyecho(int c, struct tty *tp) 2433 { 2434 ASSERT_LWKT_TOKEN_HELD(&tty_token); 2435 2436 if (!ISSET(tp->t_state, TS_CNTTB)) 2437 CLR(tp->t_lflag, FLUSHO); 2438 if ((!ISSET(tp->t_lflag, ECHO) && 2439 (c != '\n' || !ISSET(tp->t_lflag, ECHONL))) || 2440 ISSET(tp->t_lflag, EXTPROC)) 2441 return; 2442 if (ISSET(tp->t_lflag, ECHOCTL) && 2443 ((ISSET(c, TTY_CHARMASK) <= 037 && c != '\t' && c != '\n') || 2444 ISSET(c, TTY_CHARMASK) == 0177)) { 2445 (void)ttyoutput('^', tp); 2446 CLR(c, ~TTY_CHARMASK); 2447 if (c == 0177) 2448 c = '?'; 2449 else 2450 c += 'A' - 1; 2451 } 2452 (void)ttyoutput(c, tp); 2453 } 2454 2455 /* 2456 * Wake up any readers on a tty. 2457 */ 2458 void 2459 ttwakeup(struct tty *tp) 2460 { 2461 lwkt_gettoken(&tty_token); 2462 if (ISSET(tp->t_state, TS_ASYNC) && tp->t_sigio != NULL) 2463 pgsigio(tp->t_sigio, SIGIO, (tp->t_session != NULL)); 2464 wakeup(TSA_HUP_OR_INPUT(tp)); 2465 KNOTE(&tp->t_rkq.ki_note, 0); 2466 lwkt_reltoken(&tty_token); 2467 } 2468 2469 /* 2470 * Wake up any writers on a tty. 2471 */ 2472 void 2473 ttwwakeup(struct tty *tp) 2474 { 2475 lwkt_gettoken(&tty_token); 2476 if (ISSET(tp->t_state, TS_ASYNC) && tp->t_sigio != NULL) 2477 pgsigio(tp->t_sigio, SIGIO, (tp->t_session != NULL)); 2478 if (ISSET(tp->t_state, TS_BUSY | TS_SO_OCOMPLETE) == 2479 TS_SO_OCOMPLETE && tp->t_outq.c_cc == 0) { 2480 CLR(tp->t_state, TS_SO_OCOMPLETE); 2481 wakeup(TSA_OCOMPLETE(tp)); 2482 } 2483 if (ISSET(tp->t_state, TS_SO_OLOWAT) && 2484 tp->t_outq.c_cc <= tp->t_olowat) { 2485 CLR(tp->t_state, TS_SO_OLOWAT); 2486 wakeup(TSA_OLOWAT(tp)); 2487 } 2488 KNOTE(&tp->t_wkq.ki_note, 0); 2489 lwkt_reltoken(&tty_token); 2490 } 2491 2492 /* 2493 * Look up a code for a specified speed in a conversion table; 2494 * used by drivers to map software speed values to hardware parameters. 2495 * No requirements 2496 */ 2497 int 2498 ttspeedtab(int speed, struct speedtab *table) 2499 { 2500 2501 for ( ; table->sp_speed != -1; table++) 2502 if (table->sp_speed == speed) 2503 return (table->sp_code); 2504 return (-1); 2505 } 2506 2507 /* 2508 * Set input and output watermarks and buffer sizes. For input, the 2509 * high watermark is about one second's worth of input above empty, the 2510 * low watermark is slightly below high water, and the buffer size is a 2511 * driver-dependent amount above high water. For output, the watermarks 2512 * are near the ends of the buffer, with about 1 second's worth of input 2513 * between them. All this only applies to the standard line discipline. 2514 */ 2515 void 2516 ttsetwater(struct tty *tp) 2517 { 2518 int cps, ttmaxhiwat, x; 2519 2520 lwkt_gettoken(&tty_token); 2521 /* Input. */ 2522 clist_alloc_cblocks(&tp->t_canq, TTYHOG, 512); 2523 switch (tp->t_ispeedwat) { 2524 case (speed_t)-1: 2525 cps = tp->t_ispeed / 10; 2526 break; 2527 case 0: 2528 /* 2529 * This case is for old drivers that don't know about 2530 * t_ispeedwat. Arrange for them to get the old buffer 2531 * sizes and watermarks. 2532 */ 2533 cps = TTYHOG - 2 * 256; 2534 tp->t_ififosize = 2 * 2048; 2535 break; 2536 default: 2537 cps = tp->t_ispeedwat / 10; 2538 break; 2539 } 2540 tp->t_ihiwat = cps; 2541 tp->t_ilowat = 7 * cps / 8; 2542 x = cps + tp->t_ififosize; 2543 clist_alloc_cblocks(&tp->t_rawq, x, x); 2544 2545 /* Output. */ 2546 switch (tp->t_ospeedwat) { 2547 case (speed_t)-1: 2548 cps = tp->t_ospeed / 10; 2549 ttmaxhiwat = 2 * TTMAXHIWAT; 2550 break; 2551 case 0: 2552 cps = tp->t_ospeed / 10; 2553 ttmaxhiwat = TTMAXHIWAT; 2554 break; 2555 default: 2556 cps = tp->t_ospeedwat / 10; 2557 ttmaxhiwat = 8 * TTMAXHIWAT; 2558 break; 2559 } 2560 #define CLAMP(x, h, l) ((x) > h ? h : ((x) < l) ? l : (x)) 2561 tp->t_olowat = x = CLAMP(cps / 2, TTMAXLOWAT, TTMINLOWAT); 2562 x += cps; 2563 x = CLAMP(x, ttmaxhiwat, TTMINHIWAT); /* XXX clamps are too magic */ 2564 tp->t_ohiwat = roundup(x, CBSIZE); /* XXX for compat */ 2565 x = imax(tp->t_ohiwat, TTMAXHIWAT); /* XXX for compat/safety */ 2566 x += OBUFSIZ + 100; 2567 clist_alloc_cblocks(&tp->t_outq, x, x); 2568 #undef CLAMP 2569 lwkt_reltoken(&tty_token); 2570 } 2571 2572 /* 2573 * Report on state of foreground process group. 2574 */ 2575 void 2576 ttyinfo(struct tty *tp) 2577 { 2578 struct pgrp *pgrp; 2579 struct proc *p, *pick; 2580 struct lwp *lp; 2581 struct rusage ru; 2582 char buf[64]; 2583 const char *str; 2584 struct vmspace *vm; 2585 long vmsz; 2586 int pctcpu; 2587 int tmp; 2588 2589 if (ttycheckoutq(tp,0) == 0) 2590 return; 2591 2592 lwkt_gettoken(&tty_token); 2593 lwkt_gettoken(&proc_token); 2594 /* 2595 * We always print the load average, then figure out what else to 2596 * print based on the state of the current process group. 2597 */ 2598 tmp = (averunnable.ldavg[0] * 100 + FSCALE / 2) >> FSHIFT; 2599 ttyprintf(tp, "load: %d.%02d ", tmp / 100, tmp % 100); 2600 2601 if (tp->t_session == NULL) { 2602 ttyprintf(tp, "not a controlling terminal\n"); 2603 goto done2; 2604 } 2605 if ((pgrp = tp->t_pgrp) == NULL) { 2606 ttyprintf(tp, "no foreground process group\n"); 2607 goto done2; 2608 } 2609 2610 /* 2611 * Pick an interesting process. Note that certain elements, 2612 * in particular the wmesg, require a critical section for 2613 * safe access (YYY and we are still not MP safe). 2614 * 2615 * NOTE: lwp_wmesg is lwp_thread->td_wmesg. 2616 */ 2617 pgref(pgrp); 2618 lwkt_gettoken(&pgrp->pg_token); 2619 2620 pick = NULL; 2621 for (p = LIST_FIRST(&pgrp->pg_members); 2622 p != NULL; 2623 p = LIST_NEXT(p, p_pglist)) { 2624 if (proc_compare(pick, p)) 2625 pick = p; 2626 } 2627 if (pick == NULL) { 2628 ttyprintf(tp, "empty foreground process group\n"); 2629 goto done1; 2630 } 2631 2632 /* 2633 * Pick an interesting LWP (XXX) 2634 */ 2635 PHOLD(pick); 2636 lp = FIRST_LWP_IN_PROC(pick); 2637 if (lp == NULL) { 2638 PRELE(pick); 2639 ttyprintf(tp, "foreground process without lwp\n"); 2640 goto done1; 2641 } 2642 2643 /* 2644 * Figure out what wait/process-state message, and command 2645 * buffer to present 2646 */ 2647 /* 2648 * XXX lwp This is a horrible mixture. We need to rework this 2649 * as soon as lwps have their own runnable status. 2650 */ 2651 LWPHOLD(lp); 2652 if (pick->p_flags & P_WEXIT) 2653 str = "exiting"; 2654 else if (lp->lwp_stat == LSRUN) 2655 str = "running"; 2656 else if (pick->p_stat == SIDL) 2657 str = "spawning"; 2658 else if (lp->lwp_wmesg) /* lwp_thread must not be NULL */ 2659 str = lp->lwp_wmesg; 2660 else 2661 str = "iowait"; 2662 2663 ksnprintf(buf, sizeof(buf), "cmd: %s %d [%s]", 2664 pick->p_comm, pick->p_pid, str); 2665 2666 /* 2667 * Calculate cpu usage, percent cpu, and cmsz. Note that 2668 * 'pick' becomes invalid the moment we exit the critical 2669 * section. 2670 */ 2671 if (lp->lwp_thread && (pick->p_flags & P_SWAPPEDOUT) == 0) 2672 calcru_proc(pick, &ru); 2673 2674 pctcpu = (lp->lwp_pctcpu * 10000 + FSCALE / 2) >> FSHIFT; 2675 2676 LWPRELE(lp); 2677 2678 if (pick->p_stat == SIDL || pick->p_stat == SZOMB) { 2679 vmsz = 0; 2680 } else if ((vm = pick->p_vmspace) == NULL) { 2681 vmsz = 0; 2682 } else { 2683 vmspace_hold(vm); 2684 vmsz = pgtok(vmspace_resident_count(vm)); 2685 vmspace_drop(vm); 2686 } 2687 PRELE(pick); 2688 2689 /* 2690 * Dump the output 2691 */ 2692 ttyprintf(tp, " %s ", 2693 buf); 2694 ttyprintf(tp, "%ld.%02ldu ", 2695 ru.ru_utime.tv_sec, ru.ru_utime.tv_usec / 10000); 2696 ttyprintf(tp, "%ld.%02lds ", 2697 ru.ru_stime.tv_sec, ru.ru_stime.tv_usec / 10000); 2698 ttyprintf(tp, "%d%% %ldk\n", 2699 pctcpu / 100, vmsz); 2700 2701 done1: 2702 lwkt_reltoken(&pgrp->pg_token); 2703 pgrel(pgrp); 2704 done2: 2705 tp->t_rocount = 0; /* so pending input will be retyped if BS */ 2706 lwkt_reltoken(&proc_token); 2707 lwkt_reltoken(&tty_token); 2708 } 2709 2710 /* 2711 * Returns 1 if p2 is "better" than p1 2712 * 2713 * The algorithm for picking the "interesting" process is thus: 2714 * 2715 * 1) Only foreground processes are eligible - implied. 2716 * 2) Runnable processes are favored over anything else. The runner 2717 * with the highest cpu utilization is picked (p_cpticks). Ties are 2718 * broken by picking the highest pid. 2719 * 3) The sleeper with the shortest sleep time is next. With ties, 2720 * we pick out just "short-term" sleepers (LWP_SINTR == 0). 2721 * 4) Further ties are broken by picking the highest pid. 2722 * 2723 * NOTE: must be called with proc_token held. 2724 */ 2725 #define ISRUN(lp) ((lp)->lwp_stat == LSRUN) 2726 #define TESTAB(a, b) ((a)<<1 | (b)) 2727 #define ONLYA 2 2728 #define ONLYB 1 2729 #define BOTH 3 2730 2731 static int 2732 proc_compare(struct proc *p1, struct proc *p2) 2733 { 2734 struct lwp *lp1, *lp2; 2735 int res; 2736 2737 ASSERT_LWKT_TOKEN_HELD(&proc_token); 2738 2739 if (p1 == NULL) 2740 return (1); 2741 if (lwkt_trytoken(&p1->p_token) == 0) 2742 return (1); 2743 if (lwkt_trytoken(&p2->p_token) == 0) { 2744 lwkt_reltoken(&p1->p_token); 2745 return (0); 2746 } 2747 2748 /* 2749 * weed out zombies 2750 */ 2751 switch (TESTAB(p1->p_stat == SZOMB, p2->p_stat == SZOMB)) { 2752 case ONLYA: 2753 res = 1; 2754 goto done; 2755 case ONLYB: 2756 res = 0; 2757 goto done; 2758 case BOTH: 2759 res = (p2->p_pid > p1->p_pid); /* tie - return highest pid */ 2760 goto done; 2761 default: 2762 break; 2763 } 2764 2765 /* XXX choose the best lwp? */ 2766 lp1 = FIRST_LWP_IN_PROC(p1); 2767 lp2 = FIRST_LWP_IN_PROC(p2); 2768 2769 /* 2770 * Favor one with LWPs verses one that has none (is exiting). 2771 */ 2772 if (lp1 == NULL) { 2773 res = 1; 2774 goto done; 2775 } 2776 if (lp2 == NULL) { 2777 res = 0; 2778 goto done; 2779 } 2780 2781 /* 2782 * see if at least one of them is runnable 2783 */ 2784 switch (TESTAB(ISRUN(lp1), ISRUN(lp2))) { 2785 case ONLYA: 2786 res = 0; 2787 goto done; 2788 case ONLYB: 2789 res = 1; 2790 goto done; 2791 case BOTH: 2792 /* 2793 * tie - favor one with highest recent cpu utilization 2794 */ 2795 if (lp2->lwp_cpticks > lp1->lwp_cpticks) 2796 res = 1; 2797 else if (lp1->lwp_cpticks > lp2->lwp_cpticks) 2798 res = 0; 2799 else 2800 res = (p2->p_pid > p1->p_pid); /* tie - ret highest */ 2801 goto done; 2802 default: 2803 break; 2804 } 2805 2806 /* 2807 * Pick the one with the smallest sleep time 2808 */ 2809 if (lp2->lwp_slptime > lp1->lwp_slptime) { 2810 res = 0; 2811 goto done; 2812 } 2813 if (lp1->lwp_slptime > lp2->lwp_slptime) { 2814 res = 1; 2815 goto done; 2816 } 2817 2818 /* 2819 * Favor one sleeping in a non-interruptible sleep 2820 */ 2821 if ((lp1->lwp_flags & LWP_SINTR) && (lp2->lwp_flags & LWP_SINTR) == 0) 2822 res = 1; 2823 else 2824 if ((lp2->lwp_flags & LWP_SINTR) && (lp1->lwp_flags & LWP_SINTR) == 0) 2825 res = 0; 2826 else 2827 res = (p2->p_pid > p1->p_pid); /* tie - return highest pid */ 2828 /* fall through */ 2829 2830 done: 2831 lwkt_reltoken(&p2->p_token); 2832 lwkt_reltoken(&p1->p_token); 2833 return (res); 2834 } 2835 2836 /* 2837 * Output char to tty; console putchar style. 2838 */ 2839 int 2840 tputchar(int c, struct tty *tp) 2841 { 2842 crit_enter(); 2843 lwkt_gettoken(&tty_token); 2844 if (!ISSET(tp->t_state, TS_CONNECTED)) { 2845 lwkt_reltoken(&tty_token); 2846 crit_exit(); 2847 return (-1); 2848 } 2849 if (c == '\n') 2850 (void)ttyoutput('\r', tp); 2851 (void)ttyoutput(c, tp); 2852 ttstart(tp); 2853 lwkt_reltoken(&tty_token); 2854 crit_exit(); 2855 return (0); 2856 } 2857 2858 /* 2859 * Sleep on chan, returning ERESTART if tty changed while we napped and 2860 * returning any errors (e.g. EINTR/EWOULDBLOCK) reported by tsleep. If 2861 * the tty is revoked, restarting a pending call will redo validation done 2862 * at the start of the call. 2863 */ 2864 int 2865 ttysleep(struct tty *tp, void *chan, int slpflags, char *wmesg, int timo) 2866 { 2867 int error; 2868 int gen; 2869 2870 gen = tp->t_gen; 2871 error = tsleep(chan, slpflags, wmesg, timo); 2872 if (error) 2873 return (error); 2874 return (tp->t_gen == gen ? 0 : ERESTART); 2875 } 2876 2877 /* 2878 * Revoke a tty. 2879 * 2880 * We bump the gen to force any ttysleep()'s to return with ERESTART 2881 * and flush the tty. The related fp's should already have been 2882 * replaced so the tty will close when the last references on the 2883 * original fp's go away. 2884 */ 2885 int 2886 ttyrevoke(struct dev_revoke_args *ap) 2887 { 2888 struct tty *tp; 2889 2890 lwkt_gettoken(&tty_token); 2891 tp = ap->a_head.a_dev->si_tty; 2892 tp->t_gen++; 2893 ttyflush(tp, FREAD | FWRITE); 2894 wakeup(TSA_CARR_ON(tp)); 2895 ttwakeup(tp); 2896 ttwwakeup(tp); 2897 lwkt_reltoken(&tty_token); 2898 return (0); 2899 } 2900 2901 /* 2902 * Allocate a tty struct. Clists in the struct will be allocated by 2903 * ttyopen(). 2904 */ 2905 struct tty * 2906 ttymalloc(struct tty *tp) 2907 { 2908 2909 if (tp) { 2910 return(tp); 2911 } 2912 tp = kmalloc(sizeof *tp, M_TTYS, M_WAITOK|M_ZERO); 2913 ttyregister(tp); 2914 return (tp); 2915 } 2916 2917 void 2918 ttyunregister(struct tty *tp) 2919 { 2920 lwkt_gettoken(&tty_token); 2921 KKASSERT(ISSET(tp->t_state, TS_REGISTERED)); 2922 CLR(tp->t_state, TS_REGISTERED); 2923 TAILQ_REMOVE(&tty_list, tp, t_list); 2924 lwkt_reltoken(&tty_token); 2925 } 2926 2927 void 2928 ttyregister(struct tty *tp) 2929 { 2930 lwkt_gettoken(&tty_token); 2931 KKASSERT(!ISSET(tp->t_state, TS_REGISTERED)); 2932 SET(tp->t_state, TS_REGISTERED); 2933 TAILQ_INSERT_HEAD(&tty_list, tp, t_list); 2934 lwkt_reltoken(&tty_token); 2935 } 2936 2937 static int 2938 sysctl_kern_ttys(SYSCTL_HANDLER_ARGS) 2939 { 2940 int error; 2941 struct tty *tp; 2942 struct tty t; 2943 struct tty marker; 2944 2945 bzero(&marker, sizeof(marker)); 2946 marker.t_state = TS_MARKER; 2947 error = 0; 2948 2949 lwkt_gettoken(&tty_token); 2950 2951 TAILQ_INSERT_HEAD(&tty_list, &marker, t_list); 2952 while ((tp = TAILQ_NEXT(&marker, t_list)) != NULL) { 2953 TAILQ_REMOVE(&tty_list, &marker, t_list); 2954 TAILQ_INSERT_AFTER(&tty_list, tp, &marker, t_list); 2955 if (tp->t_state & TS_MARKER) 2956 continue; 2957 t = *tp; 2958 if (t.t_dev) 2959 t.t_dev = (cdev_t)(uintptr_t)dev2udev(t.t_dev); 2960 error = SYSCTL_OUT(req, (caddr_t)&t, sizeof(t)); 2961 if (error) 2962 break; 2963 } 2964 TAILQ_REMOVE(&tty_list, &marker, t_list); 2965 lwkt_reltoken(&tty_token); 2966 return (error); 2967 } 2968 2969 SYSCTL_PROC(_kern, OID_AUTO, ttys, CTLTYPE_OPAQUE|CTLFLAG_RD, 2970 0, 0, sysctl_kern_ttys, "S,tty", "All struct ttys"); 2971 2972 void 2973 nottystop(struct tty *tp, int rw) 2974 { 2975 return; 2976 } 2977 2978 int 2979 ttyread(struct dev_read_args *ap) 2980 { 2981 struct tty *tp; 2982 int ret; 2983 2984 tp = ap->a_head.a_dev->si_tty; 2985 if (tp == NULL) 2986 return (ENODEV); 2987 lwkt_gettoken(&tty_token); 2988 ret = ((*linesw[tp->t_line].l_read)(tp, ap->a_uio, ap->a_ioflag)); 2989 lwkt_reltoken(&tty_token); 2990 2991 return ret; 2992 } 2993 2994 int 2995 ttywrite(struct dev_write_args *ap) 2996 { 2997 struct tty *tp; 2998 int ret; 2999 3000 tp = ap->a_head.a_dev->si_tty; 3001 if (tp == NULL) 3002 return (ENODEV); 3003 lwkt_gettoken(&tty_token); 3004 ret = ((*linesw[tp->t_line].l_write)(tp, ap->a_uio, ap->a_ioflag)); 3005 lwkt_reltoken(&tty_token); 3006 3007 return ret; 3008 } 3009