tty.c revision 1.141
1 /* $NetBSD: tty.c,v 1.141 2002/09/04 01:32:43 matt Exp $ */ 2 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.13 (Berkeley) 1/9/95 41 */ 42 43 #include <sys/cdefs.h> 44 __KERNEL_RCSID(0, "$NetBSD: tty.c,v 1.141 2002/09/04 01:32:43 matt Exp $"); 45 46 #include "opt_uconsole.h" 47 48 #include <sys/param.h> 49 #include <sys/systm.h> 50 #include <sys/ioctl.h> 51 #include <sys/proc.h> 52 #define TTYDEFCHARS 53 #include <sys/tty.h> 54 #undef TTYDEFCHARS 55 #include <sys/file.h> 56 #include <sys/conf.h> 57 #include <sys/dkstat.h> 58 #include <sys/uio.h> 59 #include <sys/kernel.h> 60 #include <sys/vnode.h> 61 #include <sys/syslog.h> 62 #include <sys/malloc.h> 63 #include <sys/pool.h> 64 #include <sys/signalvar.h> 65 #include <sys/resourcevar.h> 66 #include <sys/poll.h> 67 68 static int ttnread(struct tty *); 69 static void ttyblock(struct tty *); 70 static void ttyecho(int, struct tty *); 71 static void ttyrubo(struct tty *, int); 72 static int proc_compare(struct proc *, struct proc *); 73 74 /* Symbolic sleep message strings. */ 75 const char ttclos[] = "ttycls"; 76 const char ttopen[] = "ttyopn"; 77 const char ttybg[] = "ttybg"; 78 const char ttyin[] = "ttyin"; 79 const char ttyout[] = "ttyout"; 80 81 /* 82 * Used to determine whether we still have a connection. This is true in 83 * one of 3 cases: 84 * 1) We have carrier. 85 * 2) It's a locally attached terminal, and we are therefore ignoring carrier. 86 * 3) We're using a flow control mechanism that overloads the carrier signal. 87 */ 88 #define CONNECTED(tp) (ISSET(tp->t_state, TS_CARR_ON) || \ 89 ISSET(tp->t_cflag, CLOCAL | MDMBUF)) 90 91 /* 92 * Table with character classes and parity. The 8th bit indicates parity, 93 * the 7th bit indicates the character is an alphameric or underscore (for 94 * ALTWERASE), and the low 6 bits indicate delay type. If the low 6 bits 95 * are 0 then the character needs no special processing on output; classes 96 * other than 0 might be translated or (not currently) require delays. 97 */ 98 #define E 0x00 /* Even parity. */ 99 #define O 0x80 /* Odd parity. */ 100 #define PARITY(c) (char_type[c] & O) 101 102 #define ALPHA 0x40 /* Alpha or underscore. */ 103 #define ISALPHA(c) (char_type[(c) & TTY_CHARMASK] & ALPHA) 104 105 #define CCLASSMASK 0x3f 106 #define CCLASS(c) (char_type[c] & CCLASSMASK) 107 108 #define BS BACKSPACE 109 #define CC CONTROL 110 #define CR RETURN 111 #define NA ORDINARY | ALPHA 112 #define NL NEWLINE 113 #define NO ORDINARY 114 #define TB TAB 115 #define VT VTAB 116 117 char const char_type[] = { 118 E|CC, O|CC, O|CC, E|CC, O|CC, E|CC, E|CC, O|CC, /* nul - bel */ 119 O|BS, E|TB, E|NL, O|CC, E|VT, O|CR, O|CC, E|CC, /* bs - si */ 120 O|CC, E|CC, E|CC, O|CC, E|CC, O|CC, O|CC, E|CC, /* dle - etb */ 121 E|CC, O|CC, O|CC, E|CC, O|CC, E|CC, E|CC, O|CC, /* can - us */ 122 O|NO, E|NO, E|NO, O|NO, E|NO, O|NO, O|NO, E|NO, /* sp - ' */ 123 E|NO, O|NO, O|NO, E|NO, O|NO, E|NO, E|NO, O|NO, /* ( - / */ 124 E|NA, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* 0 - 7 */ 125 O|NA, E|NA, E|NO, O|NO, E|NO, O|NO, O|NO, E|NO, /* 8 - ? */ 126 O|NO, E|NA, E|NA, O|NA, E|NA, O|NA, O|NA, E|NA, /* @ - G */ 127 E|NA, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* H - O */ 128 E|NA, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* P - W */ 129 O|NA, E|NA, E|NA, O|NO, E|NO, O|NO, O|NO, O|NA, /* X - _ */ 130 E|NO, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* ` - g */ 131 O|NA, E|NA, E|NA, O|NA, E|NA, O|NA, O|NA, E|NA, /* h - o */ 132 O|NA, E|NA, E|NA, O|NA, E|NA, O|NA, O|NA, E|NA, /* p - w */ 133 E|NA, O|NA, O|NA, E|NO, O|NO, E|NO, E|NO, O|CC, /* x - del */ 134 /* 135 * Meta chars; should be settable per character set; 136 * for now, treat them all as normal characters. 137 */ 138 NA, NA, NA, NA, NA, NA, NA, NA, 139 NA, NA, NA, NA, NA, NA, NA, NA, 140 NA, NA, NA, NA, NA, NA, NA, NA, 141 NA, NA, NA, NA, NA, NA, NA, NA, 142 NA, NA, NA, NA, NA, NA, NA, NA, 143 NA, NA, NA, NA, NA, NA, NA, NA, 144 NA, NA, NA, NA, NA, NA, NA, NA, 145 NA, NA, NA, NA, NA, NA, NA, NA, 146 NA, NA, NA, NA, NA, NA, NA, NA, 147 NA, NA, NA, NA, NA, NA, NA, NA, 148 NA, NA, NA, NA, NA, NA, NA, NA, 149 NA, NA, NA, NA, NA, NA, NA, NA, 150 NA, NA, NA, NA, NA, NA, NA, NA, 151 NA, NA, NA, NA, NA, NA, NA, NA, 152 NA, NA, NA, NA, NA, NA, NA, NA, 153 NA, NA, NA, NA, NA, NA, NA, NA, 154 }; 155 #undef BS 156 #undef CC 157 #undef CR 158 #undef NA 159 #undef NL 160 #undef NO 161 #undef TB 162 #undef VT 163 164 /* Macros to clear/set/test flags. */ 165 #define SET(t, f) (t) |= (f) 166 #define CLR(t, f) (t) &= ~((unsigned)(f)) 167 #define ISSET(t, f) ((t) & (f)) 168 169 struct ttylist_head ttylist; /* TAILQ_HEAD */ 170 int tty_count; 171 172 struct pool tty_pool; 173 174 u_int64_t tk_cancc; 175 u_int64_t tk_nin; 176 u_int64_t tk_nout; 177 u_int64_t tk_rawcc; 178 179 int 180 ttyopen(struct tty *tp, int dialout, int nonblock) 181 { 182 int s, error; 183 184 s = spltty(); 185 186 if (dialout) { 187 /* 188 * If the device is already open for non-dialout, fail. 189 * Otherwise, set TS_DIALOUT to block any pending non-dialout 190 * opens. 191 */ 192 if (ISSET(tp->t_state, TS_ISOPEN) && 193 !ISSET(tp->t_state, TS_DIALOUT)) { 194 splx(s); 195 return (EBUSY); 196 } 197 SET(tp->t_state, TS_DIALOUT); 198 } else { 199 if (!nonblock) { 200 /* 201 * Wait for carrier. Also wait for any dialout 202 * processes to close the tty first. 203 */ 204 while (ISSET(tp->t_state, TS_DIALOUT) || 205 (!ISSET(tp->t_state, TS_CARR_ON) && 206 !ISSET(tp->t_cflag, CLOCAL | MDMBUF))) { 207 tp->t_wopen++; 208 error = ttysleep(tp, &tp->t_rawq, 209 TTIPRI | PCATCH, ttopen, 0); 210 tp->t_wopen--; 211 if (error) { 212 splx(s); 213 return (error); 214 } 215 } 216 } else { 217 /* 218 * Don't allow a non-blocking non-dialout open if the 219 * device is already open for dialout. 220 */ 221 if (ISSET(tp->t_state, TS_DIALOUT)) { 222 splx(s); 223 return (EBUSY); 224 } 225 } 226 } 227 228 splx(s); 229 return (0); 230 } 231 232 /* 233 * Initial open of tty, or (re)entry to standard tty line discipline. 234 */ 235 int 236 ttylopen(dev_t device, struct tty *tp) 237 { 238 int s; 239 240 s = spltty(); 241 tp->t_dev = device; 242 if (!ISSET(tp->t_state, TS_ISOPEN)) { 243 SET(tp->t_state, TS_ISOPEN); 244 memset(&tp->t_winsize, 0, sizeof(tp->t_winsize)); 245 #ifdef COMPAT_OLDTTY 246 tp->t_flags = 0; 247 #endif 248 } 249 splx(s); 250 return (0); 251 } 252 253 /* 254 * Handle close() on a tty line: flush and set to initial state, 255 * bumping generation number so that pending read/write calls 256 * can detect recycling of the tty. 257 */ 258 int 259 ttyclose(struct tty *tp) 260 { 261 extern struct tty *constty; /* Temporary virtual console. */ 262 263 if (constty == tp) 264 constty = NULL; 265 266 ttyflush(tp, FREAD | FWRITE); 267 268 tp->t_gen++; 269 tp->t_pgrp = NULL; 270 if (tp->t_session != NULL) { 271 SESSRELE(tp->t_session); 272 tp->t_session = NULL; 273 } 274 tp->t_state = 0; 275 return (0); 276 } 277 278 #define FLUSHQ(q) { \ 279 if ((q)->c_cc) \ 280 ndflush(q, (q)->c_cc); \ 281 } 282 283 /* 284 * This macro is used in canonical mode input processing, where a read 285 * request shall not return unless a 'line delimiter' ('\n') or 'break' 286 * (EOF, EOL, EOL2) character (or a signal) has been received. As EOL2 287 * is an extension to the POSIX.1 defined set of special characters, 288 * recognize it only if IEXTEN is set in the set of local flags. 289 */ 290 #define TTBREAKC(c, lflg) \ 291 ((c) == '\n' || (((c) == cc[VEOF] || (c) == cc[VEOL] || \ 292 ((c) == cc[VEOL2] && ISSET(lflg, IEXTEN))) && (c) != _POSIX_VDISABLE)) 293 294 295 /* 296 * Process input of a single character received on a tty. 297 */ 298 int 299 ttyinput(int c, struct tty *tp) 300 { 301 int iflag, lflag, i, error; 302 u_char *cc; 303 304 /* 305 * Unless the receiver is enabled, drop incoming data. 306 */ 307 if (!ISSET(tp->t_cflag, CREAD)) 308 return (0); 309 310 /* 311 * If input is pending take it first. 312 */ 313 lflag = tp->t_lflag; 314 if (ISSET(lflag, PENDIN)) 315 ttypend(tp); 316 /* 317 * Gather stats. 318 */ 319 if (ISSET(lflag, ICANON)) { 320 ++tk_cancc; 321 ++tp->t_cancc; 322 } else { 323 ++tk_rawcc; 324 ++tp->t_rawcc; 325 } 326 ++tk_nin; 327 328 cc = tp->t_cc; 329 330 /* 331 * Handle exceptional conditions (break, parity, framing). 332 */ 333 iflag = tp->t_iflag; 334 if ((error = (ISSET(c, TTY_ERRORMASK))) != 0) { 335 CLR(c, TTY_ERRORMASK); 336 if (ISSET(error, TTY_FE) && c == 0) { /* Break. */ 337 if (ISSET(iflag, IGNBRK)) 338 return (0); 339 else if (ISSET(iflag, BRKINT)) { 340 ttyflush(tp, FREAD | FWRITE); 341 pgsignal(tp->t_pgrp, SIGINT, 1); 342 return (0); 343 } else if (ISSET(iflag, PARMRK)) 344 goto parmrk; 345 } else if ((ISSET(error, TTY_PE) && ISSET(iflag, INPCK)) || 346 ISSET(error, TTY_FE)) { 347 if (ISSET(iflag, IGNPAR)) 348 return (0); 349 else if (ISSET(iflag, PARMRK)) { 350 parmrk: (void)putc(0377 | TTY_QUOTE, &tp->t_rawq); 351 (void)putc(0 | TTY_QUOTE, &tp->t_rawq); 352 (void)putc(c | TTY_QUOTE, &tp->t_rawq); 353 return (0); 354 } else 355 c = 0; 356 } 357 } else if (c == 0377 && 358 ISSET(iflag, ISTRIP|IGNPAR|INPCK|PARMRK) == (INPCK|PARMRK)) { 359 /* "Escape" a valid character of '\377'. */ 360 (void)putc(0377 | TTY_QUOTE, &tp->t_rawq); 361 (void)putc(0377 | TTY_QUOTE, &tp->t_rawq); 362 goto endcase; 363 } 364 365 /* 366 * In tandem mode, check high water mark. 367 */ 368 if (ISSET(iflag, IXOFF) || ISSET(tp->t_cflag, CHWFLOW)) 369 ttyblock(tp); 370 if (!ISSET(tp->t_state, TS_TYPEN) && ISSET(iflag, ISTRIP)) 371 CLR(c, 0x80); 372 if (!ISSET(lflag, EXTPROC)) { 373 /* 374 * Check for literal nexting very first 375 */ 376 if (ISSET(tp->t_state, TS_LNCH)) { 377 SET(c, TTY_QUOTE); 378 CLR(tp->t_state, TS_LNCH); 379 } 380 /* 381 * Scan for special characters. This code 382 * is really just a big case statement with 383 * non-constant cases. The bottom of the 384 * case statement is labeled ``endcase'', so goto 385 * it after a case match, or similar. 386 */ 387 388 /* 389 * Control chars which aren't controlled 390 * by ICANON, ISIG, or IXON. 391 */ 392 if (ISSET(lflag, IEXTEN)) { 393 if (CCEQ(cc[VLNEXT], c)) { 394 if (ISSET(lflag, ECHO)) { 395 if (ISSET(lflag, ECHOE)) { 396 (void)ttyoutput('^', tp); 397 (void)ttyoutput('\b', tp); 398 } else 399 ttyecho(c, tp); 400 } 401 SET(tp->t_state, TS_LNCH); 402 goto endcase; 403 } 404 if (CCEQ(cc[VDISCARD], c)) { 405 if (ISSET(lflag, FLUSHO)) 406 CLR(tp->t_lflag, FLUSHO); 407 else { 408 ttyflush(tp, FWRITE); 409 ttyecho(c, tp); 410 if (tp->t_rawq.c_cc + tp->t_canq.c_cc) 411 ttyretype(tp); 412 SET(tp->t_lflag, FLUSHO); 413 } 414 goto startoutput; 415 } 416 } 417 /* 418 * Signals. 419 */ 420 if (ISSET(lflag, ISIG)) { 421 if (CCEQ(cc[VINTR], c) || CCEQ(cc[VQUIT], c)) { 422 if (!ISSET(lflag, NOFLSH)) 423 ttyflush(tp, FREAD | FWRITE); 424 ttyecho(c, tp); 425 pgsignal(tp->t_pgrp, 426 CCEQ(cc[VINTR], c) ? SIGINT : SIGQUIT, 1); 427 goto endcase; 428 } 429 if (CCEQ(cc[VSUSP], c)) { 430 if (!ISSET(lflag, NOFLSH)) 431 ttyflush(tp, FREAD); 432 ttyecho(c, tp); 433 pgsignal(tp->t_pgrp, SIGTSTP, 1); 434 goto endcase; 435 } 436 } 437 /* 438 * Handle start/stop characters. 439 */ 440 if (ISSET(iflag, IXON)) { 441 if (CCEQ(cc[VSTOP], c)) { 442 if (!ISSET(tp->t_state, TS_TTSTOP)) { 443 SET(tp->t_state, TS_TTSTOP); 444 (*cdevsw[major(tp->t_dev)].d_stop)(tp, 445 0); 446 return (0); 447 } 448 if (!CCEQ(cc[VSTART], c)) 449 return (0); 450 /* 451 * if VSTART == VSTOP then toggle 452 */ 453 goto endcase; 454 } 455 if (CCEQ(cc[VSTART], c)) 456 goto restartoutput; 457 } 458 /* 459 * IGNCR, ICRNL, & INLCR 460 */ 461 if (c == '\r') { 462 if (ISSET(iflag, IGNCR)) 463 goto endcase; 464 else if (ISSET(iflag, ICRNL)) 465 c = '\n'; 466 } else if (c == '\n' && ISSET(iflag, INLCR)) 467 c = '\r'; 468 } 469 if (!ISSET(tp->t_lflag, EXTPROC) && ISSET(lflag, ICANON)) { 470 /* 471 * From here on down canonical mode character 472 * processing takes place. 473 */ 474 /* 475 * erase (^H / ^?) 476 */ 477 if (CCEQ(cc[VERASE], c)) { 478 if (tp->t_rawq.c_cc) 479 ttyrub(unputc(&tp->t_rawq), tp); 480 goto endcase; 481 } 482 /* 483 * kill (^U) 484 */ 485 if (CCEQ(cc[VKILL], c)) { 486 if (ISSET(lflag, ECHOKE) && 487 tp->t_rawq.c_cc == tp->t_rocount && 488 !ISSET(lflag, ECHOPRT)) 489 while (tp->t_rawq.c_cc) 490 ttyrub(unputc(&tp->t_rawq), tp); 491 else { 492 ttyecho(c, tp); 493 if (ISSET(lflag, ECHOK) || 494 ISSET(lflag, ECHOKE)) 495 ttyecho('\n', tp); 496 FLUSHQ(&tp->t_rawq); 497 tp->t_rocount = 0; 498 } 499 CLR(tp->t_state, TS_LOCAL); 500 goto endcase; 501 } 502 /* 503 * Extensions to the POSIX.1 GTI set of functions. 504 */ 505 if (ISSET(lflag, IEXTEN)) { 506 /* 507 * word erase (^W) 508 */ 509 if (CCEQ(cc[VWERASE], c)) { 510 int alt = ISSET(lflag, ALTWERASE); 511 int ctype; 512 513 /* 514 * erase whitespace 515 */ 516 while ((c = unputc(&tp->t_rawq)) == ' ' || 517 c == '\t') 518 ttyrub(c, tp); 519 if (c == -1) 520 goto endcase; 521 /* 522 * erase last char of word and remember the 523 * next chars type (for ALTWERASE) 524 */ 525 ttyrub(c, tp); 526 c = unputc(&tp->t_rawq); 527 if (c == -1) 528 goto endcase; 529 if (c == ' ' || c == '\t') { 530 (void)putc(c, &tp->t_rawq); 531 goto endcase; 532 } 533 ctype = ISALPHA(c); 534 /* 535 * erase rest of word 536 */ 537 do { 538 ttyrub(c, tp); 539 c = unputc(&tp->t_rawq); 540 if (c == -1) 541 goto endcase; 542 } while (c != ' ' && c != '\t' && 543 (alt == 0 || ISALPHA(c) == ctype)); 544 (void)putc(c, &tp->t_rawq); 545 goto endcase; 546 } 547 /* 548 * reprint line (^R) 549 */ 550 if (CCEQ(cc[VREPRINT], c)) { 551 ttyretype(tp); 552 goto endcase; 553 } 554 /* 555 * ^T - kernel info and generate SIGINFO 556 */ 557 if (CCEQ(cc[VSTATUS], c)) { 558 if (!ISSET(lflag, NOKERNINFO)) 559 ttyinfo(tp); 560 if (ISSET(lflag, ISIG)) 561 pgsignal(tp->t_pgrp, SIGINFO, 1); 562 goto endcase; 563 } 564 } 565 } 566 /* 567 * Check for input buffer overflow 568 */ 569 if (tp->t_rawq.c_cc + tp->t_canq.c_cc >= TTYHOG) { 570 if (ISSET(iflag, IMAXBEL)) { 571 if (tp->t_outq.c_cc < tp->t_hiwat) 572 (void)ttyoutput(CTRL('g'), tp); 573 } else 574 ttyflush(tp, FREAD | FWRITE); 575 goto endcase; 576 } 577 /* 578 * Put data char in q for user and 579 * wakeup on seeing a line delimiter. 580 */ 581 if (putc(c, &tp->t_rawq) >= 0) { 582 if (!ISSET(lflag, ICANON)) { 583 ttwakeup(tp); 584 ttyecho(c, tp); 585 goto endcase; 586 } 587 if (TTBREAKC(c, lflag)) { 588 tp->t_rocount = 0; 589 catq(&tp->t_rawq, &tp->t_canq); 590 ttwakeup(tp); 591 } else if (tp->t_rocount++ == 0) 592 tp->t_rocol = tp->t_column; 593 if (ISSET(tp->t_state, TS_ERASE)) { 594 /* 595 * end of prterase \.../ 596 */ 597 CLR(tp->t_state, TS_ERASE); 598 (void)ttyoutput('/', tp); 599 } 600 i = tp->t_column; 601 ttyecho(c, tp); 602 if (CCEQ(cc[VEOF], c) && ISSET(lflag, ECHO)) { 603 /* 604 * Place the cursor over the '^' of the ^D. 605 */ 606 i = min(2, tp->t_column - i); 607 while (i > 0) { 608 (void)ttyoutput('\b', tp); 609 i--; 610 } 611 } 612 } 613 endcase: 614 /* 615 * IXANY means allow any character to restart output. 616 */ 617 if (ISSET(tp->t_state, TS_TTSTOP) && 618 !ISSET(iflag, IXANY) && cc[VSTART] != cc[VSTOP]) 619 return (0); 620 restartoutput: 621 CLR(tp->t_lflag, FLUSHO); 622 CLR(tp->t_state, TS_TTSTOP); 623 startoutput: 624 return (ttstart(tp)); 625 } 626 627 /* 628 * Output a single character on a tty, doing output processing 629 * as needed (expanding tabs, newline processing, etc.). 630 * Returns < 0 if succeeds, otherwise returns char to resend. 631 * Must be recursive. 632 */ 633 int 634 ttyoutput(int c, struct tty *tp) 635 { 636 long oflag; 637 int col, notout, s; 638 639 oflag = tp->t_oflag; 640 if (!ISSET(oflag, OPOST)) { 641 tk_nout++; 642 tp->t_outcc++; 643 if (!ISSET(tp->t_lflag, FLUSHO) && putc(c, &tp->t_outq)) 644 return (c); 645 return (-1); 646 } 647 /* 648 * Do tab expansion if OXTABS is set. Special case if we do external 649 * processing, we don't do the tab expansion because we'll probably 650 * get it wrong. If tab expansion needs to be done, let it happen 651 * externally. 652 */ 653 CLR(c, ~TTY_CHARMASK); 654 if (c == '\t' && 655 ISSET(oflag, OXTABS) && !ISSET(tp->t_lflag, EXTPROC)) { 656 c = 8 - (tp->t_column & 7); 657 if (ISSET(tp->t_lflag, FLUSHO)) { 658 notout = 0; 659 } else { 660 s = spltty(); /* Don't interrupt tabs. */ 661 notout = b_to_q(" ", c, &tp->t_outq); 662 c -= notout; 663 tk_nout += c; 664 tp->t_outcc += c; 665 splx(s); 666 } 667 tp->t_column += c; 668 return (notout ? '\t' : -1); 669 } 670 if (c == CEOT && ISSET(oflag, ONOEOT)) 671 return (-1); 672 673 /* 674 * Newline translation: if ONLCR is set, 675 * translate newline into "\r\n". 676 */ 677 if (c == '\n' && ISSET(tp->t_oflag, ONLCR)) { 678 tk_nout++; 679 tp->t_outcc++; 680 if (!ISSET(tp->t_lflag, FLUSHO) && putc('\r', &tp->t_outq)) 681 return (c); 682 } 683 /* If OCRNL is set, translate "\r" into "\n". */ 684 else if (c == '\r' && ISSET(tp->t_oflag, OCRNL)) 685 c = '\n'; 686 /* If ONOCR is set, don't transmit CRs when on column 0. */ 687 else if (c == '\r' && ISSET(tp->t_oflag, ONOCR) && tp->t_column == 0) 688 return (-1); 689 690 tk_nout++; 691 tp->t_outcc++; 692 if (!ISSET(tp->t_lflag, FLUSHO) && putc(c, &tp->t_outq)) 693 return (c); 694 695 col = tp->t_column; 696 switch (CCLASS(c)) { 697 case BACKSPACE: 698 if (col > 0) 699 --col; 700 break; 701 case CONTROL: 702 break; 703 case NEWLINE: 704 if (ISSET(tp->t_oflag, ONLCR | ONLRET)) 705 col = 0; 706 break; 707 case RETURN: 708 col = 0; 709 break; 710 case ORDINARY: 711 ++col; 712 break; 713 case TAB: 714 col = (col + 8) & ~7; 715 break; 716 } 717 tp->t_column = col; 718 return (-1); 719 } 720 721 /* 722 * Ioctls for all tty devices. Called after line-discipline specific ioctl 723 * has been called to do discipline-specific functions and/or reject any 724 * of these ioctl commands. 725 */ 726 /* ARGSUSED */ 727 int 728 ttioctl(struct tty *tp, u_long cmd, caddr_t data, int flag, struct proc *p) 729 { 730 extern struct tty *constty; /* Temporary virtual console. */ 731 struct linesw *lp; 732 int s, error; 733 734 /* If the ioctl involves modification, hang if in the background. */ 735 switch (cmd) { 736 case TIOCFLUSH: 737 case TIOCDRAIN: 738 case TIOCSBRK: 739 case TIOCCBRK: 740 case TIOCSTART: 741 case TIOCSETA: 742 case TIOCSETD: 743 case TIOCSLINED: 744 case TIOCSETAF: 745 case TIOCSETAW: 746 #ifdef notdef 747 case TIOCSPGRP: 748 #endif 749 case TIOCSTAT: 750 case TIOCSTI: 751 case TIOCSWINSZ: 752 #ifdef COMPAT_OLDTTY 753 case TIOCLBIC: 754 case TIOCLBIS: 755 case TIOCLSET: 756 case TIOCSETC: 757 case OTIOCSETD: 758 case TIOCSETN: 759 case TIOCSETP: 760 case TIOCSLTC: 761 #endif 762 while (isbackground(curproc, tp) && 763 p->p_pgrp->pg_jobc && (p->p_flag & P_PPWAIT) == 0 && 764 !sigismasked(p, SIGTTOU)) { 765 pgsignal(p->p_pgrp, SIGTTOU, 1); 766 error = ttysleep(tp, &lbolt, TTOPRI | PCATCH, ttybg, 0); 767 if (error) 768 return (error); 769 } 770 break; 771 } 772 773 switch (cmd) { /* Process the ioctl. */ 774 case FIOASYNC: /* set/clear async i/o */ 775 s = spltty(); 776 if (*(int *)data) 777 SET(tp->t_state, TS_ASYNC); 778 else 779 CLR(tp->t_state, TS_ASYNC); 780 splx(s); 781 break; 782 case FIONBIO: /* set/clear non-blocking i/o */ 783 break; /* XXX: delete. */ 784 case FIONREAD: /* get # bytes to read */ 785 *(int *)data = ttnread(tp); 786 break; 787 case TIOCEXCL: /* set exclusive use of tty */ 788 s = spltty(); 789 SET(tp->t_state, TS_XCLUDE); 790 splx(s); 791 break; 792 case TIOCFLUSH: { /* flush buffers */ 793 int flags = *(int *)data; 794 795 if (flags == 0) 796 flags = FREAD | FWRITE; 797 else 798 flags &= FREAD | FWRITE; 799 ttyflush(tp, flags); 800 break; 801 } 802 case TIOCCONS: /* become virtual console */ 803 if (*(int *)data) { 804 if (constty && constty != tp && 805 ISSET(constty->t_state, TS_CARR_ON | TS_ISOPEN) == 806 (TS_CARR_ON | TS_ISOPEN)) 807 return (EBUSY); 808 #ifndef UCONSOLE 809 if ((error = suser(p->p_ucred, &p->p_acflag)) != 0) 810 return (error); 811 #endif 812 constty = tp; 813 } else if (tp == constty) 814 constty = NULL; 815 break; 816 case TIOCDRAIN: /* wait till output drained */ 817 if ((error = ttywait(tp)) != 0) 818 return (error); 819 break; 820 case TIOCGETA: { /* get termios struct */ 821 struct termios *t = (struct termios *)data; 822 823 memcpy(t, &tp->t_termios, sizeof(struct termios)); 824 break; 825 } 826 case TIOCGETD: /* get line discipline */ 827 *(int *)data = tp->t_linesw->l_no; 828 break; 829 case TIOCGLINED: 830 (void)strncpy((char *)data, tp->t_linesw->l_name, 831 TTLINEDNAMELEN - 1); 832 break; 833 case TIOCGWINSZ: /* get window size */ 834 *(struct winsize *)data = tp->t_winsize; 835 break; 836 case TIOCGPGRP: /* get pgrp of tty */ 837 if (!isctty(p, tp)) 838 return (ENOTTY); 839 *(int *)data = tp->t_pgrp ? tp->t_pgrp->pg_id : NO_PID; 840 break; 841 case TIOCGSID: /* get sid of tty */ 842 if (!isctty(p, tp)) 843 return (ENOTTY); 844 *(int *)data = tp->t_session->s_sid; 845 break; 846 #ifdef TIOCHPCL 847 case TIOCHPCL: /* hang up on last close */ 848 s = spltty(); 849 SET(tp->t_cflag, HUPCL); 850 splx(s); 851 break; 852 #endif 853 case TIOCNXCL: /* reset exclusive use of tty */ 854 s = spltty(); 855 CLR(tp->t_state, TS_XCLUDE); 856 splx(s); 857 break; 858 case TIOCOUTQ: /* output queue size */ 859 *(int *)data = tp->t_outq.c_cc; 860 break; 861 case TIOCSETA: /* set termios struct */ 862 case TIOCSETAW: /* drain output, set */ 863 case TIOCSETAF: { /* drn out, fls in, set */ 864 struct termios *t = (struct termios *)data; 865 866 s = spltty(); 867 if (cmd == TIOCSETAW || cmd == TIOCSETAF) { 868 if ((error = ttywait(tp)) != 0) { 869 splx(s); 870 return (error); 871 } 872 if (cmd == TIOCSETAF) 873 ttyflush(tp, FREAD); 874 } 875 if (!ISSET(t->c_cflag, CIGNORE)) { 876 /* 877 * Set device hardware. 878 */ 879 if (tp->t_param && (error = (*tp->t_param)(tp, t))) { 880 splx(s); 881 return (error); 882 } else { 883 tp->t_cflag = t->c_cflag; 884 tp->t_ispeed = t->c_ispeed; 885 tp->t_ospeed = t->c_ospeed; 886 if (t->c_ospeed == 0 && tp->t_session && 887 tp->t_session->s_leader) 888 psignal(tp->t_session->s_leader, 889 SIGHUP); 890 } 891 ttsetwater(tp); 892 } 893 if (cmd != TIOCSETAF) { 894 if (ISSET(t->c_lflag, ICANON) != 895 ISSET(tp->t_lflag, ICANON)) { 896 if (ISSET(t->c_lflag, ICANON)) { 897 SET(tp->t_lflag, PENDIN); 898 ttwakeup(tp); 899 } else { 900 struct clist tq; 901 902 catq(&tp->t_rawq, &tp->t_canq); 903 tq = tp->t_rawq; 904 tp->t_rawq = tp->t_canq; 905 tp->t_canq = tq; 906 CLR(tp->t_lflag, PENDIN); 907 } 908 } 909 } 910 tp->t_iflag = t->c_iflag; 911 tp->t_oflag = t->c_oflag; 912 /* 913 * Make the EXTPROC bit read only. 914 */ 915 if (ISSET(tp->t_lflag, EXTPROC)) 916 SET(t->c_lflag, EXTPROC); 917 else 918 CLR(t->c_lflag, EXTPROC); 919 tp->t_lflag = t->c_lflag | ISSET(tp->t_lflag, PENDIN); 920 memcpy(tp->t_cc, t->c_cc, sizeof(t->c_cc)); 921 splx(s); 922 break; 923 } 924 case TIOCSETD: { /* set line discipline */ 925 int t = *(int *)data; 926 927 if (t < 0) 928 return (EINVAL); 929 if (t >= nlinesw) 930 return (ENXIO); 931 lp = linesw[t]; 932 goto setldisc; 933 } 934 case TIOCSLINED: { /* set line discipline */ 935 char *name = (char *)data; 936 dev_t device; 937 938 /* Null terminate to prevent buffer overflow */ 939 name[TTLINEDNAMELEN - 1] = '\0'; 940 lp = ttyldisc_lookup(name); 941 942 setldisc: 943 if (lp == NULL) 944 return (ENXIO); 945 946 if (lp != tp->t_linesw) { 947 device = tp->t_dev; 948 s = spltty(); 949 (*tp->t_linesw->l_close)(tp, flag); 950 error = (*lp->l_open)(device, tp); 951 if (error) { 952 (void)(*tp->t_linesw->l_open)(device, tp); 953 splx(s); 954 return (error); 955 } 956 tp->t_linesw = lp; 957 splx(s); 958 } 959 break; 960 } 961 case TIOCSTART: /* start output, like ^Q */ 962 s = spltty(); 963 if (ISSET(tp->t_state, TS_TTSTOP) || 964 ISSET(tp->t_lflag, FLUSHO)) { 965 CLR(tp->t_lflag, FLUSHO); 966 CLR(tp->t_state, TS_TTSTOP); 967 ttstart(tp); 968 } 969 splx(s); 970 break; 971 case TIOCSTI: /* simulate terminal input */ 972 if (p->p_ucred->cr_uid && (flag & FREAD) == 0) 973 return (EPERM); 974 if (p->p_ucred->cr_uid && !isctty(p, tp)) 975 return (EACCES); 976 (*tp->t_linesw->l_rint)(*(u_char *)data, tp); 977 break; 978 case TIOCSTOP: /* stop output, like ^S */ 979 s = spltty(); 980 if (!ISSET(tp->t_state, TS_TTSTOP)) { 981 SET(tp->t_state, TS_TTSTOP); 982 (*cdevsw[major(tp->t_dev)].d_stop)(tp, 0); 983 } 984 splx(s); 985 break; 986 case TIOCSCTTY: /* become controlling tty */ 987 /* Session ctty vnode pointer set in vnode layer. */ 988 if (!SESS_LEADER(p) || 989 ((p->p_session->s_ttyvp || tp->t_session) && 990 (tp->t_session != p->p_session))) 991 return (EPERM); 992 993 if (tp->t_session) 994 SESSRELE(tp->t_session); 995 996 SESSHOLD(p->p_session); 997 tp->t_session = p->p_session; 998 tp->t_pgrp = p->p_pgrp; 999 p->p_session->s_ttyp = tp; 1000 p->p_flag |= P_CONTROLT; 1001 break; 1002 case TIOCSPGRP: { /* set pgrp of tty */ 1003 struct pgrp *pgrp = pgfind(*(int *)data); 1004 1005 if (!isctty(p, tp)) 1006 return (ENOTTY); 1007 else if (pgrp == NULL) 1008 return (EINVAL); 1009 else if (pgrp->pg_session != p->p_session) 1010 return (EPERM); 1011 tp->t_pgrp = pgrp; 1012 break; 1013 } 1014 case TIOCSTAT: /* get load avg stats */ 1015 ttyinfo(tp); 1016 break; 1017 case TIOCSWINSZ: /* set window size */ 1018 if (memcmp((caddr_t)&tp->t_winsize, data, 1019 sizeof(struct winsize))) { 1020 tp->t_winsize = *(struct winsize *)data; 1021 pgsignal(tp->t_pgrp, SIGWINCH, 1); 1022 } 1023 break; 1024 default: 1025 #ifdef COMPAT_OLDTTY 1026 return (ttcompat(tp, cmd, data, flag, p)); 1027 #else 1028 return (EPASSTHROUGH); 1029 #endif 1030 } 1031 return (0); 1032 } 1033 1034 int 1035 ttpoll(struct tty *tp, int events, struct proc *p) 1036 { 1037 int revents, s; 1038 1039 revents = 0; 1040 s = spltty(); 1041 if (events & (POLLIN | POLLRDNORM)) 1042 if (ttnread(tp) > 0) 1043 revents |= events & (POLLIN | POLLRDNORM); 1044 1045 if (events & (POLLOUT | POLLWRNORM)) 1046 if (tp->t_outq.c_cc <= tp->t_lowat) 1047 revents |= events & (POLLOUT | POLLWRNORM); 1048 1049 if (events & POLLHUP) 1050 if (!CONNECTED(tp)) 1051 revents |= POLLHUP; 1052 1053 if (revents == 0) { 1054 if (events & (POLLIN | POLLHUP | POLLRDNORM)) 1055 selrecord(p, &tp->t_rsel); 1056 1057 if (events & (POLLOUT | POLLWRNORM)) 1058 selrecord(p, &tp->t_wsel); 1059 } 1060 1061 splx(s); 1062 return (revents); 1063 } 1064 1065 static int 1066 ttnread(struct tty *tp) 1067 { 1068 int nread; 1069 1070 if (ISSET(tp->t_lflag, PENDIN)) 1071 ttypend(tp); 1072 nread = tp->t_canq.c_cc; 1073 if (!ISSET(tp->t_lflag, ICANON)) { 1074 nread += tp->t_rawq.c_cc; 1075 if (nread < tp->t_cc[VMIN] && !tp->t_cc[VTIME]) 1076 nread = 0; 1077 } 1078 return (nread); 1079 } 1080 1081 /* 1082 * Wait for output to drain. 1083 */ 1084 int 1085 ttywait(struct tty *tp) 1086 { 1087 int error, s; 1088 1089 error = 0; 1090 s = spltty(); 1091 while ((tp->t_outq.c_cc || ISSET(tp->t_state, TS_BUSY)) && 1092 CONNECTED(tp) && tp->t_oproc) { 1093 (*tp->t_oproc)(tp); 1094 SET(tp->t_state, TS_ASLEEP); 1095 error = ttysleep(tp, &tp->t_outq, TTOPRI | PCATCH, ttyout, 0); 1096 if (error) 1097 break; 1098 } 1099 splx(s); 1100 return (error); 1101 } 1102 1103 /* 1104 * Flush if successfully wait. 1105 */ 1106 int 1107 ttywflush(struct tty *tp) 1108 { 1109 int error; 1110 1111 if ((error = ttywait(tp)) == 0) 1112 ttyflush(tp, FREAD); 1113 return (error); 1114 } 1115 1116 /* 1117 * Flush tty read and/or write queues, notifying anyone waiting. 1118 */ 1119 void 1120 ttyflush(struct tty *tp, int rw) 1121 { 1122 int s; 1123 1124 s = spltty(); 1125 if (rw & FREAD) { 1126 FLUSHQ(&tp->t_canq); 1127 FLUSHQ(&tp->t_rawq); 1128 tp->t_rocount = 0; 1129 tp->t_rocol = 0; 1130 CLR(tp->t_state, TS_LOCAL); 1131 ttwakeup(tp); 1132 } 1133 if (rw & FWRITE) { 1134 CLR(tp->t_state, TS_TTSTOP); 1135 (*cdevsw[major(tp->t_dev)].d_stop)(tp, rw); 1136 FLUSHQ(&tp->t_outq); 1137 wakeup((caddr_t)&tp->t_outq); 1138 selwakeup(&tp->t_wsel); 1139 } 1140 splx(s); 1141 } 1142 1143 /* 1144 * Copy in the default termios characters. 1145 */ 1146 void 1147 ttychars(struct tty *tp) 1148 { 1149 1150 memcpy(tp->t_cc, ttydefchars, sizeof(ttydefchars)); 1151 } 1152 1153 /* 1154 * Send stop character on input overflow. 1155 */ 1156 static void 1157 ttyblock(struct tty *tp) 1158 { 1159 int total; 1160 1161 total = tp->t_rawq.c_cc + tp->t_canq.c_cc; 1162 if (tp->t_rawq.c_cc > TTYHOG) { 1163 ttyflush(tp, FREAD | FWRITE); 1164 CLR(tp->t_state, TS_TBLOCK); 1165 } 1166 /* 1167 * Block further input iff: current input > threshold 1168 * AND input is available to user program. 1169 */ 1170 if (total >= TTYHOG / 2 && 1171 !ISSET(tp->t_state, TS_TBLOCK) && 1172 (!ISSET(tp->t_lflag, ICANON) || tp->t_canq.c_cc > 0)) { 1173 if (ISSET(tp->t_iflag, IXOFF) && 1174 tp->t_cc[VSTOP] != _POSIX_VDISABLE && 1175 putc(tp->t_cc[VSTOP], &tp->t_outq) == 0) { 1176 SET(tp->t_state, TS_TBLOCK); 1177 ttstart(tp); 1178 } 1179 /* Try to block remote output via hardware flow control. */ 1180 if (ISSET(tp->t_cflag, CHWFLOW) && tp->t_hwiflow && 1181 (*tp->t_hwiflow)(tp, 1) != 0) 1182 SET(tp->t_state, TS_TBLOCK); 1183 } 1184 } 1185 1186 void 1187 ttrstrt(void *tp_arg) 1188 { 1189 struct tty *tp; 1190 int s; 1191 1192 #ifdef DIAGNOSTIC 1193 if (tp_arg == NULL) 1194 panic("ttrstrt"); 1195 #endif 1196 tp = tp_arg; 1197 s = spltty(); 1198 1199 CLR(tp->t_state, TS_TIMEOUT); 1200 ttstart(tp); 1201 1202 splx(s); 1203 } 1204 1205 int 1206 ttstart(struct tty *tp) 1207 { 1208 1209 if (tp->t_oproc != NULL) /* XXX: Kludge for pty. */ 1210 (*tp->t_oproc)(tp); 1211 return (0); 1212 } 1213 1214 /* 1215 * "close" a line discipline 1216 */ 1217 int 1218 ttylclose(struct tty *tp, int flag) 1219 { 1220 1221 if (flag & FNONBLOCK) 1222 ttyflush(tp, FREAD | FWRITE); 1223 else 1224 ttywflush(tp); 1225 return (0); 1226 } 1227 1228 /* 1229 * Handle modem control transition on a tty. 1230 * Flag indicates new state of carrier. 1231 * Returns 0 if the line should be turned off, otherwise 1. 1232 */ 1233 int 1234 ttymodem(struct tty *tp, int flag) 1235 { 1236 1237 if (flag == 0) { 1238 if (ISSET(tp->t_state, TS_CARR_ON)) { 1239 /* 1240 * Lost carrier. 1241 */ 1242 CLR(tp->t_state, TS_CARR_ON); 1243 if (ISSET(tp->t_state, TS_ISOPEN) && !CONNECTED(tp)) { 1244 if (tp->t_session && tp->t_session->s_leader) 1245 psignal(tp->t_session->s_leader, 1246 SIGHUP); 1247 ttyflush(tp, FREAD | FWRITE); 1248 return (0); 1249 } 1250 } 1251 } else { 1252 if (!ISSET(tp->t_state, TS_CARR_ON)) { 1253 /* 1254 * Carrier now on. 1255 */ 1256 SET(tp->t_state, TS_CARR_ON); 1257 ttwakeup(tp); 1258 } 1259 } 1260 return (1); 1261 } 1262 1263 /* 1264 * Default modem control routine (for other line disciplines). 1265 * Return argument flag, to turn off device on carrier drop. 1266 */ 1267 int 1268 nullmodem(struct tty *tp, int flag) 1269 { 1270 1271 if (flag) 1272 SET(tp->t_state, TS_CARR_ON); 1273 else { 1274 CLR(tp->t_state, TS_CARR_ON); 1275 if (!CONNECTED(tp)) { 1276 if (tp->t_session && tp->t_session->s_leader) 1277 psignal(tp->t_session->s_leader, SIGHUP); 1278 return (0); 1279 } 1280 } 1281 return (1); 1282 } 1283 1284 /* 1285 * Reinput pending characters after state switch 1286 * call at spltty(). 1287 */ 1288 void 1289 ttypend(struct tty *tp) 1290 { 1291 struct clist tq; 1292 int c; 1293 1294 CLR(tp->t_lflag, PENDIN); 1295 SET(tp->t_state, TS_TYPEN); 1296 tq = tp->t_rawq; 1297 tp->t_rawq.c_cc = 0; 1298 tp->t_rawq.c_cf = tp->t_rawq.c_cl = 0; 1299 while ((c = getc(&tq)) >= 0) 1300 ttyinput(c, tp); 1301 CLR(tp->t_state, TS_TYPEN); 1302 } 1303 1304 /* 1305 * Process a read call on a tty device. 1306 */ 1307 int 1308 ttread(struct tty *tp, struct uio *uio, int flag) 1309 { 1310 struct clist *qp; 1311 u_char *cc; 1312 struct proc *p; 1313 int c, s, first, error, has_stime, last_cc; 1314 long lflag, slp; 1315 struct timeval stime; 1316 1317 cc = tp->t_cc; 1318 p = curproc; 1319 error = 0; 1320 has_stime = 0; 1321 last_cc = 0; 1322 slp = 0; 1323 1324 loop: 1325 lflag = tp->t_lflag; 1326 s = spltty(); 1327 /* 1328 * take pending input first 1329 */ 1330 if (ISSET(lflag, PENDIN)) 1331 ttypend(tp); 1332 splx(s); 1333 1334 /* 1335 * Hang process if it's in the background. 1336 */ 1337 if (isbackground(p, tp)) { 1338 if (sigismember(&p->p_sigctx.ps_sigignore, SIGTTIN) || 1339 sigismember(&p->p_sigctx.ps_sigmask, SIGTTIN) || 1340 p->p_flag & P_PPWAIT || p->p_pgrp->pg_jobc == 0) 1341 return (EIO); 1342 pgsignal(p->p_pgrp, SIGTTIN, 1); 1343 error = ttysleep(tp, &lbolt, TTIPRI | PCATCH, ttybg, 0); 1344 if (error) 1345 return (error); 1346 goto loop; 1347 } 1348 1349 s = spltty(); 1350 if (!ISSET(lflag, ICANON)) { 1351 int m = cc[VMIN]; 1352 long t = cc[VTIME]; 1353 1354 qp = &tp->t_rawq; 1355 /* 1356 * Check each of the four combinations. 1357 * (m > 0 && t == 0) is the normal read case. 1358 * It should be fairly efficient, so we check that and its 1359 * companion case (m == 0 && t == 0) first. 1360 * For the other two cases, we compute the target sleep time 1361 * into slp. 1362 */ 1363 if (t == 0) { 1364 if (qp->c_cc < m) 1365 goto sleep; 1366 goto read; 1367 } 1368 t *= 100000; /* time in us */ 1369 #define diff(t1, t2) (((t1).tv_sec - (t2).tv_sec) * 1000000 + \ 1370 ((t1).tv_usec - (t2).tv_usec)) 1371 if (m > 0) { 1372 if (qp->c_cc <= 0) 1373 goto sleep; 1374 if (qp->c_cc >= m) 1375 goto read; 1376 if (!has_stime) { 1377 /* first character, start timer */ 1378 has_stime = 1; 1379 stime = time; 1380 slp = t; 1381 } else if (qp->c_cc > last_cc) { 1382 /* got a character, restart timer */ 1383 stime = time; 1384 slp = t; 1385 } else { 1386 /* nothing, check expiration */ 1387 slp = t - diff(time, stime); 1388 } 1389 } else { /* m == 0 */ 1390 if (qp->c_cc > 0) 1391 goto read; 1392 if (!has_stime) { 1393 has_stime = 1; 1394 stime = time; 1395 slp = t; 1396 } else 1397 slp = t - diff(time, stime); 1398 } 1399 last_cc = qp->c_cc; 1400 #undef diff 1401 if (slp > 0) { 1402 /* 1403 * Rounding down may make us wake up just short 1404 * of the target, so we round up. 1405 * The formula is ceiling(slp * hz/1000000). 1406 * 32-bit arithmetic is enough for hz < 169. 1407 * 1408 * Also, use plain wakeup() not ttwakeup(). 1409 */ 1410 slp = (long) (((u_long)slp * hz) + 999999) / 1000000; 1411 goto sleep; 1412 } 1413 } else if ((qp = &tp->t_canq)->c_cc <= 0) { 1414 int carrier; 1415 1416 sleep: 1417 /* 1418 * If there is no input, sleep on rawq 1419 * awaiting hardware receipt and notification. 1420 * If we have data, we don't need to check for carrier. 1421 */ 1422 carrier = CONNECTED(tp); 1423 if (!carrier && ISSET(tp->t_state, TS_ISOPEN)) { 1424 splx(s); 1425 return (0); /* EOF */ 1426 } 1427 if (flag & IO_NDELAY) { 1428 splx(s); 1429 return (EWOULDBLOCK); 1430 } 1431 error = ttysleep(tp, &tp->t_rawq, TTIPRI | PCATCH, 1432 carrier ? ttyin : ttopen, slp); 1433 splx(s); 1434 /* VMIN == 0: any quantity read satisfies */ 1435 if (cc[VMIN] == 0 && error == EWOULDBLOCK) 1436 return (0); 1437 if (error && error != EWOULDBLOCK) 1438 return (error); 1439 goto loop; 1440 } 1441 read: 1442 splx(s); 1443 1444 /* 1445 * Input present, check for input mapping and processing. 1446 */ 1447 first = 1; 1448 while ((c = getc(qp)) >= 0) { 1449 /* 1450 * delayed suspend (^Y) 1451 */ 1452 if (CCEQ(cc[VDSUSP], c) && 1453 ISSET(lflag, IEXTEN|ISIG) == (IEXTEN|ISIG)) { 1454 pgsignal(tp->t_pgrp, SIGTSTP, 1); 1455 if (first) { 1456 error = ttysleep(tp, &lbolt, 1457 TTIPRI | PCATCH, ttybg, 0); 1458 if (error) 1459 break; 1460 goto loop; 1461 } 1462 break; 1463 } 1464 /* 1465 * Interpret EOF only in canonical mode. 1466 */ 1467 if (CCEQ(cc[VEOF], c) && ISSET(lflag, ICANON)) 1468 break; 1469 /* 1470 * Give user character. 1471 */ 1472 error = ureadc(c, uio); 1473 if (error) 1474 break; 1475 if (uio->uio_resid == 0) 1476 break; 1477 /* 1478 * In canonical mode check for a "break character" 1479 * marking the end of a "line of input". 1480 */ 1481 if (ISSET(lflag, ICANON) && TTBREAKC(c, lflag)) 1482 break; 1483 first = 0; 1484 } 1485 /* 1486 * Look to unblock output now that (presumably) 1487 * the input queue has gone down. 1488 */ 1489 s = spltty(); 1490 if (ISSET(tp->t_state, TS_TBLOCK) && tp->t_rawq.c_cc < TTYHOG / 5) { 1491 if (ISSET(tp->t_iflag, IXOFF) && 1492 cc[VSTART] != _POSIX_VDISABLE && 1493 putc(cc[VSTART], &tp->t_outq) == 0) { 1494 CLR(tp->t_state, TS_TBLOCK); 1495 ttstart(tp); 1496 } 1497 /* Try to unblock remote output via hardware flow control. */ 1498 if (ISSET(tp->t_cflag, CHWFLOW) && tp->t_hwiflow && 1499 (*tp->t_hwiflow)(tp, 0) != 0) 1500 CLR(tp->t_state, TS_TBLOCK); 1501 } 1502 splx(s); 1503 return (error); 1504 } 1505 1506 /* 1507 * Check the output queue on tp for space for a kernel message (from uprintf 1508 * or tprintf). Allow some space over the normal hiwater mark so we don't 1509 * lose messages due to normal flow control, but don't let the tty run amok. 1510 * Sleeps here are not interruptible, but we return prematurely if new signals 1511 * arrive. 1512 */ 1513 int 1514 ttycheckoutq(struct tty *tp, int wait) 1515 { 1516 int hiwat, s, error; 1517 1518 hiwat = tp->t_hiwat; 1519 s = spltty(); 1520 if (tp->t_outq.c_cc > hiwat + 200) 1521 while (tp->t_outq.c_cc > hiwat) { 1522 ttstart(tp); 1523 if (wait == 0) { 1524 splx(s); 1525 return (0); 1526 } 1527 callout_reset(&tp->t_outq_ch, hz, 1528 (void (*)__P((void *)))wakeup, &tp->t_outq); 1529 SET(tp->t_state, TS_ASLEEP); 1530 error = tsleep(&tp->t_outq, (PZERO - 1) | PCATCH, 1531 "ttckoutq", 0); 1532 if (error == EINTR) 1533 wait = 0; 1534 } 1535 splx(s); 1536 return (1); 1537 } 1538 1539 /* 1540 * Process a write call on a tty device. 1541 */ 1542 int 1543 ttwrite(struct tty *tp, struct uio *uio, int flag) 1544 { 1545 u_char *cp; 1546 struct proc *p; 1547 int cc, ce, i, hiwat, error, s; 1548 size_t cnt; 1549 u_char obuf[OBUFSIZ]; 1550 1551 cp = NULL; 1552 hiwat = tp->t_hiwat; 1553 cnt = uio->uio_resid; 1554 error = 0; 1555 cc = 0; 1556 loop: 1557 s = spltty(); 1558 if (!CONNECTED(tp)) { 1559 if (ISSET(tp->t_state, TS_ISOPEN)) { 1560 splx(s); 1561 return (EIO); 1562 } else if (flag & IO_NDELAY) { 1563 splx(s); 1564 error = EWOULDBLOCK; 1565 goto out; 1566 } else { 1567 /* Sleep awaiting carrier. */ 1568 error = ttysleep(tp, 1569 &tp->t_rawq, TTIPRI | PCATCH, ttopen, 0); 1570 splx(s); 1571 if (error) 1572 goto out; 1573 goto loop; 1574 } 1575 } 1576 splx(s); 1577 /* 1578 * Hang the process if it's in the background. 1579 */ 1580 p = curproc; 1581 if (isbackground(p, tp) && 1582 ISSET(tp->t_lflag, TOSTOP) && (p->p_flag & P_PPWAIT) == 0 && 1583 !sigismember(&p->p_sigctx.ps_sigignore, SIGTTOU) && 1584 !sigismember(&p->p_sigctx.ps_sigmask, SIGTTOU)) { 1585 if (p->p_pgrp->pg_jobc == 0) { 1586 error = EIO; 1587 goto out; 1588 } 1589 pgsignal(p->p_pgrp, SIGTTOU, 1); 1590 error = ttysleep(tp, &lbolt, TTIPRI | PCATCH, ttybg, 0); 1591 if (error) 1592 goto out; 1593 goto loop; 1594 } 1595 /* 1596 * Process the user's data in at most OBUFSIZ chunks. Perform any 1597 * output translation. Keep track of high water mark, sleep on 1598 * overflow awaiting device aid in acquiring new space. 1599 */ 1600 while (uio->uio_resid > 0 || cc > 0) { 1601 if (ISSET(tp->t_lflag, FLUSHO)) { 1602 uio->uio_resid = 0; 1603 return (0); 1604 } 1605 if (tp->t_outq.c_cc > hiwat) 1606 goto ovhiwat; 1607 /* 1608 * Grab a hunk of data from the user, unless we have some 1609 * leftover from last time. 1610 */ 1611 if (cc == 0) { 1612 cc = min(uio->uio_resid, OBUFSIZ); 1613 cp = obuf; 1614 error = uiomove(cp, cc, uio); 1615 if (error) { 1616 cc = 0; 1617 break; 1618 } 1619 } 1620 /* 1621 * If nothing fancy need be done, grab those characters we 1622 * can handle without any of ttyoutput's processing and 1623 * just transfer them to the output q. For those chars 1624 * which require special processing (as indicated by the 1625 * bits in char_type), call ttyoutput. After processing 1626 * a hunk of data, look for FLUSHO so ^O's will take effect 1627 * immediately. 1628 */ 1629 while (cc > 0) { 1630 if (!ISSET(tp->t_oflag, OPOST)) 1631 ce = cc; 1632 else { 1633 ce = cc - scanc((u_int)cc, cp, char_type, 1634 CCLASSMASK); 1635 /* 1636 * If ce is zero, then we're processing 1637 * a special character through ttyoutput. 1638 */ 1639 if (ce == 0) { 1640 tp->t_rocount = 0; 1641 if (ttyoutput(*cp, tp) >= 0) { 1642 /* out of space */ 1643 goto overfull; 1644 } 1645 cp++; 1646 cc--; 1647 if (ISSET(tp->t_lflag, FLUSHO) || 1648 tp->t_outq.c_cc > hiwat) 1649 goto ovhiwat; 1650 continue; 1651 } 1652 } 1653 /* 1654 * A bunch of normal characters have been found. 1655 * Transfer them en masse to the output queue and 1656 * continue processing at the top of the loop. 1657 * If there are any further characters in this 1658 * <= OBUFSIZ chunk, the first should be a character 1659 * requiring special handling by ttyoutput. 1660 */ 1661 tp->t_rocount = 0; 1662 i = b_to_q(cp, ce, &tp->t_outq); 1663 ce -= i; 1664 tp->t_column += ce; 1665 cp += ce, cc -= ce, tk_nout += ce; 1666 tp->t_outcc += ce; 1667 if (i > 0) { 1668 /* out of space */ 1669 goto overfull; 1670 } 1671 if (ISSET(tp->t_lflag, FLUSHO) || 1672 tp->t_outq.c_cc > hiwat) 1673 break; 1674 } 1675 ttstart(tp); 1676 } 1677 out: 1678 /* 1679 * If cc is nonzero, we leave the uio structure inconsistent, as the 1680 * offset and iov pointers have moved forward, but it doesn't matter 1681 * (the call will either return short or restart with a new uio). 1682 */ 1683 uio->uio_resid += cc; 1684 return (error); 1685 1686 overfull: 1687 /* 1688 * Since we are using ring buffers, if we can't insert any more into 1689 * the output queue, we can assume the ring is full and that someone 1690 * forgot to set the high water mark correctly. We set it and then 1691 * proceed as normal. 1692 */ 1693 hiwat = tp->t_outq.c_cc - 1; 1694 1695 ovhiwat: 1696 ttstart(tp); 1697 s = spltty(); 1698 /* 1699 * This can only occur if FLUSHO is set in t_lflag, 1700 * or if ttstart/oproc is synchronous (or very fast). 1701 */ 1702 if (tp->t_outq.c_cc <= hiwat) { 1703 splx(s); 1704 goto loop; 1705 } 1706 if (flag & IO_NDELAY) { 1707 splx(s); 1708 uio->uio_resid += cc; 1709 return (uio->uio_resid == cnt ? EWOULDBLOCK : 0); 1710 } 1711 SET(tp->t_state, TS_ASLEEP); 1712 error = ttysleep(tp, &tp->t_outq, TTOPRI | PCATCH, ttyout, 0); 1713 splx(s); 1714 if (error) 1715 goto out; 1716 goto loop; 1717 } 1718 1719 /* 1720 * Rubout one character from the rawq of tp 1721 * as cleanly as possible. 1722 */ 1723 void 1724 ttyrub(int c, struct tty *tp) 1725 { 1726 u_char *cp; 1727 int savecol, tabc, s; 1728 1729 if (!ISSET(tp->t_lflag, ECHO) || ISSET(tp->t_lflag, EXTPROC)) 1730 return; 1731 CLR(tp->t_lflag, FLUSHO); 1732 if (ISSET(tp->t_lflag, ECHOE)) { 1733 if (tp->t_rocount == 0) { 1734 /* 1735 * Screwed by ttwrite; retype 1736 */ 1737 ttyretype(tp); 1738 return; 1739 } 1740 if (c == ('\t' | TTY_QUOTE) || c == ('\n' | TTY_QUOTE)) 1741 ttyrubo(tp, 2); 1742 else { 1743 CLR(c, ~TTY_CHARMASK); 1744 switch (CCLASS(c)) { 1745 case ORDINARY: 1746 ttyrubo(tp, 1); 1747 break; 1748 case BACKSPACE: 1749 case CONTROL: 1750 case NEWLINE: 1751 case RETURN: 1752 case VTAB: 1753 if (ISSET(tp->t_lflag, ECHOCTL)) 1754 ttyrubo(tp, 2); 1755 break; 1756 case TAB: 1757 if (tp->t_rocount < tp->t_rawq.c_cc) { 1758 ttyretype(tp); 1759 return; 1760 } 1761 s = spltty(); 1762 savecol = tp->t_column; 1763 SET(tp->t_state, TS_CNTTB); 1764 SET(tp->t_lflag, FLUSHO); 1765 tp->t_column = tp->t_rocol; 1766 for (cp = firstc(&tp->t_rawq, &tabc); cp; 1767 cp = nextc(&tp->t_rawq, cp, &tabc)) 1768 ttyecho(tabc, tp); 1769 CLR(tp->t_lflag, FLUSHO); 1770 CLR(tp->t_state, TS_CNTTB); 1771 splx(s); 1772 1773 /* savecol will now be length of the tab. */ 1774 savecol -= tp->t_column; 1775 tp->t_column += savecol; 1776 if (savecol > 8) 1777 savecol = 8; /* overflow screw */ 1778 while (--savecol >= 0) 1779 (void)ttyoutput('\b', tp); 1780 break; 1781 default: /* XXX */ 1782 #define PANICSTR "ttyrub: would panic c = %d, val = %d\n" 1783 (void)printf(PANICSTR, c, CCLASS(c)); 1784 #ifdef notdef 1785 panic(PANICSTR, c, CCLASS(c)); 1786 #endif 1787 } 1788 } 1789 } else if (ISSET(tp->t_lflag, ECHOPRT)) { 1790 if (!ISSET(tp->t_state, TS_ERASE)) { 1791 SET(tp->t_state, TS_ERASE); 1792 (void)ttyoutput('\\', tp); 1793 } 1794 ttyecho(c, tp); 1795 } else 1796 ttyecho(tp->t_cc[VERASE], tp); 1797 --tp->t_rocount; 1798 } 1799 1800 /* 1801 * Back over cnt characters, erasing them. 1802 */ 1803 static void 1804 ttyrubo(struct tty *tp, int cnt) 1805 { 1806 1807 while (cnt-- > 0) { 1808 (void)ttyoutput('\b', tp); 1809 (void)ttyoutput(' ', tp); 1810 (void)ttyoutput('\b', tp); 1811 } 1812 } 1813 1814 /* 1815 * ttyretype -- 1816 * Reprint the rawq line. Note, it is assumed that c_cc has already 1817 * been checked. 1818 */ 1819 void 1820 ttyretype(struct tty *tp) 1821 { 1822 u_char *cp; 1823 int s, c; 1824 1825 /* Echo the reprint character. */ 1826 if (tp->t_cc[VREPRINT] != _POSIX_VDISABLE) 1827 ttyecho(tp->t_cc[VREPRINT], tp); 1828 1829 (void)ttyoutput('\n', tp); 1830 1831 s = spltty(); 1832 for (cp = firstc(&tp->t_canq, &c); cp; cp = nextc(&tp->t_canq, cp, &c)) 1833 ttyecho(c, tp); 1834 for (cp = firstc(&tp->t_rawq, &c); cp; cp = nextc(&tp->t_rawq, cp, &c)) 1835 ttyecho(c, tp); 1836 CLR(tp->t_state, TS_ERASE); 1837 splx(s); 1838 1839 tp->t_rocount = tp->t_rawq.c_cc; 1840 tp->t_rocol = 0; 1841 } 1842 1843 /* 1844 * Echo a typed character to the terminal. 1845 */ 1846 static void 1847 ttyecho(int c, struct tty *tp) 1848 { 1849 1850 if (!ISSET(tp->t_state, TS_CNTTB)) 1851 CLR(tp->t_lflag, FLUSHO); 1852 if ((!ISSET(tp->t_lflag, ECHO) && 1853 (!ISSET(tp->t_lflag, ECHONL) || c != '\n')) || 1854 ISSET(tp->t_lflag, EXTPROC)) 1855 return; 1856 if (((ISSET(tp->t_lflag, ECHOCTL) && 1857 (ISSET(c, TTY_CHARMASK) <= 037 && c != '\t' && c != '\n')) || 1858 ISSET(c, TTY_CHARMASK) == 0177)) { 1859 (void)ttyoutput('^', tp); 1860 CLR(c, ~TTY_CHARMASK); 1861 if (c == 0177) 1862 c = '?'; 1863 else 1864 c += 'A' - 1; 1865 } 1866 (void)ttyoutput(c, tp); 1867 } 1868 1869 /* 1870 * Wake up any readers on a tty. 1871 */ 1872 void 1873 ttwakeup(struct tty *tp) 1874 { 1875 1876 selwakeup(&tp->t_rsel); 1877 if (ISSET(tp->t_state, TS_ASYNC)) 1878 pgsignal(tp->t_pgrp, SIGIO, 1); 1879 wakeup((caddr_t)&tp->t_rawq); 1880 } 1881 1882 /* 1883 * Look up a code for a specified speed in a conversion table; 1884 * used by drivers to map software speed values to hardware parameters. 1885 */ 1886 int 1887 ttspeedtab(int speed, struct speedtab *table) 1888 { 1889 1890 for (; table->sp_speed != -1; table++) 1891 if (table->sp_speed == speed) 1892 return (table->sp_code); 1893 return (-1); 1894 } 1895 1896 /* 1897 * Set tty hi and low water marks. 1898 * 1899 * Try to arrange the dynamics so there's about one second 1900 * from hi to low water. 1901 */ 1902 void 1903 ttsetwater(struct tty *tp) 1904 { 1905 int cps, x; 1906 1907 #define CLAMP(x, h, l) ((x) > h ? h : ((x) < l) ? l : (x)) 1908 1909 cps = tp->t_ospeed / 10; 1910 tp->t_lowat = x = CLAMP(cps / 2, TTMAXLOWAT, TTMINLOWAT); 1911 x += cps; 1912 x = CLAMP(x, TTMAXHIWAT, TTMINHIWAT); 1913 tp->t_hiwat = roundup(x, CBSIZE); 1914 #undef CLAMP 1915 } 1916 1917 /* 1918 * Report on state of foreground process group. 1919 */ 1920 void 1921 ttyinfo(struct tty *tp) 1922 { 1923 struct proc *p, *pick; 1924 struct timeval utime, stime; 1925 int tmp; 1926 1927 if (ttycheckoutq(tp, 0) == 0) 1928 return; 1929 1930 /* Print load average. */ 1931 tmp = (averunnable.ldavg[0] * 100 + FSCALE / 2) >> FSHIFT; 1932 ttyprintf(tp, "load: %d.%02d ", tmp / 100, tmp % 100); 1933 1934 if (tp->t_session == NULL) 1935 ttyprintf(tp, "not a controlling terminal\n"); 1936 else if (tp->t_pgrp == NULL) 1937 ttyprintf(tp, "no foreground process group\n"); 1938 else if ((p = LIST_FIRST(&tp->t_pgrp->pg_members)) == 0) 1939 ttyprintf(tp, "empty foreground process group\n"); 1940 else { 1941 /* Pick interesting process. */ 1942 for (pick = NULL; p != NULL; p = LIST_NEXT(p, p_pglist)) 1943 if (proc_compare(pick, p)) 1944 pick = p; 1945 1946 ttyprintf(tp, " cmd: %s %d [%s] ", pick->p_comm, pick->p_pid, 1947 pick->p_stat == SONPROC ? "running" : 1948 pick->p_stat == SRUN ? "runnable" : 1949 pick->p_wmesg ? pick->p_wmesg : "iowait"); 1950 1951 calcru(pick, &utime, &stime, NULL); 1952 1953 /* Round up and print user time. */ 1954 utime.tv_usec += 5000; 1955 if (utime.tv_usec >= 1000000) { 1956 utime.tv_sec += 1; 1957 utime.tv_usec -= 1000000; 1958 } 1959 ttyprintf(tp, "%ld.%02ldu ", (long int)utime.tv_sec, 1960 (long int)utime.tv_usec / 10000); 1961 1962 /* Round up and print system time. */ 1963 stime.tv_usec += 5000; 1964 if (stime.tv_usec >= 1000000) { 1965 stime.tv_sec += 1; 1966 stime.tv_usec -= 1000000; 1967 } 1968 ttyprintf(tp, "%ld.%02lds ", (long int)stime.tv_sec, 1969 (long int)stime.tv_usec / 10000); 1970 1971 #define pgtok(a) (((u_long) ((a) * PAGE_SIZE) / 1024)) 1972 /* Print percentage cpu. */ 1973 tmp = (pick->p_pctcpu * 10000 + FSCALE / 2) >> FSHIFT; 1974 ttyprintf(tp, "%d%% ", tmp / 100); 1975 1976 /* Print resident set size. */ 1977 if (pick->p_stat == SIDL || P_ZOMBIE(pick)) 1978 tmp = 0; 1979 else { 1980 struct vmspace *vm = pick->p_vmspace; 1981 tmp = pgtok(vm_resident_count(vm)); 1982 } 1983 ttyprintf(tp, "%dk\n", tmp); 1984 } 1985 tp->t_rocount = 0; /* so pending input will be retyped if BS */ 1986 } 1987 1988 /* 1989 * Returns 1 if p2 is "better" than p1 1990 * 1991 * The algorithm for picking the "interesting" process is thus: 1992 * 1993 * 1) Only foreground processes are eligible - implied. 1994 * 2) Runnable processes are favored over anything else. The runner 1995 * with the highest cpu utilization is picked (p_estcpu). Ties are 1996 * broken by picking the highest pid. 1997 * 3) The sleeper with the shortest sleep time is next. With ties, 1998 * we pick out just "short-term" sleepers (P_SINTR == 0). 1999 * 4) Further ties are broken by picking the highest pid. 2000 */ 2001 #define ISRUN(p) (((p)->p_stat == SRUN) || ((p)->p_stat == SIDL) || \ 2002 ((p)->p_stat == SONPROC)) 2003 #define TESTAB(a, b) ((a)<<1 | (b)) 2004 #define ONLYA 2 2005 #define ONLYB 1 2006 #define BOTH 3 2007 2008 static int 2009 proc_compare(struct proc *p1, struct proc *p2) 2010 { 2011 2012 if (p1 == NULL) 2013 return (1); 2014 /* 2015 * see if at least one of them is runnable 2016 */ 2017 switch (TESTAB(ISRUN(p1), ISRUN(p2))) { 2018 case ONLYA: 2019 return (0); 2020 case ONLYB: 2021 return (1); 2022 case BOTH: 2023 /* 2024 * tie - favor one with highest recent cpu utilization 2025 */ 2026 if (p2->p_estcpu > p1->p_estcpu) 2027 return (1); 2028 if (p1->p_estcpu > p2->p_estcpu) 2029 return (0); 2030 return (p2->p_pid > p1->p_pid); /* tie - return highest pid */ 2031 } 2032 /* 2033 * weed out zombies 2034 */ 2035 switch (TESTAB(P_ZOMBIE(p1), P_ZOMBIE(p2))) { 2036 case ONLYA: 2037 return (1); 2038 case ONLYB: 2039 return (0); 2040 case BOTH: 2041 return (p2->p_pid > p1->p_pid); /* tie - return highest pid */ 2042 } 2043 /* 2044 * pick the one with the smallest sleep time 2045 */ 2046 if (p2->p_slptime > p1->p_slptime) 2047 return (0); 2048 if (p1->p_slptime > p2->p_slptime) 2049 return (1); 2050 /* 2051 * favor one sleeping in a non-interruptible sleep 2052 */ 2053 if (p1->p_flag & P_SINTR && (p2->p_flag & P_SINTR) == 0) 2054 return (1); 2055 if (p2->p_flag & P_SINTR && (p1->p_flag & P_SINTR) == 0) 2056 return (0); 2057 return (p2->p_pid > p1->p_pid); /* tie - return highest pid */ 2058 } 2059 2060 /* 2061 * Output char to tty; console putchar style. 2062 */ 2063 int 2064 tputchar(int c, struct tty *tp) 2065 { 2066 int s; 2067 2068 s = spltty(); 2069 if (ISSET(tp->t_state, 2070 TS_CARR_ON | TS_ISOPEN) != (TS_CARR_ON | TS_ISOPEN)) { 2071 splx(s); 2072 return (-1); 2073 } 2074 if (c == '\n') 2075 (void)ttyoutput('\r', tp); 2076 (void)ttyoutput(c, tp); 2077 ttstart(tp); 2078 splx(s); 2079 return (0); 2080 } 2081 2082 /* 2083 * Sleep on chan, returning ERESTART if tty changed while we napped and 2084 * returning any errors (e.g. EINTR/ETIMEDOUT) reported by tsleep. If 2085 * the tty is revoked, restarting a pending call will redo validation done 2086 * at the start of the call. 2087 */ 2088 int 2089 ttysleep(struct tty *tp, void *chan, int pri, const char *wmesg, int timo) 2090 { 2091 int error; 2092 short gen; 2093 2094 gen = tp->t_gen; 2095 if ((error = tsleep(chan, pri, wmesg, timo)) != 0) 2096 return (error); 2097 return (tp->t_gen == gen ? 0 : ERESTART); 2098 } 2099 2100 /* 2101 * Initialise the global tty list. 2102 */ 2103 void 2104 tty_init(void) 2105 { 2106 2107 ttyldisc_init(); 2108 2109 TAILQ_INIT(&ttylist); 2110 tty_count = 0; 2111 2112 pool_init(&tty_pool, sizeof(struct tty), 0, 0, 0, "ttypl", 2113 &pool_allocator_nointr); 2114 } 2115 2116 /* 2117 * Attach a tty to the tty list. 2118 * 2119 * This should be called ONLY once per real tty (including pty's). 2120 * eg, on the sparc, the keyboard and mouse have struct tty's that are 2121 * distinctly NOT usable as tty's, and thus should not be attached to 2122 * the ttylist. This is why this call is not done from ttymalloc(). 2123 * 2124 * Device drivers should attach tty's at a similar time that they are 2125 * ttymalloc()'ed, or, for the case of statically allocated struct tty's 2126 * either in the attach or (first) open routine. 2127 */ 2128 void 2129 tty_attach(struct tty *tp) 2130 { 2131 2132 TAILQ_INSERT_TAIL(&ttylist, tp, tty_link); 2133 ++tty_count; 2134 } 2135 2136 /* 2137 * Remove a tty from the tty list. 2138 */ 2139 void 2140 tty_detach(struct tty *tp) 2141 { 2142 2143 --tty_count; 2144 #ifdef DIAGNOSTIC 2145 if (tty_count < 0) 2146 panic("tty_detach: tty_count < 0"); 2147 #endif 2148 TAILQ_REMOVE(&ttylist, tp, tty_link); 2149 } 2150 2151 /* 2152 * Allocate a tty structure and its associated buffers. 2153 */ 2154 struct tty * 2155 ttymalloc(void) 2156 { 2157 struct tty *tp; 2158 2159 tp = pool_get(&tty_pool, PR_WAITOK); 2160 memset(tp, 0, sizeof(*tp)); 2161 callout_init(&tp->t_outq_ch); 2162 callout_init(&tp->t_rstrt_ch); 2163 /* XXX: default to 1024 chars for now */ 2164 clalloc(&tp->t_rawq, 1024, 1); 2165 clalloc(&tp->t_canq, 1024, 1); 2166 /* output queue doesn't need quoting */ 2167 clalloc(&tp->t_outq, 1024, 0); 2168 /* Set default line discipline. */ 2169 tp->t_linesw = linesw[0]; 2170 return (tp); 2171 } 2172 2173 /* 2174 * Free a tty structure and its buffers. 2175 * 2176 * Be sure to call tty_detach() for any tty that has been 2177 * tty_attach()ed. 2178 */ 2179 void 2180 ttyfree(struct tty *tp) 2181 { 2182 2183 callout_stop(&tp->t_outq_ch); 2184 callout_stop(&tp->t_rstrt_ch); 2185 clfree(&tp->t_rawq); 2186 clfree(&tp->t_canq); 2187 clfree(&tp->t_outq); 2188 pool_put(&tty_pool, tp); 2189 } 2190
Indexes created Tue Sep 23 13:09:54 GMT 2025