1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 26 27 /* 28 * Zone Console Driver. 29 * 30 * This driver, derived from the pts/ptm drivers, is the pseudo console driver 31 * for system zones. Its implementation is straightforward. Each instance 32 * of the driver represents a global-zone/local-zone pair (this maps in a 33 * straightforward way to the commonly used terminal notion of "master side" 34 * and "slave side", and we use that terminology throughout). 35 * 36 * Instances of zcons are onlined as children of /pseudo/zconsnex@1/ 37 * by zoneadmd in userland, using the devctl framework; thus the driver 38 * does not need to maintain any sort of "admin" node. 39 * 40 * The driver shuttles I/O from master side to slave side and back. In a break 41 * from the pts/ptm semantics, if one side is not open, I/O directed towards 42 * it will simply be discarded. This is so that if zoneadmd is not holding 43 * the master side console open (i.e. it has died somehow), processes in 44 * the zone do not experience any errors and I/O to the console does not 45 * hang. 46 * 47 * TODO: we may want to revisit the other direction; i.e. we may want 48 * zoneadmd to be able to detect whether no zone processes are holding the 49 * console open, an unusual situation. 50 * 51 * 52 * 53 * MASTER SIDE IOCTLS 54 * 55 * The ZC_HOLDSLAVE and ZC_RELEASESLAVE ioctls instruct the master side of the 56 * console to hold and release a reference to the slave side's vnode. They are 57 * meant to be issued by zoneadmd after the console device node is created and 58 * before it is destroyed so that the slave's STREAMS anchor, ptem, is 59 * preserved when ttymon starts popping STREAMS modules from within the 60 * associated zone. This guarantees that the zone console will always have 61 * terminal semantics while the zone is running. 62 * 63 * Here is the issue: the ptem module is anchored in the zone console 64 * (slave side) so that processes within the associated non-global zone will 65 * fail to pop it off, thus ensuring that the slave will retain terminal 66 * semantics. When a process attempts to pop the anchor off of a stream, the 67 * STREAMS subsystem checks whether the calling process' zone is the same as 68 * that of the process that pushed the anchor onto the stream and cancels the 69 * pop if they differ. zoneadmd used to hold an open file descriptor for the 70 * slave while the associated non-global zone ran, thus ensuring that the 71 * slave's STREAMS anchor would never be popped from within the non-global zone 72 * (because zoneadmd runs in the global zone). However, this file descriptor 73 * was removed to make zone console management more robust. sad(7D) is now 74 * used to automatically set up the slave's STREAMS modules when the zone 75 * console is freshly opened within the associated non-global zone. However, 76 * when a process within the non-global zone freshly opens the zone console, the 77 * anchor is pushed from within the non-global zone, making it possible for 78 * processes within the non-global zone (e.g., ttymon) to pop the anchor and 79 * destroy the zone console's terminal semantics. 80 * 81 * One solution is to make the zcons device hold the slave open while the 82 * associated non-global zone runs so that the STREAMS anchor will always be 83 * associated with the global zone. Unfortunately, the slave cannot be opened 84 * from within the zcons driver because the driver is not reentrant: it has 85 * an outer STREAMS perimeter. Therefore, the next best option is for zcons to 86 * provide an ioctl interface to zoneadmd to manage holding and releasing 87 * the slave side of the console. It is sufficient to hold the slave side's 88 * vnode and bump the associated snode's reference count to preserve the slave's 89 * STREAMS configuration while the associated zone runs, so that's what the 90 * ioctls do. 91 * 92 * 93 * ZC_HOLDSLAVE 94 * 95 * This ioctl takes a file descriptor as an argument. It effectively gets a 96 * reference to the slave side's minor node's vnode and bumps the associated 97 * snode's reference count. The vnode reference is stored in the zcons device 98 * node's soft state. This ioctl succeeds if the given file descriptor refers 99 * to the slave side's minor node or if there is already a reference to the 100 * slave side's minor node's vnode in the device's soft state. 101 * 102 * 103 * ZC_RELEASESLAVE 104 * 105 * This ioctl takes a file descriptor as an argument. It effectively releases 106 * the vnode reference stored in the zcons device node's soft state (which was 107 * previously acquired via ZC_HOLDSLAVE) and decrements the reference count of 108 * the snode associated with the vnode. This ioctl succeeds if the given file 109 * descriptor refers to the slave side's minor node or if no reference to the 110 * slave side's minor node's vnode is stored in the device's soft state. 111 * 112 * 113 * Note that the file descriptor arguments for both ioctls must be cast to 114 * integers of pointer width. 115 * 116 * Here's how the dance between zcons and zoneadmd works: 117 * 118 * Zone boot: 119 * 1. While booting the zone, zoneadmd creates an instance of zcons. 120 * 2. zoneadmd opens the master and slave sides of the new zone console 121 * and issues the ZC_HOLDSLAVE ioctl on the master side, passing its 122 * file descriptor for the slave side as the ioctl argument. 123 * 3. zcons holds the slave side's vnode, bumps the snode's reference 124 * count, and stores a pointer to the vnode in the device's soft 125 * state. 126 * 4. zoneadmd closes the master and slave sides and continues to boot 127 * the zone. 128 * 129 * Zone halt: 130 * 1. While halting the zone, zoneadmd opens the master and slave sides 131 * of the zone's console and issues the ZC_RELEASESLAVE ioctl on the 132 * master side, passing its file descriptor for the slave side as the 133 * ioctl argument. 134 * 2. zcons decrements the slave side's snode's reference count, releases 135 * the slave's vnode, and eliminates its reference to the vnode in the 136 * device's soft state. 137 * 3. zoneadmd closes the master and slave sides. 138 * 4. zoneadmd destroys the zcons device and continues to halt the zone. 139 * 140 * It is necessary for zoneadmd to hold the slave open while issuing 141 * ZC_RELEASESLAVE because zcons might otherwise release the last reference to 142 * the slave's vnode. If it does, then specfs will panic because it will expect 143 * that the STREAMS configuration for the vnode was destroyed, which VN_RELE 144 * doesn't do. Forcing zoneadmd to hold the slave open guarantees that zcons 145 * won't release the vnode's last reference. zoneadmd will properly destroy the 146 * vnode and the snode when it closes the file descriptor. 147 * 148 * Technically, any process that can access the master side can issue these 149 * ioctls, but they should be treated as private interfaces for zoneadmd. 150 */ 151 152 #include <sys/types.h> 153 #include <sys/cmn_err.h> 154 #include <sys/conf.h> 155 #include <sys/cred.h> 156 #include <sys/ddi.h> 157 #include <sys/debug.h> 158 #include <sys/devops.h> 159 #include <sys/errno.h> 160 #include <sys/file.h> 161 #include <sys/kstr.h> 162 #include <sys/modctl.h> 163 #include <sys/param.h> 164 #include <sys/stat.h> 165 #include <sys/stream.h> 166 #include <sys/stropts.h> 167 #include <sys/strsun.h> 168 #include <sys/sunddi.h> 169 #include <sys/sysmacros.h> 170 #include <sys/systm.h> 171 #include <sys/types.h> 172 #include <sys/zcons.h> 173 #include <sys/vnode.h> 174 #include <sys/fs/snode.h> 175 #include <sys/zone.h> 176 177 static int zc_getinfo(dev_info_t *, ddi_info_cmd_t, void *, void **); 178 static int zc_attach(dev_info_t *, ddi_attach_cmd_t); 179 static int zc_detach(dev_info_t *, ddi_detach_cmd_t); 180 181 static int zc_open(queue_t *, dev_t *, int, int, cred_t *); 182 static int zc_close(queue_t *, int, cred_t *); 183 static int zc_wput(queue_t *, mblk_t *); 184 static int zc_rsrv(queue_t *); 185 static int zc_wsrv(queue_t *); 186 187 /* 188 * The instance number is encoded in the dev_t in the minor number; the lowest 189 * bit of the minor number is used to track the master vs. slave side of the 190 * virtual console. The rest of the bits in the minor number are the instance. 191 */ 192 #define ZC_MASTER_MINOR 0 193 #define ZC_SLAVE_MINOR 1 194 195 #define ZC_INSTANCE(x) (getminor((x)) >> 1) 196 #define ZC_NODE(x) (getminor((x)) & 0x01) 197 198 /* 199 * This macro converts a zc_state_t pointer to the associated slave minor node's 200 * dev_t. 201 */ 202 #define ZC_STATE_TO_SLAVEDEV(x) (makedevice(ddi_driver_major((x)->zc_devinfo), \ 203 (minor_t)(ddi_get_instance((x)->zc_devinfo) << 1 | ZC_SLAVE_MINOR))) 204 205 int zcons_debug = 0; 206 #define DBG(a) if (zcons_debug) cmn_err(CE_NOTE, a) 207 #define DBG1(a, b) if (zcons_debug) cmn_err(CE_NOTE, a, b) 208 209 210 /* 211 * Zone Console Pseudo Terminal Module: stream data structure definitions 212 */ 213 static struct module_info zc_info = { 214 31337, /* c0z we r hAx0rs */ 215 "zcons", 216 0, 217 INFPSZ, 218 _TTY_BUFSIZ, 219 128 220 }; 221 222 static struct qinit zc_rinit = { 223 NULL, 224 zc_rsrv, 225 zc_open, 226 zc_close, 227 NULL, 228 &zc_info, 229 NULL 230 }; 231 232 static struct qinit zc_winit = { 233 zc_wput, 234 zc_wsrv, 235 NULL, 236 NULL, 237 NULL, 238 &zc_info, 239 NULL 240 }; 241 242 static struct streamtab zc_tab_info = { 243 &zc_rinit, 244 &zc_winit, 245 NULL, 246 NULL 247 }; 248 249 #define ZC_CONF_FLAG (D_MP | D_MTQPAIR | D_MTOUTPERIM | D_MTOCEXCL) 250 251 /* 252 * this will define (struct cb_ops cb_zc_ops) and (struct dev_ops zc_ops) 253 */ 254 DDI_DEFINE_STREAM_OPS(zc_ops, nulldev, nulldev, zc_attach, zc_detach, nodev, \ 255 zc_getinfo, ZC_CONF_FLAG, &zc_tab_info, ddi_quiesce_not_needed); 256 257 /* 258 * Module linkage information for the kernel. 259 */ 260 261 static struct modldrv modldrv = { 262 &mod_driverops, /* Type of module (this is a pseudo driver) */ 263 "Zone console driver", /* description of module */ 264 &zc_ops /* driver ops */ 265 }; 266 267 static struct modlinkage modlinkage = { 268 MODREV_1, 269 &modldrv, 270 NULL 271 }; 272 273 typedef struct zc_state { 274 dev_info_t *zc_devinfo; 275 queue_t *zc_master_rdq; 276 queue_t *zc_slave_rdq; 277 vnode_t *zc_slave_vnode; 278 int zc_state; 279 } zc_state_t; 280 281 #define ZC_STATE_MOPEN 0x01 282 #define ZC_STATE_SOPEN 0x02 283 284 static void *zc_soft_state; 285 286 /* 287 * List of STREAMS modules that should be pushed onto every slave instance. 288 */ 289 static char *zcons_mods[] = { 290 "ptem", 291 "ldterm", 292 "ttcompat", 293 NULL 294 }; 295 296 int 297 _init(void) 298 { 299 int err; 300 301 if ((err = ddi_soft_state_init(&zc_soft_state, 302 sizeof (zc_state_t), 0)) != 0) { 303 return (err); 304 } 305 306 if ((err = mod_install(&modlinkage)) != 0) 307 ddi_soft_state_fini(zc_soft_state); 308 309 return (err); 310 } 311 312 313 int 314 _fini(void) 315 { 316 int err; 317 318 if ((err = mod_remove(&modlinkage)) != 0) { 319 return (err); 320 } 321 322 ddi_soft_state_fini(&zc_soft_state); 323 return (0); 324 } 325 326 int 327 _info(struct modinfo *modinfop) 328 { 329 return (mod_info(&modlinkage, modinfop)); 330 } 331 332 static int 333 zc_attach(dev_info_t *dip, ddi_attach_cmd_t cmd) 334 { 335 zc_state_t *zcs; 336 int instance; 337 338 if (cmd != DDI_ATTACH) 339 return (DDI_FAILURE); 340 341 instance = ddi_get_instance(dip); 342 if (ddi_soft_state_zalloc(zc_soft_state, instance) != DDI_SUCCESS) 343 return (DDI_FAILURE); 344 345 /* 346 * Create the master and slave minor nodes. 347 */ 348 if ((ddi_create_minor_node(dip, ZCONS_SLAVE_NAME, S_IFCHR, 349 instance << 1 | ZC_SLAVE_MINOR, DDI_PSEUDO, 0) == DDI_FAILURE) || 350 (ddi_create_minor_node(dip, ZCONS_MASTER_NAME, S_IFCHR, 351 instance << 1 | ZC_MASTER_MINOR, DDI_PSEUDO, 0) == DDI_FAILURE)) { 352 ddi_remove_minor_node(dip, NULL); 353 ddi_soft_state_free(zc_soft_state, instance); 354 return (DDI_FAILURE); 355 } 356 357 VERIFY((zcs = ddi_get_soft_state(zc_soft_state, instance)) != NULL); 358 zcs->zc_devinfo = dip; 359 return (DDI_SUCCESS); 360 } 361 362 static int 363 zc_detach(dev_info_t *dip, ddi_detach_cmd_t cmd) 364 { 365 zc_state_t *zcs; 366 int instance; 367 368 if (cmd != DDI_DETACH) 369 return (DDI_FAILURE); 370 371 instance = ddi_get_instance(dip); 372 if ((zcs = ddi_get_soft_state(zc_soft_state, instance)) == NULL) 373 return (DDI_FAILURE); 374 375 if ((zcs->zc_state & ZC_STATE_MOPEN) || 376 (zcs->zc_state & ZC_STATE_SOPEN)) { 377 DBG1("zc_detach: device (dip=%p) still open\n", (void *)dip); 378 return (DDI_FAILURE); 379 } 380 381 ddi_remove_minor_node(dip, NULL); 382 ddi_soft_state_free(zc_soft_state, instance); 383 384 return (DDI_SUCCESS); 385 } 386 387 /* 388 * zc_getinfo() 389 * getinfo(9e) entrypoint. 390 */ 391 /*ARGSUSED*/ 392 static int 393 zc_getinfo(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result) 394 { 395 zc_state_t *zcs; 396 int instance = ZC_INSTANCE((dev_t)arg); 397 398 switch (infocmd) { 399 case DDI_INFO_DEVT2DEVINFO: 400 if ((zcs = ddi_get_soft_state(zc_soft_state, instance)) == NULL) 401 return (DDI_FAILURE); 402 *result = zcs->zc_devinfo; 403 return (DDI_SUCCESS); 404 case DDI_INFO_DEVT2INSTANCE: 405 *result = (void *)(uintptr_t)instance; 406 return (DDI_SUCCESS); 407 } 408 return (DDI_FAILURE); 409 } 410 411 /* 412 * Return the equivalent queue from the other side of the relationship. 413 * e.g.: given the slave's write queue, return the master's write queue. 414 */ 415 static queue_t * 416 zc_switch(queue_t *qp) 417 { 418 zc_state_t *zcs = qp->q_ptr; 419 ASSERT(zcs != NULL); 420 421 if (qp == zcs->zc_master_rdq) 422 return (zcs->zc_slave_rdq); 423 else if (OTHERQ(qp) == zcs->zc_master_rdq && zcs->zc_slave_rdq != NULL) 424 return (OTHERQ(zcs->zc_slave_rdq)); 425 else if (qp == zcs->zc_slave_rdq) 426 return (zcs->zc_master_rdq); 427 else if (OTHERQ(qp) == zcs->zc_slave_rdq && zcs->zc_master_rdq != NULL) 428 return (OTHERQ(zcs->zc_master_rdq)); 429 else 430 return (NULL); 431 } 432 433 /* 434 * For debugging and outputting messages. Returns the name of the side of 435 * the relationship associated with this queue. 436 */ 437 static const char * 438 zc_side(queue_t *qp) 439 { 440 zc_state_t *zcs = qp->q_ptr; 441 ASSERT(zcs != NULL); 442 443 if (qp == zcs->zc_master_rdq || 444 OTHERQ(qp) == zcs->zc_master_rdq) { 445 return ("master"); 446 } 447 ASSERT(qp == zcs->zc_slave_rdq || OTHERQ(qp) == zcs->zc_slave_rdq); 448 return ("slave"); 449 } 450 451 /*ARGSUSED*/ 452 static int 453 zc_master_open(zc_state_t *zcs, 454 queue_t *rqp, /* pointer to the read side queue */ 455 dev_t *devp, /* pointer to stream tail's dev */ 456 int oflag, /* the user open(2) supplied flags */ 457 int sflag, /* open state flag */ 458 cred_t *credp) /* credentials */ 459 { 460 mblk_t *mop; 461 struct stroptions *sop; 462 463 /* 464 * Enforce exclusivity on the master side; the only consumer should 465 * be the zoneadmd for the zone. 466 */ 467 if ((zcs->zc_state & ZC_STATE_MOPEN) != 0) 468 return (EBUSY); 469 470 if ((mop = allocb(sizeof (struct stroptions), BPRI_MED)) == NULL) { 471 DBG("zc_master_open(): mop allocation failed\n"); 472 return (ENOMEM); 473 } 474 475 zcs->zc_state |= ZC_STATE_MOPEN; 476 477 /* 478 * q_ptr stores driver private data; stash the soft state data on both 479 * read and write sides of the queue. 480 */ 481 WR(rqp)->q_ptr = rqp->q_ptr = zcs; 482 qprocson(rqp); 483 484 /* 485 * Following qprocson(), the master side is fully plumbed into the 486 * STREAM and may send/receive messages. Setting zcs->zc_master_rdq 487 * will allow the slave to send messages to us (the master). 488 * This cannot occur before qprocson() because the master is not 489 * ready to process them until that point. 490 */ 491 zcs->zc_master_rdq = rqp; 492 493 /* 494 * set up hi/lo water marks on stream head read queue and add 495 * controlling tty as needed. 496 */ 497 mop->b_datap->db_type = M_SETOPTS; 498 mop->b_wptr += sizeof (struct stroptions); 499 sop = (struct stroptions *)(void *)mop->b_rptr; 500 if (oflag & FNOCTTY) 501 sop->so_flags = SO_HIWAT | SO_LOWAT; 502 else 503 sop->so_flags = SO_HIWAT | SO_LOWAT | SO_ISTTY; 504 sop->so_hiwat = _TTY_BUFSIZ; 505 sop->so_lowat = 256; 506 putnext(rqp, mop); 507 508 return (0); 509 } 510 511 /*ARGSUSED*/ 512 static int 513 zc_slave_open(zc_state_t *zcs, 514 queue_t *rqp, /* pointer to the read side queue */ 515 dev_t *devp, /* pointer to stream tail's dev */ 516 int oflag, /* the user open(2) supplied flags */ 517 int sflag, /* open state flag */ 518 cred_t *credp) /* credentials */ 519 { 520 mblk_t *mop; 521 struct stroptions *sop; 522 major_t major; 523 minor_t minor; 524 minor_t lastminor; 525 uint_t anchorindex; 526 527 /* 528 * The slave side can be opened as many times as needed. 529 */ 530 if ((zcs->zc_state & ZC_STATE_SOPEN) != 0) { 531 ASSERT((rqp != NULL) && (WR(rqp)->q_ptr == zcs)); 532 return (0); 533 } 534 535 /* 536 * Set up sad(7D) so that the necessary STREAMS modules will be in 537 * place. A wrinkle is that 'ptem' must be anchored 538 * in place (see streamio(7i)) because we always want the console to 539 * have terminal semantics. 540 */ 541 minor = ddi_get_instance(zcs->zc_devinfo) << 1 | ZC_SLAVE_MINOR; 542 major = ddi_driver_major(zcs->zc_devinfo); 543 lastminor = 0; 544 anchorindex = 1; 545 if (kstr_autopush(SET_AUTOPUSH, &major, &minor, &lastminor, 546 &anchorindex, zcons_mods) != 0) { 547 DBG("zc_slave_open(): kstr_autopush() failed\n"); 548 return (EIO); 549 } 550 551 if ((mop = allocb(sizeof (struct stroptions), BPRI_MED)) == NULL) { 552 DBG("zc_slave_open(): mop allocation failed\n"); 553 return (ENOMEM); 554 } 555 556 zcs->zc_state |= ZC_STATE_SOPEN; 557 558 /* 559 * q_ptr stores driver private data; stash the soft state data on both 560 * read and write sides of the queue. 561 */ 562 WR(rqp)->q_ptr = rqp->q_ptr = zcs; 563 564 qprocson(rqp); 565 566 /* 567 * Must follow qprocson(), since we aren't ready to process until then. 568 */ 569 zcs->zc_slave_rdq = rqp; 570 571 /* 572 * set up hi/lo water marks on stream head read queue and add 573 * controlling tty as needed. 574 */ 575 mop->b_datap->db_type = M_SETOPTS; 576 mop->b_wptr += sizeof (struct stroptions); 577 sop = (struct stroptions *)(void *)mop->b_rptr; 578 sop->so_flags = SO_HIWAT | SO_LOWAT | SO_ISTTY; 579 sop->so_hiwat = _TTY_BUFSIZ; 580 sop->so_lowat = 256; 581 putnext(rqp, mop); 582 583 return (0); 584 } 585 586 /* 587 * open(9e) entrypoint; checks sflag, and rejects anything unordinary. 588 */ 589 static int 590 zc_open(queue_t *rqp, /* pointer to the read side queue */ 591 dev_t *devp, /* pointer to stream tail's dev */ 592 int oflag, /* the user open(2) supplied flags */ 593 int sflag, /* open state flag */ 594 cred_t *credp) /* credentials */ 595 { 596 int instance = ZC_INSTANCE(*devp); 597 int ret; 598 zc_state_t *zcs; 599 600 if (sflag != 0) 601 return (EINVAL); 602 603 if ((zcs = ddi_get_soft_state(zc_soft_state, instance)) == NULL) 604 return (ENXIO); 605 606 switch (ZC_NODE(*devp)) { 607 case ZC_MASTER_MINOR: 608 ret = zc_master_open(zcs, rqp, devp, oflag, sflag, credp); 609 break; 610 case ZC_SLAVE_MINOR: 611 ret = zc_slave_open(zcs, rqp, devp, oflag, sflag, credp); 612 break; 613 default: 614 ret = ENXIO; 615 break; 616 } 617 618 return (ret); 619 } 620 621 /* 622 * close(9e) entrypoint. 623 */ 624 /*ARGSUSED1*/ 625 static int 626 zc_close(queue_t *rqp, int flag, cred_t *credp) 627 { 628 queue_t *wqp; 629 mblk_t *bp; 630 zc_state_t *zcs; 631 major_t major; 632 minor_t minor; 633 634 zcs = (zc_state_t *)rqp->q_ptr; 635 636 if (rqp == zcs->zc_master_rdq) { 637 DBG("Closing master side"); 638 639 zcs->zc_master_rdq = NULL; 640 zcs->zc_state &= ~ZC_STATE_MOPEN; 641 642 /* 643 * qenable slave side write queue so that it can flush 644 * its messages as master's read queue is going away 645 */ 646 if (zcs->zc_slave_rdq != NULL) { 647 qenable(WR(zcs->zc_slave_rdq)); 648 } 649 650 qprocsoff(rqp); 651 WR(rqp)->q_ptr = rqp->q_ptr = NULL; 652 653 } else if (rqp == zcs->zc_slave_rdq) { 654 655 DBG("Closing slave side"); 656 zcs->zc_state &= ~ZC_STATE_SOPEN; 657 zcs->zc_slave_rdq = NULL; 658 659 wqp = WR(rqp); 660 while ((bp = getq(wqp)) != NULL) { 661 if (zcs->zc_master_rdq != NULL) 662 putnext(zcs->zc_master_rdq, bp); 663 else if (bp->b_datap->db_type == M_IOCTL) 664 miocnak(wqp, bp, 0, 0); 665 else 666 freemsg(bp); 667 } 668 669 /* 670 * Qenable master side write queue so that it can flush its 671 * messages as slaves's read queue is going away. 672 */ 673 if (zcs->zc_master_rdq != NULL) 674 qenable(WR(zcs->zc_master_rdq)); 675 676 qprocsoff(rqp); 677 WR(rqp)->q_ptr = rqp->q_ptr = NULL; 678 679 /* 680 * Clear the sad configuration so that reopening doesn't fail 681 * to set up sad configuration. 682 */ 683 major = ddi_driver_major(zcs->zc_devinfo); 684 minor = ddi_get_instance(zcs->zc_devinfo) << 1 | ZC_SLAVE_MINOR; 685 (void) kstr_autopush(CLR_AUTOPUSH, &major, &minor, NULL, NULL, 686 NULL); 687 } 688 689 return (0); 690 } 691 692 static void 693 handle_mflush(queue_t *qp, mblk_t *mp) 694 { 695 mblk_t *nmp; 696 DBG1("M_FLUSH on %s side", zc_side(qp)); 697 698 if (*mp->b_rptr & FLUSHW) { 699 DBG1("M_FLUSH, FLUSHW, %s side", zc_side(qp)); 700 flushq(qp, FLUSHDATA); 701 *mp->b_rptr &= ~FLUSHW; 702 if ((*mp->b_rptr & FLUSHR) == 0) { 703 /* 704 * FLUSHW only. Change to FLUSHR and putnext other side, 705 * then we are done. 706 */ 707 *mp->b_rptr |= FLUSHR; 708 if (zc_switch(RD(qp)) != NULL) { 709 putnext(zc_switch(RD(qp)), mp); 710 return; 711 } 712 } else if ((zc_switch(RD(qp)) != NULL) && 713 (nmp = copyb(mp)) != NULL) { 714 /* 715 * It is a FLUSHRW; we copy the mblk and send 716 * it to the other side, since we still need to use 717 * the mblk in FLUSHR processing, below. 718 */ 719 putnext(zc_switch(RD(qp)), nmp); 720 } 721 } 722 723 if (*mp->b_rptr & FLUSHR) { 724 DBG("qreply(qp) turning FLUSHR around\n"); 725 qreply(qp, mp); 726 return; 727 } 728 freemsg(mp); 729 } 730 731 /* 732 * wput(9E) is symmetric for master and slave sides, so this handles both 733 * without splitting the codepath. (The only exception to this is the 734 * processing of zcons ioctls, which is restricted to the master side.) 735 * 736 * zc_wput() looks at the other side; if there is no process holding that 737 * side open, it frees the message. This prevents processes from hanging 738 * if no one is holding open the console. Otherwise, it putnext's high 739 * priority messages, putnext's normal messages if possible, and otherwise 740 * enqueues the messages; in the case that something is enqueued, wsrv(9E) 741 * will take care of eventually shuttling I/O to the other side. 742 */ 743 static int 744 zc_wput(queue_t *qp, mblk_t *mp) 745 { 746 unsigned char type = mp->b_datap->db_type; 747 zc_state_t *zcs; 748 struct iocblk *iocbp; 749 file_t *slave_filep; 750 struct snode *slave_snodep; 751 int slave_fd; 752 753 ASSERT(qp->q_ptr); 754 755 DBG1("entering zc_wput, %s side", zc_side(qp)); 756 757 /* 758 * Process zcons ioctl messages if qp is the master console's write 759 * queue. 760 */ 761 zcs = (zc_state_t *)qp->q_ptr; 762 if (zcs->zc_master_rdq != NULL && qp == WR(zcs->zc_master_rdq) && 763 type == M_IOCTL) { 764 iocbp = (struct iocblk *)(void *)mp->b_rptr; 765 switch (iocbp->ioc_cmd) { 766 case ZC_HOLDSLAVE: 767 /* 768 * Hold the slave's vnode and increment the refcount 769 * of the snode. If the vnode is already held, then 770 * indicate success. 771 */ 772 if (iocbp->ioc_count != TRANSPARENT) { 773 miocack(qp, mp, 0, EINVAL); 774 return (0); 775 } 776 if (zcs->zc_slave_vnode != NULL) { 777 miocack(qp, mp, 0, 0); 778 return (0); 779 } 780 781 /* 782 * The process that passed the ioctl must be running in 783 * the global zone. 784 */ 785 if (curzone != global_zone) { 786 miocack(qp, mp, 0, EINVAL); 787 return (0); 788 } 789 790 /* 791 * The calling process must pass a file descriptor for 792 * the slave device. 793 */ 794 slave_fd = 795 (int)(intptr_t)*(caddr_t *)(void *)mp->b_cont-> 796 b_rptr; 797 slave_filep = getf(slave_fd); 798 if (slave_filep == NULL) { 799 miocack(qp, mp, 0, EINVAL); 800 return (0); 801 } 802 if (ZC_STATE_TO_SLAVEDEV(zcs) != 803 slave_filep->f_vnode->v_rdev) { 804 releasef(slave_fd); 805 miocack(qp, mp, 0, EINVAL); 806 return (0); 807 } 808 809 /* 810 * Get a reference to the slave's vnode. Also bump the 811 * reference count on the associated snode. 812 */ 813 ASSERT(vn_matchops(slave_filep->f_vnode, 814 spec_getvnodeops())); 815 zcs->zc_slave_vnode = slave_filep->f_vnode; 816 VN_HOLD(zcs->zc_slave_vnode); 817 slave_snodep = VTOCS(zcs->zc_slave_vnode); 818 mutex_enter(&slave_snodep->s_lock); 819 ++slave_snodep->s_count; 820 mutex_exit(&slave_snodep->s_lock); 821 releasef(slave_fd); 822 miocack(qp, mp, 0, 0); 823 return (0); 824 case ZC_RELEASESLAVE: 825 /* 826 * Release the master's handle on the slave's vnode. 827 * If there isn't a handle for the vnode, then indicate 828 * success. 829 */ 830 if (iocbp->ioc_count != TRANSPARENT) { 831 miocack(qp, mp, 0, EINVAL); 832 return (0); 833 } 834 if (zcs->zc_slave_vnode == NULL) { 835 miocack(qp, mp, 0, 0); 836 return (0); 837 } 838 839 /* 840 * The process that passed the ioctl must be running in 841 * the global zone. 842 */ 843 if (curzone != global_zone) { 844 miocack(qp, mp, 0, EINVAL); 845 return (0); 846 } 847 848 /* 849 * The process that passed the ioctl must have provided 850 * a file descriptor for the slave device. Make sure 851 * this is correct. 852 */ 853 slave_fd = 854 (int)(intptr_t)*(caddr_t *)(void *)mp->b_cont-> 855 b_rptr; 856 slave_filep = getf(slave_fd); 857 if (slave_filep == NULL) { 858 miocack(qp, mp, 0, EINVAL); 859 return (0); 860 } 861 if (zcs->zc_slave_vnode->v_rdev != 862 slave_filep->f_vnode->v_rdev) { 863 releasef(slave_fd); 864 miocack(qp, mp, 0, EINVAL); 865 return (0); 866 } 867 868 /* 869 * Decrement the snode's reference count and release the 870 * vnode. 871 */ 872 ASSERT(vn_matchops(slave_filep->f_vnode, 873 spec_getvnodeops())); 874 slave_snodep = VTOCS(zcs->zc_slave_vnode); 875 mutex_enter(&slave_snodep->s_lock); 876 --slave_snodep->s_count; 877 mutex_exit(&slave_snodep->s_lock); 878 VN_RELE(zcs->zc_slave_vnode); 879 zcs->zc_slave_vnode = NULL; 880 releasef(slave_fd); 881 miocack(qp, mp, 0, 0); 882 return (0); 883 default: 884 break; 885 } 886 } 887 888 if (zc_switch(RD(qp)) == NULL) { 889 DBG1("wput to %s side (no one listening)", zc_side(qp)); 890 switch (type) { 891 case M_FLUSH: 892 handle_mflush(qp, mp); 893 break; 894 case M_IOCTL: 895 miocnak(qp, mp, 0, 0); 896 break; 897 default: 898 freemsg(mp); 899 break; 900 } 901 return (0); 902 } 903 904 if (type >= QPCTL) { 905 DBG1("(hipri) wput, %s side", zc_side(qp)); 906 switch (type) { 907 case M_READ: /* supposedly from ldterm? */ 908 DBG("zc_wput: tossing M_READ\n"); 909 freemsg(mp); 910 break; 911 case M_FLUSH: 912 handle_mflush(qp, mp); 913 break; 914 default: 915 /* 916 * Put this to the other side. 917 */ 918 ASSERT(zc_switch(RD(qp)) != NULL); 919 putnext(zc_switch(RD(qp)), mp); 920 break; 921 } 922 DBG1("done (hipri) wput, %s side", zc_side(qp)); 923 return (0); 924 } 925 926 /* 927 * Only putnext if there isn't already something in the queue. 928 * otherwise things would wind up out of order. 929 */ 930 if (qp->q_first == NULL && bcanputnext(RD(zc_switch(qp)), mp->b_band)) { 931 DBG("wput: putting message to other side\n"); 932 putnext(RD(zc_switch(qp)), mp); 933 } else { 934 DBG("wput: putting msg onto queue\n"); 935 (void) putq(qp, mp); 936 } 937 DBG1("done wput, %s side", zc_side(qp)); 938 return (0); 939 } 940 941 /* 942 * rsrv(9E) is symmetric for master and slave, so zc_rsrv() handles both 943 * without splitting up the codepath. 944 * 945 * Enable the write side of the partner. This triggers the partner to send 946 * messages queued on its write side to this queue's read side. 947 */ 948 static int 949 zc_rsrv(queue_t *qp) 950 { 951 zc_state_t *zcs; 952 zcs = (zc_state_t *)qp->q_ptr; 953 954 /* 955 * Care must be taken here, as either of the master or slave side 956 * qptr could be NULL. 957 */ 958 ASSERT(qp == zcs->zc_master_rdq || qp == zcs->zc_slave_rdq); 959 if (zc_switch(qp) == NULL) { 960 DBG("zc_rsrv: other side isn't listening\n"); 961 return (0); 962 } 963 qenable(WR(zc_switch(qp))); 964 return (0); 965 } 966 967 /* 968 * This routine is symmetric for master and slave, so it handles both without 969 * splitting up the codepath. 970 * 971 * If there are messages on this queue that can be sent to the other, send 972 * them via putnext(). Else, if queued messages cannot be sent, leave them 973 * on this queue. 974 */ 975 static int 976 zc_wsrv(queue_t *qp) 977 { 978 mblk_t *mp; 979 980 DBG1("zc_wsrv master (%s) side", zc_side(qp)); 981 982 /* 983 * Partner has no read queue, so take the data, and throw it away. 984 */ 985 if (zc_switch(RD(qp)) == NULL) { 986 DBG("zc_wsrv: other side isn't listening"); 987 while ((mp = getq(qp)) != NULL) { 988 if (mp->b_datap->db_type == M_IOCTL) 989 miocnak(qp, mp, 0, 0); 990 else 991 freemsg(mp); 992 } 993 flushq(qp, FLUSHALL); 994 return (0); 995 } 996 997 /* 998 * while there are messages on this write queue... 999 */ 1000 while ((mp = getq(qp)) != NULL) { 1001 /* 1002 * Due to the way zc_wput is implemented, we should never 1003 * see a control message here. 1004 */ 1005 ASSERT(mp->b_datap->db_type < QPCTL); 1006 1007 if (bcanputnext(RD(zc_switch(qp)), mp->b_band)) { 1008 DBG("wsrv: send message to other side\n"); 1009 putnext(RD(zc_switch(qp)), mp); 1010 } else { 1011 DBG("wsrv: putting msg back on queue\n"); 1012 (void) putbq(qp, mp); 1013 break; 1014 } 1015 } 1016 return (0); 1017 } 1018