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