OpenSolaris_b135/uts/common/io/zcons.c
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2009 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/*
* Zone Console Driver.
*
* This driver, derived from the pts/ptm drivers, is the pseudo console driver
* for system zones. Its implementation is straightforward. Each instance
* of the driver represents a global-zone/local-zone pair (this maps in a
* straightforward way to the commonly used terminal notion of "master side"
* and "slave side", and we use that terminology throughout).
*
* Instances of zcons are onlined as children of /pseudo/zconsnex@1/
* by zoneadmd in userland, using the devctl framework; thus the driver
* does not need to maintain any sort of "admin" node.
*
* The driver shuttles I/O from master side to slave side and back. In a break
* from the pts/ptm semantics, if one side is not open, I/O directed towards
* it will simply be discarded. This is so that if zoneadmd is not holding
* the master side console open (i.e. it has died somehow), processes in
* the zone do not experience any errors and I/O to the console does not
* hang.
*
* TODO: we may want to revisit the other direction; i.e. we may want
* zoneadmd to be able to detect whether no zone processes are holding the
* console open, an unusual situation.
*
*
*
* MASTER SIDE IOCTLS
*
* The ZC_HOLDSLAVE and ZC_RELEASESLAVE ioctls instruct the master side of the
* console to hold and release a reference to the slave side's vnode. They are
* meant to be issued by zoneadmd after the console device node is created and
* before it is destroyed so that the slave's STREAMS anchor, ptem, is
* preserved when ttymon starts popping STREAMS modules from within the
* associated zone. This guarantees that the zone console will always have
* terminal semantics while the zone is running.
*
* Here is the issue: the ptem module is anchored in the zone console
* (slave side) so that processes within the associated non-global zone will
* fail to pop it off, thus ensuring that the slave will retain terminal
* semantics. When a process attempts to pop the anchor off of a stream, the
* STREAMS subsystem checks whether the calling process' zone is the same as
* that of the process that pushed the anchor onto the stream and cancels the
* pop if they differ. zoneadmd used to hold an open file descriptor for the
* slave while the associated non-global zone ran, thus ensuring that the
* slave's STREAMS anchor would never be popped from within the non-global zone
* (because zoneadmd runs in the global zone). However, this file descriptor
* was removed to make zone console management more robust. sad(7D) is now
* used to automatically set up the slave's STREAMS modules when the zone
* console is freshly opened within the associated non-global zone. However,
* when a process within the non-global zone freshly opens the zone console, the
* anchor is pushed from within the non-global zone, making it possible for
* processes within the non-global zone (e.g., ttymon) to pop the anchor and
* destroy the zone console's terminal semantics.
*
* One solution is to make the zcons device hold the slave open while the
* associated non-global zone runs so that the STREAMS anchor will always be
* associated with the global zone. Unfortunately, the slave cannot be opened
* from within the zcons driver because the driver is not reentrant: it has
* an outer STREAMS perimeter. Therefore, the next best option is for zcons to
* provide an ioctl interface to zoneadmd to manage holding and releasing
* the slave side of the console. It is sufficient to hold the slave side's
* vnode and bump the associated snode's reference count to preserve the slave's
* STREAMS configuration while the associated zone runs, so that's what the
* ioctls do.
*
*
* ZC_HOLDSLAVE
*
* This ioctl takes a file descriptor as an argument. It effectively gets a
* reference to the slave side's minor node's vnode and bumps the associated
* snode's reference count. The vnode reference is stored in the zcons device
* node's soft state. This ioctl succeeds if the given file descriptor refers
* to the slave side's minor node or if there is already a reference to the
* slave side's minor node's vnode in the device's soft state.
*
*
* ZC_RELEASESLAVE
*
* This ioctl takes a file descriptor as an argument. It effectively releases
* the vnode reference stored in the zcons device node's soft state (which was
* previously acquired via ZC_HOLDSLAVE) and decrements the reference count of
* the snode associated with the vnode. This ioctl succeeds if the given file
* descriptor refers to the slave side's minor node or if no reference to the
* slave side's minor node's vnode is stored in the device's soft state.
*
*
* Note that the file descriptor arguments for both ioctls must be cast to
* integers of pointer width.
*
* Here's how the dance between zcons and zoneadmd works:
*
* Zone boot:
* 1. While booting the zone, zoneadmd creates an instance of zcons.
* 2. zoneadmd opens the master and slave sides of the new zone console
* and issues the ZC_HOLDSLAVE ioctl on the master side, passing its
* file descriptor for the slave side as the ioctl argument.
* 3. zcons holds the slave side's vnode, bumps the snode's reference
* count, and stores a pointer to the vnode in the device's soft
* state.
* 4. zoneadmd closes the master and slave sides and continues to boot
* the zone.
*
* Zone halt:
* 1. While halting the zone, zoneadmd opens the master and slave sides
* of the zone's console and issues the ZC_RELEASESLAVE ioctl on the
* master side, passing its file descriptor for the slave side as the
* ioctl argument.
* 2. zcons decrements the slave side's snode's reference count, releases
* the slave's vnode, and eliminates its reference to the vnode in the
* device's soft state.
* 3. zoneadmd closes the master and slave sides.
* 4. zoneadmd destroys the zcons device and continues to halt the zone.
*
* It is necessary for zoneadmd to hold the slave open while issuing
* ZC_RELEASESLAVE because zcons might otherwise release the last reference to
* the slave's vnode. If it does, then specfs will panic because it will expect
* that the STREAMS configuration for the vnode was destroyed, which VN_RELE
* doesn't do. Forcing zoneadmd to hold the slave open guarantees that zcons
* won't release the vnode's last reference. zoneadmd will properly destroy the
* vnode and the snode when it closes the file descriptor.
*
* Technically, any process that can access the master side can issue these
* ioctls, but they should be treated as private interfaces for zoneadmd.
*/
#include <sys/types.h>
#include <sys/cmn_err.h>
#include <sys/conf.h>
#include <sys/cred.h>
#include <sys/ddi.h>
#include <sys/debug.h>
#include <sys/devops.h>
#include <sys/errno.h>
#include <sys/file.h>
#include <sys/kstr.h>
#include <sys/modctl.h>
#include <sys/param.h>
#include <sys/stat.h>
#include <sys/stream.h>
#include <sys/stropts.h>
#include <sys/strsun.h>
#include <sys/sunddi.h>
#include <sys/sysmacros.h>
#include <sys/systm.h>
#include <sys/types.h>
#include <sys/zcons.h>
#include <sys/vnode.h>
#include <sys/fs/snode.h>
#include <sys/zone.h>
static int zc_getinfo(dev_info_t *, ddi_info_cmd_t, void *, void **);
static int zc_attach(dev_info_t *, ddi_attach_cmd_t);
static int zc_detach(dev_info_t *, ddi_detach_cmd_t);
static int zc_open(queue_t *, dev_t *, int, int, cred_t *);
static int zc_close(queue_t *, int, cred_t *);
static void zc_wput(queue_t *, mblk_t *);
static void zc_rsrv(queue_t *);
static void zc_wsrv(queue_t *);
/*
* The instance number is encoded in the dev_t in the minor number; the lowest
* bit of the minor number is used to track the master vs. slave side of the
* virtual console. The rest of the bits in the minor number are the instance.
*/
#define ZC_MASTER_MINOR 0
#define ZC_SLAVE_MINOR 1
#define ZC_INSTANCE(x) (getminor((x)) >> 1)
#define ZC_NODE(x) (getminor((x)) & 0x01)
/*
* This macro converts a zc_state_t pointer to the associated slave minor node's
* dev_t.
*/
#define ZC_STATE_TO_SLAVEDEV(x) (makedevice(ddi_driver_major((x)->zc_devinfo), \
(minor_t)(ddi_get_instance((x)->zc_devinfo) << 1 | ZC_SLAVE_MINOR)))
int zcons_debug = 0;
#define DBG(a) if (zcons_debug) cmn_err(CE_NOTE, a)
#define DBG1(a, b) if (zcons_debug) cmn_err(CE_NOTE, a, b)
/*
* Zone Console Pseudo Terminal Module: stream data structure definitions
*/
static struct module_info zc_info = {
31337, /* c0z we r hAx0rs */
"zcons",
0,
INFPSZ,
2048,
128
};
static struct qinit zc_rinit = {
NULL,
(int (*)()) zc_rsrv,
zc_open,
zc_close,
NULL,
&zc_info,
NULL
};
static struct qinit zc_winit = {
(int (*)()) zc_wput,
(int (*)()) zc_wsrv,
NULL,
NULL,
NULL,
&zc_info,
NULL
};
static struct streamtab zc_tab_info = {
&zc_rinit,
&zc_winit,
NULL,
NULL
};
#define ZC_CONF_FLAG (D_MP | D_MTQPAIR | D_MTOUTPERIM | D_MTOCEXCL)
/*
* this will define (struct cb_ops cb_zc_ops) and (struct dev_ops zc_ops)
*/
DDI_DEFINE_STREAM_OPS(zc_ops, nulldev, nulldev, zc_attach, zc_detach, nodev, \
zc_getinfo, ZC_CONF_FLAG, &zc_tab_info, ddi_quiesce_not_needed);
/*
* Module linkage information for the kernel.
*/
static struct modldrv modldrv = {
&mod_driverops, /* Type of module (this is a pseudo driver) */
"Zone console driver", /* description of module */
&zc_ops /* driver ops */
};
static struct modlinkage modlinkage = {
MODREV_1,
&modldrv,
NULL
};
typedef struct zc_state {
dev_info_t *zc_devinfo;
queue_t *zc_master_rdq;
queue_t *zc_slave_rdq;
vnode_t *zc_slave_vnode;
int zc_state;
} zc_state_t;
#define ZC_STATE_MOPEN 0x01
#define ZC_STATE_SOPEN 0x02
static void *zc_soft_state;
/*
* List of STREAMS modules that should be pushed onto every slave instance.
*/
static char *zcons_mods[] = {
"ptem",
"ldterm",
"ttcompat",
NULL
};
int
_init(void)
{
int err;
if ((err = ddi_soft_state_init(&zc_soft_state,
sizeof (zc_state_t), 0)) != 0) {
return (err);
}
if ((err = mod_install(&modlinkage)) != 0)
ddi_soft_state_fini(zc_soft_state);
return (err);
}
int
_fini(void)
{
int err;
if ((err = mod_remove(&modlinkage)) != 0) {
return (err);
}
ddi_soft_state_fini(&zc_soft_state);
return (0);
}
int
_info(struct modinfo *modinfop)
{
return (mod_info(&modlinkage, modinfop));
}
static int
zc_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
zc_state_t *zcs;
int instance;
if (cmd != DDI_ATTACH)
return (DDI_FAILURE);
instance = ddi_get_instance(dip);
if (ddi_soft_state_zalloc(zc_soft_state, instance) != DDI_SUCCESS)
return (DDI_FAILURE);
/*
* Create the master and slave minor nodes.
*/
if ((ddi_create_minor_node(dip, ZCONS_SLAVE_NAME, S_IFCHR,
instance << 1 | ZC_SLAVE_MINOR, DDI_PSEUDO, 0) == DDI_FAILURE) ||
(ddi_create_minor_node(dip, ZCONS_MASTER_NAME, S_IFCHR,
instance << 1 | ZC_MASTER_MINOR, DDI_PSEUDO, 0) == DDI_FAILURE)) {
ddi_remove_minor_node(dip, NULL);
ddi_soft_state_free(zc_soft_state, instance);
return (DDI_FAILURE);
}
VERIFY((zcs = ddi_get_soft_state(zc_soft_state, instance)) != NULL);
zcs->zc_devinfo = dip;
return (DDI_SUCCESS);
}
static int
zc_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
zc_state_t *zcs;
int instance;
if (cmd != DDI_DETACH)
return (DDI_FAILURE);
instance = ddi_get_instance(dip);
if ((zcs = ddi_get_soft_state(zc_soft_state, instance)) == NULL)
return (DDI_FAILURE);
if ((zcs->zc_state & ZC_STATE_MOPEN) ||
(zcs->zc_state & ZC_STATE_SOPEN)) {
DBG1("zc_detach: device (dip=%p) still open\n", (void *)dip);
return (DDI_FAILURE);
}
ddi_remove_minor_node(dip, NULL);
ddi_soft_state_free(zc_soft_state, instance);
return (DDI_SUCCESS);
}
/*
* zc_getinfo()
* getinfo(9e) entrypoint.
*/
/*ARGSUSED*/
static int
zc_getinfo(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result)
{
zc_state_t *zcs;
int instance = ZC_INSTANCE((dev_t)arg);
switch (infocmd) {
case DDI_INFO_DEVT2DEVINFO:
if ((zcs = ddi_get_soft_state(zc_soft_state, instance)) == NULL)
return (DDI_FAILURE);
*result = zcs->zc_devinfo;
return (DDI_SUCCESS);
case DDI_INFO_DEVT2INSTANCE:
*result = (void *)(uintptr_t)instance;
return (DDI_SUCCESS);
}
return (DDI_FAILURE);
}
/*
* Return the equivalent queue from the other side of the relationship.
* e.g.: given the slave's write queue, return the master's write queue.
*/
static queue_t *
zc_switch(queue_t *qp)
{
zc_state_t *zcs = qp->q_ptr;
ASSERT(zcs != NULL);
if (qp == zcs->zc_master_rdq)
return (zcs->zc_slave_rdq);
else if (OTHERQ(qp) == zcs->zc_master_rdq && zcs->zc_slave_rdq != NULL)
return (OTHERQ(zcs->zc_slave_rdq));
else if (qp == zcs->zc_slave_rdq)
return (zcs->zc_master_rdq);
else if (OTHERQ(qp) == zcs->zc_slave_rdq && zcs->zc_master_rdq != NULL)
return (OTHERQ(zcs->zc_master_rdq));
else
return (NULL);
}
/*
* For debugging and outputting messages. Returns the name of the side of
* the relationship associated with this queue.
*/
static const char *
zc_side(queue_t *qp)
{
zc_state_t *zcs = qp->q_ptr;
ASSERT(zcs != NULL);
if (qp == zcs->zc_master_rdq ||
OTHERQ(qp) == zcs->zc_master_rdq) {
return ("master");
}
ASSERT(qp == zcs->zc_slave_rdq || OTHERQ(qp) == zcs->zc_slave_rdq);
return ("slave");
}
/*ARGSUSED*/
static int
zc_master_open(zc_state_t *zcs,
queue_t *rqp, /* pointer to the read side queue */
dev_t *devp, /* pointer to stream tail's dev */
int oflag, /* the user open(2) supplied flags */
int sflag, /* open state flag */
cred_t *credp) /* credentials */
{
mblk_t *mop;
struct stroptions *sop;
/*
* Enforce exclusivity on the master side; the only consumer should
* be the zoneadmd for the zone.
*/
if ((zcs->zc_state & ZC_STATE_MOPEN) != 0)
return (EBUSY);
if ((mop = allocb(sizeof (struct stroptions), BPRI_MED)) == NULL) {
DBG("zc_master_open(): mop allocation failed\n");
return (ENOMEM);
}
zcs->zc_state |= ZC_STATE_MOPEN;
/*
* q_ptr stores driver private data; stash the soft state data on both
* read and write sides of the queue.
*/
WR(rqp)->q_ptr = rqp->q_ptr = zcs;
qprocson(rqp);
/*
* Following qprocson(), the master side is fully plumbed into the
* STREAM and may send/receive messages. Setting zcs->zc_master_rdq
* will allow the slave to send messages to us (the master).
* This cannot occur before qprocson() because the master is not
* ready to process them until that point.
*/
zcs->zc_master_rdq = rqp;
/*
* set up hi/lo water marks on stream head read queue and add
* controlling tty as needed.
*/
mop->b_datap->db_type = M_SETOPTS;
mop->b_wptr += sizeof (struct stroptions);
sop = (struct stroptions *)(void *)mop->b_rptr;
if (oflag & FNOCTTY)
sop->so_flags = SO_HIWAT | SO_LOWAT;
else
sop->so_flags = SO_HIWAT | SO_LOWAT | SO_ISTTY;
sop->so_hiwat = 512;
sop->so_lowat = 256;
putnext(rqp, mop);
return (0);
}
/*ARGSUSED*/
static int
zc_slave_open(zc_state_t *zcs,
queue_t *rqp, /* pointer to the read side queue */
dev_t *devp, /* pointer to stream tail's dev */
int oflag, /* the user open(2) supplied flags */
int sflag, /* open state flag */
cred_t *credp) /* credentials */
{
mblk_t *mop;
struct stroptions *sop;
major_t major;
minor_t minor;
minor_t lastminor;
uint_t anchorindex;
/*
* The slave side can be opened as many times as needed.
*/
if ((zcs->zc_state & ZC_STATE_SOPEN) != 0) {
ASSERT((rqp != NULL) && (WR(rqp)->q_ptr == zcs));
return (0);
}
/*
* Set up sad(7D) so that the necessary STREAMS modules will be in
* place. A wrinkle is that 'ptem' must be anchored
* in place (see streamio(7i)) because we always want the console to
* have terminal semantics.
*/
minor = ddi_get_instance(zcs->zc_devinfo) << 1 | ZC_SLAVE_MINOR;
major = ddi_driver_major(zcs->zc_devinfo);
lastminor = 0;
anchorindex = 1;
if (kstr_autopush(SET_AUTOPUSH, &major, &minor, &lastminor,
&anchorindex, zcons_mods) != 0) {
DBG("zc_slave_open(): kstr_autopush() failed\n");
return (EIO);
}
if ((mop = allocb(sizeof (struct stroptions), BPRI_MED)) == NULL) {
DBG("zc_slave_open(): mop allocation failed\n");
return (ENOMEM);
}
zcs->zc_state |= ZC_STATE_SOPEN;
/*
* q_ptr stores driver private data; stash the soft state data on both
* read and write sides of the queue.
*/
WR(rqp)->q_ptr = rqp->q_ptr = zcs;
qprocson(rqp);
/*
* Must follow qprocson(), since we aren't ready to process until then.
*/
zcs->zc_slave_rdq = rqp;
/*
* set up hi/lo water marks on stream head read queue and add
* controlling tty as needed.
*/
mop->b_datap->db_type = M_SETOPTS;
mop->b_wptr += sizeof (struct stroptions);
sop = (struct stroptions *)(void *)mop->b_rptr;
sop->so_flags = SO_HIWAT | SO_LOWAT | SO_ISTTY;
sop->so_hiwat = 512;
sop->so_lowat = 256;
putnext(rqp, mop);
return (0);
}
/*
* open(9e) entrypoint; checks sflag, and rejects anything unordinary.
*/
static int
zc_open(queue_t *rqp, /* pointer to the read side queue */
dev_t *devp, /* pointer to stream tail's dev */
int oflag, /* the user open(2) supplied flags */
int sflag, /* open state flag */
cred_t *credp) /* credentials */
{
int instance = ZC_INSTANCE(*devp);
int ret;
zc_state_t *zcs;
if (sflag != 0)
return (EINVAL);
if ((zcs = ddi_get_soft_state(zc_soft_state, instance)) == NULL)
return (ENXIO);
switch (ZC_NODE(*devp)) {
case ZC_MASTER_MINOR:
ret = zc_master_open(zcs, rqp, devp, oflag, sflag, credp);
break;
case ZC_SLAVE_MINOR:
ret = zc_slave_open(zcs, rqp, devp, oflag, sflag, credp);
break;
default:
ret = ENXIO;
break;
}
return (ret);
}
/*
* close(9e) entrypoint.
*/
/*ARGSUSED1*/
static int
zc_close(queue_t *rqp, int flag, cred_t *credp)
{
queue_t *wqp;
mblk_t *bp;
zc_state_t *zcs;
major_t major;
minor_t minor;
zcs = (zc_state_t *)rqp->q_ptr;
if (rqp == zcs->zc_master_rdq) {
DBG("Closing master side");
zcs->zc_master_rdq = NULL;
zcs->zc_state &= ~ZC_STATE_MOPEN;
/*
* qenable slave side write queue so that it can flush
* its messages as master's read queue is going away
*/
if (zcs->zc_slave_rdq != NULL) {
qenable(WR(zcs->zc_slave_rdq));
}
qprocsoff(rqp);
WR(rqp)->q_ptr = rqp->q_ptr = NULL;
} else if (rqp == zcs->zc_slave_rdq) {
DBG("Closing slave side");
zcs->zc_state &= ~ZC_STATE_SOPEN;
zcs->zc_slave_rdq = NULL;
wqp = WR(rqp);
while ((bp = getq(wqp)) != NULL) {
if (zcs->zc_master_rdq != NULL)
putnext(zcs->zc_master_rdq, bp);
else if (bp->b_datap->db_type == M_IOCTL)
miocnak(wqp, bp, 0, 0);
else
freemsg(bp);
}
/*
* Qenable master side write queue so that it can flush its
* messages as slaves's read queue is going away.
*/
if (zcs->zc_master_rdq != NULL)
qenable(WR(zcs->zc_master_rdq));
qprocsoff(rqp);
WR(rqp)->q_ptr = rqp->q_ptr = NULL;
/*
* Clear the sad configuration so that reopening doesn't fail
* to set up sad configuration.
*/
major = ddi_driver_major(zcs->zc_devinfo);
minor = ddi_get_instance(zcs->zc_devinfo) << 1 | ZC_SLAVE_MINOR;
(void) kstr_autopush(CLR_AUTOPUSH, &major, &minor, NULL, NULL,
NULL);
}
return (0);
}
static void
handle_mflush(queue_t *qp, mblk_t *mp)
{
mblk_t *nmp;
DBG1("M_FLUSH on %s side", zc_side(qp));
if (*mp->b_rptr & FLUSHW) {
DBG1("M_FLUSH, FLUSHW, %s side", zc_side(qp));
flushq(qp, FLUSHDATA);
*mp->b_rptr &= ~FLUSHW;
if ((*mp->b_rptr & FLUSHR) == 0) {
/*
* FLUSHW only. Change to FLUSHR and putnext other side,
* then we are done.
*/
*mp->b_rptr |= FLUSHR;
if (zc_switch(RD(qp)) != NULL) {
putnext(zc_switch(RD(qp)), mp);
return;
}
} else if ((zc_switch(RD(qp)) != NULL) &&
(nmp = copyb(mp)) != NULL) {
/*
* It is a FLUSHRW; we copy the mblk and send
* it to the other side, since we still need to use
* the mblk in FLUSHR processing, below.
*/
putnext(zc_switch(RD(qp)), nmp);
}
}
if (*mp->b_rptr & FLUSHR) {
DBG("qreply(qp) turning FLUSHR around\n");
qreply(qp, mp);
return;
}
freemsg(mp);
}
/*
* wput(9E) is symmetric for master and slave sides, so this handles both
* without splitting the codepath. (The only exception to this is the
* processing of zcons ioctls, which is restricted to the master side.)
*
* zc_wput() looks at the other side; if there is no process holding that
* side open, it frees the message. This prevents processes from hanging
* if no one is holding open the console. Otherwise, it putnext's high
* priority messages, putnext's normal messages if possible, and otherwise
* enqueues the messages; in the case that something is enqueued, wsrv(9E)
* will take care of eventually shuttling I/O to the other side.
*/
static void
zc_wput(queue_t *qp, mblk_t *mp)
{
unsigned char type = mp->b_datap->db_type;
zc_state_t *zcs;
struct iocblk *iocbp;
file_t *slave_filep;
struct snode *slave_snodep;
int slave_fd;
ASSERT(qp->q_ptr);
DBG1("entering zc_wput, %s side", zc_side(qp));
/*
* Process zcons ioctl messages if qp is the master console's write
* queue.
*/
zcs = (zc_state_t *)qp->q_ptr;
if (zcs->zc_master_rdq != NULL && qp == WR(zcs->zc_master_rdq) &&
type == M_IOCTL) {
iocbp = (struct iocblk *)(void *)mp->b_rptr;
switch (iocbp->ioc_cmd) {
case ZC_HOLDSLAVE:
/*
* Hold the slave's vnode and increment the refcount
* of the snode. If the vnode is already held, then
* indicate success.
*/
if (iocbp->ioc_count != TRANSPARENT) {
miocack(qp, mp, 0, EINVAL);
return;
}
if (zcs->zc_slave_vnode != NULL) {
miocack(qp, mp, 0, 0);
return;
}
/*
* The process that passed the ioctl must be running in
* the global zone.
*/
if (curzone != global_zone) {
miocack(qp, mp, 0, EINVAL);
return;
}
/*
* The calling process must pass a file descriptor for
* the slave device.
*/
slave_fd =
(int)(intptr_t)*(caddr_t *)(void *)mp->b_cont->
b_rptr;
slave_filep = getf(slave_fd);
if (slave_filep == NULL) {
miocack(qp, mp, 0, EINVAL);
return;
}
if (ZC_STATE_TO_SLAVEDEV(zcs) !=
slave_filep->f_vnode->v_rdev) {
releasef(slave_fd);
miocack(qp, mp, 0, EINVAL);
return;
}
/*
* Get a reference to the slave's vnode. Also bump the
* reference count on the associated snode.
*/
ASSERT(vn_matchops(slave_filep->f_vnode,
spec_getvnodeops()));
zcs->zc_slave_vnode = slave_filep->f_vnode;
VN_HOLD(zcs->zc_slave_vnode);
slave_snodep = VTOCS(zcs->zc_slave_vnode);
mutex_enter(&slave_snodep->s_lock);
++slave_snodep->s_count;
mutex_exit(&slave_snodep->s_lock);
releasef(slave_fd);
miocack(qp, mp, 0, 0);
return;
case ZC_RELEASESLAVE:
/*
* Release the master's handle on the slave's vnode.
* If there isn't a handle for the vnode, then indicate
* success.
*/
if (iocbp->ioc_count != TRANSPARENT) {
miocack(qp, mp, 0, EINVAL);
return;
}
if (zcs->zc_slave_vnode == NULL) {
miocack(qp, mp, 0, 0);
return;
}
/*
* The process that passed the ioctl must be running in
* the global zone.
*/
if (curzone != global_zone) {
miocack(qp, mp, 0, EINVAL);
return;
}
/*
* The process that passed the ioctl must have provided
* a file descriptor for the slave device. Make sure
* this is correct.
*/
slave_fd =
(int)(intptr_t)*(caddr_t *)(void *)mp->b_cont->
b_rptr;
slave_filep = getf(slave_fd);
if (slave_filep == NULL) {
miocack(qp, mp, 0, EINVAL);
return;
}
if (zcs->zc_slave_vnode->v_rdev !=
slave_filep->f_vnode->v_rdev) {
releasef(slave_fd);
miocack(qp, mp, 0, EINVAL);
return;
}
/*
* Decrement the snode's reference count and release the
* vnode.
*/
ASSERT(vn_matchops(slave_filep->f_vnode,
spec_getvnodeops()));
slave_snodep = VTOCS(zcs->zc_slave_vnode);
mutex_enter(&slave_snodep->s_lock);
--slave_snodep->s_count;
mutex_exit(&slave_snodep->s_lock);
VN_RELE(zcs->zc_slave_vnode);
zcs->zc_slave_vnode = NULL;
releasef(slave_fd);
miocack(qp, mp, 0, 0);
return;
default:
break;
}
}
if (zc_switch(RD(qp)) == NULL) {
DBG1("wput to %s side (no one listening)", zc_side(qp));
switch (type) {
case M_FLUSH:
handle_mflush(qp, mp);
break;
case M_IOCTL:
miocnak(qp, mp, 0, 0);
break;
default:
freemsg(mp);
break;
}
return;
}
if (type >= QPCTL) {
DBG1("(hipri) wput, %s side", zc_side(qp));
switch (type) {
case M_READ: /* supposedly from ldterm? */
DBG("zc_wput: tossing M_READ\n");
freemsg(mp);
break;
case M_FLUSH:
handle_mflush(qp, mp);
break;
default:
/*
* Put this to the other side.
*/
ASSERT(zc_switch(RD(qp)) != NULL);
putnext(zc_switch(RD(qp)), mp);
break;
}
DBG1("done (hipri) wput, %s side", zc_side(qp));
return;
}
/*
* Only putnext if there isn't already something in the queue.
* otherwise things would wind up out of order.
*/
if (qp->q_first == NULL && bcanputnext(RD(zc_switch(qp)), mp->b_band)) {
DBG("wput: putting message to other side\n");
putnext(RD(zc_switch(qp)), mp);
} else {
DBG("wput: putting msg onto queue\n");
(void) putq(qp, mp);
}
DBG1("done wput, %s side", zc_side(qp));
}
/*
* rsrv(9E) is symmetric for master and slave, so zc_rsrv() handles both
* without splitting up the codepath.
*
* Enable the write side of the partner. This triggers the partner to send
* messages queued on its write side to this queue's read side.
*/
static void
zc_rsrv(queue_t *qp)
{
zc_state_t *zcs;
zcs = (zc_state_t *)qp->q_ptr;
/*
* Care must be taken here, as either of the master or slave side
* qptr could be NULL.
*/
ASSERT(qp == zcs->zc_master_rdq || qp == zcs->zc_slave_rdq);
if (zc_switch(qp) == NULL) {
DBG("zc_rsrv: other side isn't listening\n");
return;
}
qenable(WR(zc_switch(qp)));
}
/*
* This routine is symmetric for master and slave, so it handles both without
* splitting up the codepath.
*
* If there are messages on this queue that can be sent to the other, send
* them via putnext(). Else, if queued messages cannot be sent, leave them
* on this queue.
*/
static void
zc_wsrv(queue_t *qp)
{
mblk_t *mp;
DBG1("zc_wsrv master (%s) side", zc_side(qp));
/*
* Partner has no read queue, so take the data, and throw it away.
*/
if (zc_switch(RD(qp)) == NULL) {
DBG("zc_wsrv: other side isn't listening");
while ((mp = getq(qp)) != NULL) {
if (mp->b_datap->db_type == M_IOCTL)
miocnak(qp, mp, 0, 0);
else
freemsg(mp);
}
flushq(qp, FLUSHALL);
return;
}
/*
* while there are messages on this write queue...
*/
while ((mp = getq(qp)) != NULL) {
/*
* Due to the way zc_wput is implemented, we should never
* see a control message here.
*/
ASSERT(mp->b_datap->db_type < QPCTL);
if (bcanputnext(RD(zc_switch(qp)), mp->b_band)) {
DBG("wsrv: send message to other side\n");
putnext(RD(zc_switch(qp)), mp);
} else {
DBG("wsrv: putting msg back on queue\n");
(void) putbq(qp, mp);
break;
}
}
}