tty.c revision 178219
1/*- 2 * Copyright (c) 1982, 1986, 1990, 1991, 1993 3 * The Regents of the University of California. All rights reserved. 4 * (c) UNIX System Laboratories, Inc. 5 * All or some portions of this file are derived from material licensed 6 * to the University of California by American Telephone and Telegraph 7 * Co. or Unix System Laboratories, Inc. and are reproduced herein with 8 * the permission of UNIX System Laboratories, Inc. 9 * 10 * Copyright (c) 2002 Networks Associates Technologies, Inc. 11 * All rights reserved. 12 * 13 * Portions of this software were developed for the FreeBSD Project by 14 * ThinkSec AS and NAI Labs, the Security Research Division of Network 15 * Associates, Inc. under DARPA/SPAWAR contract N66001-01-C-8035 16 * ("CBOSS"), as part of the DARPA CHATS research program. 17 * 18 * Redistribution and use in source and binary forms, with or without 19 * modification, are permitted provided that the following conditions 20 * are met: 21 * 1. Redistributions of source code must retain the above copyright 22 * notice, this list of conditions and the following disclaimer. 23 * 2. Redistributions in binary form must reproduce the above copyright 24 * notice, this list of conditions and the following disclaimer in the 25 * documentation and/or other materials provided with the distribution. 26 * 4. Neither the name of the University nor the names of its contributors 27 * may be used to endorse or promote products derived from this software 28 * without specific prior written permission. 29 * 30 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 31 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 32 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 33 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 34 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 35 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 36 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 37 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 38 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 39 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 40 * SUCH DAMAGE. 41 * 42 * @(#)tty.c 8.8 (Berkeley) 1/21/94 43 */ 44 45/*- 46 * TODO: 47 * o Fix races for sending the start char in ttyflush(). 48 * o Handle inter-byte timeout for "MIN > 0, TIME > 0" in ttyselect(). 49 * With luck, there will be MIN chars before select() returns(). 50 * o Handle CLOCAL consistently for ptys. Perhaps disallow setting it. 51 * o Don't allow input in TS_ZOMBIE case. It would be visible through 52 * FIONREAD. 53 * o Do the new sio locking stuff here and use it to avoid special 54 * case for EXTPROC? 55 * o Lock PENDIN too? 56 * o Move EXTPROC and/or PENDIN to t_state? 57 * o Wrap most of ttioctl in spltty/splx. 58 * o Implement TIOCNOTTY or remove it from <sys/ioctl.h>. 59 * o Send STOP if IXOFF is toggled off while TS_TBLOCK is set. 60 * o Don't allow certain termios flags to affect disciplines other 61 * than TTYDISC. Cancel their effects before switch disciplines 62 * and ignore them if they are set while we are in another 63 * discipline. 64 * o Now that historical speed conversions are handled here, don't 65 * do them in drivers. 66 * o Check for TS_CARR_ON being set while everything is closed and not 67 * waiting for carrier. TS_CARR_ON isn't cleared if nothing is open, 68 * so it would live until the next open even if carrier drops. 69 * o Restore TS_WOPEN since it is useful in pstat. It must be cleared 70 * only when _all_ openers leave open(). 71 */ 72 73#include <sys/cdefs.h> 74__FBSDID("$FreeBSD: head/sys/kern/tty.c 178219 2008-04-15 08:33:32Z davidxu $"); 75 76#include "opt_compat.h" 77#include "opt_tty.h" 78 79#include <sys/param.h> 80#include <sys/systm.h> 81#include <sys/filio.h> 82#include <sys/lock.h> 83#include <sys/mutex.h> 84#include <sys/namei.h> 85#include <sys/sx.h> 86#if defined(COMPAT_43TTY) 87#include <sys/ioctl_compat.h> 88#endif 89#include <sys/priv.h> 90#include <sys/proc.h> 91#define TTYDEFCHARS 92#include <sys/tty.h> 93#undef TTYDEFCHARS 94#include <sys/fcntl.h> 95#include <sys/conf.h> 96#include <sys/poll.h> 97#include <sys/kernel.h> 98#include <sys/vnode.h> 99#include <sys/serial.h> 100#include <sys/signalvar.h> 101#include <sys/resourcevar.h> 102#include <sys/malloc.h> 103#include <sys/filedesc.h> 104#include <sys/sched.h> 105#include <sys/sysctl.h> 106#include <sys/timepps.h> 107 108#include <machine/stdarg.h> 109 110#include <vm/vm.h> 111#include <vm/pmap.h> 112#include <vm/vm_map.h> 113 114MALLOC_DEFINE(M_TTYS, "ttys", "tty data structures"); 115 116long tk_cancc; 117long tk_nin; 118long tk_nout; 119long tk_rawcc; 120 121static d_open_t ttysopen; 122static d_close_t ttysclose; 123static d_read_t ttysrdwr; 124static d_ioctl_t ttysioctl; 125static d_purge_t ttypurge; 126 127/* Default cdevsw for common tty devices */ 128static struct cdevsw tty_cdevsw = { 129 .d_version = D_VERSION, 130 .d_open = ttyopen, 131 .d_close = ttyclose, 132 .d_ioctl = ttyioctl, 133 .d_purge = ttypurge, 134 .d_name = "ttydrv", 135 .d_flags = D_TTY | D_NEEDGIANT, 136}; 137 138/* Cdevsw for slave tty devices */ 139static struct cdevsw ttys_cdevsw = { 140 .d_version = D_VERSION, 141 .d_open = ttysopen, 142 .d_close = ttysclose, 143 .d_read = ttysrdwr, 144 .d_write = ttysrdwr, 145 .d_ioctl = ttysioctl, 146 .d_name = "TTYS", 147 .d_flags = D_TTY | D_NEEDGIANT, 148}; 149 150static int proc_sum(struct proc *, int *); 151static int proc_compare(struct proc *, struct proc *); 152static int thread_compare(struct thread *, struct thread *); 153static int ttnread(struct tty *tp); 154static void ttyecho(int c, struct tty *tp); 155static int ttyoutput(int c, struct tty *tp); 156static void ttypend(struct tty *tp); 157static void ttyretype(struct tty *tp); 158static void ttyrub(int c, struct tty *tp); 159static void ttyrubo(struct tty *tp, int cnt); 160static void ttyunblock(struct tty *tp); 161static int ttywflush(struct tty *tp); 162static int filt_ttyread(struct knote *kn, long hint); 163static void filt_ttyrdetach(struct knote *kn); 164static int filt_ttywrite(struct knote *kn, long hint); 165static void filt_ttywdetach(struct knote *kn); 166 167/* 168 * Table with character classes and parity. The 8th bit indicates parity, 169 * the 7th bit indicates the character is an alphameric or underscore (for 170 * ALTWERASE), and the low 6 bits indicate delay type. If the low 6 bits 171 * are 0 then the character needs no special processing on output; classes 172 * other than 0 might be translated or (not currently) require delays. 173 */ 174#define E 0x00 /* Even parity. */ 175#define O 0x80 /* Odd parity. */ 176#define PARITY(c) (char_type[c] & O) 177 178#define ALPHA 0x40 /* Alpha or underscore. */ 179#define ISALPHA(c) (char_type[(c) & TTY_CHARMASK] & ALPHA) 180 181#define CCLASSMASK 0x3f 182#define CCLASS(c) (char_type[c] & CCLASSMASK) 183 184#define BS BACKSPACE 185#define CC CONTROL 186#define CR RETURN 187#define NA ORDINARY | ALPHA 188#define NL NEWLINE 189#define NO ORDINARY 190#define TB TAB 191#define VT VTAB 192 193static u_char const char_type[] = { 194 E|CC, O|CC, O|CC, E|CC, O|CC, E|CC, E|CC, O|CC, /* nul - bel */ 195 O|BS, E|TB, E|NL, O|CC, E|VT, O|CR, O|CC, E|CC, /* bs - si */ 196 O|CC, E|CC, E|CC, O|CC, E|CC, O|CC, O|CC, E|CC, /* dle - etb */ 197 E|CC, O|CC, O|CC, E|CC, O|CC, E|CC, E|CC, O|CC, /* can - us */ 198 O|NO, E|NO, E|NO, O|NO, E|NO, O|NO, O|NO, E|NO, /* sp - ' */ 199 E|NO, O|NO, O|NO, E|NO, O|NO, E|NO, E|NO, O|NO, /* ( - / */ 200 E|NA, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* 0 - 7 */ 201 O|NA, E|NA, E|NO, O|NO, E|NO, O|NO, O|NO, E|NO, /* 8 - ? */ 202 O|NO, E|NA, E|NA, O|NA, E|NA, O|NA, O|NA, E|NA, /* @ - G */ 203 E|NA, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* H - O */ 204 E|NA, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* P - W */ 205 O|NA, E|NA, E|NA, O|NO, E|NO, O|NO, O|NO, O|NA, /* X - _ */ 206 E|NO, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* ` - g */ 207 O|NA, E|NA, E|NA, O|NA, E|NA, O|NA, O|NA, E|NA, /* h - o */ 208 O|NA, E|NA, E|NA, O|NA, E|NA, O|NA, O|NA, E|NA, /* p - w */ 209 E|NA, O|NA, O|NA, E|NO, O|NO, E|NO, E|NO, O|CC, /* x - del */ 210 /* 211 * Meta chars; should be settable per character set; 212 * for now, treat them all as normal characters. 213 */ 214 NA, NA, NA, NA, NA, NA, NA, NA, 215 NA, NA, NA, NA, NA, NA, NA, NA, 216 NA, NA, NA, NA, NA, NA, NA, NA, 217 NA, NA, NA, NA, NA, NA, NA, NA, 218 NA, NA, NA, NA, NA, NA, NA, NA, 219 NA, NA, NA, NA, NA, NA, NA, NA, 220 NA, NA, NA, NA, NA, NA, NA, NA, 221 NA, NA, NA, NA, NA, NA, NA, NA, 222 NA, NA, NA, NA, NA, NA, NA, NA, 223 NA, NA, NA, NA, NA, NA, NA, NA, 224 NA, NA, NA, NA, NA, NA, NA, NA, 225 NA, NA, NA, NA, NA, NA, NA, NA, 226 NA, NA, NA, NA, NA, NA, NA, NA, 227 NA, NA, NA, NA, NA, NA, NA, NA, 228 NA, NA, NA, NA, NA, NA, NA, NA, 229 NA, NA, NA, NA, NA, NA, NA, NA, 230}; 231#undef BS 232#undef CC 233#undef CR 234#undef NA 235#undef NL 236#undef NO 237#undef TB 238#undef VT 239 240/* Macros to clear/set/test flags. */ 241#define SET(t, f) (t) |= (f) 242#define CLR(t, f) (t) &= ~(f) 243#define ISSET(t, f) ((t) & (f)) 244 245#undef MAX_INPUT /* XXX wrong in <sys/syslimits.h> */ 246#define MAX_INPUT TTYHOG /* XXX limit is usually larger for !ICANON */ 247 248/* 249 * list of struct tty where pstat(8) can pick it up with sysctl 250 * 251 * The lock order is to grab the list mutex before the tty mutex. 252 * Together with additions going on the tail of the list, this allows 253 * the sysctl to avoid doing retries. 254 */ 255static TAILQ_HEAD(, tty) tty_list = TAILQ_HEAD_INITIALIZER(tty_list); 256static struct mtx tty_list_mutex; 257MTX_SYSINIT(tty_list, &tty_list_mutex, "ttylist", MTX_DEF); 258 259static struct unrhdr *tty_unit; 260 261static int drainwait = 5*60; 262SYSCTL_INT(_kern, OID_AUTO, drainwait, CTLFLAG_RW, &drainwait, 263 0, "Output drain timeout in seconds"); 264 265static struct tty * 266tty_gettp(struct cdev *dev) 267{ 268 struct tty *tp; 269 struct cdevsw *csw; 270 271 csw = dev_refthread(dev); 272 KASSERT(csw != NULL, ("No cdevsw in ttycode (%s)", devtoname(dev))); 273 KASSERT(csw->d_flags & D_TTY, 274 ("non D_TTY (%s) in tty code", devtoname(dev))); 275 dev_relthread(dev); 276 tp = dev->si_tty; 277 KASSERT(tp != NULL, 278 ("no tty pointer on (%s) in tty code", devtoname(dev))); 279 return (tp); 280} 281 282/* 283 * Initial open of tty, or (re)entry to standard tty line discipline. 284 */ 285int 286tty_open(struct cdev *device, struct tty *tp) 287{ 288 int s; 289 290 s = spltty(); 291 tp->t_dev = device; 292 tp->t_hotchar = 0; 293 if (!ISSET(tp->t_state, TS_ISOPEN)) { 294 ttyref(tp); 295 SET(tp->t_state, TS_ISOPEN); 296 if (ISSET(tp->t_cflag, CLOCAL)) 297 SET(tp->t_state, TS_CONNECTED); 298 bzero(&tp->t_winsize, sizeof(tp->t_winsize)); 299 } 300 /* XXX don't hang forever on output */ 301 if (tp->t_timeout < 0) 302 tp->t_timeout = drainwait*hz; 303 ttsetwater(tp); 304 splx(s); 305 return (0); 306} 307 308/* 309 * Handle close() on a tty line: flush and set to initial state, 310 * bumping generation number so that pending read/write calls 311 * can detect recycling of the tty. 312 * XXX our caller should have done `spltty(); l_close(); tty_close();' 313 * and l_close() should have flushed, but we repeat the spltty() and 314 * the flush in case there are buggy callers. 315 */ 316int 317tty_close(struct tty *tp) 318{ 319 int ostate, s; 320 321 funsetown(&tp->t_sigio); 322 s = spltty(); 323 if (constty == tp) 324 constty_clear(); 325 326 ttyflush(tp, FREAD | FWRITE); 327 clist_free_cblocks(&tp->t_canq); 328 clist_free_cblocks(&tp->t_outq); 329 clist_free_cblocks(&tp->t_rawq); 330 331 tp->t_gen++; 332 tp->t_line = TTYDISC; 333 tp->t_hotchar = 0; 334 tp->t_pgrp = NULL; 335 tp->t_session = NULL; 336 ostate = tp->t_state; 337 tp->t_state = 0; 338 knlist_clear(&tp->t_rsel.si_note, 0); 339 knlist_clear(&tp->t_wsel.si_note, 0); 340 /* 341 * Both final close and revocation close might end up calling 342 * this method. Only the thread clearing TS_ISOPEN should 343 * release the reference to the tty. 344 */ 345 if (ISSET(ostate, TS_ISOPEN)) 346 ttyrel(tp); 347 splx(s); 348 return (0); 349} 350 351#define FLUSHQ(q) { \ 352 if ((q)->c_cc) \ 353 ndflush(q, (q)->c_cc); \ 354} 355 356/* Is 'c' a line delimiter ("break" character)? */ 357#define TTBREAKC(c, lflag) \ 358 ((c) == '\n' || (((c) == cc[VEOF] || \ 359 (c) == cc[VEOL] || ((c) == cc[VEOL2] && lflag & IEXTEN)) && \ 360 (c) != _POSIX_VDISABLE)) 361 362/* 363 * Process input of a single character received on a tty. 364 */ 365int 366ttyinput(int c, struct tty *tp) 367{ 368 tcflag_t iflag, lflag; 369 cc_t *cc; 370 int i, err; 371 372 /* 373 * If input is pending take it first. 374 */ 375 lflag = tp->t_lflag; 376 if (ISSET(lflag, PENDIN)) 377 ttypend(tp); 378 /* 379 * Gather stats. 380 */ 381 if (ISSET(lflag, ICANON)) { 382 ++tk_cancc; 383 ++tp->t_cancc; 384 } else { 385 ++tk_rawcc; 386 ++tp->t_rawcc; 387 } 388 ++tk_nin; 389 390 /* 391 * Block further input iff: 392 * current input > threshold AND input is available to user program 393 * AND input flow control is enabled and not yet invoked. 394 * The 3 is slop for PARMRK. 395 */ 396 iflag = tp->t_iflag; 397 if (tp->t_rawq.c_cc + tp->t_canq.c_cc > tp->t_ihiwat - 3 && 398 (!ISSET(lflag, ICANON) || tp->t_canq.c_cc != 0) && 399 (ISSET(tp->t_cflag, CRTS_IFLOW) || ISSET(iflag, IXOFF)) && 400 !ISSET(tp->t_state, TS_TBLOCK)) 401 ttyblock(tp); 402 403 /* Handle exceptional conditions (break, parity, framing). */ 404 cc = tp->t_cc; 405 err = (ISSET(c, TTY_ERRORMASK)); 406 if (err) { 407 CLR(c, TTY_ERRORMASK); 408 if (ISSET(err, TTY_BI)) { 409 if (ISSET(iflag, IGNBRK)) 410 return (0); 411 if (ISSET(iflag, BRKINT)) { 412 ttyflush(tp, FREAD | FWRITE); 413 if (tp->t_pgrp != NULL) { 414 PGRP_LOCK(tp->t_pgrp); 415 pgsignal(tp->t_pgrp, SIGINT, 1); 416 PGRP_UNLOCK(tp->t_pgrp); 417 } 418 goto endcase; 419 } 420 if (ISSET(iflag, PARMRK)) 421 goto parmrk; 422 } else if ((ISSET(err, TTY_PE) && ISSET(iflag, INPCK)) 423 || ISSET(err, TTY_FE)) { 424 if (ISSET(iflag, IGNPAR)) 425 return (0); 426 else if (ISSET(iflag, PARMRK)) { 427parmrk: 428 if (tp->t_rawq.c_cc + tp->t_canq.c_cc > 429 MAX_INPUT - 3) 430 goto input_overflow; 431 (void)putc(0377 | TTY_QUOTE, &tp->t_rawq); 432 (void)putc(0 | TTY_QUOTE, &tp->t_rawq); 433 (void)putc(c | TTY_QUOTE, &tp->t_rawq); 434 goto endcase; 435 } else 436 c = 0; 437 } 438 } 439 440 if (!ISSET(tp->t_state, TS_TYPEN) && ISSET(iflag, ISTRIP)) 441 CLR(c, 0x80); 442 if (!ISSET(lflag, EXTPROC)) { 443 /* 444 * Check for literal nexting very first 445 */ 446 if (ISSET(tp->t_state, TS_LNCH)) { 447 SET(c, TTY_QUOTE); 448 CLR(tp->t_state, TS_LNCH); 449 } 450 /* 451 * Scan for special characters. This code 452 * is really just a big case statement with 453 * non-constant cases. The bottom of the 454 * case statement is labeled ``endcase'', so goto 455 * it after a case match, or similar. 456 */ 457 458 /* 459 * Control chars which aren't controlled 460 * by ICANON, ISIG, or IXON. 461 */ 462 if (ISSET(lflag, IEXTEN)) { 463 if (CCEQ(cc[VLNEXT], c)) { 464 if (ISSET(lflag, ECHO)) { 465 if (ISSET(lflag, ECHOE)) { 466 (void)ttyoutput('^', tp); 467 (void)ttyoutput('\b', tp); 468 } else 469 ttyecho(c, tp); 470 } 471 SET(tp->t_state, TS_LNCH); 472 goto endcase; 473 } 474 if (CCEQ(cc[VDISCARD], c)) { 475 if (ISSET(lflag, FLUSHO)) 476 CLR(tp->t_lflag, FLUSHO); 477 else { 478 ttyflush(tp, FWRITE); 479 ttyecho(c, tp); 480 if (tp->t_rawq.c_cc + tp->t_canq.c_cc) 481 ttyretype(tp); 482 SET(tp->t_lflag, FLUSHO); 483 } 484 goto startoutput; 485 } 486 } 487 /* 488 * Signals. 489 */ 490 if (ISSET(lflag, ISIG)) { 491 if (CCEQ(cc[VINTR], c) || CCEQ(cc[VQUIT], c)) { 492 if (!ISSET(lflag, NOFLSH)) 493 ttyflush(tp, FREAD | FWRITE); 494 ttyecho(c, tp); 495 if (tp->t_pgrp != NULL) { 496 PGRP_LOCK(tp->t_pgrp); 497 pgsignal(tp->t_pgrp, 498 CCEQ(cc[VINTR], c) ? SIGINT : SIGQUIT, 1); 499 PGRP_UNLOCK(tp->t_pgrp); 500 } 501 goto endcase; 502 } 503 if (CCEQ(cc[VSUSP], c)) { 504 if (!ISSET(lflag, NOFLSH)) 505 ttyflush(tp, FREAD); 506 ttyecho(c, tp); 507 if (tp->t_pgrp != NULL) { 508 PGRP_LOCK(tp->t_pgrp); 509 pgsignal(tp->t_pgrp, SIGTSTP, 1); 510 PGRP_UNLOCK(tp->t_pgrp); 511 } 512 goto endcase; 513 } 514 } 515 /* 516 * Handle start/stop characters. 517 */ 518 if (ISSET(iflag, IXON)) { 519 if (CCEQ(cc[VSTOP], c)) { 520 if (!ISSET(tp->t_state, TS_TTSTOP)) { 521 SET(tp->t_state, TS_TTSTOP); 522 tt_stop(tp, 0); 523 return (0); 524 } 525 if (!CCEQ(cc[VSTART], c)) 526 return (0); 527 /* 528 * if VSTART == VSTOP then toggle 529 */ 530 goto endcase; 531 } 532 if (CCEQ(cc[VSTART], c)) 533 goto restartoutput; 534 } 535 /* 536 * IGNCR, ICRNL, & INLCR 537 */ 538 if (c == '\r') { 539 if (ISSET(iflag, IGNCR)) 540 return (0); 541 else if (ISSET(iflag, ICRNL)) 542 c = '\n'; 543 } else if (c == '\n' && ISSET(iflag, INLCR)) 544 c = '\r'; 545 } 546 if (!ISSET(tp->t_lflag, EXTPROC) && ISSET(lflag, ICANON)) { 547 /* 548 * From here on down canonical mode character 549 * processing takes place. 550 */ 551 /* 552 * erase or erase2 (^H / ^?) 553 */ 554 if (CCEQ(cc[VERASE], c) || CCEQ(cc[VERASE2], c) ) { 555 if (tp->t_rawq.c_cc) 556 ttyrub(unputc(&tp->t_rawq), tp); 557 goto endcase; 558 } 559 /* 560 * kill (^U) 561 */ 562 if (CCEQ(cc[VKILL], c)) { 563 if (ISSET(lflag, ECHOKE) && 564 tp->t_rawq.c_cc == tp->t_rocount && 565 !ISSET(lflag, ECHOPRT)) 566 while (tp->t_rawq.c_cc) 567 ttyrub(unputc(&tp->t_rawq), tp); 568 else { 569 ttyecho(c, tp); 570 if (ISSET(lflag, ECHOK) || 571 ISSET(lflag, ECHOKE)) 572 ttyecho('\n', tp); 573 FLUSHQ(&tp->t_rawq); 574 tp->t_rocount = 0; 575 } 576 CLR(tp->t_state, TS_LOCAL); 577 goto endcase; 578 } 579 /* 580 * word erase (^W) 581 */ 582 if (CCEQ(cc[VWERASE], c) && ISSET(lflag, IEXTEN)) { 583 int ctype; 584 585 /* 586 * erase whitespace 587 */ 588 while ((c = unputc(&tp->t_rawq)) == ' ' || c == '\t') 589 ttyrub(c, tp); 590 if (c == -1) 591 goto endcase; 592 /* 593 * erase last char of word and remember the 594 * next chars type (for ALTWERASE) 595 */ 596 ttyrub(c, tp); 597 c = unputc(&tp->t_rawq); 598 if (c == -1) 599 goto endcase; 600 if (c == ' ' || c == '\t') { 601 (void)putc(c, &tp->t_rawq); 602 goto endcase; 603 } 604 ctype = ISALPHA(c); 605 /* 606 * erase rest of word 607 */ 608 do { 609 ttyrub(c, tp); 610 c = unputc(&tp->t_rawq); 611 if (c == -1) 612 goto endcase; 613 } while (c != ' ' && c != '\t' && 614 (!ISSET(lflag, ALTWERASE) || ISALPHA(c) == ctype)); 615 (void)putc(c, &tp->t_rawq); 616 goto endcase; 617 } 618 /* 619 * reprint line (^R) 620 */ 621 if (CCEQ(cc[VREPRINT], c) && ISSET(lflag, IEXTEN)) { 622 ttyretype(tp); 623 goto endcase; 624 } 625 /* 626 * ^T - kernel info and generate SIGINFO 627 */ 628 if (CCEQ(cc[VSTATUS], c) && ISSET(lflag, IEXTEN)) { 629 if (ISSET(lflag, ISIG) && tp->t_pgrp != NULL) { 630 PGRP_LOCK(tp->t_pgrp); 631 pgsignal(tp->t_pgrp, SIGINFO, 1); 632 PGRP_UNLOCK(tp->t_pgrp); 633 } 634 if (!ISSET(lflag, NOKERNINFO)) 635 ttyinfo(tp); 636 goto endcase; 637 } 638 } 639 /* 640 * Check for input buffer overflow 641 */ 642 if (tp->t_rawq.c_cc + tp->t_canq.c_cc >= MAX_INPUT) { 643input_overflow: 644 if (ISSET(iflag, IMAXBEL)) { 645 if (tp->t_outq.c_cc < tp->t_ohiwat) 646 (void)ttyoutput(CTRL('g'), tp); 647 } 648 goto endcase; 649 } 650 651 if ( c == 0377 && ISSET(iflag, PARMRK) && !ISSET(iflag, ISTRIP) 652 && ISSET(iflag, IGNBRK|IGNPAR) != (IGNBRK|IGNPAR)) 653 (void)putc(0377 | TTY_QUOTE, &tp->t_rawq); 654 655 /* 656 * Put data char in q for user and 657 * wakeup on seeing a line delimiter. 658 */ 659 if (putc(c, &tp->t_rawq) >= 0) { 660 if (!ISSET(lflag, ICANON)) { 661 ttwakeup(tp); 662 ttyecho(c, tp); 663 goto endcase; 664 } 665 if (TTBREAKC(c, lflag)) { 666 tp->t_rocount = 0; 667 catq(&tp->t_rawq, &tp->t_canq); 668 ttwakeup(tp); 669 } else if (tp->t_rocount++ == 0) 670 tp->t_rocol = tp->t_column; 671 if (ISSET(tp->t_state, TS_ERASE)) { 672 /* 673 * end of prterase \.../ 674 */ 675 CLR(tp->t_state, TS_ERASE); 676 (void)ttyoutput('/', tp); 677 } 678 i = tp->t_column; 679 ttyecho(c, tp); 680 if (CCEQ(cc[VEOF], c) && ISSET(lflag, ECHO)) { 681 /* 682 * Place the cursor over the '^' of the ^D. 683 */ 684 i = imin(2, tp->t_column - i); 685 while (i > 0) { 686 (void)ttyoutput('\b', tp); 687 i--; 688 } 689 } 690 } 691endcase: 692 /* 693 * IXANY means allow any character to restart output. 694 */ 695 if (ISSET(tp->t_state, TS_TTSTOP) && 696 !ISSET(iflag, IXANY) && cc[VSTART] != cc[VSTOP]) 697 return (0); 698restartoutput: 699 CLR(tp->t_lflag, FLUSHO); 700 CLR(tp->t_state, TS_TTSTOP); 701startoutput: 702 return (ttstart(tp)); 703} 704 705/* 706 * Output a single character on a tty, doing output processing 707 * as needed (expanding tabs, newline processing, etc.). 708 * Returns < 0 if succeeds, otherwise returns char to resend. 709 * Must be recursive. 710 */ 711static int 712ttyoutput(int c, struct tty *tp) 713{ 714 tcflag_t oflag; 715 int col, s; 716 717 oflag = tp->t_oflag; 718 if (!ISSET(oflag, OPOST)) { 719 if (ISSET(tp->t_lflag, FLUSHO)) 720 return (-1); 721 if (putc(c, &tp->t_outq)) 722 return (c); 723 tk_nout++; 724 tp->t_outcc++; 725 return (-1); 726 } 727 /* 728 * Do tab expansion if OXTABS is set. Special case if we external 729 * processing, we don't do the tab expansion because we'll probably 730 * get it wrong. If tab expansion needs to be done, let it happen 731 * externally. 732 */ 733 CLR(c, ~TTY_CHARMASK); 734 if (c == '\t' && 735 ISSET(oflag, OXTABS) && !ISSET(tp->t_lflag, EXTPROC)) { 736 c = 8 - (tp->t_column & 7); 737 if (!ISSET(tp->t_lflag, FLUSHO)) { 738 s = spltty(); /* Don't interrupt tabs. */ 739 c -= b_to_q(" ", c, &tp->t_outq); 740 tk_nout += c; 741 tp->t_outcc += c; 742 splx(s); 743 } 744 tp->t_column += c; 745 return (c ? -1 : '\t'); 746 } 747 if (c == CEOT && ISSET(oflag, ONOEOT)) 748 return (-1); 749 750 /* 751 * Newline translation: if ONLCR is set, 752 * translate newline into "\r\n". 753 */ 754 if (c == '\n' && ISSET(tp->t_oflag, ONLCR)) { 755 tk_nout++; 756 tp->t_outcc++; 757 if (!ISSET(tp->t_lflag, FLUSHO) && putc('\r', &tp->t_outq)) 758 return (c); 759 } 760 /* If OCRNL is set, translate "\r" into "\n". */ 761 else if (c == '\r' && ISSET(tp->t_oflag, OCRNL)) 762 c = '\n'; 763 /* If ONOCR is set, don't transmit CRs when on column 0. */ 764 else if (c == '\r' && ISSET(tp->t_oflag, ONOCR) && tp->t_column == 0) 765 return (-1); 766 767 tk_nout++; 768 tp->t_outcc++; 769 if (!ISSET(tp->t_lflag, FLUSHO) && putc(c, &tp->t_outq)) 770 return (c); 771 772 col = tp->t_column; 773 switch (CCLASS(c)) { 774 case BACKSPACE: 775 if (col > 0) 776 --col; 777 break; 778 case CONTROL: 779 break; 780 case NEWLINE: 781 if (ISSET(tp->t_oflag, ONLCR | ONLRET)) 782 col = 0; 783 break; 784 case RETURN: 785 col = 0; 786 break; 787 case ORDINARY: 788 ++col; 789 break; 790 case TAB: 791 col = (col + 8) & ~7; 792 break; 793 } 794 tp->t_column = col; 795 return (-1); 796} 797 798/* 799 * Ioctls for all tty devices. Called after line-discipline specific ioctl 800 * has been called to do discipline-specific functions and/or reject any 801 * of these ioctl commands. 802 */ 803/* ARGSUSED */ 804int 805ttioctl(struct tty *tp, u_long cmd, void *data, int flag) 806{ 807 struct proc *p; 808 struct thread *td; 809 struct pgrp *pgrp; 810 int s, error, bits, sig, sig2; 811 812 td = curthread; /* XXX */ 813 p = td->td_proc; 814 815 /* If the ioctl involves modification, hang if in the background. */ 816 switch (cmd) { 817 case TIOCCBRK: 818 case TIOCCONS: 819 case TIOCDRAIN: 820 case TIOCEXCL: 821 case TIOCFLUSH: 822#ifdef TIOCHPCL 823 case TIOCHPCL: 824#endif 825 case TIOCNXCL: 826 case TIOCSBRK: 827 case TIOCSCTTY: 828 case TIOCSDRAINWAIT: 829 case TIOCSETA: 830 case TIOCSETAF: 831 case TIOCSETAW: 832 case TIOCSETD: 833 case TIOCSPGRP: 834 case TIOCSTART: 835 case TIOCSTAT: 836 case TIOCSTI: 837 case TIOCSTOP: 838 case TIOCSWINSZ: 839#if defined(COMPAT_43TTY) 840 case TIOCLBIC: 841 case TIOCLBIS: 842 case TIOCLSET: 843 case TIOCSETC: 844 case OTIOCSETD: 845 case TIOCSETN: 846 case TIOCSETP: 847 case TIOCSLTC: 848#endif 849 sx_slock(&proctree_lock); 850 PROC_LOCK(p); 851 while (isbackground(p, tp) && !(p->p_flag & P_PPWAIT) && 852 !SIGISMEMBER(p->p_sigacts->ps_sigignore, SIGTTOU) && 853 !SIGISMEMBER(td->td_sigmask, SIGTTOU)) { 854 pgrp = p->p_pgrp; 855 PROC_UNLOCK(p); 856 if (pgrp->pg_jobc == 0) { 857 sx_sunlock(&proctree_lock); 858 return (EIO); 859 } 860 PGRP_LOCK(pgrp); 861 sx_sunlock(&proctree_lock); 862 pgsignal(pgrp, SIGTTOU, 1); 863 PGRP_UNLOCK(pgrp); 864 error = ttysleep(tp, &lbolt, TTOPRI | PCATCH, "ttybg1", 865 0); 866 if (error) 867 return (error); 868 sx_slock(&proctree_lock); 869 PROC_LOCK(p); 870 } 871 PROC_UNLOCK(p); 872 sx_sunlock(&proctree_lock); 873 break; 874 } 875 876 877 if (tp->t_modem != NULL) { 878 switch (cmd) { 879 case TIOCSDTR: 880 tt_modem(tp, SER_DTR, 0); 881 return (0); 882 case TIOCCDTR: 883 tt_modem(tp, 0, SER_DTR); 884 return (0); 885 case TIOCMSET: 886 bits = *(int *)data; 887 sig = (bits & (TIOCM_DTR | TIOCM_RTS)) >> 1; 888 sig2 = ((~bits) & (TIOCM_DTR | TIOCM_RTS)) >> 1; 889 tt_modem(tp, sig, sig2); 890 return (0); 891 case TIOCMBIS: 892 bits = *(int *)data; 893 sig = (bits & (TIOCM_DTR | TIOCM_RTS)) >> 1; 894 tt_modem(tp, sig, 0); 895 return (0); 896 case TIOCMBIC: 897 bits = *(int *)data; 898 sig = (bits & (TIOCM_DTR | TIOCM_RTS)) >> 1; 899 tt_modem(tp, 0, sig); 900 return (0); 901 case TIOCMGET: 902 sig = tt_modem(tp, 0, 0); 903 /* See <sys/serial.h. for the "<< 1" stuff */ 904 bits = TIOCM_LE + (sig << 1); 905 *(int *)data = bits; 906 return (0); 907 default: 908 break; 909 } 910 } 911 912 if (tp->t_pps != NULL) { 913 error = pps_ioctl(cmd, data, tp->t_pps); 914 if (error != ENOIOCTL) 915 return (error); 916 } 917 918 switch (cmd) { /* Process the ioctl. */ 919 case FIOASYNC: /* set/clear async i/o */ 920 s = spltty(); 921 if (*(int *)data) 922 SET(tp->t_state, TS_ASYNC); 923 else 924 CLR(tp->t_state, TS_ASYNC); 925 splx(s); 926 break; 927 case FIONBIO: /* set/clear non-blocking i/o */ 928 break; /* XXX: delete. */ 929 case FIONREAD: /* get # bytes to read */ 930 s = spltty(); 931 *(int *)data = ttnread(tp); 932 splx(s); 933 break; 934 935 case FIOSETOWN: 936 /* 937 * Policy -- Don't allow FIOSETOWN on someone else's 938 * controlling tty 939 */ 940 if (tp->t_session != NULL && !isctty(p, tp)) 941 return (ENOTTY); 942 943 error = fsetown(*(int *)data, &tp->t_sigio); 944 if (error) 945 return (error); 946 break; 947 case FIOGETOWN: 948 if (tp->t_session != NULL && !isctty(p, tp)) 949 return (ENOTTY); 950 *(int *)data = fgetown(&tp->t_sigio); 951 break; 952 953 case TIOCEXCL: /* set exclusive use of tty */ 954 s = spltty(); 955 SET(tp->t_state, TS_XCLUDE); 956 splx(s); 957 break; 958 case TIOCFLUSH: { /* flush buffers */ 959 int flags = *(int *)data; 960 961 if (flags == 0) 962 flags = FREAD | FWRITE; 963 else 964 flags &= FREAD | FWRITE; 965 ttyflush(tp, flags); 966 break; 967 } 968 case TIOCCONS: /* become virtual console */ 969 if (*(int *)data) { 970 struct nameidata nid; 971 972 if (constty && constty != tp && 973 ISSET(constty->t_state, TS_CONNECTED)) 974 return (EBUSY); 975 976 /* Ensure user can open the real console. */ 977 NDINIT(&nid, LOOKUP, LOCKLEAF | FOLLOW, UIO_SYSSPACE, 978 "/dev/console", td); 979 if ((error = namei(&nid)) != 0) 980 return (error); 981 NDFREE(&nid, NDF_ONLY_PNBUF); 982 error = VOP_ACCESS(nid.ni_vp, VREAD, td->td_ucred, td); 983 vput(nid.ni_vp); 984 if (error) 985 return (error); 986 987 constty_set(tp); 988 } else if (tp == constty) 989 constty_clear(); 990 break; 991 case TIOCDRAIN: /* wait till output drained */ 992 error = ttywait(tp); 993 if (error) 994 return (error); 995 break; 996 case TIOCGETA: { /* get termios struct */ 997 struct termios *t = (struct termios *)data; 998 999 bcopy(&tp->t_termios, t, sizeof(struct termios)); 1000 break; 1001 } 1002 case TIOCGETD: /* get line discipline */ 1003 *(int *)data = tp->t_line; 1004 break; 1005 case TIOCGWINSZ: /* get window size */ 1006 *(struct winsize *)data = tp->t_winsize; 1007 break; 1008 case TIOCGPGRP: /* get pgrp of tty */ 1009 if (!isctty(p, tp)) 1010 return (ENOTTY); 1011 *(int *)data = tp->t_pgrp ? tp->t_pgrp->pg_id : NO_PID; 1012 break; 1013 case TIOCGSID: /* get sid of tty */ 1014 if (!isctty(p, tp)) 1015 return (ENOTTY); 1016 *(int *)data = tp->t_session->s_sid; 1017 break; 1018#ifdef TIOCHPCL 1019 case TIOCHPCL: /* hang up on last close */ 1020 s = spltty(); 1021 SET(tp->t_cflag, HUPCL); 1022 splx(s); 1023 break; 1024#endif 1025 case TIOCMGDTRWAIT: 1026 *(int *)data = tp->t_dtr_wait * 100 / hz; 1027 break; 1028 case TIOCMSDTRWAIT: 1029 /* must be root since the wait applies to following logins */ 1030 error = priv_check(td, PRIV_TTY_DTRWAIT); 1031 if (error) 1032 return (error); 1033 tp->t_dtr_wait = *(int *)data * hz / 100; 1034 break; 1035 case TIOCNXCL: /* reset exclusive use of tty */ 1036 s = spltty(); 1037 CLR(tp->t_state, TS_XCLUDE); 1038 splx(s); 1039 break; 1040 case TIOCOUTQ: /* output queue size */ 1041 *(int *)data = tp->t_outq.c_cc; 1042 break; 1043 case TIOCSETA: /* set termios struct */ 1044 case TIOCSETAW: /* drain output, set */ 1045 case TIOCSETAF: { /* drn out, fls in, set */ 1046 struct termios *t = (struct termios *)data; 1047 1048 if (t->c_ispeed == 0) 1049 t->c_ispeed = t->c_ospeed; 1050 if (t->c_ispeed == 0) 1051 t->c_ispeed = tp->t_ospeed; 1052 if (t->c_ispeed == 0) 1053 return (EINVAL); 1054 s = spltty(); 1055 if (cmd == TIOCSETAW || cmd == TIOCSETAF) { 1056 error = ttywait(tp); 1057 if (error) { 1058 splx(s); 1059 return (error); 1060 } 1061 if (cmd == TIOCSETAF) 1062 ttyflush(tp, FREAD); 1063 } 1064 if (!ISSET(t->c_cflag, CIGNORE)) { 1065 /* 1066 * Set device hardware. 1067 */ 1068 error = tt_param(tp, t); 1069 if (error) { 1070 splx(s); 1071 return (error); 1072 } 1073 if (ISSET(t->c_cflag, CLOCAL) && 1074 !ISSET(tp->t_cflag, CLOCAL)) { 1075 /* 1076 * XXX disconnections would be too hard to 1077 * get rid of without this kludge. The only 1078 * way to get rid of controlling terminals 1079 * is to exit from the session leader. 1080 */ 1081 CLR(tp->t_state, TS_ZOMBIE); 1082 1083 wakeup(TSA_CARR_ON(tp)); 1084 ttwakeup(tp); 1085 ttwwakeup(tp); 1086 } 1087 if ((ISSET(tp->t_state, TS_CARR_ON) || 1088 ISSET(t->c_cflag, CLOCAL)) && 1089 !ISSET(tp->t_state, TS_ZOMBIE)) 1090 SET(tp->t_state, TS_CONNECTED); 1091 else 1092 CLR(tp->t_state, TS_CONNECTED); 1093 tp->t_cflag = t->c_cflag; 1094 tp->t_ispeed = t->c_ispeed; 1095 if (t->c_ospeed != 0) 1096 tp->t_ospeed = t->c_ospeed; 1097 ttsetwater(tp); 1098 } 1099 if (ISSET(t->c_lflag, ICANON) != ISSET(tp->t_lflag, ICANON) && 1100 cmd != TIOCSETAF) { 1101 if (ISSET(t->c_lflag, ICANON)) 1102 SET(tp->t_lflag, PENDIN); 1103 else { 1104 /* 1105 * XXX we really shouldn't allow toggling 1106 * ICANON while we're in a non-termios line 1107 * discipline. Now we have to worry about 1108 * panicing for a null queue. 1109 */ 1110 if (tp->t_canq.c_cbreserved > 0 && 1111 tp->t_rawq.c_cbreserved > 0) { 1112 catq(&tp->t_rawq, &tp->t_canq); 1113 /* 1114 * XXX the queue limits may be 1115 * different, so the old queue 1116 * swapping method no longer works. 1117 */ 1118 catq(&tp->t_canq, &tp->t_rawq); 1119 } 1120 CLR(tp->t_lflag, PENDIN); 1121 } 1122 ttwakeup(tp); 1123 } 1124 tp->t_iflag = t->c_iflag; 1125 tp->t_oflag = t->c_oflag; 1126 /* 1127 * Make the EXTPROC bit read only. 1128 */ 1129 if (ISSET(tp->t_lflag, EXTPROC)) 1130 SET(t->c_lflag, EXTPROC); 1131 else 1132 CLR(t->c_lflag, EXTPROC); 1133 tp->t_lflag = t->c_lflag | ISSET(tp->t_lflag, PENDIN); 1134 if (t->c_cc[VMIN] != tp->t_cc[VMIN] || 1135 t->c_cc[VTIME] != tp->t_cc[VTIME]) 1136 ttwakeup(tp); 1137 bcopy(t->c_cc, tp->t_cc, sizeof(t->c_cc)); 1138 splx(s); 1139 break; 1140 } 1141 case TIOCSETD: { /* set line discipline */ 1142 int t = *(int *)data; 1143 1144 if ((u_int)t >= nlinesw) 1145 return (ENXIO); 1146 if (t == tp->t_line) 1147 return (0); 1148 s = spltty(); 1149 ttyld_close(tp, flag); 1150 tp->t_line = t; 1151 /* XXX: we should use the correct cdev here */ 1152 error = ttyld_open(tp, tp->t_dev); 1153 if (error) { 1154 /* 1155 * If we fail to switch line discipline we cannot 1156 * fall back to the previous, because we can not 1157 * trust that ldisc to open successfully either. 1158 * Fall back to the default ldisc which we know 1159 * will allways succeed. 1160 */ 1161 tp->t_line = TTYDISC; 1162 (void)ttyld_open(tp, tp->t_dev); 1163 } 1164 splx(s); 1165 return (error); 1166 break; 1167 } 1168 case TIOCSTART: /* start output, like ^Q */ 1169 s = spltty(); 1170 if (ISSET(tp->t_state, TS_TTSTOP) || 1171 ISSET(tp->t_lflag, FLUSHO)) { 1172 CLR(tp->t_lflag, FLUSHO); 1173 CLR(tp->t_state, TS_TTSTOP); 1174 ttstart(tp); 1175 } 1176 splx(s); 1177 break; 1178 case TIOCSTI: /* simulate terminal input */ 1179 if ((flag & FREAD) == 0 && priv_check(td, PRIV_TTY_STI)) 1180 return (EPERM); 1181 if (!isctty(p, tp) && priv_check(td, PRIV_TTY_STI)) 1182 return (EACCES); 1183 s = spltty(); 1184 ttyld_rint(tp, *(u_char *)data); 1185 splx(s); 1186 break; 1187 case TIOCSTOP: /* stop output, like ^S */ 1188 s = spltty(); 1189 if (!ISSET(tp->t_state, TS_TTSTOP)) { 1190 SET(tp->t_state, TS_TTSTOP); 1191 tt_stop(tp, 0); 1192 } 1193 splx(s); 1194 break; 1195 case TIOCSCTTY: /* become controlling tty */ 1196 /* Session ctty vnode pointer set in vnode layer. */ 1197 sx_slock(&proctree_lock); 1198 if (!SESS_LEADER(p) || 1199 ((p->p_session->s_ttyvp || tp->t_session) && 1200 (tp->t_session != p->p_session))) { 1201 sx_sunlock(&proctree_lock); 1202 return (EPERM); 1203 } 1204 tp->t_session = p->p_session; 1205 tp->t_pgrp = p->p_pgrp; 1206 SESS_LOCK(p->p_session); 1207 ttyref(tp); /* ttyrel(): kern_proc.c:pgdelete() */ 1208 p->p_session->s_ttyp = tp; 1209 SESS_UNLOCK(p->p_session); 1210 PROC_LOCK(p); 1211 p->p_flag |= P_CONTROLT; 1212 PROC_UNLOCK(p); 1213 sx_sunlock(&proctree_lock); 1214 break; 1215 case TIOCSPGRP: { /* set pgrp of tty */ 1216 sx_slock(&proctree_lock); 1217 pgrp = pgfind(*(int *)data); 1218 if (!isctty(p, tp)) { 1219 if (pgrp != NULL) 1220 PGRP_UNLOCK(pgrp); 1221 sx_sunlock(&proctree_lock); 1222 return (ENOTTY); 1223 } 1224 if (pgrp == NULL) { 1225 sx_sunlock(&proctree_lock); 1226 return (EPERM); 1227 } 1228 PGRP_UNLOCK(pgrp); 1229 if (pgrp->pg_session != p->p_session) { 1230 sx_sunlock(&proctree_lock); 1231 return (EPERM); 1232 } 1233 sx_sunlock(&proctree_lock); 1234 tp->t_pgrp = pgrp; 1235 break; 1236 } 1237 case TIOCSTAT: /* simulate control-T */ 1238 s = spltty(); 1239 ttyinfo(tp); 1240 splx(s); 1241 break; 1242 case TIOCSWINSZ: /* set window size */ 1243 if (bcmp((caddr_t)&tp->t_winsize, data, 1244 sizeof (struct winsize))) { 1245 tp->t_winsize = *(struct winsize *)data; 1246 if (tp->t_pgrp != NULL) { 1247 PGRP_LOCK(tp->t_pgrp); 1248 pgsignal(tp->t_pgrp, SIGWINCH, 1); 1249 PGRP_UNLOCK(tp->t_pgrp); 1250 } 1251 } 1252 break; 1253 case TIOCSDRAINWAIT: 1254 error = priv_check(td, PRIV_TTY_DRAINWAIT); 1255 if (error) 1256 return (error); 1257 tp->t_timeout = *(int *)data * hz; 1258 wakeup(TSA_OCOMPLETE(tp)); 1259 wakeup(TSA_OLOWAT(tp)); 1260 break; 1261 case TIOCGDRAINWAIT: 1262 *(int *)data = tp->t_timeout / hz; 1263 break; 1264 case TIOCSBRK: 1265 return (tt_break(tp, 1)); 1266 case TIOCCBRK: 1267 return (tt_break(tp, 0)); 1268 default: 1269#if defined(COMPAT_43TTY) 1270 return (ttcompat(tp, cmd, data, flag)); 1271#else 1272 return (ENOIOCTL); 1273#endif 1274 } 1275 return (0); 1276} 1277 1278int 1279ttypoll(struct cdev *dev, int events, struct thread *td) 1280{ 1281 int s; 1282 int revents = 0; 1283 struct tty *tp; 1284 1285 tp = tty_gettp(dev); 1286 1287 if (tp == NULL) /* XXX used to return ENXIO, but that means true! */ 1288 return ((events & (POLLIN | POLLOUT | POLLRDNORM | POLLWRNORM)) 1289 | POLLHUP); 1290 1291 s = spltty(); 1292 if (events & (POLLIN | POLLRDNORM)) { 1293 if (ISSET(tp->t_state, TS_ZOMBIE)) 1294 revents |= (events & (POLLIN | POLLRDNORM)) | 1295 POLLHUP; 1296 else if (ttnread(tp) > 0) 1297 revents |= events & (POLLIN | POLLRDNORM); 1298 else 1299 selrecord(td, &tp->t_rsel); 1300 } 1301 if (events & POLLOUT) { 1302 if (ISSET(tp->t_state, TS_ZOMBIE)) 1303 revents |= POLLHUP; 1304 else if (tp->t_outq.c_cc <= tp->t_olowat && 1305 ISSET(tp->t_state, TS_CONNECTED)) 1306 revents |= events & POLLOUT; 1307 else 1308 selrecord(td, &tp->t_wsel); 1309 } 1310 splx(s); 1311 return (revents); 1312} 1313 1314static struct filterops ttyread_filtops = 1315 { 1, NULL, filt_ttyrdetach, filt_ttyread }; 1316static struct filterops ttywrite_filtops = 1317 { 1, NULL, filt_ttywdetach, filt_ttywrite }; 1318 1319int 1320ttykqfilter(struct cdev *dev, struct knote *kn) 1321{ 1322 struct tty *tp; 1323 struct knlist *klist; 1324 int s; 1325 1326 tp = tty_gettp(dev); 1327 if (tp->t_state & TS_GONE) 1328 return (ENODEV); 1329 1330 switch (kn->kn_filter) { 1331 case EVFILT_READ: 1332 klist = &tp->t_rsel.si_note; 1333 kn->kn_fop = &ttyread_filtops; 1334 break; 1335 case EVFILT_WRITE: 1336 klist = &tp->t_wsel.si_note; 1337 kn->kn_fop = &ttywrite_filtops; 1338 break; 1339 default: 1340 return (EINVAL); 1341 } 1342 1343 kn->kn_hook = (caddr_t)tp; 1344 1345 s = spltty(); 1346 knlist_add(klist, kn, 0); 1347 splx(s); 1348 1349 return (0); 1350} 1351 1352static void 1353filt_ttyrdetach(struct knote *kn) 1354{ 1355 struct tty *tp = (struct tty *)kn->kn_hook; 1356 int s = spltty(); 1357 1358 knlist_remove(&tp->t_rsel.si_note, kn, 0); 1359 splx(s); 1360} 1361 1362static int 1363filt_ttyread(struct knote *kn, long hint) 1364{ 1365 struct tty *tp = (struct tty *)kn->kn_hook; 1366 1367 kn->kn_data = ttnread(tp); 1368 if ((tp->t_state & TS_GONE) || ISSET(tp->t_state, TS_ZOMBIE)) { 1369 kn->kn_flags |= EV_EOF; 1370 return (1); 1371 } 1372 return (kn->kn_data > 0); 1373} 1374 1375static void 1376filt_ttywdetach(struct knote *kn) 1377{ 1378 struct tty *tp = (struct tty *)kn->kn_hook; 1379 int s = spltty(); 1380 1381 knlist_remove(&tp->t_wsel.si_note, kn, 0); 1382 splx(s); 1383} 1384 1385static int 1386filt_ttywrite(struct knote *kn, long hint) 1387{ 1388 struct tty *tp = (struct tty *)kn->kn_hook; 1389 1390 kn->kn_data = tp->t_outq.c_cc; 1391 if ((tp->t_state & TS_GONE) || ISSET(tp->t_state, TS_ZOMBIE)) 1392 return (1); 1393 return (kn->kn_data <= tp->t_olowat && 1394 ISSET(tp->t_state, TS_CONNECTED)); 1395} 1396 1397/* 1398 * Must be called at spltty(). 1399 */ 1400static int 1401ttnread(struct tty *tp) 1402{ 1403 int nread; 1404 1405 if (ISSET(tp->t_lflag, PENDIN)) 1406 ttypend(tp); 1407 nread = tp->t_canq.c_cc; 1408 if (!ISSET(tp->t_lflag, ICANON)) { 1409 nread += tp->t_rawq.c_cc; 1410 if (nread < tp->t_cc[VMIN] && tp->t_cc[VTIME] == 0) 1411 nread = 0; 1412 } 1413 return (nread); 1414} 1415 1416/* 1417 * Wait for output to drain. 1418 */ 1419int 1420ttywait(struct tty *tp) 1421{ 1422 int error, s; 1423 1424 error = 0; 1425 s = spltty(); 1426 while ((tp->t_outq.c_cc || ISSET(tp->t_state, TS_BUSY)) && 1427 ISSET(tp->t_state, TS_CONNECTED) && tp->t_oproc) { 1428 tt_oproc(tp); 1429 if ((tp->t_outq.c_cc || ISSET(tp->t_state, TS_BUSY)) && 1430 ISSET(tp->t_state, TS_CONNECTED)) { 1431 SET(tp->t_state, TS_SO_OCOMPLETE); 1432 error = ttysleep(tp, TSA_OCOMPLETE(tp), 1433 TTOPRI | PCATCH, "ttywai", 1434 tp->t_timeout); 1435 if (error) { 1436 if (error == EWOULDBLOCK) 1437 error = EIO; 1438 break; 1439 } 1440 } else 1441 break; 1442 } 1443 if (!error && (tp->t_outq.c_cc || ISSET(tp->t_state, TS_BUSY))) 1444 error = EIO; 1445 splx(s); 1446 return (error); 1447} 1448 1449/* 1450 * Flush if successfully wait. 1451 */ 1452static int 1453ttywflush(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 */ 1465void 1466ttyflush(struct tty *tp, int rw) 1467{ 1468 int s; 1469 1470 s = spltty(); 1471#if 0 1472again: 1473#endif 1474 if (rw & FWRITE) { 1475 FLUSHQ(&tp->t_outq); 1476 CLR(tp->t_state, TS_TTSTOP); 1477 } 1478 tt_stop(tp, rw); 1479 if (rw & FREAD) { 1480 FLUSHQ(&tp->t_canq); 1481 FLUSHQ(&tp->t_rawq); 1482 CLR(tp->t_lflag, PENDIN); 1483 tp->t_rocount = 0; 1484 tp->t_rocol = 0; 1485 CLR(tp->t_state, TS_LOCAL); 1486 ttwakeup(tp); 1487 if (ISSET(tp->t_state, TS_TBLOCK)) { 1488 if (rw & FWRITE) 1489 FLUSHQ(&tp->t_outq); 1490 ttyunblock(tp); 1491 1492 /* 1493 * Don't let leave any state that might clobber the 1494 * next line discipline (although we should do more 1495 * to send the START char). Not clearing the state 1496 * may have caused the "putc to a clist with no 1497 * reserved cblocks" panic/printf. 1498 */ 1499 CLR(tp->t_state, TS_TBLOCK); 1500 1501#if 0 /* forget it, sleeping isn't always safe and we don't know when it is */ 1502 if (ISSET(tp->t_iflag, IXOFF)) { 1503 /* 1504 * XXX wait a bit in the hope that the stop 1505 * character (if any) will go out. Waiting 1506 * isn't good since it allows races. This 1507 * will be fixed when the stop character is 1508 * put in a special queue. Don't bother with 1509 * the checks in ttywait() since the timeout 1510 * will save us. 1511 */ 1512 SET(tp->t_state, TS_SO_OCOMPLETE); 1513 ttysleep(tp, TSA_OCOMPLETE(tp), TTOPRI, 1514 "ttyfls", hz / 10); 1515 /* 1516 * Don't try sending the stop character again. 1517 */ 1518 CLR(tp->t_state, TS_TBLOCK); 1519 goto again; 1520 } 1521#endif 1522 } 1523 } 1524 if (rw & FWRITE) { 1525 FLUSHQ(&tp->t_outq); 1526 ttwwakeup(tp); 1527 } 1528 splx(s); 1529} 1530 1531/* 1532 * Copy in the default termios characters. 1533 */ 1534void 1535termioschars(struct termios *t) 1536{ 1537 1538 bcopy(ttydefchars, t->c_cc, sizeof t->c_cc); 1539} 1540 1541/* 1542 * Old interface. 1543 */ 1544void 1545ttychars(struct tty *tp) 1546{ 1547 1548 termioschars(&tp->t_termios); 1549} 1550 1551/* 1552 * Handle input high water. Send stop character for the IXOFF case. Turn 1553 * on our input flow control bit and propagate the changes to the driver. 1554 * XXX the stop character should be put in a special high priority queue. 1555 */ 1556void 1557ttyblock(struct tty *tp) 1558{ 1559 1560 SET(tp->t_state, TS_TBLOCK); 1561 if (ISSET(tp->t_iflag, IXOFF) && tp->t_cc[VSTOP] != _POSIX_VDISABLE && 1562 putc(tp->t_cc[VSTOP], &tp->t_outq) != 0) 1563 CLR(tp->t_state, TS_TBLOCK); /* try again later */ 1564 ttstart(tp); 1565} 1566 1567/* 1568 * Handle input low water. Send start character for the IXOFF case. Turn 1569 * off our input flow control bit and propagate the changes to the driver. 1570 * XXX the start character should be put in a special high priority queue. 1571 */ 1572static void 1573ttyunblock(struct tty *tp) 1574{ 1575 1576 CLR(tp->t_state, TS_TBLOCK); 1577 if (ISSET(tp->t_iflag, IXOFF) && tp->t_cc[VSTART] != _POSIX_VDISABLE && 1578 putc(tp->t_cc[VSTART], &tp->t_outq) != 0) 1579 SET(tp->t_state, TS_TBLOCK); /* try again later */ 1580 ttstart(tp); 1581} 1582 1583#ifdef notyet 1584/* Not used by any current (i386) drivers. */ 1585/* 1586 * Restart after an inter-char delay. 1587 */ 1588void 1589ttrstrt(void *tp_arg) 1590{ 1591 struct tty *tp; 1592 int s; 1593 1594 KASSERT(tp_arg != NULL, ("ttrstrt")); 1595 1596 tp = tp_arg; 1597 s = spltty(); 1598 1599 CLR(tp->t_state, TS_TIMEOUT); 1600 ttstart(tp); 1601 1602 splx(s); 1603} 1604#endif 1605 1606int 1607ttstart(struct tty *tp) 1608{ 1609 1610 tt_oproc(tp); 1611 return (0); 1612} 1613 1614/* 1615 * "close" a line discipline 1616 */ 1617int 1618ttylclose(struct tty *tp, int flag) 1619{ 1620 1621 if (flag & FNONBLOCK || ttywflush(tp)) 1622 ttyflush(tp, FREAD | FWRITE); 1623 return (0); 1624} 1625 1626/* 1627 * Handle modem control transition on a tty. 1628 * Flag indicates new state of carrier. 1629 * Returns 0 if the line should be turned off, otherwise 1. 1630 */ 1631int 1632ttymodem(struct tty *tp, int flag) 1633{ 1634 1635 if (ISSET(tp->t_state, TS_CARR_ON) && ISSET(tp->t_cflag, MDMBUF)) { 1636 /* 1637 * MDMBUF: do flow control according to carrier flag 1638 * XXX TS_CAR_OFLOW doesn't do anything yet. TS_TTSTOP 1639 * works if IXON and IXANY are clear. 1640 */ 1641 if (flag) { 1642 CLR(tp->t_state, TS_CAR_OFLOW); 1643 CLR(tp->t_state, TS_TTSTOP); 1644 ttstart(tp); 1645 } else if (!ISSET(tp->t_state, TS_CAR_OFLOW)) { 1646 SET(tp->t_state, TS_CAR_OFLOW); 1647 SET(tp->t_state, TS_TTSTOP); 1648 tt_stop(tp, 0); 1649 } 1650 } else if (flag == 0) { 1651 /* 1652 * Lost carrier. 1653 */ 1654 CLR(tp->t_state, TS_CARR_ON); 1655 if (ISSET(tp->t_state, TS_ISOPEN) && 1656 !ISSET(tp->t_cflag, CLOCAL)) { 1657 SET(tp->t_state, TS_ZOMBIE); 1658 CLR(tp->t_state, TS_CONNECTED); 1659 if (tp->t_session) { 1660 sx_slock(&proctree_lock); 1661 if (tp->t_session && tp->t_session->s_leader) { 1662 struct proc *p; 1663 1664 p = tp->t_session->s_leader; 1665 PROC_LOCK(p); 1666 psignal(p, SIGHUP); 1667 PROC_UNLOCK(p); 1668 } 1669 sx_sunlock(&proctree_lock); 1670 } 1671 ttyflush(tp, FREAD | FWRITE); 1672 return (0); 1673 } 1674 } else { 1675 /* 1676 * Carrier now on. 1677 */ 1678 SET(tp->t_state, TS_CARR_ON); 1679 if (!ISSET(tp->t_state, TS_ZOMBIE)) 1680 SET(tp->t_state, TS_CONNECTED); 1681 wakeup(TSA_CARR_ON(tp)); 1682 ttwakeup(tp); 1683 ttwwakeup(tp); 1684 } 1685 return (1); 1686} 1687 1688/* 1689 * Reinput pending characters after state switch 1690 * call at spltty(). 1691 */ 1692static void 1693ttypend(struct tty *tp) 1694{ 1695 struct clist tq; 1696 int c; 1697 1698 CLR(tp->t_lflag, PENDIN); 1699 SET(tp->t_state, TS_TYPEN); 1700 /* 1701 * XXX this assumes too much about clist internals. It may even 1702 * fail if the cblock slush pool is empty. We can't allocate more 1703 * cblocks here because we are called from an interrupt handler 1704 * and clist_alloc_cblocks() can wait. 1705 */ 1706 tq = tp->t_rawq; 1707 bzero(&tp->t_rawq, sizeof tp->t_rawq); 1708 tp->t_rawq.c_cbmax = tq.c_cbmax; 1709 tp->t_rawq.c_cbreserved = tq.c_cbreserved; 1710 while ((c = getc(&tq)) >= 0) 1711 ttyinput(c, tp); 1712 CLR(tp->t_state, TS_TYPEN); 1713} 1714 1715/* 1716 * Process a read call on a tty device. 1717 */ 1718int 1719ttread(struct tty *tp, struct uio *uio, int flag) 1720{ 1721 struct clist *qp; 1722 int c; 1723 tcflag_t lflag; 1724 cc_t *cc = tp->t_cc; 1725 struct thread *td; 1726 struct proc *p; 1727 int s, first, error = 0; 1728 int has_stime = 0, last_cc = 0; 1729 long slp = 0; /* XXX this should be renamed `timo'. */ 1730 struct timeval stime = { 0, 0 }; 1731 struct pgrp *pg; 1732 1733 td = curthread; 1734 p = td->td_proc; 1735loop: 1736 s = spltty(); 1737 lflag = tp->t_lflag; 1738 /* 1739 * take pending input first 1740 */ 1741 if (ISSET(lflag, PENDIN)) { 1742 ttypend(tp); 1743 splx(s); /* reduce latency */ 1744 s = spltty(); 1745 lflag = tp->t_lflag; /* XXX ttypend() clobbers it */ 1746 } 1747 1748 /* 1749 * Hang process if it's in the background. 1750 */ 1751 if (isbackground(p, tp)) { 1752 splx(s); 1753 sx_slock(&proctree_lock); 1754 PROC_LOCK(p); 1755 if (SIGISMEMBER(p->p_sigacts->ps_sigignore, SIGTTIN) || 1756 SIGISMEMBER(td->td_sigmask, SIGTTIN) || 1757 (p->p_flag & P_PPWAIT) || p->p_pgrp->pg_jobc == 0) { 1758 PROC_UNLOCK(p); 1759 sx_sunlock(&proctree_lock); 1760 return (EIO); 1761 } 1762 pg = p->p_pgrp; 1763 PROC_UNLOCK(p); 1764 PGRP_LOCK(pg); 1765 sx_sunlock(&proctree_lock); 1766 pgsignal(pg, SIGTTIN, 1); 1767 PGRP_UNLOCK(pg); 1768 error = ttysleep(tp, &lbolt, TTIPRI | PCATCH, "ttybg2", 0); 1769 if (error) 1770 return (error); 1771 goto loop; 1772 } 1773 1774 if (ISSET(tp->t_state, TS_ZOMBIE)) { 1775 splx(s); 1776 return (0); /* EOF */ 1777 } 1778 1779 /* 1780 * If canonical, use the canonical queue, 1781 * else use the raw queue. 1782 * 1783 * (should get rid of clists...) 1784 */ 1785 qp = ISSET(lflag, ICANON) ? &tp->t_canq : &tp->t_rawq; 1786 1787 if (flag & IO_NDELAY) { 1788 if (qp->c_cc > 0) 1789 goto read; 1790 if (!ISSET(lflag, ICANON) && cc[VMIN] == 0) { 1791 splx(s); 1792 return (0); 1793 } 1794 splx(s); 1795 return (EWOULDBLOCK); 1796 } 1797 if (!ISSET(lflag, ICANON)) { 1798 int m = cc[VMIN]; 1799 long t = cc[VTIME]; 1800 struct timeval timecopy; 1801 1802 /* 1803 * Check each of the four combinations. 1804 * (m > 0 && t == 0) is the normal read case. 1805 * It should be fairly efficient, so we check that and its 1806 * companion case (m == 0 && t == 0) first. 1807 * For the other two cases, we compute the target sleep time 1808 * into slp. 1809 */ 1810 if (t == 0) { 1811 if (qp->c_cc < m) 1812 goto sleep; 1813 if (qp->c_cc > 0) 1814 goto read; 1815 1816 /* m, t and qp->c_cc are all 0. 0 is enough input. */ 1817 splx(s); 1818 return (0); 1819 } 1820 t *= 100000; /* time in us */ 1821#define diff(t1, t2) (((t1).tv_sec - (t2).tv_sec) * 1000000 + \ 1822 ((t1).tv_usec - (t2).tv_usec)) 1823 if (m > 0) { 1824 if (qp->c_cc <= 0) 1825 goto sleep; 1826 if (qp->c_cc >= m) 1827 goto read; 1828 getmicrotime(&timecopy); 1829 if (!has_stime) { 1830 /* first character, start timer */ 1831 has_stime = 1; 1832 stime = timecopy; 1833 slp = t; 1834 } else if (qp->c_cc > last_cc) { 1835 /* got a character, restart timer */ 1836 stime = timecopy; 1837 slp = t; 1838 } else { 1839 /* nothing, check expiration */ 1840 slp = t - diff(timecopy, stime); 1841 if (slp <= 0) 1842 goto read; 1843 } 1844 last_cc = qp->c_cc; 1845 } else { /* m == 0 */ 1846 if (qp->c_cc > 0) 1847 goto read; 1848 getmicrotime(&timecopy); 1849 if (!has_stime) { 1850 has_stime = 1; 1851 stime = timecopy; 1852 slp = t; 1853 } else { 1854 slp = t - diff(timecopy, stime); 1855 if (slp <= 0) { 1856 /* Timed out, but 0 is enough input. */ 1857 splx(s); 1858 return (0); 1859 } 1860 } 1861 } 1862#undef diff 1863 if (slp != 0) { 1864 struct timeval tv; /* XXX style bug. */ 1865 1866 tv.tv_sec = slp / 1000000; 1867 tv.tv_usec = slp % 1000000; 1868 slp = tvtohz(&tv); 1869 /* 1870 * XXX bad variable names. slp was the timeout in 1871 * usec. Now it is the timeout in ticks. 1872 */ 1873 } 1874 goto sleep; 1875 } 1876 if (qp->c_cc <= 0) { 1877sleep: 1878 /* 1879 * There is no input, or not enough input and we can block. 1880 */ 1881 error = ttysleep(tp, TSA_HUP_OR_INPUT(tp), TTIPRI | PCATCH, 1882 ISSET(tp->t_state, TS_CONNECTED) ? 1883 "ttyin" : "ttyhup", (int)slp); 1884 splx(s); 1885 if (error == EWOULDBLOCK) 1886 error = 0; 1887 else if (error) 1888 return (error); 1889 /* 1890 * XXX what happens if another process eats some input 1891 * while we are asleep (not just here)? It would be 1892 * safest to detect changes and reset our state variables 1893 * (has_stime and last_cc). 1894 */ 1895 slp = 0; 1896 goto loop; 1897 } 1898read: 1899 splx(s); 1900 /* 1901 * Input present, check for input mapping and processing. 1902 */ 1903 first = 1; 1904 if (ISSET(lflag, ICANON | ISIG)) 1905 goto slowcase; 1906 for (;;) { 1907 char ibuf[IBUFSIZ]; 1908 int icc; 1909 1910 icc = imin(uio->uio_resid, IBUFSIZ); 1911 icc = q_to_b(qp, ibuf, icc); 1912 if (icc <= 0) { 1913 if (first) 1914 goto loop; 1915 break; 1916 } 1917 error = uiomove(ibuf, icc, uio); 1918 /* 1919 * XXX if there was an error then we should ungetc() the 1920 * unmoved chars and reduce icc here. 1921 */ 1922 if (error) 1923 break; 1924 if (uio->uio_resid == 0) 1925 break; 1926 first = 0; 1927 } 1928 goto out; 1929slowcase: 1930 for (;;) { 1931 c = getc(qp); 1932 if (c < 0) { 1933 if (first) 1934 goto loop; 1935 break; 1936 } 1937 /* 1938 * delayed suspend (^Y) 1939 */ 1940 if (CCEQ(cc[VDSUSP], c) && 1941 ISSET(lflag, IEXTEN | ISIG) == (IEXTEN | ISIG)) { 1942 if (tp->t_pgrp != NULL) { 1943 PGRP_LOCK(tp->t_pgrp); 1944 pgsignal(tp->t_pgrp, SIGTSTP, 1); 1945 PGRP_UNLOCK(tp->t_pgrp); 1946 } 1947 if (first) { 1948 error = ttysleep(tp, &lbolt, TTIPRI | PCATCH, 1949 "ttybg3", 0); 1950 if (error) 1951 break; 1952 goto loop; 1953 } 1954 break; 1955 } 1956 /* 1957 * Interpret EOF only in canonical mode. 1958 */ 1959 if (CCEQ(cc[VEOF], c) && ISSET(lflag, ICANON)) 1960 break; 1961 /* 1962 * Give user character. 1963 */ 1964 error = ureadc(c, uio); 1965 if (error) 1966 /* XXX should ungetc(c, qp). */ 1967 break; 1968 if (uio->uio_resid == 0) 1969 break; 1970 /* 1971 * In canonical mode check for a "break character" 1972 * marking the end of a "line of input". 1973 */ 1974 if (ISSET(lflag, ICANON) && TTBREAKC(c, lflag)) 1975 break; 1976 first = 0; 1977 } 1978 1979out: 1980 /* 1981 * Look to unblock input now that (presumably) 1982 * the input queue has gone down. 1983 */ 1984 s = spltty(); 1985 if (ISSET(tp->t_state, TS_TBLOCK) && 1986 tp->t_rawq.c_cc + tp->t_canq.c_cc <= tp->t_ilowat) 1987 ttyunblock(tp); 1988 splx(s); 1989 1990 return (error); 1991} 1992 1993/* 1994 * Check the output queue on tp for space for a kernel message (from uprintf 1995 * or tprintf). Allow some space over the normal hiwater mark so we don't 1996 * lose messages due to normal flow control, but don't let the tty run amok. 1997 * Sleeps here are not interruptible, but we return prematurely if new signals 1998 * arrive. 1999 */ 2000int 2001ttycheckoutq(struct tty *tp, int wait) 2002{ 2003 int hiwat, s; 2004 sigset_t oldmask; 2005 struct thread *td; 2006 struct proc *p; 2007 2008 td = curthread; 2009 p = td->td_proc; 2010 hiwat = tp->t_ohiwat; 2011 SIGEMPTYSET(oldmask); 2012 s = spltty(); 2013 if (wait) { 2014 PROC_LOCK(p); 2015 oldmask = td->td_siglist; 2016 PROC_UNLOCK(p); 2017 } 2018 if (tp->t_outq.c_cc > hiwat + OBUFSIZ + 100) 2019 while (tp->t_outq.c_cc > hiwat) { 2020 ttstart(tp); 2021 if (tp->t_outq.c_cc <= hiwat) 2022 break; 2023 if (!wait) { 2024 splx(s); 2025 return (0); 2026 } 2027 PROC_LOCK(p); 2028 if (!SIGSETEQ(td->td_siglist, oldmask)) { 2029 PROC_UNLOCK(p); 2030 splx(s); 2031 return (0); 2032 } 2033 PROC_UNLOCK(p); 2034 SET(tp->t_state, TS_SO_OLOWAT); 2035 tsleep(TSA_OLOWAT(tp), PZERO - 1, "ttoutq", hz); 2036 } 2037 splx(s); 2038 return (1); 2039} 2040 2041/* 2042 * Process a write call on a tty device. 2043 */ 2044int 2045ttwrite(struct tty *tp, struct uio *uio, int flag) 2046{ 2047 char *cp = NULL; 2048 int cc, ce; 2049 struct thread *td; 2050 struct proc *p; 2051 int i, hiwat, cnt, error, s; 2052 char obuf[OBUFSIZ]; 2053 2054 hiwat = tp->t_ohiwat; 2055 cnt = uio->uio_resid; 2056 error = 0; 2057 cc = 0; 2058 td = curthread; 2059 p = td->td_proc; 2060loop: 2061 s = spltty(); 2062 if (ISSET(tp->t_state, TS_ZOMBIE)) { 2063 splx(s); 2064 if (uio->uio_resid == cnt) 2065 error = EIO; 2066 goto out; 2067 } 2068 if (!ISSET(tp->t_state, TS_CONNECTED)) { 2069 if (flag & IO_NDELAY) { 2070 splx(s); 2071 error = EWOULDBLOCK; 2072 goto out; 2073 } 2074 error = ttysleep(tp, TSA_CARR_ON(tp), TTIPRI | PCATCH, 2075 "ttywdcd", 0); 2076 splx(s); 2077 if (error) 2078 goto out; 2079 goto loop; 2080 } 2081 splx(s); 2082 /* 2083 * Hang the process if it's in the background. 2084 */ 2085 sx_slock(&proctree_lock); 2086 PROC_LOCK(p); 2087 if (isbackground(p, tp) && 2088 ISSET(tp->t_lflag, TOSTOP) && !(p->p_flag & P_PPWAIT) && 2089 !SIGISMEMBER(p->p_sigacts->ps_sigignore, SIGTTOU) && 2090 !SIGISMEMBER(td->td_sigmask, SIGTTOU)) { 2091 if (p->p_pgrp->pg_jobc == 0) { 2092 PROC_UNLOCK(p); 2093 sx_sunlock(&proctree_lock); 2094 error = EIO; 2095 goto out; 2096 } 2097 PROC_UNLOCK(p); 2098 PGRP_LOCK(p->p_pgrp); 2099 sx_sunlock(&proctree_lock); 2100 pgsignal(p->p_pgrp, SIGTTOU, 1); 2101 PGRP_UNLOCK(p->p_pgrp); 2102 error = ttysleep(tp, &lbolt, TTIPRI | PCATCH, "ttybg4", 0); 2103 if (error) 2104 goto out; 2105 goto loop; 2106 } else { 2107 PROC_UNLOCK(p); 2108 sx_sunlock(&proctree_lock); 2109 } 2110 /* 2111 * Process the user's data in at most OBUFSIZ chunks. Perform any 2112 * output translation. Keep track of high water mark, sleep on 2113 * overflow awaiting device aid in acquiring new space. 2114 */ 2115 while (uio->uio_resid > 0 || cc > 0) { 2116 if (ISSET(tp->t_lflag, FLUSHO)) { 2117 uio->uio_resid = 0; 2118 return (0); 2119 } 2120 if (tp->t_outq.c_cc > hiwat) 2121 goto ovhiwat; 2122 /* 2123 * Grab a hunk of data from the user, unless we have some 2124 * leftover from last time. 2125 */ 2126 if (cc == 0) { 2127 cc = imin(uio->uio_resid, OBUFSIZ); 2128 cp = obuf; 2129 error = uiomove(cp, cc, uio); 2130 if (error) { 2131 cc = 0; 2132 break; 2133 } 2134 } 2135 /* 2136 * If nothing fancy need be done, grab those characters we 2137 * can handle without any of ttyoutput's processing and 2138 * just transfer them to the output q. For those chars 2139 * which require special processing (as indicated by the 2140 * bits in char_type), call ttyoutput. After processing 2141 * a hunk of data, look for FLUSHO so ^O's will take effect 2142 * immediately. 2143 */ 2144 while (cc > 0) { 2145 if (!ISSET(tp->t_oflag, OPOST)) 2146 ce = cc; 2147 else { 2148 ce = cc - scanc((u_int)cc, (u_char *)cp, 2149 char_type, CCLASSMASK); 2150 /* 2151 * If ce is zero, then we're processing 2152 * a special character through ttyoutput. 2153 */ 2154 if (ce == 0) { 2155 tp->t_rocount = 0; 2156 if (ttyoutput(*cp, tp) >= 0) { 2157 /* No Clists, wait a bit. */ 2158 ttstart(tp); 2159 if (flag & IO_NDELAY) { 2160 error = EWOULDBLOCK; 2161 goto out; 2162 } 2163 error = ttysleep(tp, &lbolt, 2164 TTOPRI|PCATCH, 2165 "ttybf1", 0); 2166 if (error) 2167 goto out; 2168 goto loop; 2169 } 2170 cp++; 2171 cc--; 2172 if (ISSET(tp->t_lflag, FLUSHO) || 2173 tp->t_outq.c_cc > hiwat) 2174 goto ovhiwat; 2175 continue; 2176 } 2177 } 2178 /* 2179 * A bunch of normal characters have been found. 2180 * Transfer them en masse to the output queue and 2181 * continue processing at the top of the loop. 2182 * If there are any further characters in this 2183 * <= OBUFSIZ chunk, the first should be a character 2184 * requiring special handling by ttyoutput. 2185 */ 2186 tp->t_rocount = 0; 2187 i = b_to_q(cp, ce, &tp->t_outq); 2188 ce -= i; 2189 tp->t_column += ce; 2190 cp += ce, cc -= ce, tk_nout += ce; 2191 tp->t_outcc += ce; 2192 if (i > 0) { 2193 /* No Clists, wait a bit. */ 2194 ttstart(tp); 2195 if (flag & IO_NDELAY) { 2196 error = EWOULDBLOCK; 2197 goto out; 2198 } 2199 error = ttysleep(tp, &lbolt, TTOPRI | PCATCH, 2200 "ttybf2", 0); 2201 if (error) 2202 goto out; 2203 goto loop; 2204 } 2205 if (ISSET(tp->t_lflag, FLUSHO) || 2206 tp->t_outq.c_cc > hiwat) 2207 break; 2208 } 2209 ttstart(tp); 2210 } 2211out: 2212 /* 2213 * If cc is nonzero, we leave the uio structure inconsistent, as the 2214 * offset and iov pointers have moved forward, but it doesn't matter 2215 * (the call will either return short or restart with a new uio). 2216 */ 2217 uio->uio_resid += cc; 2218 return (error); 2219 2220ovhiwat: 2221 ttstart(tp); 2222 s = spltty(); 2223 /* 2224 * This can only occur if FLUSHO is set in t_lflag, 2225 * or if ttstart/oproc is synchronous (or very fast). 2226 */ 2227 if (tp->t_outq.c_cc <= hiwat) { 2228 splx(s); 2229 goto loop; 2230 } 2231 if (flag & IO_NDELAY) { 2232 splx(s); 2233 uio->uio_resid += cc; 2234 return (uio->uio_resid == cnt ? EWOULDBLOCK : 0); 2235 } 2236 SET(tp->t_state, TS_SO_OLOWAT); 2237 error = ttysleep(tp, TSA_OLOWAT(tp), TTOPRI | PCATCH, "ttywri", 2238 tp->t_timeout); 2239 splx(s); 2240 if (error == EWOULDBLOCK) 2241 error = EIO; 2242 if (error) 2243 goto out; 2244 goto loop; 2245} 2246 2247/* 2248 * Rubout one character from the rawq of tp 2249 * as cleanly as possible. 2250 */ 2251static void 2252ttyrub(int c, struct tty *tp) 2253{ 2254 char *cp; 2255 int savecol; 2256 int tabc, s; 2257 2258 if (!ISSET(tp->t_lflag, ECHO) || ISSET(tp->t_lflag, EXTPROC)) 2259 return; 2260 CLR(tp->t_lflag, FLUSHO); 2261 if (ISSET(tp->t_lflag, ECHOE)) { 2262 if (tp->t_rocount == 0) { 2263 /* 2264 * Screwed by ttwrite; retype 2265 */ 2266 ttyretype(tp); 2267 return; 2268 } 2269 if (c == ('\t' | TTY_QUOTE) || c == ('\n' | TTY_QUOTE)) 2270 ttyrubo(tp, 2); 2271 else { 2272 CLR(c, ~TTY_CHARMASK); 2273 switch (CCLASS(c)) { 2274 case ORDINARY: 2275 ttyrubo(tp, 1); 2276 break; 2277 case BACKSPACE: 2278 case CONTROL: 2279 case NEWLINE: 2280 case RETURN: 2281 case VTAB: 2282 if (ISSET(tp->t_lflag, ECHOCTL)) 2283 ttyrubo(tp, 2); 2284 break; 2285 case TAB: 2286 if (tp->t_rocount < tp->t_rawq.c_cc) { 2287 ttyretype(tp); 2288 return; 2289 } 2290 s = spltty(); 2291 savecol = tp->t_column; 2292 SET(tp->t_state, TS_CNTTB); 2293 SET(tp->t_lflag, FLUSHO); 2294 tp->t_column = tp->t_rocol; 2295 cp = tp->t_rawq.c_cf; 2296 if (cp) 2297 tabc = *cp; /* XXX FIX NEXTC */ 2298 for (; cp; cp = nextc(&tp->t_rawq, cp, &tabc)) 2299 ttyecho(tabc, tp); 2300 CLR(tp->t_lflag, FLUSHO); 2301 CLR(tp->t_state, TS_CNTTB); 2302 splx(s); 2303 2304 /* savecol will now be length of the tab. */ 2305 savecol -= tp->t_column; 2306 tp->t_column += savecol; 2307 if (savecol > 8) 2308 savecol = 8; /* overflow screw */ 2309 while (--savecol >= 0) 2310 (void)ttyoutput('\b', tp); 2311 break; 2312 default: /* XXX */ 2313#define PANICSTR "ttyrub: would panic c = %d, val = %d\n" 2314 (void)printf(PANICSTR, c, CCLASS(c)); 2315#ifdef notdef 2316 panic(PANICSTR, c, CCLASS(c)); 2317#endif 2318 } 2319 } 2320 } else if (ISSET(tp->t_lflag, ECHOPRT)) { 2321 if (!ISSET(tp->t_state, TS_ERASE)) { 2322 SET(tp->t_state, TS_ERASE); 2323 (void)ttyoutput('\\', tp); 2324 } 2325 ttyecho(c, tp); 2326 } else { 2327 ttyecho(tp->t_cc[VERASE], tp); 2328 /* 2329 * This code may be executed not only when an ERASE key 2330 * is pressed, but also when ^U (KILL) or ^W (WERASE) are. 2331 * So, I didn't think it was worthwhile to pass the extra 2332 * information (which would need an extra parameter, 2333 * changing every call) needed to distinguish the ERASE2 2334 * case from the ERASE. 2335 */ 2336 } 2337 --tp->t_rocount; 2338} 2339 2340/* 2341 * Back over cnt characters, erasing them. 2342 */ 2343static void 2344ttyrubo(struct tty *tp, int cnt) 2345{ 2346 2347 while (cnt-- > 0) { 2348 (void)ttyoutput('\b', tp); 2349 (void)ttyoutput(' ', tp); 2350 (void)ttyoutput('\b', tp); 2351 } 2352} 2353 2354/* 2355 * ttyretype -- 2356 * Reprint the rawq line. Note, it is assumed that c_cc has already 2357 * been checked. 2358 */ 2359static void 2360ttyretype(struct tty *tp) 2361{ 2362 char *cp; 2363 int s, c; 2364 2365 /* Echo the reprint character. */ 2366 if (tp->t_cc[VREPRINT] != _POSIX_VDISABLE) 2367 ttyecho(tp->t_cc[VREPRINT], tp); 2368 2369 (void)ttyoutput('\n', tp); 2370 2371 /* 2372 * XXX 2373 * FIX: NEXTC IS BROKEN - DOESN'T CHECK QUOTE 2374 * BIT OF FIRST CHAR. 2375 */ 2376 s = spltty(); 2377 for (cp = tp->t_canq.c_cf, c = (cp != NULL ? *cp : 0); 2378 cp != NULL; cp = nextc(&tp->t_canq, cp, &c)) 2379 ttyecho(c, tp); 2380 for (cp = tp->t_rawq.c_cf, c = (cp != NULL ? *cp : 0); 2381 cp != NULL; cp = nextc(&tp->t_rawq, cp, &c)) 2382 ttyecho(c, tp); 2383 CLR(tp->t_state, TS_ERASE); 2384 splx(s); 2385 2386 tp->t_rocount = tp->t_rawq.c_cc; 2387 tp->t_rocol = 0; 2388} 2389 2390/* 2391 * Echo a typed character to the terminal. 2392 */ 2393static void 2394ttyecho(int c, struct tty *tp) 2395{ 2396 2397 if (!ISSET(tp->t_state, TS_CNTTB)) 2398 CLR(tp->t_lflag, FLUSHO); 2399 if ((!ISSET(tp->t_lflag, ECHO) && 2400 (c != '\n' || !ISSET(tp->t_lflag, ECHONL))) || 2401 ISSET(tp->t_lflag, EXTPROC)) 2402 return; 2403 if (ISSET(tp->t_lflag, ECHOCTL) && 2404 ((ISSET(c, TTY_CHARMASK) <= 037 && c != '\t' && c != '\n') || 2405 ISSET(c, TTY_CHARMASK) == 0177)) { 2406 (void)ttyoutput('^', tp); 2407 CLR(c, ~TTY_CHARMASK); 2408 if (c == 0177) 2409 c = '?'; 2410 else 2411 c += 'A' - 1; 2412 } 2413 (void)ttyoutput(c, tp); 2414} 2415 2416/* 2417 * Wake up any readers on a tty. 2418 */ 2419void 2420ttwakeup(struct tty *tp) 2421{ 2422 2423 if (SEL_WAITING(&tp->t_rsel)) 2424 selwakeuppri(&tp->t_rsel, TTIPRI); 2425 if (ISSET(tp->t_state, TS_ASYNC) && tp->t_sigio != NULL) 2426 pgsigio(&tp->t_sigio, SIGIO, (tp->t_session != NULL)); 2427 wakeup(TSA_HUP_OR_INPUT(tp)); 2428 KNOTE_UNLOCKED(&tp->t_rsel.si_note, 0); 2429} 2430 2431/* 2432 * Wake up any writers on a tty. 2433 */ 2434void 2435ttwwakeup(struct tty *tp) 2436{ 2437 2438 if (SEL_WAITING(&tp->t_wsel) && tp->t_outq.c_cc <= tp->t_olowat) 2439 selwakeuppri(&tp->t_wsel, TTOPRI); 2440 if (ISSET(tp->t_state, TS_ASYNC) && tp->t_sigio != NULL) 2441 pgsigio(&tp->t_sigio, SIGIO, (tp->t_session != NULL)); 2442 if (ISSET(tp->t_state, TS_BUSY | TS_SO_OCOMPLETE) == 2443 TS_SO_OCOMPLETE && tp->t_outq.c_cc == 0) { 2444 CLR(tp->t_state, TS_SO_OCOMPLETE); 2445 wakeup(TSA_OCOMPLETE(tp)); 2446 } 2447 if (ISSET(tp->t_state, TS_SO_OLOWAT) && 2448 tp->t_outq.c_cc <= tp->t_olowat) { 2449 CLR(tp->t_state, TS_SO_OLOWAT); 2450 wakeup(TSA_OLOWAT(tp)); 2451 } 2452 KNOTE_UNLOCKED(&tp->t_wsel.si_note, 0); 2453} 2454 2455/* 2456 * Look up a code for a specified speed in a conversion table; 2457 * used by drivers to map software speed values to hardware parameters. 2458 */ 2459int 2460ttspeedtab(int speed, struct speedtab *table) 2461{ 2462 2463 for ( ; table->sp_speed != -1; table++) 2464 if (table->sp_speed == speed) 2465 return (table->sp_code); 2466 return (-1); 2467} 2468 2469/* 2470 * Set input and output watermarks and buffer sizes. For input, the 2471 * high watermark is about one second's worth of input above empty, the 2472 * low watermark is slightly below high water, and the buffer size is a 2473 * driver-dependent amount above high water. For output, the watermarks 2474 * are near the ends of the buffer, with about 1 second's worth of input 2475 * between them. All this only applies to the standard line discipline. 2476 */ 2477void 2478ttsetwater(struct tty *tp) 2479{ 2480 int cps, ttmaxhiwat, x; 2481 2482 /* Input. */ 2483 clist_alloc_cblocks(&tp->t_canq, TTYHOG, 512); 2484 switch (tp->t_ispeedwat) { 2485 case (speed_t)-1: 2486 cps = tp->t_ispeed / 10; 2487 break; 2488 case 0: 2489 /* 2490 * This case is for old drivers that don't know about 2491 * t_ispeedwat. Arrange for them to get the old buffer 2492 * sizes and watermarks. 2493 */ 2494 cps = TTYHOG - 2 * 256; 2495 tp->t_ififosize = 2 * 256; 2496 break; 2497 default: 2498 cps = tp->t_ispeedwat / 10; 2499 break; 2500 } 2501 tp->t_ihiwat = cps; 2502 tp->t_ilowat = 7 * cps / 8; 2503 x = cps + tp->t_ififosize; 2504 clist_alloc_cblocks(&tp->t_rawq, x, x); 2505 2506 /* Output. */ 2507 switch (tp->t_ospeedwat) { 2508 case (speed_t)-1: 2509 cps = tp->t_ospeed / 10; 2510 ttmaxhiwat = 2 * TTMAXHIWAT; 2511 break; 2512 case 0: 2513 cps = tp->t_ospeed / 10; 2514 ttmaxhiwat = TTMAXHIWAT; 2515 break; 2516 default: 2517 cps = tp->t_ospeedwat / 10; 2518 ttmaxhiwat = 8 * TTMAXHIWAT; 2519 break; 2520 } 2521#define CLAMP(x, h, l) ((x) > h ? h : ((x) < l) ? l : (x)) 2522 tp->t_olowat = x = CLAMP(cps / 2, TTMAXLOWAT, TTMINLOWAT); 2523 x += cps; 2524 x = CLAMP(x, ttmaxhiwat, TTMINHIWAT); /* XXX clamps are too magic */ 2525 tp->t_ohiwat = roundup(x, CBSIZE); /* XXX for compat */ 2526 x = imax(tp->t_ohiwat, TTMAXHIWAT); /* XXX for compat/safety */ 2527 x += OBUFSIZ + 100; 2528 clist_alloc_cblocks(&tp->t_outq, x, x); 2529#undef CLAMP 2530} 2531 2532/* 2533 * Report on state of foreground process group. 2534 */ 2535void 2536ttyinfo(struct tty *tp) 2537{ 2538 struct timeval utime, stime; 2539 struct proc *p, *pick; 2540 struct thread *td, *picktd; 2541 const char *stateprefix, *state; 2542 long rss; 2543 int load, pctcpu; 2544 pid_t pid; 2545 char comm[MAXCOMLEN + 1]; 2546 struct rusage ru; 2547 2548 if (ttycheckoutq(tp,0) == 0) 2549 return; 2550 2551 /* Print load average. */ 2552 load = (averunnable.ldavg[0] * 100 + FSCALE / 2) >> FSHIFT; 2553 ttyprintf(tp, "load: %d.%02d ", load / 100, load % 100); 2554 2555 /* 2556 * On return following a ttyprintf(), we set tp->t_rocount to 0 so 2557 * that pending input will be retyped on BS. 2558 */ 2559 if (tp->t_session == NULL) { 2560 ttyprintf(tp, "not a controlling terminal\n"); 2561 tp->t_rocount = 0; 2562 return; 2563 } 2564 if (tp->t_pgrp == NULL) { 2565 ttyprintf(tp, "no foreground process group\n"); 2566 tp->t_rocount = 0; 2567 return; 2568 } 2569 PGRP_LOCK(tp->t_pgrp); 2570 if (LIST_EMPTY(&tp->t_pgrp->pg_members)) { 2571 PGRP_UNLOCK(tp->t_pgrp); 2572 ttyprintf(tp, "empty foreground process group\n"); 2573 tp->t_rocount = 0; 2574 return; 2575 } 2576 2577 /* 2578 * Pick the most interesting process and copy some of its 2579 * state for printing later. This operation could rely on stale 2580 * data as we can't hold the proc slock or thread locks over the 2581 * whole list. However, we're guaranteed not to reference an exited 2582 * thread or proc since we hold the tty locked. 2583 */ 2584 pick = NULL; 2585 LIST_FOREACH(p, &tp->t_pgrp->pg_members, p_pglist) 2586 if (proc_compare(pick, p)) 2587 pick = p; 2588 2589 PROC_LOCK(pick); 2590 picktd = NULL; 2591 td = FIRST_THREAD_IN_PROC(pick); 2592 FOREACH_THREAD_IN_PROC(pick, td) 2593 if (thread_compare(picktd, td)) 2594 picktd = td; 2595 td = picktd; 2596 stateprefix = ""; 2597 thread_lock(td); 2598 if (TD_IS_RUNNING(td)) 2599 state = "running"; 2600 else if (TD_ON_RUNQ(td) || TD_CAN_RUN(td)) 2601 state = "runnable"; 2602 else if (TD_IS_SLEEPING(td)) { 2603 /* XXX: If we're sleeping, are we ever not in a queue? */ 2604 if (TD_ON_SLEEPQ(td)) 2605 state = td->td_wmesg; 2606 else 2607 state = "sleeping without queue"; 2608 } else if (TD_ON_LOCK(td)) { 2609 state = td->td_lockname; 2610 stateprefix = "*"; 2611 } else if (TD_IS_SUSPENDED(td)) 2612 state = "suspended"; 2613 else if (TD_AWAITING_INTR(td)) 2614 state = "intrwait"; 2615 else 2616 state = "unknown"; 2617 pctcpu = (sched_pctcpu(td) * 10000 + FSCALE / 2) >> FSHIFT; 2618 thread_unlock(td); 2619 if (pick->p_state == PRS_NEW || pick->p_state == PRS_ZOMBIE) 2620 rss = 0; 2621 else 2622 rss = pgtok(vmspace_resident_count(pick->p_vmspace)); 2623 PROC_UNLOCK(pick); 2624 PROC_LOCK(pick); 2625 PGRP_UNLOCK(tp->t_pgrp); 2626 rufetchcalc(pick, &ru, &utime, &stime); 2627 pid = pick->p_pid; 2628 bcopy(pick->p_comm, comm, sizeof(comm)); 2629 PROC_UNLOCK(pick); 2630 2631 /* Print command, pid, state, utime, stime, %cpu, and rss. */ 2632 ttyprintf(tp, 2633 " cmd: %s %d [%s%s] %ld.%02ldu %ld.%02lds %d%% %ldk\n", 2634 comm, pid, stateprefix, state, 2635 (long)utime.tv_sec, utime.tv_usec / 10000, 2636 (long)stime.tv_sec, stime.tv_usec / 10000, 2637 pctcpu / 100, rss); 2638 tp->t_rocount = 0; 2639} 2640 2641/* 2642 * Returns 1 if p2 is "better" than p1 2643 * 2644 * The algorithm for picking the "interesting" process is thus: 2645 * 2646 * 1) Only foreground processes are eligible - implied. 2647 * 2) Runnable processes are favored over anything else. The runner 2648 * with the highest cpu utilization is picked (p_estcpu). Ties are 2649 * broken by picking the highest pid. 2650 * 3) The sleeper with the shortest sleep time is next. With ties, 2651 * we pick out just "short-term" sleepers (P_SINTR == 0). 2652 * 4) Further ties are broken by picking the highest pid. 2653 */ 2654 2655#define TESTAB(a, b) ((a)<<1 | (b)) 2656#define ONLYA 2 2657#define ONLYB 1 2658#define BOTH 3 2659 2660static int 2661proc_sum(struct proc *p, int *estcpup) 2662{ 2663 struct thread *td; 2664 int estcpu; 2665 int val; 2666 2667 val = 0; 2668 estcpu = 0; 2669 FOREACH_THREAD_IN_PROC(p, td) { 2670 thread_lock(td); 2671 if (TD_ON_RUNQ(td) || 2672 TD_IS_RUNNING(td)) 2673 val = 1; 2674 estcpu += sched_pctcpu(td); 2675 thread_unlock(td); 2676 } 2677 *estcpup = estcpu; 2678 2679 return (val); 2680} 2681 2682static int 2683thread_compare(struct thread *td, struct thread *td2) 2684{ 2685 int runa, runb; 2686 int slpa, slpb; 2687 fixpt_t esta, estb; 2688 2689 if (td == NULL) 2690 return (1); 2691 2692 /* 2693 * Fetch running stats, pctcpu usage, and interruptable flag. 2694 */ 2695 thread_lock(td); 2696 runa = TD_IS_RUNNING(td) | TD_ON_RUNQ(td); 2697 slpa = td->td_flags & TDF_SINTR; 2698 esta = sched_pctcpu(td); 2699 thread_unlock(td); 2700 thread_lock(td2); 2701 runb = TD_IS_RUNNING(td2) | TD_ON_RUNQ(td2); 2702 estb = sched_pctcpu(td2); 2703 slpb = td2->td_flags & TDF_SINTR; 2704 thread_unlock(td2); 2705 /* 2706 * see if at least one of them is runnable 2707 */ 2708 switch (TESTAB(runa, runb)) { 2709 case ONLYA: 2710 return (0); 2711 case ONLYB: 2712 return (1); 2713 case BOTH: 2714 break; 2715 } 2716 /* 2717 * favor one with highest recent cpu utilization 2718 */ 2719 if (estb > esta) 2720 return (1); 2721 if (esta > estb) 2722 return (0); 2723 /* 2724 * favor one sleeping in a non-interruptible sleep 2725 */ 2726 switch (TESTAB(slpa, slpb)) { 2727 case ONLYA: 2728 return (0); 2729 case ONLYB: 2730 return (1); 2731 case BOTH: 2732 break; 2733 } 2734 2735 return (td < td2); 2736} 2737 2738static int 2739proc_compare(struct proc *p1, struct proc *p2) 2740{ 2741 2742 int runa, runb; 2743 fixpt_t esta, estb; 2744 2745 if (p1 == NULL) 2746 return (1); 2747 2748 /* 2749 * Fetch various stats about these processes. After we drop the 2750 * lock the information could be stale but the race is unimportant. 2751 */ 2752 PROC_LOCK(p1); 2753 runa = proc_sum(p1, &esta); 2754 PROC_UNLOCK(p1); 2755 PROC_LOCK(p2); 2756 runb = proc_sum(p2, &estb); 2757 PROC_UNLOCK(p2); 2758 2759 /* 2760 * see if at least one of them is runnable 2761 */ 2762 switch (TESTAB(runa, runb)) { 2763 case ONLYA: 2764 return (0); 2765 case ONLYB: 2766 return (1); 2767 case BOTH: 2768 break; 2769 } 2770 /* 2771 * favor one with highest recent cpu utilization 2772 */ 2773 if (estb > esta) 2774 return (1); 2775 if (esta > estb) 2776 return (0); 2777 /* 2778 * weed out zombies 2779 */ 2780 switch (TESTAB(p1->p_state == PRS_ZOMBIE, p2->p_state == PRS_ZOMBIE)) { 2781 case ONLYA: 2782 return (1); 2783 case ONLYB: 2784 return (0); 2785 case BOTH: 2786 break; 2787 } 2788 2789 return (p2->p_pid > p1->p_pid); /* tie - return highest pid */ 2790} 2791 2792/* 2793 * Output char to tty; console putchar style. 2794 */ 2795int 2796tputchar(int c, struct tty *tp) 2797{ 2798 int s; 2799 2800 s = spltty(); 2801 if (!ISSET(tp->t_state, TS_CONNECTED)) { 2802 splx(s); 2803 return (-1); 2804 } 2805 if (c == '\n') 2806 (void)ttyoutput('\r', tp); 2807 (void)ttyoutput(c, tp); 2808 ttstart(tp); 2809 splx(s); 2810 return (0); 2811} 2812 2813/* 2814 * Sleep on chan, returning ERESTART if tty changed while we napped and 2815 * returning any errors (e.g. EINTR/EWOULDBLOCK) reported by tsleep. If 2816 * the tty is revoked, restarting a pending call will redo validation done 2817 * at the start of the call. 2818 */ 2819int 2820ttysleep(struct tty *tp, void *chan, int pri, char *wmesg, int timo) 2821{ 2822 int error; 2823 int gen; 2824 2825 gen = tp->t_gen; 2826 error = tsleep(chan, pri, wmesg, timo); 2827 if (tp->t_state & TS_GONE) 2828 return (ENXIO); 2829 if (error) 2830 return (error); 2831 return (tp->t_gen == gen ? 0 : ERESTART); 2832} 2833 2834/* 2835 * Gain a reference to a TTY 2836 */ 2837int 2838ttyref(struct tty *tp) 2839{ 2840 int i; 2841 2842 mtx_lock(&tp->t_mtx); 2843 KASSERT(tp->t_refcnt > 0, 2844 ("ttyref(): tty refcnt is %d (%s)", 2845 tp->t_refcnt, tp->t_dev != NULL ? devtoname(tp->t_dev) : "??")); 2846 i = ++tp->t_refcnt; 2847 mtx_unlock(&tp->t_mtx); 2848 return (i); 2849} 2850 2851/* 2852 * Drop a reference to a TTY. 2853 * When reference count drops to zero, we free it. 2854 */ 2855int 2856ttyrel(struct tty *tp) 2857{ 2858 int i; 2859 2860 mtx_lock(&tty_list_mutex); 2861 mtx_lock(&tp->t_mtx); 2862 KASSERT(tp->t_refcnt > 0, 2863 ("ttyrel(): tty refcnt is %d (%s)", 2864 tp->t_refcnt, tp->t_dev != NULL ? devtoname(tp->t_dev) : "??")); 2865 i = --tp->t_refcnt; 2866 if (i != 0) { 2867 mtx_unlock(&tp->t_mtx); 2868 mtx_unlock(&tty_list_mutex); 2869 return (i); 2870 } 2871 TAILQ_REMOVE(&tty_list, tp, t_list); 2872 mtx_unlock(&tp->t_mtx); 2873 mtx_unlock(&tty_list_mutex); 2874 knlist_destroy(&tp->t_rsel.si_note); 2875 knlist_destroy(&tp->t_wsel.si_note); 2876 mtx_destroy(&tp->t_mtx); 2877 free(tp, M_TTYS); 2878 return (i); 2879} 2880 2881/* 2882 * Allocate a tty struct. Clists in the struct will be allocated by 2883 * tty_open(). 2884 */ 2885struct tty * 2886ttyalloc() 2887{ 2888 struct tty *tp; 2889 2890 tp = malloc(sizeof *tp, M_TTYS, M_WAITOK | M_ZERO); 2891 mtx_init(&tp->t_mtx, "tty", NULL, MTX_DEF); 2892 2893 /* 2894 * Set up the initial state 2895 */ 2896 tp->t_refcnt = 1; 2897 tp->t_timeout = -1; 2898 tp->t_dtr_wait = 3 * hz; 2899 2900 ttyinitmode(tp, 0, 0); 2901 bcopy(ttydefchars, tp->t_init_in.c_cc, sizeof tp->t_init_in.c_cc); 2902 2903 /* Make callout the same as callin */ 2904 tp->t_init_out = tp->t_init_in; 2905 2906 mtx_lock(&tty_list_mutex); 2907 TAILQ_INSERT_TAIL(&tty_list, tp, t_list); 2908 mtx_unlock(&tty_list_mutex); 2909 knlist_init(&tp->t_rsel.si_note, &tp->t_mtx, NULL, NULL, NULL); 2910 knlist_init(&tp->t_wsel.si_note, &tp->t_mtx, NULL, NULL, NULL); 2911 return (tp); 2912} 2913 2914static void 2915ttypurge(struct cdev *dev) 2916{ 2917 2918 if (dev->si_tty == NULL) 2919 return; 2920 ttygone(dev->si_tty); 2921} 2922 2923/* 2924 * ttycreate() 2925 * 2926 * Create the device entries for this tty thereby opening it for business. 2927 * 2928 * The flags argument controls if "cua" units are created. 2929 * 2930 * The t_sc filed is copied to si_drv1 in the created cdevs. This 2931 * is particularly important for ->t_cioctl() users. 2932 * 2933 * XXX: implement the init and lock devices by cloning. 2934 */ 2935 2936int 2937ttycreate(struct tty *tp, int flags, const char *fmt, ...) 2938{ 2939 char namebuf[SPECNAMELEN - 3]; /* XXX space for "tty" */ 2940 struct cdevsw *csw = NULL; 2941 int unit = 0; 2942 va_list ap; 2943 struct cdev *cp; 2944 int i, minor, sminor, sunit; 2945 2946 mtx_assert(&Giant, MA_OWNED); 2947 2948 if (tty_unit == NULL) 2949 tty_unit = new_unrhdr(0, 0xffff, NULL); 2950 2951 sunit = alloc_unr(tty_unit); 2952 tp->t_devunit = sunit; 2953 2954 if (csw == NULL) { 2955 csw = &tty_cdevsw; 2956 unit = sunit; 2957 } 2958 KASSERT(csw->d_purge == NULL || csw->d_purge == ttypurge, 2959 ("tty should not have d_purge")); 2960 2961 csw->d_purge = ttypurge; 2962 2963 minor = unit2minor(unit); 2964 sminor = unit2minor(sunit); 2965 va_start(ap, fmt); 2966 i = vsnrprintf(namebuf, sizeof namebuf, 32, fmt, ap); 2967 va_end(ap); 2968 KASSERT(i < sizeof namebuf, ("Too long tty name (%s)", namebuf)); 2969 2970 cp = make_dev(csw, minor, 2971 UID_ROOT, GID_WHEEL, 0600, "tty%s", namebuf); 2972 tp->t_dev = cp; 2973 tp->t_mdev = cp; 2974 cp->si_tty = tp; 2975 cp->si_drv1 = tp->t_sc; 2976 2977 cp = make_dev(&ttys_cdevsw, sminor | MINOR_INIT, 2978 UID_ROOT, GID_WHEEL, 0600, "tty%s.init", namebuf); 2979 dev_depends(tp->t_dev, cp); 2980 cp->si_drv1 = tp->t_sc; 2981 cp->si_drv2 = &tp->t_init_in; 2982 cp->si_tty = tp; 2983 2984 cp = make_dev(&ttys_cdevsw, sminor | MINOR_LOCK, 2985 UID_ROOT, GID_WHEEL, 0600, "tty%s.lock", namebuf); 2986 dev_depends(tp->t_dev, cp); 2987 cp->si_drv1 = tp->t_sc; 2988 cp->si_drv2 = &tp->t_lock_in; 2989 cp->si_tty = tp; 2990 2991 if (flags & TS_CALLOUT) { 2992 cp = make_dev(csw, minor | MINOR_CALLOUT, 2993 UID_UUCP, GID_DIALER, 0660, "cua%s", namebuf); 2994 dev_depends(tp->t_dev, cp); 2995 cp->si_drv1 = tp->t_sc; 2996 cp->si_tty = tp; 2997 2998 cp = make_dev(&ttys_cdevsw, sminor | MINOR_CALLOUT | MINOR_INIT, 2999 UID_UUCP, GID_DIALER, 0660, "cua%s.init", namebuf); 3000 dev_depends(tp->t_dev, cp); 3001 cp->si_drv1 = tp->t_sc; 3002 cp->si_drv2 = &tp->t_init_out; 3003 cp->si_tty = tp; 3004 3005 cp = make_dev(&ttys_cdevsw, sminor | MINOR_CALLOUT | MINOR_LOCK, 3006 UID_UUCP, GID_DIALER, 0660, "cua%s.lock", namebuf); 3007 dev_depends(tp->t_dev, cp); 3008 cp->si_drv1 = tp->t_sc; 3009 cp->si_drv2 = &tp->t_lock_out; 3010 cp->si_tty = tp; 3011 } 3012 3013 return (0); 3014} 3015 3016/* 3017 * This function is called when the hardware disappears. We set a flag 3018 * and wake up stuff so all sleeping threads will notice. 3019 */ 3020void 3021ttygone(struct tty *tp) 3022{ 3023 3024 tp->t_state |= TS_GONE; 3025 if (SEL_WAITING(&tp->t_rsel)) 3026 selwakeuppri(&tp->t_rsel, TTIPRI); 3027 if (SEL_WAITING(&tp->t_wsel)) 3028 selwakeuppri(&tp->t_wsel, TTOPRI); 3029 if (ISSET(tp->t_state, TS_ASYNC) && tp->t_sigio != NULL) 3030 pgsigio(&tp->t_sigio, SIGIO, (tp->t_session != NULL)); 3031 wakeup(&tp->t_dtr_wait); 3032 wakeup(TSA_CARR_ON(tp)); 3033 wakeup(TSA_HUP_OR_INPUT(tp)); 3034 wakeup(TSA_OCOMPLETE(tp)); 3035 wakeup(TSA_OLOWAT(tp)); 3036 KNOTE_UNLOCKED(&tp->t_rsel.si_note, 0); 3037 KNOTE_UNLOCKED(&tp->t_wsel.si_note, 0); 3038 tt_purge(tp); 3039} 3040 3041/* 3042 * ttyfree() 3043 * 3044 * Called when the driver is ready to free the tty structure. 3045 * 3046 * XXX: This shall sleep until all threads have left the driver. 3047 */ 3048void 3049ttyfree(struct tty *tp) 3050{ 3051 struct cdev *dev; 3052 u_int unit; 3053 3054 mtx_assert(&Giant, MA_OWNED); 3055 ttygone(tp); 3056 unit = tp->t_devunit; 3057 dev = tp->t_mdev; 3058 tp->t_dev = NULL; 3059 ttyrel(tp); 3060 destroy_dev(dev); 3061 free_unr(tty_unit, unit); 3062} 3063 3064static int 3065sysctl_kern_ttys(SYSCTL_HANDLER_ARGS) 3066{ 3067 struct tty *tp, *tp2; 3068 struct xtty xt; 3069 int error; 3070 3071 error = 0; 3072 mtx_lock(&tty_list_mutex); 3073 tp = TAILQ_FIRST(&tty_list); 3074 if (tp != NULL) 3075 ttyref(tp); 3076 while (tp != NULL) { 3077 bzero(&xt, sizeof xt); 3078 xt.xt_size = sizeof xt; 3079#define XT_COPY(field) xt.xt_##field = tp->t_##field 3080 xt.xt_rawcc = tp->t_rawq.c_cc; 3081 xt.xt_cancc = tp->t_canq.c_cc; 3082 xt.xt_outcc = tp->t_outq.c_cc; 3083 XT_COPY(line); 3084 3085 /* 3086 * XXX: We hold the tty list lock while doing this to 3087 * work around a race with pty/pts tty destruction. 3088 * They set t_dev to NULL and then call ttyrel() to 3089 * free the structure which will block on the list 3090 * lock before they call destroy_dev() on the cdev 3091 * backing t_dev. 3092 * 3093 * XXX: ttyfree() now does the same since it has been 3094 * fixed to not leak ttys. 3095 */ 3096 if (tp->t_dev != NULL) 3097 xt.xt_dev = dev2udev(tp->t_dev); 3098 XT_COPY(state); 3099 XT_COPY(flags); 3100 XT_COPY(timeout); 3101 if (tp->t_pgrp != NULL) 3102 xt.xt_pgid = tp->t_pgrp->pg_id; 3103 if (tp->t_session != NULL) 3104 xt.xt_sid = tp->t_session->s_sid; 3105 XT_COPY(termios); 3106 XT_COPY(winsize); 3107 XT_COPY(column); 3108 XT_COPY(rocount); 3109 XT_COPY(rocol); 3110 XT_COPY(ififosize); 3111 XT_COPY(ihiwat); 3112 XT_COPY(ilowat); 3113 XT_COPY(ispeedwat); 3114 XT_COPY(ohiwat); 3115 XT_COPY(olowat); 3116 XT_COPY(ospeedwat); 3117#undef XT_COPY 3118 mtx_unlock(&tty_list_mutex); 3119 error = SYSCTL_OUT(req, &xt, sizeof xt); 3120 if (error != 0) { 3121 ttyrel(tp); 3122 return (error); 3123 } 3124 mtx_lock(&tty_list_mutex); 3125 tp2 = TAILQ_NEXT(tp, t_list); 3126 if (tp2 != NULL) 3127 ttyref(tp2); 3128 mtx_unlock(&tty_list_mutex); 3129 ttyrel(tp); 3130 tp = tp2; 3131 mtx_lock(&tty_list_mutex); 3132 } 3133 mtx_unlock(&tty_list_mutex); 3134 return (0); 3135} 3136 3137SYSCTL_PROC(_kern, OID_AUTO, ttys, CTLTYPE_OPAQUE|CTLFLAG_RD, 3138 0, 0, sysctl_kern_ttys, "S,xtty", "All ttys"); 3139SYSCTL_LONG(_kern, OID_AUTO, tty_nin, CTLFLAG_RD, 3140 &tk_nin, 0, "Total TTY in characters"); 3141SYSCTL_LONG(_kern, OID_AUTO, tty_nout, CTLFLAG_RD, 3142 &tk_nout, 0, "Total TTY out characters"); 3143 3144void 3145nottystop(struct tty *tp, int rw) 3146{ 3147 3148 return; 3149} 3150 3151int 3152ttyopen(struct cdev *dev, int flag, int mode, struct thread *td) 3153{ 3154 int error; 3155 int s; 3156 struct tty *tp; 3157 3158 tp = dev->si_tty; 3159 3160 s = spltty(); 3161 /* 3162 * We jump to this label after all non-interrupted sleeps to pick 3163 * up any changes of the device state. 3164 */ 3165open_top: 3166 if (tp->t_state & TS_GONE) 3167 return (ENXIO); 3168 error = ttydtrwaitsleep(tp); 3169 if (error) 3170 goto out; 3171 if (tp->t_state & TS_ISOPEN) { 3172 /* 3173 * The device is open, so everything has been initialized. 3174 * Handle conflicts. 3175 */ 3176 if (ISCALLOUT(dev) && !tp->t_actout) 3177 return (EBUSY); 3178 if (tp->t_actout && !ISCALLOUT(dev)) { 3179 if (flag & O_NONBLOCK) 3180 return (EBUSY); 3181 error = tsleep(&tp->t_actout, 3182 TTIPRI | PCATCH, "ttybi", 0); 3183 if (error != 0 || (tp->t_flags & TS_GONE)) 3184 goto out; 3185 goto open_top; 3186 } 3187 if (tp->t_state & TS_XCLUDE && priv_check(td, 3188 PRIV_TTY_EXCLUSIVE)) 3189 return (EBUSY); 3190 } else { 3191 /* 3192 * The device isn't open, so there are no conflicts. 3193 * Initialize it. Initialization is done twice in many 3194 * cases: to preempt sleeping callin opens if we are 3195 * callout, and to complete a callin open after DCD rises. 3196 */ 3197 tp->t_termios = ISCALLOUT(dev) ? tp->t_init_out : tp->t_init_in; 3198 tp->t_cflag = tp->t_termios.c_cflag; 3199 if (tp->t_modem != NULL) 3200 tt_modem(tp, SER_DTR | SER_RTS, 0); 3201 ++tp->t_wopeners; 3202 error = tt_param(tp, &tp->t_termios); 3203 --tp->t_wopeners; 3204 if (error == 0) 3205 error = tt_open(tp, dev); 3206 if (error != 0) 3207 goto out; 3208 if (ISCALLOUT(dev) || (tt_modem(tp, 0, 0) & SER_DCD)) 3209 ttyld_modem(tp, 1); 3210 } 3211 /* 3212 * Wait for DCD if necessary. 3213 */ 3214 if (!(tp->t_state & TS_CARR_ON) && !ISCALLOUT(dev) 3215 && !(tp->t_cflag & CLOCAL) && !(flag & O_NONBLOCK)) { 3216 ++tp->t_wopeners; 3217 error = tsleep(TSA_CARR_ON(tp), TTIPRI | PCATCH, "ttydcd", 0); 3218 --tp->t_wopeners; 3219 if (error != 0 || (tp->t_state & TS_GONE)) 3220 goto out; 3221 goto open_top; 3222 } 3223 error = ttyld_open(tp, dev); 3224 ttyldoptim(tp); 3225 if (tp->t_state & TS_ISOPEN && ISCALLOUT(dev)) 3226 tp->t_actout = TRUE; 3227out: 3228 splx(s); 3229 if (!(tp->t_state & TS_ISOPEN) && tp->t_wopeners == 0) 3230 tt_close(tp); 3231 return (error); 3232} 3233 3234int 3235ttyclose(struct cdev *dev, int flag, int mode, struct thread *td) 3236{ 3237 struct tty *tp; 3238 3239 tp = dev->si_tty; 3240 ttyld_close(tp, flag); 3241 ttyldoptim(tp); 3242 tt_close(tp); 3243 tp->t_do_timestamp = 0; 3244 if (tp->t_pps != NULL) 3245 tp->t_pps->ppsparam.mode = 0; 3246 tty_close(tp); 3247 return (0); 3248} 3249 3250int 3251ttyread(struct cdev *dev, struct uio *uio, int flag) 3252{ 3253 struct tty *tp; 3254 3255 tp = tty_gettp(dev); 3256 3257 if (tp->t_state & TS_GONE) 3258 return (ENODEV); 3259 return (ttyld_read(tp, uio, flag)); 3260} 3261 3262int 3263ttywrite(struct cdev *dev, struct uio *uio, int flag) 3264{ 3265 struct tty *tp; 3266 3267 tp = tty_gettp(dev); 3268 3269 if (tp->t_state & TS_GONE) 3270 return (ENODEV); 3271 return (ttyld_write(tp, uio, flag)); 3272} 3273 3274int 3275ttyioctl(struct cdev *dev, u_long cmd, caddr_t data, int flag, struct thread *td) 3276{ 3277 struct tty *tp; 3278 int error; 3279 3280 tp = dev->si_tty; 3281 3282 if (cmd == TIOCSETA || cmd == TIOCSETAW || cmd == TIOCSETAF) { 3283 int cc; 3284 struct termios *dt = (struct termios *)data; 3285 struct termios *lt = 3286 ISCALLOUT(dev) ? &tp->t_lock_out : &tp->t_lock_in; 3287 3288 dt->c_iflag = (tp->t_iflag & lt->c_iflag) 3289 | (dt->c_iflag & ~lt->c_iflag); 3290 dt->c_oflag = (tp->t_oflag & lt->c_oflag) 3291 | (dt->c_oflag & ~lt->c_oflag); 3292 dt->c_cflag = (tp->t_cflag & lt->c_cflag) 3293 | (dt->c_cflag & ~lt->c_cflag); 3294 dt->c_lflag = (tp->t_lflag & lt->c_lflag) 3295 | (dt->c_lflag & ~lt->c_lflag); 3296 for (cc = 0; cc < NCCS; ++cc) 3297 if (lt->c_cc[cc] != 0) 3298 dt->c_cc[cc] = tp->t_cc[cc]; 3299 if (lt->c_ispeed != 0) 3300 dt->c_ispeed = tp->t_ispeed; 3301 if (lt->c_ospeed != 0) 3302 dt->c_ospeed = tp->t_ospeed; 3303 } 3304 3305 error = ttyld_ioctl(tp, cmd, data, flag, td); 3306 if (error == ENOIOCTL) 3307 error = ttioctl(tp, cmd, data, flag); 3308 ttyldoptim(tp); 3309 if (error != ENOIOCTL) 3310 return (error); 3311 return (ENOTTY); 3312} 3313 3314void 3315ttyldoptim(struct tty *tp) 3316{ 3317 struct termios *t; 3318 3319 t = &tp->t_termios; 3320 if (!(t->c_iflag & (ICRNL | IGNCR | IMAXBEL | INLCR | ISTRIP | IXON)) 3321 && (!(t->c_iflag & BRKINT) || (t->c_iflag & IGNBRK)) 3322 && (!(t->c_iflag & PARMRK) 3323 || (t->c_iflag & (IGNPAR | IGNBRK)) == (IGNPAR | IGNBRK)) 3324 && !(t->c_lflag & (ECHO | ICANON | IEXTEN | ISIG | PENDIN)) 3325 && linesw[tp->t_line]->l_rint == ttyinput) 3326 tp->t_state |= TS_CAN_BYPASS_L_RINT; 3327 else 3328 tp->t_state &= ~TS_CAN_BYPASS_L_RINT; 3329} 3330 3331static void 3332ttydtrwaitwakeup(void *arg) 3333{ 3334 struct tty *tp; 3335 3336 tp = arg; 3337 tp->t_state &= ~TS_DTR_WAIT; 3338 wakeup(&tp->t_dtr_wait); 3339} 3340 3341 3342void 3343ttydtrwaitstart(struct tty *tp) 3344{ 3345 3346 if (tp->t_dtr_wait == 0) 3347 return; 3348 if (tp->t_state & TS_DTR_WAIT) 3349 return; 3350 timeout(ttydtrwaitwakeup, tp, tp->t_dtr_wait); 3351 tp->t_state |= TS_DTR_WAIT; 3352} 3353 3354int 3355ttydtrwaitsleep(struct tty *tp) 3356{ 3357 int error; 3358 3359 error = 0; 3360 while (error == 0) { 3361 if (tp->t_state & TS_GONE) 3362 error = ENXIO; 3363 else if (!(tp->t_state & TS_DTR_WAIT)) 3364 break; 3365 else 3366 error = tsleep(&tp->t_dtr_wait, TTIPRI | PCATCH, 3367 "dtrwait", 0); 3368 } 3369 return (error); 3370} 3371 3372static int 3373ttysopen(struct cdev *dev, int flag, int mode, struct thread *td) 3374{ 3375 struct tty *tp; 3376 3377 tp = dev->si_tty; 3378 KASSERT(tp != NULL, 3379 ("ttysopen(): no tty pointer on device (%s)", devtoname(dev))); 3380 if (tp->t_state & TS_GONE) 3381 return (ENODEV); 3382 return (0); 3383} 3384 3385static int 3386ttysclose(struct cdev *dev, int flag, int mode, struct thread *td) 3387{ 3388 3389 return (0); 3390} 3391 3392static int 3393ttysrdwr(struct cdev *dev, struct uio *uio, int flag) 3394{ 3395 3396 return (ENODEV); 3397} 3398 3399static int 3400ttysioctl(struct cdev *dev, u_long cmd, caddr_t data, int flag, struct thread *td) 3401{ 3402 struct tty *tp; 3403 int error; 3404 struct termios *ct; 3405 3406 tp = dev->si_tty; 3407 KASSERT(tp != NULL, 3408 ("ttysopen(): no tty pointer on device (%s)", devtoname(dev))); 3409 if (tp->t_state & TS_GONE) 3410 return (ENODEV); 3411 ct = dev->si_drv2; 3412 switch (cmd) { 3413 case TIOCSETA: 3414 error = priv_check(td, PRIV_TTY_SETA); 3415 if (error != 0) 3416 return (error); 3417 *ct = *(struct termios *)data; 3418 return (0); 3419 case TIOCGETA: 3420 *(struct termios *)data = *ct; 3421 return (0); 3422 case TIOCGETD: 3423 *(int *)data = TTYDISC; 3424 return (0); 3425 case TIOCGWINSZ: 3426 bzero(data, sizeof(struct winsize)); 3427 return (0); 3428 default: 3429 if (tp->t_cioctl != NULL) 3430 return(tp->t_cioctl(dev, cmd, data, flag, td)); 3431 return (ENOTTY); 3432 } 3433} 3434 3435/* 3436 * Initialize a tty to sane modes. 3437 */ 3438void 3439ttyinitmode(struct tty *tp, int echo, int speed) 3440{ 3441 3442 if (speed == 0) 3443 speed = TTYDEF_SPEED; 3444 tp->t_init_in.c_iflag = TTYDEF_IFLAG; 3445 tp->t_init_in.c_oflag = TTYDEF_OFLAG; 3446 tp->t_init_in.c_cflag = TTYDEF_CFLAG; 3447 if (echo) 3448 tp->t_init_in.c_lflag = TTYDEF_LFLAG_ECHO; 3449 else 3450 tp->t_init_in.c_lflag = TTYDEF_LFLAG_NOECHO; 3451 3452 tp->t_init_in.c_ispeed = tp->t_init_in.c_ospeed = speed; 3453 termioschars(&tp->t_init_in); 3454 tp->t_init_out = tp->t_init_in; 3455 tp->t_termios = tp->t_init_in; 3456} 3457 3458/* 3459 * Use more "normal" termios paramters for consoles. 3460 */ 3461void 3462ttyconsolemode(struct tty *tp, int speed) 3463{ 3464 3465 if (speed == 0) 3466 speed = TTYDEF_SPEED; 3467 ttyinitmode(tp, 1, speed); 3468 tp->t_init_in.c_cflag |= CLOCAL; 3469 tp->t_lock_out.c_cflag = tp->t_lock_in.c_cflag = CLOCAL; 3470 tp->t_lock_out.c_ispeed = tp->t_lock_out.c_ospeed = 3471 tp->t_lock_in.c_ispeed = tp->t_lock_in.c_ospeed = speed; 3472 tp->t_init_out = tp->t_init_in; 3473 tp->t_termios = tp->t_init_in; 3474 ttsetwater(tp); 3475} 3476 3477/* 3478 * Record the relationship between the serial ports notion of modem control 3479 * signals and the one used in certain ioctls in a way the compiler can enforce 3480 * XXX: We should define TIOCM_* in terms of SER_ if we can limit the 3481 * XXX: consequences of the #include work that would take. 3482 */ 3483CTASSERT(SER_DTR == TIOCM_DTR / 2); 3484CTASSERT(SER_RTS == TIOCM_RTS / 2); 3485CTASSERT(SER_STX == TIOCM_ST / 2); 3486CTASSERT(SER_SRX == TIOCM_SR / 2); 3487CTASSERT(SER_CTS == TIOCM_CTS / 2); 3488CTASSERT(SER_DCD == TIOCM_DCD / 2); 3489CTASSERT(SER_RI == TIOCM_RI / 2); 3490CTASSERT(SER_DSR == TIOCM_DSR / 2); 3491 3492