ip_strm_mod.c

来自「7号信令功能代码,为开源代码」· C语言 代码 · 共 1,537 行 · 第 1/3 页

    }

    case M_IOCTL:
	if (ip_to_streams_ioctl(q, mp))		/* forward */
	    putnext(q, mp);
	break;

    case M_FLUSH:
	if (*mp->b_rptr & FLUSHW)
	{
	    flushq(q, FLUSHDATA);
	}

	if (*mp->b_rptr & FLUSHR)
	{
	    flushq(RD(q), FLUSHDATA);
	    *mp->b_rptr &= ~FLUSHW;
	    qreply(q, mp);
	}
	else
	    freemsg(mp);

	break;

    default:
	freemsg(mp) ;
	break;

    } /* switch */

    return(0) ;

} /* ip_to_streams_wput */


/************************************************************************
*                        ip_to_streams_allocb                           *
*************************************************************************
*									*
* Allocate a STREAMS buffer.  Trigger retry mechanism if fail.		*
*									*
* Parameters:								*
*	q	The queue to use for retries.				*
*		NULL q defeats retry procedure.				*
*	mp	The message to insert into the queue if retrying.	*
*		A NULL mp means nothing to insert into the queue	*
*		but the retry occurs anyway.				*
*	type	The type of message to allocate (M_PROTO, ...)		*
*	size	The size of the STREAMS buffer to allocate.		*
*	priority The buffer allocation priority.			*
*	head	Queue the buffer at the head of the queue, not tail.	*
*	bufcall_id Pointer to integer where bufcall id is to be stored.	*
*									*
* Returns:								*
*	ptr	If buffer was allocated.				*
*	NULL	If buffer not allocated.  bufcall() has been called	*
*		and the 'mp' has been placed into the 'q'.		*
*									*
************************************************************************/
mblk_t *ip_to_streams_allocb(queue_t		*q,
		    mblk_t		*mp,
		    int   		 type,
		    int    		 size,
		    int     		 priority,
		    int	    		 head,
		    int			*bufcall_id)
{
    mblk_t	*msg ;

    if ( ip_to_streams_debug_mask & DBG_ALLOCB )
	cmn_err(CE_CONT, "\nip_to_streams_allocb: called\n");

    msg = allocb(size, priority) ;

    if (msg != (mblk_t *) NULL)
    {						/* buffer allocated */
	msg->b_datap->db_type = type ;
	return(msg) ;
    }
    return((mblk_t *) NULL) ;

} /* ip_to_streams_allocb */

/************************************************************************
*                          ip_to_streams_merror                         *
*************************************************************************
*									*
* Send an M_ERROR upstream.						*
*									*
* We will use the mp given to us if we can.				*
*									*
************************************************************************/
int
ip_to_streams_m_error(ip_to_streams_minor_t *minor_ptr, mblk_t *mp, int errno, int retry)
{
    if ( ip_to_streams_debug_mask & DBG_SQUAWK )
	cmn_err(CE_CONT, "\nip_to_streams_m_error: called\n");

    if (   minor_ptr == (ip_to_streams_minor_t *) NULL)
    {
	if (ip_to_streams_debug_mask & DBG_SQUAWK)
	    cmn_err(CE_NOTE, "ip_to_streams_m_error: bad or detached minor %x",
		    minor_ptr) ;

	if (mp != (mblk_t *) NULL) freemsg(mp) ;
	return(1) ;				/* message "sent" */
    }

    flushq(minor_ptr->dl_rdq, FLUSHALL);	/* ensure queue empty */
    minor_ptr->dl_retry_proto = 0 ;		/* TLI proto to retry */
    minor_ptr->dl_err_prim = -1 ;		/* for error ack retry */
    minor_ptr->dlstate = 0 ;			/* go to null state */

    if (mp == (mblk_t *) NULL)
    {
	mp = ip_to_streams_allocb(minor_ptr->dl_wrq,
			 mp,
			 M_ERROR,
			 1,
			 BPRI_HI,
			 retry,
			 &minor_ptr->dl_bufcall_id) ;

	minor_ptr->dl_m_error  = errno | 0x100 ;	/* set retry flag */
	if (mp == (mblk_t *) NULL) return(0) ;		/* deferred */
    }
    else
    {
	mp->b_datap->db_type = M_ERROR ;
	mp->b_rptr = mp->b_wptr = mp->b_datap->db_base ;
    }

    *mp->b_wptr++ = errno ;			/* plant error code */

    minor_ptr->dl_m_error  = 0 ;		/* unset retry flag */

#ifdef GCOM
    if ( ip_to_streams_debug_mask & (DBG_UPR_PROTOS | DBG_MERROR) )
	rsys_decode_msg(rsys_nextq_name(minor_ptr->dl_rdq),
			"ip_to_streams_m_error: To",
			mp,
			0) ;
#endif

    putnext(minor_ptr->dl_rdq, mp);
    return(0);
} /* ip_to_streams_merror */


