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