1 /* 2 * Copyright (c) 2011 Bayard G. Bell. All rights reserved. 3 * Copyright 2008 Sun Microsystems, Inc. All rights reserved. 4 * Use is subject to license terms. 5 */ 6 7 /* 8 * Copyright (c) 1983 Regents of the University of California. 9 * All rights reserved. The Berkeley software License Agreement 10 * specifies the terms and conditions for redistribution. 11 */ 12 13 /* 14 * PTY - Stream "pseudo-tty" device. 15 * This is the "slave" side. 16 */ 17 18 19 #include <sys/param.h> 20 #include <sys/systm.h> 21 #include <sys/filio.h> 22 #include <sys/ioccom.h> 23 #include <sys/termios.h> 24 #include <sys/termio.h> 25 #include <sys/ttold.h> 26 #include <sys/stropts.h> 27 #include <sys/stream.h> 28 #include <sys/strsun.h> 29 #include <sys/tty.h> 30 #include <sys/user.h> 31 #include <sys/conf.h> 32 #include <sys/file.h> 33 #include <sys/vnode.h> /* 1/0 on the vomit meter */ 34 #include <sys/proc.h> 35 #include <sys/uio.h> 36 #include <sys/errno.h> 37 #include <sys/strsubr.h> 38 #include <sys/poll.h> 39 #include <sys/sysmacros.h> 40 #include <sys/debug.h> 41 #include <sys/procset.h> 42 #include <sys/cred.h> 43 #include <sys/ptyvar.h> 44 #include <sys/suntty.h> 45 #include <sys/stat.h> 46 #include <sys/policy.h> 47 48 #include <sys/conf.h> 49 #include <sys/ddi.h> 50 #include <sys/sunddi.h> 51 52 extern void gsignal(int pid, int sig); 53 54 extern int npty; /* number of pseudo-ttys configured in */ 55 extern struct pty *pty_softc; 56 57 extern struct pollhead ptcph; /* poll head for ptcpoll() use */ 58 59 #define IFLAGS (CS7|CREAD|PARENB) 60 61 62 /* 63 * Most of these should be "void", but the people who defined the "streams" 64 * data structure for S5 didn't understand data types. 65 */ 66 67 /* 68 * Slave side. This is a streams device. 69 */ 70 static int ptslopen(queue_t *, dev_t *, int flag, int, cred_t *); 71 static int ptslclose(queue_t *, int, cred_t *); 72 static int ptslrserv(queue_t *); 73 74 /* 75 * To save instructions, since STREAMS ignores the return value 76 * from this function, it is defined as void here. Kind of icky, but... 77 */ 78 79 static void ptslwput(queue_t *q, mblk_t *mp); 80 81 static struct module_info ptslm_info = { 82 0, 83 "ptys", 84 0, 85 INFPSZ, 86 2048, 87 200 88 }; 89 90 static struct qinit ptslrinit = { 91 putq, 92 ptslrserv, 93 ptslopen, 94 ptslclose, 95 NULL, 96 &ptslm_info, 97 NULL 98 }; 99 100 static struct qinit ptslwinit = { 101 (int (*)())ptslwput, 102 NULL, 103 NULL, 104 NULL, 105 NULL, 106 &ptslm_info, 107 NULL 108 }; 109 110 struct streamtab ptysinfo = { 111 &ptslrinit, 112 &ptslwinit, 113 NULL, 114 NULL 115 }; 116 117 static void ptslreioctl(void *); 118 static void ptslioctl(struct pty *, queue_t *, mblk_t *); 119 static void pt_sendstop(struct pty *); 120 static void ptcpollwakeup(struct pty *, int); 121 122 123 static int ptsl_info(dev_info_t *, ddi_info_cmd_t, void *, void **); 124 static int ptsl_attach(dev_info_t *, ddi_attach_cmd_t); 125 static dev_info_t *ptsl_dip; /* for dev-to-dip conversions */ 126 127 DDI_DEFINE_STREAM_OPS(ptsl_ops, nulldev, nulldev, 128 ptsl_attach, nodev, nodev, ptsl_info, D_MP, &ptysinfo, 129 ddi_quiesce_not_supported); 130 131 #include <sys/types.h> 132 #include <sys/conf.h> 133 #include <sys/param.h> 134 #include <sys/systm.h> 135 #include <sys/errno.h> 136 #include <sys/modctl.h> 137 138 /* 139 * Module linkage information for the kernel. 140 */ 141 142 static struct modldrv modldrv = { 143 &mod_driverops, /* Type of module. This one is a pseudo driver */ 144 "tty pseudo driver slave 'ptsl'", 145 &ptsl_ops, /* driver ops */ 146 }; 147 148 static struct modlinkage modlinkage = { 149 MODREV_1, 150 &modldrv, 151 NULL 152 }; 153 154 int 155 _init(void) 156 { 157 return (mod_install(&modlinkage)); 158 } 159 160 int 161 _fini(void) 162 { 163 return (mod_remove(&modlinkage)); 164 } 165 166 int 167 _info(struct modinfo *modinfop) 168 { 169 return (mod_info(&modlinkage, modinfop)); 170 } 171 172 static char *tty_banks = PTY_BANKS; 173 static char *tty_digits = PTY_DIGITS; 174 175 /* ARGSUSED */ 176 static int 177 ptsl_attach(dev_info_t *devi, ddi_attach_cmd_t cmd) 178 { 179 char name[8]; 180 int tty_num; 181 char *tty_digit = tty_digits; 182 char *tty_bank = tty_banks; 183 184 for (tty_num = 0; tty_num < npty; tty_num++) { 185 (void) sprintf(name, "tty%c%c", *tty_bank, *tty_digit); 186 if (ddi_create_minor_node(devi, name, S_IFCHR, 187 tty_num, DDI_PSEUDO, NULL) == DDI_FAILURE) { 188 ddi_remove_minor_node(devi, NULL); 189 return (-1); 190 } 191 if (*(++tty_digit) == '\0') { 192 tty_digit = tty_digits; 193 if (*(++tty_bank) == '\0') 194 break; 195 } 196 } 197 ptsl_dip = devi; 198 return (DDI_SUCCESS); 199 } 200 201 /* ARGSUSED */ 202 static int 203 ptsl_info(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, 204 void **result) 205 { 206 int error; 207 208 switch (infocmd) { 209 case DDI_INFO_DEVT2DEVINFO: 210 if (ptsl_dip == NULL) { 211 error = DDI_FAILURE; 212 } else { 213 *result = (void *)ptsl_dip; 214 error = DDI_SUCCESS; 215 } 216 break; 217 case DDI_INFO_DEVT2INSTANCE: 218 *result = (void *)0; 219 error = DDI_SUCCESS; 220 break; 221 default: 222 error = DDI_FAILURE; 223 } 224 return (error); 225 } 226 227 228 /* 229 * Open the slave side of a pty. 230 */ 231 /*ARGSUSED*/ 232 static int 233 ptslopen(queue_t *q, dev_t *devp, int flag, int sflag, cred_t *cred) 234 { 235 minor_t unit; 236 dev_t dev = *devp; 237 struct pty *pty; 238 239 unit = getminor(dev); 240 if (unit >= npty) 241 return (ENXIO); 242 243 pty = &pty_softc[unit]; 244 245 mutex_enter(&pty->ptc_lock); 246 /* 247 * Block waiting for controller to open, unless this is a no-delay 248 * open. 249 */ 250 again: 251 if (pty->pt_ttycommon.t_writeq == NULL) { 252 pty->pt_ttycommon.t_iflag = 0; 253 pty->pt_ttycommon.t_cflag = (B38400 << IBSHIFT)|B38400|IFLAGS; 254 pty->pt_ttycommon.t_iocpending = NULL; 255 pty->pt_wbufcid = 0; 256 pty->pt_ttycommon.t_size.ws_row = 0; 257 pty->pt_ttycommon.t_size.ws_col = 0; 258 pty->pt_ttycommon.t_size.ws_xpixel = 0; 259 pty->pt_ttycommon.t_size.ws_ypixel = 0; 260 } else if ((pty->pt_ttycommon.t_flags & TS_XCLUDE) && 261 secpolicy_excl_open(cred) != 0) { 262 mutex_exit(&pty->ptc_lock); 263 return (EBUSY); 264 } 265 if (!(flag & (FNONBLOCK|FNDELAY)) && 266 !(pty->pt_ttycommon.t_cflag & CLOCAL)) { 267 if (!(pty->pt_flags & PF_CARR_ON)) { 268 pty->pt_flags |= PF_WOPEN; 269 if (!cv_wait_sig(&pty->pt_cv_flags, &pty->ptc_lock)) { 270 pty->pt_flags &= ~PF_WOPEN; 271 mutex_exit(&pty->ptc_lock); 272 return (EINTR); 273 } 274 goto again; 275 } 276 } 277 278 pty->pt_sdev = dev; 279 q->q_ptr = WR(q)->q_ptr = pty; 280 pty->pt_flags &= ~PF_SLAVEGONE; 281 pty->pt_ttycommon.t_readq = pty->pt_ttycommon.t_writeq = NULL; 282 283 /* 284 * Slave is ready to accept messages but master still can't send 285 * messages to the slave queue since it is not plumbed 286 * yet. So do qprocson() and finish slave initialization. 287 */ 288 289 mutex_exit(&pty->ptc_lock); 290 291 qprocson(q); 292 293 /* 294 * Now it is safe to send messages to q, so wakeup master possibly 295 * waiting for slave queue to finish open. 296 */ 297 mutex_enter(&pty->ptc_lock); 298 /* 299 * queue has already been setup with a pointer to 300 * the stream head that is being referenced 301 */ 302 pty->pt_vnode = strq2vp(q); 303 VN_RELE(pty->pt_vnode); 304 pty->pt_ttycommon.t_readq = q; 305 pty->pt_ttycommon.t_writeq = WR(q); 306 /* tell master device that slave is ready for writing */ 307 if (pty->pt_flags & PF_CARR_ON) 308 cv_broadcast(&pty->pt_cv_readq); 309 mutex_exit(&pty->ptc_lock); 310 311 return (0); 312 } 313 314 static int 315 ptslclose(queue_t *q, int flag, cred_t *cred) 316 { 317 struct pty *pty; 318 bufcall_id_t pt_wbufcid = 0; 319 320 #ifdef lint 321 flag = flag; 322 cred = cred; 323 #endif 324 325 if ((pty = (struct pty *)q->q_ptr) == NULL) 326 return (ENODEV); /* already been closed once */ 327 328 /* 329 * Prevent the queues from being uses by master device. 330 * This should be done before qprocsoff or writer may attempt 331 * to use the slave queue after qprocsoff removed it from the stream and 332 * before entering mutex_enter(). 333 */ 334 mutex_enter(&pty->ptc_lock); 335 pty->pt_ttycommon.t_readq = NULL; 336 pty->pt_ttycommon.t_writeq = NULL; 337 while (pty->pt_flags & PF_IOCTL) { 338 pty->pt_flags |= PF_WAIT; 339 cv_wait(&pty->pt_cv_flags, &pty->ptc_lock); 340 } 341 pty->pt_vnode = NULL; 342 mutex_exit(&pty->ptc_lock); 343 344 qprocsoff(q); 345 346 mutex_enter(&pty->ptc_lock); 347 /* 348 * ptc_lock mutex is not dropped across 349 * the call to the routine ttycommon_close 350 */ 351 ttycommon_close(&pty->pt_ttycommon); 352 353 /* 354 * Cancel outstanding "bufcall" request. 355 */ 356 if (pty->pt_wbufcid) { 357 pt_wbufcid = pty->pt_wbufcid; 358 pty->pt_wbufcid = 0; 359 } 360 361 /* 362 * Clear out all the slave-side state. 363 */ 364 pty->pt_flags &= ~(PF_WOPEN|PF_STOPPED|PF_NOSTOP); 365 if (pty->pt_flags & PF_CARR_ON) { 366 pty->pt_flags |= PF_SLAVEGONE; /* let the controller know */ 367 ptcpollwakeup(pty, 0); /* wake up readers/selectors */ 368 ptcpollwakeup(pty, FWRITE); /* wake up writers/selectors */ 369 cv_broadcast(&pty->pt_cv_flags); 370 } 371 pty->pt_sdev = 0; 372 q->q_ptr = WR(q)->q_ptr = NULL; 373 mutex_exit(&pty->ptc_lock); 374 375 if (pt_wbufcid) 376 unbufcall(pt_wbufcid); 377 378 return (0); 379 } 380 381 /* 382 * Put procedure for write queue. 383 * Respond to M_STOP, M_START, M_IOCTL, and M_FLUSH messages here; 384 * queue up M_DATA messages for processing by the controller "read" 385 * routine; discard everything else. 386 */ 387 static void 388 ptslwput(queue_t *q, mblk_t *mp) 389 { 390 struct pty *pty; 391 mblk_t *bp; 392 393 pty = (struct pty *)q->q_ptr; 394 395 mutex_enter(&pty->ptc_lock); 396 397 switch (mp->b_datap->db_type) { 398 399 case M_STOP: 400 if (!(pty->pt_flags & PF_STOPPED)) { 401 pty->pt_flags |= PF_STOPPED; 402 pty->pt_send |= TIOCPKT_STOP; 403 ptcpollwakeup(pty, 0); 404 } 405 freemsg(mp); 406 break; 407 408 case M_START: 409 if (pty->pt_flags & PF_STOPPED) { 410 pty->pt_flags &= ~PF_STOPPED; 411 pty->pt_send = TIOCPKT_START; 412 ptcpollwakeup(pty, 0); 413 } 414 ptcpollwakeup(pty, FREAD); /* permit controller to read */ 415 freemsg(mp); 416 break; 417 418 case M_IOCTL: 419 ptslioctl(pty, q, mp); 420 break; 421 422 case M_FLUSH: 423 if (*mp->b_rptr & FLUSHW) { 424 /* 425 * Set the "flush write" flag, so that we 426 * notify the controller if they're in packet 427 * or user control mode. 428 */ 429 if (!(pty->pt_send & TIOCPKT_FLUSHWRITE)) { 430 pty->pt_send |= TIOCPKT_FLUSHWRITE; 431 ptcpollwakeup(pty, 0); 432 } 433 /* 434 * Flush our write queue. 435 */ 436 flushq(q, FLUSHDATA); /* XXX doesn't flush M_DELAY */ 437 *mp->b_rptr &= ~FLUSHW; /* it has been flushed */ 438 } 439 if (*mp->b_rptr & FLUSHR) { 440 /* 441 * Set the "flush read" flag, so that we 442 * notify the controller if they're in packet 443 * mode. 444 */ 445 if (!(pty->pt_send & TIOCPKT_FLUSHREAD)) { 446 pty->pt_send |= TIOCPKT_FLUSHREAD; 447 ptcpollwakeup(pty, 0); 448 } 449 flushq(RD(q), FLUSHDATA); 450 mutex_exit(&pty->ptc_lock); 451 qreply(q, mp); /* give the read queues a crack at it */ 452 return; 453 } else 454 freemsg(mp); 455 break; 456 457 case M_DATA: 458 /* 459 * Throw away any leading zero-length blocks, and queue it up 460 * for the controller to read. 461 */ 462 if (pty->pt_flags & PF_CARR_ON) { 463 bp = mp; 464 while ((bp->b_wptr - bp->b_rptr) == 0) { 465 mp = bp->b_cont; 466 freeb(bp); 467 if (mp == NULL) { 468 mutex_exit(&pty->ptc_lock); 469 return; /* damp squib of a message */ 470 } 471 bp = mp; 472 } 473 (void) putq(q, mp); 474 ptcpollwakeup(pty, FREAD); /* soup's on! */ 475 } else 476 freemsg(mp); /* nobody listening */ 477 break; 478 479 case M_CTL: 480 if ((*(int *)mp->b_rptr) == MC_CANONQUERY) { 481 /* 482 * We're being asked whether we do canonicalization 483 * or not. Send a reply back up indicating whether 484 * we do or not. 485 */ 486 (void) putctl1(RD(q), M_CTL, 487 (pty->pt_flags & PF_REMOTE) ? 488 MC_NOCANON : MC_DOCANON); 489 } 490 freemsg(mp); 491 break; 492 493 default: 494 /* 495 * "No, I don't want a subscription to Chain Store Age, 496 * thank you anyway." 497 */ 498 freemsg(mp); 499 break; 500 } 501 mutex_exit(&pty->ptc_lock); 502 } 503 504 /* 505 * Retry an "ioctl", now that "bufcall" claims we may be able to allocate 506 * the buffer we need. 507 */ 508 static void 509 ptslreioctl(void *arg) 510 { 511 struct pty *pty = arg; 512 queue_t *q; 513 mblk_t *mp; 514 515 mutex_enter(&pty->ptc_lock); 516 /* 517 * The bufcall is no longer pending. 518 */ 519 if (pty->pt_wbufcid == 0) { 520 mutex_exit(&pty->ptc_lock); 521 return; 522 } 523 524 pty->pt_wbufcid = 0; 525 if ((q = pty->pt_ttycommon.t_writeq) == NULL) { 526 mutex_exit(&pty->ptc_lock); 527 return; 528 } 529 if ((mp = pty->pt_ttycommon.t_iocpending) != NULL) { 530 /* It's not pending any more. */ 531 pty->pt_ttycommon.t_iocpending = NULL; 532 ptslioctl(pty, q, mp); 533 } 534 mutex_exit(&pty->ptc_lock); 535 } 536 537 /* 538 * Process an "ioctl" message sent down to us. 539 * Drops pty's ptc_lock mutex and then reacquire 540 */ 541 static void 542 ptslioctl(struct pty *pty, queue_t *q, mblk_t *mp) 543 { 544 struct iocblk *iocp; 545 int cmd; 546 size_t datasize; 547 int error = 0; 548 549 ASSERT(MUTEX_HELD(&pty->ptc_lock)); 550 551 iocp = (struct iocblk *)mp->b_rptr; 552 cmd = iocp->ioc_cmd; 553 554 switch (cmd) { 555 556 case TIOCSTI: { 557 /* 558 * The permission checking has already been done at the stream 559 * head, since it has to be done in the context of the process 560 * doing the call. 561 */ 562 mblk_t *bp; 563 564 error = miocpullup(mp, sizeof (char)); 565 if (error != 0) 566 goto out; 567 568 /* 569 * Simulate typing of a character at the terminal. 570 */ 571 if ((bp = allocb(1, BPRI_MED)) != NULL) { 572 *bp->b_wptr++ = *mp->b_cont->b_rptr; 573 if (!(pty->pt_flags & PF_REMOTE)) { 574 if (!canput(pty->pt_ttycommon.t_readq)) { 575 mutex_exit(&pty->ptc_lock); 576 ttycommon_qfull(&pty->pt_ttycommon, q); 577 mutex_enter(&pty->ptc_lock); 578 freemsg(bp); 579 error = EAGAIN; 580 goto out; 581 } else 582 (void) putq( 583 pty->pt_ttycommon.t_readq, bp); 584 } else { 585 if (pty->pt_flags & PF_UCNTL) { 586 /* 587 * XXX - flow control; don't overflow 588 * this "queue". 589 */ 590 if (pty->pt_stuffqfirst != NULL) { 591 pty->pt_stuffqlast->b_next = bp; 592 bp->b_prev = pty->pt_stuffqlast; 593 } else { 594 pty->pt_stuffqfirst = bp; 595 bp->b_prev = NULL; 596 } 597 bp->b_next = NULL; 598 pty->pt_stuffqlast = bp; 599 pty->pt_stuffqlen++; 600 ptcpollwakeup(pty, 0); 601 } 602 } 603 } else { 604 error = EAGAIN; 605 goto out; 606 } 607 608 /* 609 * Turn the ioctl message into an ioctl ACK message. 610 */ 611 iocp->ioc_count = 0; /* no data returned */ 612 mp->b_datap->db_type = M_IOCACK; 613 goto out; 614 } 615 616 case TIOCSSIZE: { 617 tty_common_t *tc = &pty->pt_ttycommon; 618 struct ttysize *tp; 619 620 error = miocpullup(mp, sizeof (struct ttysize)); 621 if (error != 0) 622 goto out; 623 624 /* 625 * Set the window size, but don't send a SIGWINCH. 626 */ 627 tp = (struct ttysize *)mp->b_cont->b_rptr; 628 tc->t_size.ws_row = tp->ts_lines; 629 tc->t_size.ws_col = tp->ts_cols; 630 tc->t_size.ws_xpixel = 0; 631 tc->t_size.ws_ypixel = 0; 632 633 /* 634 * Send an ACK back. 635 */ 636 iocp->ioc_count = 0; /* no data returned */ 637 mp->b_datap->db_type = M_IOCACK; 638 goto out; 639 } 640 641 case TIOCGSIZE: { 642 tty_common_t *tc = &pty->pt_ttycommon; 643 mblk_t *datap; 644 struct ttysize *tp; 645 646 if ((datap = allocb(sizeof (struct ttysize), 647 BPRI_HI)) == NULL) { 648 if (pty->pt_wbufcid) { 649 if (pty->pt_ttycommon.t_iocpending) 650 freemsg(pty->pt_ttycommon.t_iocpending); 651 pty->pt_ttycommon.t_iocpending = mp; 652 return; 653 } 654 pty->pt_wbufcid = bufcall(sizeof (struct ttysize), 655 BPRI_HI, ptslreioctl, pty); 656 if (pty->pt_wbufcid == 0) { 657 error = ENOMEM; 658 goto out; 659 } 660 pty->pt_ttycommon.t_iocpending = mp; 661 return; 662 } 663 /* 664 * Return the current size. 665 */ 666 tp = (struct ttysize *)datap->b_wptr; 667 tp->ts_lines = tc->t_size.ws_row; 668 tp->ts_cols = tc->t_size.ws_col; 669 datap->b_wptr += sizeof (struct ttysize); 670 iocp->ioc_count = sizeof (struct ttysize); 671 672 if (mp->b_cont != NULL) 673 freemsg(mp->b_cont); 674 mp->b_cont = datap; 675 mp->b_datap->db_type = M_IOCACK; 676 goto out; 677 } 678 679 /* 680 * Imported from ttycommon_ioctl routine 681 */ 682 683 case TCSETSF: { 684 tty_common_t *tc = &pty->pt_ttycommon; 685 struct termios *cb; 686 687 error = miocpullup(mp, sizeof (struct termios)); 688 if (error != 0) 689 goto out; 690 691 cb = (struct termios *)mp->b_cont->b_rptr; 692 693 flushq(RD(q), FLUSHDATA); 694 mutex_exit(&pty->ptc_lock); 695 (void) putnextctl1(RD(q), M_FLUSH, FLUSHR); 696 mutex_enter(&pty->ptc_lock); 697 mutex_enter(&tc->t_excl); 698 tc->t_iflag = cb->c_iflag; 699 tc->t_cflag = cb->c_cflag; 700 tc->t_stopc = cb->c_cc[VSTOP]; 701 tc->t_startc = cb->c_cc[VSTART]; 702 mutex_exit(&tc->t_excl); 703 704 /* 705 * Turn the ioctl message into an ioctl ACK message. 706 */ 707 iocp->ioc_count = 0; /* no data returned */ 708 mp->b_datap->db_type = M_IOCACK; 709 goto ioctldone; 710 } 711 712 case TCSETAF: { 713 tty_common_t *tc = &pty->pt_ttycommon; 714 struct termios *cb; 715 716 error = miocpullup(mp, sizeof (struct termios)); 717 if (error != 0) 718 goto out; 719 720 cb = (struct termios *)mp->b_cont->b_rptr; 721 722 flushq(RD(q), FLUSHDATA); 723 mutex_exit(&pty->ptc_lock); 724 (void) putnextctl1(RD(q), M_FLUSH, FLUSHR); 725 mutex_enter(&pty->ptc_lock); 726 mutex_enter(&tc->t_excl); 727 tc->t_iflag = (tc->t_iflag & 0xffff0000 | cb->c_iflag); 728 tc->t_cflag = (tc->t_cflag & 0xffff0000 | cb->c_cflag); 729 mutex_exit(&tc->t_excl); 730 731 /* 732 * Turn the ioctl message into an ioctl ACK message. 733 */ 734 iocp->ioc_count = 0; /* no data returned */ 735 mp->b_datap->db_type = M_IOCACK; 736 goto ioctldone; 737 } 738 739 case TIOCSWINSZ: { 740 tty_common_t *tc = &pty->pt_ttycommon; 741 struct winsize *ws; 742 743 error = miocpullup(mp, sizeof (struct winsize)); 744 if (error != 0) 745 goto out; 746 747 ws = (struct winsize *)mp->b_cont->b_rptr; 748 /* 749 * If the window size changed, send a SIGWINCH. 750 */ 751 mutex_enter(&tc->t_excl); 752 if (bcmp(&tc->t_size, ws, sizeof (struct winsize))) { 753 tc->t_size = *ws; 754 mutex_exit(&tc->t_excl); 755 mutex_exit(&pty->ptc_lock); 756 (void) putnextctl1(RD(q), M_PCSIG, SIGWINCH); 757 mutex_enter(&pty->ptc_lock); 758 } else 759 mutex_exit(&tc->t_excl); 760 761 /* 762 * Turn the ioctl message into an ioctl ACK message. 763 */ 764 iocp->ioc_count = 0; /* no data returned */ 765 mp->b_datap->db_type = M_IOCACK; 766 goto ioctldone; 767 } 768 769 /* 770 * If they were just trying to drain output, that's OK. 771 * If they are actually trying to send a break it's an error. 772 */ 773 case TCSBRK: 774 error = miocpullup(mp, sizeof (int)); 775 if (error != 0) 776 goto out; 777 778 if (*(int *)mp->b_cont->b_rptr != 0) { 779 /* 780 * Turn the ioctl message into an ioctl ACK message. 781 */ 782 iocp->ioc_count = 0; /* no data returned */ 783 mp->b_datap->db_type = M_IOCACK; 784 } else { 785 error = ENOTTY; 786 } 787 goto out; 788 } 789 790 /* 791 * The only way in which "ttycommon_ioctl" can fail is if the "ioctl" 792 * requires a response containing data to be returned to the user, 793 * and no mblk could be allocated for the data. 794 * No such "ioctl" alters our state. Thus, we always go ahead and 795 * do any state-changes the "ioctl" calls for. If we couldn't allocate 796 * the data, "ttycommon_ioctl" has stashed the "ioctl" away safely, so 797 * we just call "bufcall" to request that we be called back when we 798 * stand a better chance of allocating the data. 799 */ 800 if ((datasize = 801 ttycommon_ioctl(&pty->pt_ttycommon, q, mp, &error)) != 0) { 802 if (pty->pt_wbufcid) { 803 if (pty->pt_ttycommon.t_iocpending) 804 freemsg(pty->pt_ttycommon.t_iocpending); 805 pty->pt_ttycommon.t_iocpending = mp; 806 return; 807 } 808 pty->pt_wbufcid = bufcall(datasize, BPRI_HI, ptslreioctl, pty); 809 if (pty->pt_wbufcid == 0) { 810 error = ENOMEM; 811 goto out; 812 } 813 pty->pt_ttycommon.t_iocpending = mp; 814 return; 815 } 816 817 ioctldone: 818 if (error == 0) { 819 /* 820 * "ttycommon_ioctl" did most of the work; we just use the 821 * data it set up. 822 */ 823 switch (cmd) { 824 825 case TCSETSF: 826 case TCSETAF: 827 /* 828 * Set the "flush read" flag, so that we 829 * notify the controller if they're in packet 830 * mode. 831 */ 832 if (!(pty->pt_send & TIOCPKT_FLUSHREAD)) { 833 pty->pt_send |= TIOCPKT_FLUSHREAD; 834 ptcpollwakeup(pty, 0); 835 } 836 /*FALLTHROUGH*/ 837 838 case TCSETSW: 839 case TCSETAW: 840 cmd = TIOCSETP; /* map backwards to old codes */ 841 pt_sendstop(pty); 842 break; 843 844 case TCSETS: 845 case TCSETA: 846 cmd = TIOCSETN; /* map backwards to old codes */ 847 pt_sendstop(pty); 848 break; 849 } 850 } 851 852 if (pty->pt_flags & PF_43UCNTL) { 853 if (error < 0) { 854 if ((cmd & ~0xff) == _IO('u', 0)) { 855 if (cmd & 0xff) { 856 pty->pt_ucntl = (uchar_t)cmd & 0xff; 857 ptcpollwakeup(pty, FREAD); 858 } 859 error = 0; /* XXX */ 860 goto out; 861 } 862 error = ENOTTY; 863 } 864 } else { 865 if ((pty->pt_flags & PF_UCNTL) && 866 (cmd & (IOC_INOUT | 0xff00)) == (IOC_IN|('t'<<8)) && 867 (cmd & 0xff)) { 868 pty->pt_ucntl = (uchar_t)cmd & 0xff; 869 ptcpollwakeup(pty, FREAD); 870 goto out; 871 } 872 if (error < 0) 873 error = ENOTTY; 874 } 875 876 out: 877 if (error != 0) { 878 ((struct iocblk *)mp->b_rptr)->ioc_error = error; 879 mp->b_datap->db_type = M_IOCNAK; 880 } 881 882 mutex_exit(&pty->ptc_lock); 883 qreply(q, mp); 884 mutex_enter(&pty->ptc_lock); 885 } 886 887 /* 888 * Service routine for read queue. 889 * Just wakes the controller side up so it can write some more data 890 * to that queue. 891 */ 892 static int 893 ptslrserv(queue_t *q) 894 { 895 struct pty *pty = (struct pty *)q->q_ptr; 896 mblk_t *mp; 897 mblk_t *head = NULL, *tail = NULL; 898 /* 899 * Build up the link list of messages, then drop 900 * drop the lock and do putnext() 901 */ 902 mutex_enter(&pty->ptc_lock); 903 904 while ((mp = getq(q)) != NULL) { 905 if ((mp->b_datap->db_type < QPCTL) && !canputnext(q)) { 906 (void) putbq(q, mp); 907 break; 908 } 909 if (!head) { 910 head = mp; 911 tail = mp; 912 } else { 913 tail->b_next = mp; 914 tail = mp; 915 } 916 } 917 918 if (q->q_count <= q->q_lowat) 919 ptcpollwakeup((struct pty *)q->q_ptr, FWRITE); 920 921 mutex_exit(&pty->ptc_lock); 922 923 while (head) { 924 mp = head; 925 head = mp->b_next; 926 mp->b_next = NULL; 927 putnext(q, mp); 928 } 929 930 return (0); 931 } 932 933 static void 934 pt_sendstop(struct pty *pty) 935 { 936 int stop; 937 938 ASSERT(MUTEX_HELD(&pty->ptc_lock)); 939 940 if ((pty->pt_ttycommon.t_cflag&CBAUD) == 0) { 941 if (pty->pt_flags & PF_CARR_ON) { 942 /* 943 * Let the controller know, then wake up 944 * readers/selectors and writers/selectors. 945 */ 946 pty->pt_flags |= PF_SLAVEGONE; 947 ptcpollwakeup(pty, 0); 948 ptcpollwakeup(pty, FWRITE); 949 } 950 } 951 952 stop = (pty->pt_ttycommon.t_iflag & IXON) && 953 pty->pt_ttycommon.t_stopc == CTRL('s') && 954 pty->pt_ttycommon.t_startc == CTRL('q'); 955 956 if (pty->pt_flags & PF_NOSTOP) { 957 if (stop) { 958 pty->pt_send &= ~TIOCPKT_NOSTOP; 959 pty->pt_send |= TIOCPKT_DOSTOP; 960 pty->pt_flags &= ~PF_NOSTOP; 961 ptcpollwakeup(pty, 0); 962 } 963 } else { 964 if (!stop) { 965 pty->pt_send &= ~TIOCPKT_DOSTOP; 966 pty->pt_send |= TIOCPKT_NOSTOP; 967 pty->pt_flags |= PF_NOSTOP; 968 ptcpollwakeup(pty, 0); 969 } 970 } 971 } 972 973 /* 974 * Wake up controller side. "flag" is 0 if a special packet or 975 * user control mode message has been queued up (this data is readable, 976 * so we also treat it as a regular data event; should we send SIGIO, 977 * though?), FREAD if regular data has been queued up, or FWRITE if 978 * the slave's read queue has drained sufficiently to allow writing. 979 */ 980 static void 981 ptcpollwakeup(struct pty *pty, int flag) 982 { 983 ASSERT(MUTEX_HELD(&pty->ptc_lock)); 984 985 if (flag == 0) { 986 /* 987 * "Exceptional condition" occurred. This means that 988 * a "read" is now possible, so do a "read" wakeup. 989 */ 990 flag = FREAD; 991 pollwakeup(&ptcph, POLLIN | POLLRDBAND); 992 if (pty->pt_flags & PF_ASYNC) 993 gsignal(pty->pt_pgrp, SIGURG); 994 } 995 if (flag & FREAD) { 996 /* 997 * Wake up the parent process as there is regular 998 * data to read from slave's write queue 999 */ 1000 pollwakeup(&ptcph, POLLIN | POLLRDNORM); 1001 cv_broadcast(&pty->pt_cv_writeq); 1002 if (pty->pt_flags & PF_ASYNC) 1003 gsignal(pty->pt_pgrp, SIGIO); 1004 } 1005 if (flag & FWRITE) { 1006 /* 1007 * Wake up the parent process to write 1008 * data into slave's read queue as the 1009 * read queue has drained enough 1010 */ 1011 pollwakeup(&ptcph, POLLOUT | POLLWRNORM); 1012 cv_broadcast(&pty->pt_cv_readq); 1013 if (pty->pt_flags & PF_ASYNC) 1014 gsignal(pty->pt_pgrp, SIGIO); 1015 } 1016 } 1017