/************************************************************************
*                          ip_to_streams_error_ack                      *
*************************************************************************
*									*
* Send an error_ack upstream.						*
*									*
* Return 1 if succeed, 0 if deferred.					*
*									*
************************************************************************/
int
ip_to_streams_error_ack(ip_to_streams_minor_t *minor_ptr,
	       mblk_t       *mp,
	       long	     err_prim,
	       long          tli_error,
	       long          unix_error,
	       int	     retry)
{
    dl_error_ack_t		*p ;

    if ( ip_to_streams_debug_mask & DBG_SQUAWK )
	cmn_err(CE_CONT, "\nip_to_streams_error_ack: called\n");

    if (   mp == (mblk_t *) NULL
	|| mp->b_datap->db_lim - mp->b_datap->db_base < sizeof(*p)
	|| (!retry && (ip_to_streams_debug_mask & DBG_ALLOCB))
       )
    {					/* must allocate a buffer */
	if (mp != (mblk_t *) NULL) freemsg(mp) ;
	mp = ip_to_streams_allocb(minor_ptr->dl_rdq,
			 (mblk_t *) NULL,
			 M_PCPROTO,
			 sizeof(*p),
			 BPRI_MED,
			 retry,
			 &minor_ptr->dl_bufcall_id) ;
	if (mp == (mblk_t *) NULL)
	{
	    minor_ptr->dl_err_prim = err_prim ;
	    minor_ptr->dl_tli_err  = tli_error ;
	    minor_ptr->dl_unix_err = unix_error ;
	    return(0) ;				/* deferred */
	}
    }
    else
    {
	mp->b_datap->db_type = M_PCPROTO ;
	mp->b_rptr = mp->b_wptr = mp->b_datap->db_base ;
    }

    minor_ptr->dl_err_prim = -1 ;		/* ensure no retry */

    /*
     * Have a buffer, build error_ack and send it
     */
    mp->b_rptr = mp->b_datap->db_base ;
    mp->b_wptr = mp->b_datap->db_base ;

    p             = (dl_error_ack_t *) mp->b_wptr ;
    p->dl_primitive       = DL_ERROR_ACK ;
    p->dl_error_primitive = err_prim ;
    p->dl_errno           = tli_error ;
    p->dl_unix_errno      = unix_error ;
    mp->b_wptr   += sizeof(*p) ;

    putnext(minor_ptr->dl_rdq, mp);
    return(1) ;					/* succeed */

} /* ip_to_streams_error_ack */

