OpenSolaris_b135/uts/common/io/tirdwr.c
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License, Version 1.0 only
* (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 2004 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
/* All Rights Reserved */
#pragma ident "%Z%%M% %I% %E% SMI" /* from S5R4 1.4 */
/*
* Transport Interface Library read/write module - issue 1
*/
#include <sys/types.h>
#include <sys/param.h>
#include <sys/stream.h>
#include <sys/stropts.h>
#include <sys/tihdr.h>
#include <sys/debug.h>
#include <sys/errno.h>
#include <sys/kmem.h>
#include <sys/tirdwr.h>
#include <sys/conf.h>
#include <sys/modctl.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#define ORDREL 002
#define DISCON 004
#define FATAL 010
#define WAITACK 020
#define TIRDWR_ID 4
/*
* Per-Stream private data structure.
*/
struct trw_trw {
queue_t *trw_rdq;
uint_t trw_flags;
};
/*
* stream data structure definitions
*/
static int tirdwropen(queue_t *q, dev_t *dev,
int flag, int sflag, cred_t *cr);
static int tirdwrclose(queue_t *q, int flag, cred_t *cr);
static int check_strhead(queue_t *q);
/*
* To save instructions, since STREAMS ignores the return value
* from these functions, they are defined as void here. Kind of icky, but...
*/
static void tirdwrrput(queue_t *q, mblk_t *mp);
static void tirdwrwput(queue_t *q, mblk_t *mp);
static struct module_info tirdwr_info = {
TIRDWR_ID,
"tirdwr",
0,
INFPSZ,
4096,
1024
};
static struct qinit tirdwrrinit = {
(int (*)())tirdwrrput,
(int (*)())NULL,
tirdwropen,
tirdwrclose,
nulldev,
&tirdwr_info,
NULL
};
static struct qinit tirdwrwinit = {
(int (*)())tirdwrwput,
(int (*)())NULL,
tirdwropen,
tirdwrclose,
nulldev,
&tirdwr_info,
NULL
};
static struct streamtab trwinfo = {
&tirdwrrinit,
&tirdwrwinit,
NULL,
NULL
};
static struct fmodsw fsw = {
"tirdwr",
&trwinfo,
D_NEW|D_MTQPAIR|D_MP
};
static struct modlstrmod modlstrmod = {
&mod_strmodops, "xport interface rd/wr str mod", &fsw
};
static struct modlinkage modlinkage = {
MODREV_1, &modlstrmod, NULL
};
int
_init(void)
{
return (mod_install(&modlinkage));
}
int
_fini(void)
{
return (mod_remove(&modlinkage));
}
int
_info(struct modinfo *modinfop)
{
return (mod_info(&modlinkage, modinfop));
}
static void send_fatal(queue_t *q, mblk_t *mp);
static void strip_strhead(queue_t *q);
/*
* tirdwropen - open routine gets called when the
* module gets pushed onto the stream.
*/
/*ARGSUSED*/
static int
tirdwropen(
queue_t *q,
dev_t *dev,
int flag,
int sflag,
cred_t *cr)
{
struct trw_trw *trwptr;
/* check if already open */
if (q->q_ptr) {
return (0);
}
/*
* Allocate a new trw_trw struct.
*/
trwptr = kmem_alloc(sizeof (struct trw_trw), KM_SLEEP);
/* initialize data structure */
trwptr->trw_flags = 0;
trwptr->trw_rdq = q;
q->q_ptr = (caddr_t)trwptr;
WR(q)->q_ptr = (caddr_t)trwptr;
qprocson(q);
freezestr(q);
(void) strqset(WR(q), QMAXPSZ, 0, (uintptr_t)WR(q)->q_next->q_maxpsz);
(void) strqset(q, QMAXPSZ, 0, (uintptr_t)q->q_next->q_maxpsz);
if (!check_strhead(q)) {
unfreezestr(q);
qprocsoff(q);
kmem_free(trwptr, sizeof (struct trw_trw));
return (EPROTO);
}
strip_strhead(q);
unfreezestr(q);
return (0);
}
/*
* tirdwrclose - This routine gets called when the module
* gets popped off of the stream.
*/
/*ARGSUSED1*/
static int
tirdwrclose(queue_t *q, int flag, cred_t *cr)
{
struct trw_trw *trwptr;
mblk_t *mp;
union T_primitives *pptr;
qprocsoff(q);
trwptr = (struct trw_trw *)q->q_ptr;
ASSERT(trwptr != NULL);
/*
* Send up a T_DISCON_IND if necessary.
*/
if ((trwptr->trw_flags & ORDREL) && !(trwptr->trw_flags & FATAL))
if (mp = allocb(sizeof (struct T_discon_req), BPRI_LO)) {
pptr = (union T_primitives *)mp->b_rptr;
mp->b_wptr = mp->b_rptr + sizeof (struct T_ordrel_req);
pptr->type = T_ORDREL_REQ;
mp->b_datap->db_type = M_PROTO;
putnext(WR(q), mp);
}
kmem_free(trwptr, sizeof (struct trw_trw));
return (0);
}
/*
* tirdwrrput - Module read queue put procedure.
* This is called from the module or
* driver downstream.
*/
static void
tirdwrrput(queue_t *q, mblk_t *mp)
{
union T_primitives *pptr;
struct trw_trw *trwptr;
mblk_t *tmp;
trwptr = (struct trw_trw *)q->q_ptr;
ASSERT(trwptr != NULL);
if ((trwptr->trw_flags & FATAL) && !(trwptr->trw_flags & WAITACK)) {
freemsg(mp);
return;
}
switch (mp->b_datap->db_type) {
default:
putnext(q, mp);
break;
case M_DATA:
putnext(q, mp);
break;
case M_PCPROTO:
case M_PROTO:
/* is there enough data to check type */
if ((mp->b_wptr - mp->b_rptr) < sizeof (t_scalar_t)) {
/* malformed message */
freemsg(mp);
break;
}
pptr = (union T_primitives *)mp->b_rptr;
switch (pptr->type) {
case T_EXDATA_IND:
send_fatal(q, mp);
break;
case T_DATA_IND:
if (msgdsize(mp) == 0) {
freemsg(mp);
break;
}
tmp = (mblk_t *)unlinkb(mp);
freemsg(mp);
putnext(q, tmp);
break;
case T_ORDREL_IND:
trwptr->trw_flags |= ORDREL;
mp->b_datap->db_type = M_DATA;
mp->b_wptr = mp->b_rptr;
putnext(q, mp);
break;
case T_DISCON_IND:
trwptr->trw_flags |= DISCON;
trwptr->trw_flags &= ~ORDREL;
if (msgdsize(mp) != 0) {
tmp = (mblk_t *)unlinkb(mp);
putnext(q, tmp);
}
mp->b_datap->db_type = M_HANGUP;
mp->b_wptr = mp->b_rptr;
putnext(q, mp);
break;
default:
send_fatal(q, mp);
break;
}
}
}
/*
* tirdwrwput - Module write queue put procedure.
* This is called from the module or
* stream head upstream.
*/
static void
tirdwrwput(queue_t *q, mblk_t *mp)
{
struct trw_trw *trwptr;
trwptr = (struct trw_trw *)q->q_ptr;
ASSERT(trwptr != NULL);
if (trwptr->trw_flags & FATAL) {
freemsg(mp);
return;
}
switch (mp->b_datap->db_type) {
default:
putnext(q, mp);
break;
case M_DATA:
putnext(q, mp);
break;
case M_PROTO:
case M_PCPROTO:
send_fatal(q, mp);
break;
}
}
static void
send_fatal(queue_t *q, mblk_t *mp)
{
struct trw_trw *trwptr;
trwptr = (struct trw_trw *)q->q_ptr;
trwptr->trw_flags |= FATAL;
mp->b_datap->db_type = M_ERROR;
*mp->b_datap->db_base = EPROTO;
mp->b_rptr = mp->b_datap->db_base;
mp->b_wptr = mp->b_datap->db_base + sizeof (char);
freemsg(unlinkb(mp));
if (q->q_flag&QREADR)
putnext(q, mp);
else
qreply(q, mp);
}
static int
check_strhead(queue_t *q)
{
mblk_t *mp;
union T_primitives *pptr;
for (mp = q->q_next->q_first; mp != NULL; mp = mp->b_next) {
switch (mp->b_datap->db_type) {
case M_PROTO:
pptr = (union T_primitives *)mp->b_rptr;
if ((mp->b_wptr - mp->b_rptr) < sizeof (t_scalar_t))
return (0);
switch (pptr->type) {
case T_EXDATA_IND:
return (0);
case T_DATA_IND:
if (mp->b_cont &&
(mp->b_cont->b_datap->db_type != M_DATA))
return (0);
break;
default:
return (0);
}
break;
case M_PCPROTO:
return (0);
case M_DATA:
case M_SIG:
break;
default:
return (0);
}
}
return (1);
}
static void
strip_strhead(queue_t *q)
{
mblk_t *mp;
mblk_t *emp;
mblk_t *tmp;
union T_primitives *pptr;
q = q->q_next;
/*CSTYLED*/
for (mp = q->q_first; mp != NULL; ) {
switch (mp->b_datap->db_type) {
case M_PROTO:
pptr = (union T_primitives *)mp->b_rptr;
switch (pptr->type) {
case T_DATA_IND:
if (msgdsize(mp) == 0) {
strip0:
tmp = mp->b_next;
rmvq(q, mp);
freemsg(mp);
mp = tmp;
break;
}
emp = mp->b_next;
rmvq(q, mp);
tmp = (mblk_t *)unlinkb(mp);
freeb(mp);
(void) insq(q, emp, tmp);
mp = emp;
break;
}
break;
case M_DATA:
if (msgdsize(mp) == 0)
goto strip0;
mp = mp->b_next;
break;
case M_SIG:
mp = mp->b_next;
break;
}
}
}