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