/************************************************************************
*                         ip_to_streams_ok_ack	                        *
*************************************************************************
*									*
* Send an ok_ack upstream.						*
*									*
* Return 1 if succeed, 0 if deferred.					*
*									*
************************************************************************/
int
ip_to_streams_ok_ack(ip_to_streams_minor_t *minor_ptr,
	       mblk_t    *mp,
	       long	  ok_prim,
	       int	  retry)
{
    dl_ok_ack_t		*p ;

    if ( ip_to_streams_debug_mask & DBG_SQUAWK )
	cmn_err(CE_CONT, "\nip_to_streams_ok_ack: called\n");

    if (   minor_ptr == (ip_to_streams_minor_t *) NULL
	|| minor_ptr->dl_magic != DL_MAGIC
       )
    {
	if (ip_to_streams_debug_mask & DBG_SQUAWK)
	    cmn_err(CE_NOTE, "ip_to_streams_ok_ack: bad minor") ;

	if (mp != (mblk_t *) NULL) freemsg(mp) ;
	return(1) ;
    }

    if (   mp == (mblk_t *) NULL
	|| mp->b_datap->db_lim - mp->b_datap->db_base < sizeof(*p)
	|| (!retry && (ip_to_streams_debug_mask & DBG_ALLOCB))
       )
    {					/* must allocate a buffer */
	if (mp != (mblk_t *) NULL) freemsg(mp) ;
	mp = ip_to_streams_allocb(minor_ptr->dl_rdq,
			 (mblk_t *) NULL,
			 M_PCPROTO,
			 sizeof(*p),
			 BPRI_MED,
			 retry,
			 &minor_ptr->dl_bufcall_id) ;
	if (mp == (mblk_t *) NULL)
	{
	    minor_ptr->dl_err_prim = ok_prim ;
	    minor_ptr->dl_tli_err  = 0 ;
	    minor_ptr->dl_unix_err = 0 ;
	    return(0) ;				/* deferred */
	}
    }
    else
    {
	mp->b_datap->db_type = M_PCPROTO ;
	mp->b_rptr = mp->b_wptr = mp->b_datap->db_base ;
    }

    minor_ptr->dl_err_prim = -1 ;		/* ensure no retry */

    /*
     * Have a buffer, build ok_ack and send it
     */
    mp->b_rptr = mp->b_datap->db_base ;
    mp->b_wptr = mp->b_datap->db_base ;

    p               = (dl_ok_ack_t *) mp->b_wptr ;
    p->dl_primitive  = DL_OK_ACK ;
    p->dl_correct_primitive = ok_prim ;
    mp->b_wptr     += sizeof(*p) ;

    putnext(minor_ptr->dl_rdq, mp);
    return(1) ;					/* succeed */

} /* ip_to_streams_ok_ack */

/************************************************************************
*                          ip_to_streams_rsrv                           *
*************************************************************************
*									*
* Upstream retry procedure.						*
*									*
* Return 1 for success, 0 for deferred.					*
*									*
************************************************************************/

int ip_to_streams_rsrv(queue_t *q)
{
    ip_to_streams_minor_t	*minor_ptr ;
    int			 done ;

    if ( ip_to_streams_debug_mask & DBG_SVC )
	cmn_err(CE_CONT, "\nip_to_streams_rsrv: q=%x\n", q) ;

    minor_ptr = (ip_to_streams_minor_t *) q->q_ptr ;

    if (   minor_ptr == (ip_to_streams_minor_t *) NULL
	|| minor_ptr->dl_magic != DL_MAGIC
	|| minor_ptr->dl_rdq != q
       )
    {
	return(0) ;
    }

    done = 1 ;
    if (minor_ptr->dl_m_error > 0)
    {
	flushq(q, FLUSHALL);			/* ensure queue empty */
	ip_to_streams_m_error(minor_ptr, (mblk_t *) NULL, minor_ptr->dl_m_error, 1) ;
	return(0) ;
    }

    if (minor_ptr->dl_err_prim >= 0)
    {
	flushq(q, FLUSHALL);			/* ensure queue empty */
	if (minor_ptr->dl_tli_err == 0)
	{
	    done = ip_to_streams_ok_ack(minor_ptr,
			       (mblk_t *) NULL,
			       minor_ptr->dl_err_prim, 1) ;
	}
	else
	{
	    done = ip_to_streams_error_ack(minor_ptr,
				  (mblk_t *) NULL,
				  minor_ptr->dl_err_prim,
				  minor_ptr->dl_tli_err,
				  minor_ptr->dl_unix_err, 1) ;
	}
    }

    if (!done) return(0) ;		/* still retrying error/ok acks */

    /*
     * Try other protos
     */

    return(0) ;

} /* ip_to_streams_rsrv */

