/**
* ch_msg: - process message from queue
* @q: queue
* @mp: the message to process
*
* This simply flows data messages through with flow control and intercepts
* all other messages.
*/
static inline fastcall __hot int
ch_msg(queue_t *q, mblk_t *mp)
{
struct ch *ch = CH_PRIV(q);
if (test_bit(CH_ENABLE_BIT, &ch->flags)) {
if (likely(DB_TYPE(mp) == M_DATA)) {
if (likely(bcanputnext(q, mp->b_band))) {
putnext(q, mp);
return (0);
}
return (-EBUSY);
} else if (DB_TYPE(mp) == M_PROTO) {
if (*(uint32_t *) mp->b_rptr = CH_DATA_REQ) {
if (likely(bcanputnext(q, mp->b_band))) {
*(uint32_t *) mp->b_rptr = CH_DATA_IND;
putnext(q, mp);
return (0);
}
return (-EBUSY);
}
/* go slow */
}
}
return ch_msg_slow(ch, q, mp);
}
/*
* -------------------------------------------------------------------------
*
* M_FLUSH Handling
*
* -------------------------------------------------------------------------
*/
STATIC inline void
sscop_w_flush(queue_t *q, mblk_t *mp)
{
if (*mp->b_rptr & FLUSHW) {
if (*mp->b_rptr & FLUSHBAND)
flushband(q, mp->b_rptr[1], FLUSHDATA);
else
flushq(q, FLUSHDATA);
if (q - q_next) {
putnext(q, mp);
return;
}
*mp->b_rptr &= ~FLUSHW;
}
if (*mp->b_rptr & FLUSHR) {
if (*mp->b_rptr & FLUSHBAND)
flushband(RD(q), mp->b_rptr[1], FLUSHDATA);
else
flushq(RD(q), FLUSHDATA);
qreply(q, mp);
return;
}
if (q->q_next) {
putnext(q, mp);
return;
}
}
/**
* ptem_rput - read put procedure
* @q: read queue
* @mp: message to put
*/
static streamscall __hot_get int
ptem_rput(queue_t *q, mblk_t *mp)
{
/* fast path for data */
if (likely(mp->b_datap->db_type == M_DATA)) {
m_data:
/* no read side service procedure, do not check for flow control. */
putnext(q, mp);
return (0);
}
switch (mp->b_datap->db_type) {
case M_DATA:
goto m_data;
case M_IOCDATA:
case M_IOCACK:
/* should not happen */
swerr();
case M_READ:
case M_DELAY:
case M_IOCNAK:
freemsg(mp);
break;
default:
swerr();
case M_HANGUP:
case M_FLUSH: /* we do not queue on the read side */
putnext(q, mp);
break;
case M_IOCTL:
ptem_r_msg(q, mp);
break;
}
return (0);
}
/*
* wput(9E) is symmetric for master and slave sides, so this handles both
* without splitting the codepath.
*
* 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;
ASSERT(qp->q_ptr);
DBG1("entering zc_wput, %s side", zc_side(qp));
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));
}
/*
* telmodwsrv - module write service procedure
*/
static void
telmodwsrv(queue_t *q)
{
mblk_t *mp, *savemp;
struct telmod_info *tmip = (struct telmod_info *)q->q_ptr;
while ((mp = getq(q)) != NULL) {
if (!canputnext(q)) {
ASSERT(mp->b_datap->db_type < QPCTL);
(void) putbq(q, mp);
return;
}
switch (mp->b_datap->db_type) {
case M_DATA:
if (tmip->flags & TEL_STOPPED) {
(void) putbq(q, mp);
return;
}
/*
* Insert a null character if carraige return
* is not followed by line feed
*/
if (!snd_parse(q, mp)) {
return;
}
break;
case M_CTL:
if (((mp->b_wptr - mp->b_rptr) == 1) &&
(*(mp->b_rptr) == M_CTL_MAGIC_NUMBER)) {
savemp = mp->b_cont;
freeb(mp);
mp = savemp;
}
putnext(q, mp);
break;
case M_PROTO:
putnext(q, mp);
break;
default:
#ifdef DEBUG
cmn_err(CE_NOTE,
"telmodwsrv: unexpected msg type 0x%x",
mp->b_datap->db_type);
#endif
freemsg(mp);
}
}
}
/*
* dm2s_rsrv - Streams read side service procedure.
*
* All messages are received in the service procedure
* only. This is done to simplify the streams synchronization.
*/
int
dm2s_rsrv(queue_t *rq)
{
mblk_t *mp;
dm2s_t *dm2sp = (dm2s_t *)rq->q_ptr;
DPRINTF(DBG_DRV, ("dm2s_rsrv: called\n"));
ASSERT(dm2sp != NULL);
mutex_enter(&dm2sp->ms_lock);
/* Receive if there are any messages waiting in the mailbox. */
dm2s_receive(dm2sp);
mutex_exit(&dm2sp->ms_lock);
/* Send the received messages up the stream. */
while ((mp = getq(rq)) != NULL) {
if (canputnext(rq)) {
putnext(rq, mp);
} else {
putbq(rq, mp);
break;
}
}
DPRINTF(DBG_DRV, ("dm2s_rsrv: return\n"));
return (0);
}
static int
setup_stream(
queue_t *q,
int mode
)
{
register mblk_t *mp;
pprintf(DD_OPEN,"parse: SETUP_STREAM - setting up stream for q=%x\n", q);
mp = allocb(sizeof(struct stroptions), BPRI_MED);
if (mp)
{
struct stroptions *str = (void *)mp->b_wptr;
str->so_flags = SO_READOPT|SO_HIWAT|SO_LOWAT|SO_ISNTTY;
str->so_readopt = (mode == M_PARSE) ? RMSGD : RNORM;
str->so_hiwat = (mode == M_PARSE) ? sizeof(parsetime_t) : 256;
str->so_lowat = 0;
mp->b_datap->db_type = M_SETOPTS;
mp->b_wptr += sizeof(struct stroptions);
if (!q)
panic("NULL q - strange");
putnext(q, mp);
return putctl1(WR(q)->q_next, M_CTL, (mode == M_PARSE) ? MC_SERVICEIMM :
MC_SERVICEDEF);
}
else
{
pprintf(DD_OPEN, "parse: setup_stream - FAILED - no MEMORY for allocb\n");
return 0;
}
}
static int
log_rsrv(queue_t *q)
{
mblk_t *mp;
char *msg, *msgid_start, *msgid_end;
size_t idlen;
while (canputnext(q) && (mp = getq(q)) != NULL) {
if (log_msgid == 0) {
/*
* Strip out the message ID. If it's a kernel
* SL_CONSOLE message, replace msgid with "unix: ".
*/
msg = (char *)mp->b_cont->b_rptr;
if ((msgid_start = strstr(msg, "[ID ")) != NULL &&
(msgid_end = strstr(msgid_start, "] ")) != NULL) {
log_ctl_t *lc = (log_ctl_t *)mp->b_rptr;
if ((lc->flags & SL_CONSOLE) &&
(lc->pri & LOG_FACMASK) == LOG_KERN)
msgid_start = msg + snprintf(msg,
7, "unix: ");
idlen = msgid_end + 2 - msgid_start;
ovbcopy(msg, msg + idlen, msgid_start - msg);
mp->b_cont->b_rptr += idlen;
}
}
mp->b_band = 0;
putnext(q, mp);
}
return (0);
}
static void
t_rput(queue_t *q, mblk_t *mp)
{
int err = EOPNOTSUPP;
trace();
if (q->q_count && mp->b_datap->db_type < QPCTL) {
putq(q, mp);
return;
}
switch (mp->b_datap->db_type) {
case M_DATA:
if ((err = t_m_data(q, mp)))
break;
return;
case M_CTL:
case M_PROTO:
case M_PCPROTO:
if ((err = t_m_proto(q, mp)))
break;
return;
}
switch (err) {
case EAGAIN:
putq(q, mp);
return;
case EOPNOTSUPP:
if (q->q_next) {
putnext(q, mp);
return;
}
}
freemsg(mp);
}
static fastcall __unlikely int
ch_m_flush(queue_t *q, mblk_t *mp)
{
if (mp->b_rptr[0] & ((q->q_flag & QREADR) ? FLUSHR : FLUSHW)) {
if (mp->b_rptr[0] & FLUSHBAND)
flushband(q, mp->b_rptr[1], FLUSHDATA);
else
flushq(q, FLUSHDATA);
}
/* do a pipemod flush sense reversal too */
switch (mp->b_rptr[0] & FLUSHRW) {
case FLUSHR:
mp->b_rptr[0] &= ~FLUSHRW;
mp->b_rptr[0] |= FLUSHW;
break;
case FLUSHW:
mp->b_rptr[0] &= ~FLUSHRW;
mp->b_rptr[0] |= FLUSHR;
break;
case FLUSHRW:
mp->b_rptr[0] &= ~FLUSHRW;
mp->b_rptr[0] |= FLUSHRW;
break;
}
putnext(q, mp);
return (0);
}
static int
setup_stream(
queue_t *q,
int mode
)
{
mblk_t *mp;
mp = allocb(sizeof(struct stroptions), BPRI_MED);
if (mp)
{
struct stroptions *str = (struct stroptions *)(void *)mp->b_rptr;
str->so_flags = SO_READOPT|SO_HIWAT|SO_LOWAT;
str->so_readopt = (mode == M_PARSE) ? RMSGD : RNORM;
str->so_hiwat = (mode == M_PARSE) ? sizeof(parsetime_t) : 256;
str->so_lowat = 0;
mp->b_datap->db_type = M_SETOPTS;
mp->b_wptr += sizeof(struct stroptions);
putnext(q, mp);
return putctl1(WR(q)->q_next, M_CTL, (mode == M_PARSE) ? MC_SERVICEIMM :
MC_SERVICEDEF);
}
else
{
parseprintf(DD_OPEN,("parse: setup_stream - FAILED - no MEMORY for allocb\n"));
return 0;
}
}
/************************************************************************
*
* Function Name: ip2xinet_lwsrv
* Title: IP2XINET Lower Write Service routine
*
* Description:
* Send all of the messages on this queue down to the next driver.
* If we discover that we can't do a put, then stop the Linux
* devices from sending us stuff.
*
************************************************************************/
STATIC streamscall int
ip2xinet_lwsrv(queue_t *q)
{
mblk_t *mp;
int allsent = 1;
int i;
struct ip2xinet_dev *dev = ip2xinet_devs;
struct ip2xinet_priv *privp;
while ((mp = getq(q))) {
/* M_PROTO's should be last on the list. If it is something else, then it should
be ahead, and we can just go ahead and put it down. */
if (mp->b_datap->db_type == M_PROTO) {
if (canputnext(q)) {
putnext(q, mp);
} else {
noenable(q);
if (!putbq(q, mp))
freemsg(mp); /* FIXME */
enableok(q);
allsent = 0;
break;
}
} else {
putnext(q, mp);
}
}
/* Handle the flow control. If we were able to send everything then it is ok for the
kernel to send us more stuff. Otherwise it is not ok. Go through all of the devices
and set the appropriate state. */
spin_lock(&ip2xinet_lock);
for (i = 0; i < NUMIP2XINET; i++, dev++) {
privp = &dev->priv;
if (privp->state == 1 && ip2xinet_status.ip2x_dlstate == DL_IDLE) {
if (allsent) {
netif_start_queue(&dev->dev); /* kernel can transmit */
} else {
netif_stop_queue(&dev->dev); /* We are flow controlled. */
}
}
}
spin_unlock(&ip2xinet_lock);
return (0);
}
/**
* pckt_wput - write-side put procedure
* @q: write queue
* @mp: message to put
*
* When the user process writes data, the pckt module passes the message on to
* the next module or driver unchanged.
*/
static streamscall int
pckt_wput(queue_t *q, mblk_t *mp)
{
/* No write-side service procedure, no need to check for flow control, pass the message
along. */
putnext(q, mp);
return (0);
}
int kz_put_json (kz_t *kz, const char *json_str)
{
if (!(kz->flags & KZ_FLAGS_RAW)) {
errno = EINVAL;
return -1;
}
return putnext (kz, json_str);
}
/* ARGSUSED */
static void
cvc_input_daemon(void)
{
char linebuf[MAX_XFER_CINPUT + 1];
char *cp;
mblk_t *mbp;
int c;
int dropped_read = 0;
for (;;) {
cvc_getstr(linebuf);
mbp = allocb(strlen(linebuf), BPRI_MED);
if (mbp == NULL) { /* drop it & go on if no buffer */
if (!dropped_read) {
cmn_err(CE_WARN, "cvc_input_daemon: "
"dropping IOSRAM reads");
}
dropped_read++;
continue;
}
if (dropped_read) {
cmn_err(CE_WARN,
"cvc_input_daemon: dropped %d IOSRAM reads",
dropped_read);
dropped_read = 0;
}
for (cp = linebuf; *cp != '\0'; cp++) {
c = (int)*cp;
if (c == '\r')
c = '\n';
c &= 0177;
*mbp->b_wptr = (char)c;
mbp->b_wptr++;
}
mutex_enter(&cvcmutex);
if (input_ok) {
if (cvcinput_q == NULL) {
cmn_err(CE_WARN,
"cvc_input_daemon: cvcinput_q is NULL!");
} else {
/*
* XXX - should canputnext be called here?
* Starfire's cvc doesn't do that, and it
* appears to work anyway.
*/
(void) putnext(cvcinput_q, mbp);
}
} else {
freemsg(mbp);
}
mutex_exit(&cvcmutex);
}
/* NOTREACHED */
}
/*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 = _TTY_BUFSIZ;
sop->so_lowat = 256;
putnext(rqp, mop);
return (0);
}
/*
* Upstream messages are passed unchanged.
* If a hangup occurs the target is no longer usable, so deprecate it.
*/
static int
wcmrput(queue_t *q, mblk_t *mp)
{
if (DB_TYPE(mp) == M_HANGUP)
/* Don't block waiting for outstanding operations to complete */
srpop(q->q_stream->sd_vnode, B_FALSE);
putnext(q, mp);
return (0);
}
static void
t_wput(queue_t *q, mblk_t *mp)
{
trace();
if (mp->b_datap->db_type < QPCTL && (q->q_count || !canputnext(q)))
putq(q, mp);
else
putnext(q, mp);
}
/*
* -------------------------------------------------------------------------
*
* WRITE QUEUE PUT and SRV routines
*
* -------------------------------------------------------------------------
*
* SSCOP WPUT - Message from above.
*
* If the message is priority message we attempt to process it immediately.
* If the message is non-priority message, but there are no messages on the
* queue yet, we attempt to process it immediately. If the message is not
* supported, we pass it down-queue if possible. If the message cannot be
* processed immediately, we place it on the queue.
*/
STATIC int
sscop_wput(queue_t *q, mblk_t *mp)
{
mblk_t *mp;
int err = -EOPNOTSUPP;
if (q->q_count && mp->b_datap->db_type < QPCTL) {
putq(q, mp);
/*
* NOTE:- after placing messages on the queue here, I should
* check for transmit congestion. I should check if placing
* the message on the queue crosses a band threshold for
* congestion onset and abatement. When crossing congestion
* thresholds, I should notify MTP3.
*/
return (0);
}
switch (mp->b_datap->db_type) {
case M_DATA:
if ((err = sscop_w_data(q, mp)))
break;
return (0);
case M_PROTO:
if ((err = sscop_w_proto(q, mp)))
break;
return (0);
case M_PCPROTO:
if ((err = sscop_w_pcproto(q, mp)))
break;
return (0);
case M_CTL:
if ((err = sscop_w_ctl(q, mp)))
break;
return (0);
case M_IOCTL:
if ((err = sscop_w_ioctl(q, mp)))
break;
return (0);
case M_FLUSH:
sscop_w_flush(q, mp);
return (0);
}
switch (err) {
case -EAGAIN:
if (mp->b_datap->db_type < QPCTL) {
putq(q, mp);
return (0);
}
case -EOPNOTSUPP:
if (q->q_next) {
putnext(q, mp);
return (0);
}
}
freemsg(mp);
return (err);
}
/*
* SDL_DISCONNECT_IND
* -----------------------------------
*/
STATIC INLINE int
sdl_disconnect_ind(queue_t *q, mblk_t *mp)
{
union SDL_primitives *p = (union SDL_primitives *) mp->b_rptr;
p->sdl_primitive = SDL_DISCONNECT_IND;
putnext(q, mp);
return (QR_ABSORBED);
}
/*
* SDL_RECEIVED_BITS_IND
* -----------------------------------
*/
STATIC INLINE int
sdl_received_bits_ind(queue_t *q, mblk_t *mp)
{
union SDL_primitives *p = (union SDL_primitives *) mp->b_rptr;
p->sdl_primitive = SDL_RECEIVED_BITS_IND;
putnext(q, mp);
return (QR_ABSORBED);
}
/************************************************************************
*
* Function Name: ip2xinet_ursrv
* Title: IP2XINET Upper Read Service routine
*
* Description:
* Send all of the messages on this queue up to the next driver.
* We don't worry about doing flow control. This is used because in
* the places where we might want to call putnext, we call putq
* instead.
*
************************************************************************/
STATIC streamscall int
ip2xinet_ursrv(queue_t *q)
{
mblk_t *mp;
while ((mp = getq(q))) {
putnext(q, mp);
}
return (0);
}
/*ARGSUSED1*/
static int
zc_close(queue_t *rqp, int flag, cred_t *credp)
{
queue_t *wqp;
mblk_t *bp;
zc_state_t *zcs;
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;
}
return (0);
}
/*
* SSCOP RSRV - Queued message from below.
*
* If the message is a priority message we attempt to process it immediately
* and without flow control. If the message is a non-priority message and
* the next queue is flow controlled, we put the message back on the queue
* and wait. If we cannot process a priority message immediately we cannot
* place it back on the queue and discard it. We requeue non-priority
* messages which cannot be processed immediately. Unrecognized messages are
* passed down-queue.
*/
STATIC int
sscop_rsrv(queue_t *q)
{
mblk_t *mp;
int err = -EOPNOTSUPP;
while ((mp = getq(q))) {
if (mp->b_datap->db_type < QPCTL && !canputnext(q)) {
putbq(q, mp);
return (0);
}
switch (mp->b_datap->db_type) {
case M_DATA:
if ((err = sscop_r_data(q, mp)))
break;
goto rsrv_continue;
case M_PROTO:
if ((err = sscop_r_proto(q, mp)))
break;
goto rsrv_continue;
case M_PCPROTO:
if ((err = sscop_r_pcproto(q, mp)))
break;
goto rsrv_continue;
case M_CTL:
if ((err = sscop_r_ctl(q, mp)))
break;
goto rsrv_continue;
}
switch (err) {
case -EAGAIN:
if (mp->b_datap->db_type < QPCTL) {
putbq(q, mp);
return (0);
}
case -EOPNOTSUPP:
if (q->q_next) {
putnext(q, mp);
goto rsrv_continue;
}
break;
}
freemsg(mp);
rsrv_continue:
/*
* NOTE:- I have removed and processed a message from the
* receive queue, so I should check for receive congestion
* abatement. If receive congestion has abated below the
* accept threshold, I should signal MTP that there is no
* longer any receive congestion.
*/
continue;
}
return (0);
}
/*
* -------------------------------------------------------------------------
*
* M_IOCTL Handling
*
* -------------------------------------------------------------------------
*/
STATIC inline int
sscop_w_ioctl(queue_t *q, mblk_t *mp)
{
int ret;
struct iocblk *iocp = (struct iocblk *) mp->b_rptr;
int cmd = iocp->ioc_cmd;
void *arg = mp->b_cont ? mp->b_cont->b_rptr : NULL;
int type = _IOC_TYPE(cmd);
int nr = _IOC_NR(cmd);
int size = _IOC_SIZE(cmd);
switch (type) {
case __SID:
switch (cmd) {
case I_LINK:
case I_PLINK:
case I_UNLINK:
case I_PUNLINK:
{
struct linkblk *lp = (struct linkblk *) arg;
(void) lp;
}
default:
case I_FDINSERT:
ret = -EINVAL;
}
break;
case SSCOP_IOC_MAGIC:
if (iocp->ioc_count >= size) {
if (0 <= nr && nr < sizeof(sscop_ioctl) / sizeof(void *)) {
if (sscop_ioctl[nr])
ret = (*sscop_ioctl[nr]) (q, cmd, arg);
else
ret = -EOPNOTSUPP;
}
} else
return = -EINVAL;
break;
default:
if (q->q_next) {
putnext(q, mp);
return (0);
}
ret = -EOPNOTSUPP;
}
mp->b_datap->db_type = ret ? M_IOCNAK : M_IOCACK;
iocp->ioc_error = -ret;
iocp->ioc_rval = ret ? -1 : 0;
qrepy(q, mp);
return (0);
}
/*
* -------------------------------------------------------------------------
*
* M_ERROR Handling
*
* -------------------------------------------------------------------------
*/
STATIC inline void
sscop_r_error(queue_t *q, mblk_t *mp)
{
sscop_t *sp = SSCOP_PRIV(q);
sp->zapped = 1;
if (q->q_next) {
putnext(q, mp);
return;
}
}
int
dl_unitdata_req( queue_t *q, mblk_t *m0, ushort type, caddr_t addr )
{
union DL_primitives *dl;
struct llc *llc;
mblk_t *m1, *m;
ushort len;
/* len = msgdsize( m0 ) + sizeof( struct llc ); */
if (( m1 = allocb( sizeof( struct llc ), BPRI_HI )) == NULL ) {
cmn_err( CE_NOTE, "dl_unitdate_req NOMEM 1\n" );
return( ENOMEM );
}
m1->b_wptr = m1->b_rptr + sizeof( struct llc );
m1->b_datap->db_type = M_DATA;
llc = (struct llc *)m1->b_rptr;
llc->llc_dsap = llc->llc_ssap = LLC_SNAP_LSAP;
llc->llc_control = LLC_UI;
if ( type == ETHERTYPE_AARP ) {
bcopy( aarp_org_code, llc->llc_org_code, sizeof( aarp_org_code ));
} else if ( type == ETHERTYPE_AT ) {
bcopy( at_org_code, llc->llc_org_code, sizeof( aarp_org_code ));
} else {
cmn_err( CE_NOTE, "dl_unitdate_req type %X\n", type );
return( EINVAL );
}
llc->llc_ether_type = htons( type );
linkb( m1, m0 );
if (( m = allocb( DL_UNITDATA_REQ_SIZE + ETHERADDRL + sizeof( ushort ),
BPRI_HI )) == NULL ) {
cmn_err( CE_NOTE, "dl_unitdate_req NOMEM 2\n" );
return( ENOMEM );
}
m->b_wptr = m->b_rptr + DL_UNITDATA_REQ_SIZE;
m->b_datap->db_type = M_PROTO;
linkb( m, m1 );
dl = (union DL_primitives *)m->b_rptr;
dl->dl_primitive = DL_UNITDATA_REQ;
dl->unitdata_req.dl_dest_addr_length = ETHERADDRL + sizeof ( ushort );
dl->unitdata_req.dl_dest_addr_offset = m->b_wptr - m->b_rptr;
bcopy(addr, m->b_wptr, ETHERADDRL );
m->b_wptr += ETHERADDRL;
len = 0;
bcopy( &len, m->b_wptr, sizeof( ushort ));
m->b_wptr += sizeof( ushort );
putnext( q, m );
return( 0 );
}
/*
* SSCOP WSRV = Queued message from above.
*
* If the message is a priority message we attempt to process it immediately
* and without flow control. If the message is a non-priority message and
* the next queue is flow controlled, we put the message back on the queue
* and wait. If we cannot process a priority message immediately we cannot
* place it back on the queue, we discard it. We requeue non-priority
* messages which cannot be processed immediately. Unrecognized messages are
* passed down-queue.
*/
STATIC int
sscop_wsrv(queue_t *q)
{
int err = -EOPNOTSUPP;
mblk_t *mp;
while ((mp = getq(q))) {
if (q->q_next && mp->b_datap->db_type < QPCTL && !canputnext(q)) {
putbq(q, mp);
return (0);
}
switch (mp->b_datap->db_type) {
case M_DATA:
if ((err = sscop_w_data(q, mp)))
break;
goto wsrv_continue;
case M_PROTO:
if ((err = sscop_w_proto(q, mp)))
break;
goto wsrv_continue;
case M_PCPROTO:
if ((err = sscop_w_pcproto(q, mp)))
break;
goto wsrv_continue;
case M_CTL:
if ((err = sscop_w_ctl(q, mp)))
break;
goto wsrv_continue;
}
switch (err) {
case -EAGAIN:
if (mp->b_datap->db_type < QPCTL) {
putbq(q, mp);
return (0);
}
case -EOPNOTSUPP:
if (q->q_next) {
putnext(q, mp);
goto wsrv_continue;
}
}
freemsg(mp);
wsrv_continue:
/*
* NOTE:- I have removed a message from the queue, so I
* should check for band congestion abatement for the data
* band to see if transmit congestion has abated. If it has,
* I should notify MTP3 of transmit abatement.
*/
continue;
}
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;
/*
* 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);
}
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 *)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);
}
int streamscall
ip2xinet_open(queue_t *q, dev_t *devp, int flag, int sflag, cred_t *credp)
{
mblk_t *bp;
minor_t minor;
struct stroptions *sop;
/* already open */
if (sflag != CLONEOPEN)
return ENXIO;
spin_lock(&ip2xinet_lock);
/* Can only open one time */
if (ip2xinet_numopen) {
spin_unlock(&ip2xinet_lock);
return ENXIO;
} else
ip2xinet_numopen = 1;
if (q->q_count != 0)
printk("ip2x level:q_count is %lu", (ulong) q->q_count);
/* Set up the flow control parameters and send them up to the stream head. */
minor = getminor(*devp);
if ((bp = allocb(sizeof(struct stroptions), BPRI_LO)) == NULL) {
spin_unlock(&ip2xinet_lock);
printk("%s: allocb failed", __FUNCTION__);
return ENOMEM;
}
ip2xinet_status.myminor = minor;
ip2xinet_status.ip2x_dlstate = DL_UNATTACHED;
/* These are dummy to keep track of the fact the device is open */
q->q_ptr = (char *) &ip2xinet_numopen;
WR(q)->q_ptr = (char *) &ip2xinet_numopen;
spin_unlock(&ip2xinet_lock);
bp->b_datap->db_type = M_SETOPTS;
bp->b_wptr += sizeof(struct stroptions);
sop = (struct stroptions *) bp->b_rptr;
sop->so_flags = SO_HIWAT | SO_LOWAT;
sop->so_hiwat = ip2xinet_minfo.mi_hiwat;
sop->so_lowat = ip2xinet_minfo.mi_lowat;
putnext(q, bp);
*devp = makedevice(getmajor(*devp), 0);
return 0;
}