/************************************************************************
*                             ip_to_streams_wsrv                        *
*************************************************************************
*									*
* This is the downstream retry routine.					*
*									*
************************************************************************/

int ip_to_streams_wsrv(queue_t *q)
{
    ip_to_streams_minor_t	*minor_ptr ;
    mblk_t			*mp ;
    struct ism_dev		*dev ;
    int				 wakeup = 0 ;

    if ( ip_to_streams_debug_mask & DBG_SVC )
	cmn_err(CE_CONT, "\nip_to_streams_wsrv: q=%x\n", q) ;

    minor_ptr = (ip_to_streams_minor_t *) q->q_ptr ;

    if (   minor_ptr == (ip_to_streams_minor_t *) NULL
	|| minor_ptr->dl_magic != DL_MAGIC
       )
    {
	return(0) ;			/* bad minor */
    }

    dev = &minor_ptr->mydev;
    for (;;)
    {
	if ((mp = getq (minor_ptr -> dl_wrq)) == NULL)
	{
	    if (netif_queue_stopped(dev))
	    {
		netif_start_queue(dev) ;
		wakeup = 1 ;
	    }
	    break;			/* done */
	}

	if (mp -> b_datap -> db_type == M_DATA)
	{
	    if ( canputnext(q) )
	    {
		putnext(q, mp);		/* send downstream */
		if (netif_queue_stopped(dev))
		{
		    netif_start_queue(dev) ;
		    wakeup = 1 ;
		}
	    }
	    else
	    {
		netif_stop_queue(dev) ;
		putbq(q, mp);
		return(0);			/* quit */
	    }
	    minor_ptr->stats.tx_packets++;
	}
	else
	{
	    if (ip_to_streams_proto(minor_ptr, mp, 1) == 0)
	    {				/* deferred, queued */
		netif_stop_queue(dev) ;	/* stop output from above */
		return(0) ;		/* quit */
	    }

	    if (netif_queue_stopped(dev))
	    {
		netif_start_queue(dev) ;
		wakeup = 1 ;
	    }
	}
    }

    if (wakeup)
	netif_wake_queue(dev) ;		/* have netif look at our queue */

    return(0) ;

} /* ip_to_streams_wsrv */


/************************************************************************
*                           ip_to_streams_proto                         *
*************************************************************************
*									*
* Handle a DLPI proto message from above.				*
*									*
* Return 1 if succeed in handling msg, 0 if deferred.			*
*									*
************************************************************************/
int
ip_to_streams_proto(ip_to_streams_minor_t *minor_ptr, mblk_t *mp, int retry)
{
    queue_t *q = minor_ptr->dl_wrq ;
    long	*lp ;

    if ( ip_to_streams_debug_mask & DBG_SQUAWK )
	cmn_err(CE_CONT, "\nip_to_streams_proto: called\n");

    lp = (long *) mp->b_rptr ;

    switch (*lp)
    {
    case DL_UNITDATA_REQ:
	if ( canputnext(q) )
	{
	    putnext(q, mp);
	    return(1) ;
	}

	putq(q, mp);

	break ;

    default:
	if ( canputnext(q) )
	{
	    putnext(q, mp);
	    return(1) ;
	}

	putq(q, mp);
	break ;
    }

    return(0);				/* deferred */

} /* ip_to_streams_proto */

/************************************************************************
*                           ip_to_streams_rput                          *
*************************************************************************
*									*
* Handle a message from below.						*
*									*
************************************************************************/
int ip_to_streams_rput(queue_t *q, mblk_t  *mp)
{
    ip_to_streams_minor_t      *minor_ptr = q->q_ptr;
    struct ism_dev *dev ;
    int convert_to_skbuf(ip_to_streams_minor_t *, mblk_t *);

    if (minor_ptr == NULL)
    {
	cmn_err(CE_WARN, "ip_to_streams_rput: q->q_ptr NULL") ;
	freemsg(mp) ;
	return(0) ;
    }

    dev = &minor_ptr->mydev;
    if ( ip_to_streams_debug_mask & DBG_PUT )
	cmn_err(CE_CONT,