sdt2.c

No7信令,我需要交换类似的代码, 请店长审核,谢谢了,急着交换,谢谢

	} while(0); seldom(); return(err);
}
/*
 *  SDL_DAEDT_TRANSMISSION_REQUEST_IND
 *  -----------------------------------
 */
static int
sdl_daedt_transmission_request_ind(sdt_t *s, mblk_t *mp)
{
	int err;
	size_t mlen = mp->b_wptr - mp->b_rptr;
	sdl_daedt_transmission_request_ind_t *p = (sdl_daedt_transmission_request_ind_t *)mp->b_rptr;
	do {
	if ( mlen >= sizeof(*p) ) {
		return sdt_daedt_transmission_request(s);
	} seldom(); err = -EMSGSIZE;	    break;
	} while(0); seldom(); return(err);
}

/*
 *  =========================================================================
 *
 *  STREAMS Message Handling
 *
 *  =========================================================================
 */
/*
 *  -------------------------------------------------------------------------
 *
 *  M_IOCDATA Handling
 *
 *  -------------------------------------------------------------------------
 */
static int
sdt_w_iocdata(queue_t *q, mblk_t *mp)
{
	(void)q; (void)mp;
	return(4);
}
/*
 *  -------------------------------------------------------------------------
 *
 *  M_IOCTL Handling
 *
 *  -------------------------------------------------------------------------
 */
static int
sdt_w_ioctl(queue_t *q, mblk_t *mp)
{
	sdt_t *s = (sdt_t *)q->q_ptr;
	struct iocblk *iocp = (struct iocblk *)mp->b_rptr;
	void *arg = mp->b_cont?mp->b_cont->b_rptr:NULL;
	int cmd = iocp->ioc_cmd, count = iocp->ioc_count;
	struct linkblk *lp = (struct linkblk *)arg;
	caddr_t *uaddr = (caddr_t *)arg;
	int ret	    = 0;
	int type    = _IOC_TYPE	(cmd);
	int nr	    = _IOC_NR	(cmd);
	int size    = _IOC_SIZE	(cmd);
	int dir	    = _IOC_DIR	(cmd);
	switch ( type )
	{
		case __SID:
			switch ( cmd )
			{
				default:
					ptrace(("Unknown IOCTL %#08x\n",cmd));
				case I_STR:
				case I_LINK:
				case I_UNLINK:
				case I_PLINK:
				case I_PUNLINK:
					rare();
					(void)lp;
					ret = -EOPNOTSUPP;
					break;
			}
			ret = -EOPNOTSUPP;
			break;
		case SDT_IOC_MAGIC:
			if ( count == TRANSPARENT )
				ret = -EINVAL;
			else if ( count >= size )
			{
				switch ( cmd )
				{
					case SDT_IOCGOPTIONS:
					case SDT_IOCSOPTIONS:
					case SDT_IOCGCONFIG:
					case SDT_IOCSCONFIG:
					case SDT_IOCTCONFIG:
					case SDT_IOCCCONFIG:
					case SDT_IOCGSTATEM:
					case SDT_IOCCMRESET:
					case SDT_IOCSSTATSP:
					case SDT_IOCGSTATS:
					case SDT_IOCCSTATS:
					case SDT_IOCGNOTIFY:
					case SDT_IOCSNOTIFY:
					case SDT_IOCCNOTIFY:
					default:
						ret = -EOPNOTSUPP;
						break;
				}
			}
			else ret = -EINVAL;
			break;
		default:
			return(4);
	}
	if ( ret >= 0 )
	{
		mp->b_datap->db_type = M_IOCACK;
		iocp->ioc_error = 0;
		iocp->ioc_rval  = 0;
	}
	else
	{
		mp->b_datap->db_type = M_IOCNAK;
		iocp->ioc_error = -ret;
		iocp->ioc_rval	= -1;
	}
	qreply(q, mp);
	return(1);
}
/*
 *  -------------------------------------------------------------------------
 *
 *  M_PROTO, M_PCPROTO Handling
 *
 *  -------------------------------------------------------------------------
 */
static int
sdt_w_proto(queue_t *q, mblk_t *mp)
{
	int rtn;
	sdt_t *s = (sdt_t *)q->q_ptr;
	ulong oldstate = s->i_state;
	if ( mp->b_wptr - mp->b_rptr >= sizeof(long) ) {
	switch ( *((long *)mp->b_rptr) )
	{
		case LMI_INFO_REQ:			rtn = lmi_info_req		 (s, mp); break;
		case LMI_ATTACH_REQ:			rtn = lmi_attach_req		 (s, mp); break;
		case LMI_DETACH_REQ:			rtn = lmi_detach_req		 (s, mp); break;
		case LMI_ENABLE_REQ:			rtn = lmi_enable_req		 (s, mp); break;
		case LMI_DISABLE_REQ:			rtn = lmi_disable_req		 (s, mp); break;
		case LMI_OPTMGMT_REQ:			rtn = lmi_optmgmt_req		 (s, mp); break;
		case SDT_DAEDT_TRANSMISSION_REQ:	rtn = sdt_daedt_transmission_req (s, mp); break;
		case SDT_DAEDT_START_REQ:		rtn = sdt_daedt_start_req	 (s, mp); break;
		case SDT_DAEDR_START_REQ:		rtn = sdt_daedr_start_req	 (s, mp); break;
		case SDT_AERM_START_REQ:		rtn = sdt_aerm_start_req	 (s, mp); break;
		case SDT_AERM_STOP_REQ:			rtn = sdt_aerm_stop_req		 (s, mp); break;
		case SDT_AERM_SET_TI_TO_TIN_REQ:	rtn = sdt_aerm_set_ti_to_tin_req (s, mp); break;
		case SDT_AERM_SET_TI_TO_TIE_REQ:	rtn = sdt_aerm_set_ti_to_tie_req (s, mp); break;
		case SDT_SUERM_START_REQ:		rtn = sdt_suerm_start_req	 (s, mp); break;
		case SDT_SUERM_STOP_REQ:		rtn = sdt_suerm_stop_req	 (s, mp); break;
		default:				rtn = -EOPNOTSUPP;			  break;
	}
	} else { rare(); rtn = -EMSGSIZE; }
	if ( rtn < 0 ) { seldom(); sl->i_state = oldstate; }
	return(rtn);
}
static int
sdt_r_proto(queue_t *q, mblk_t *mp)
{
	int rtn;
	sdt_t *s = (sdt_t *)q->q_ptr;
	if ( mp->b_wptr - mp->b_rptr >= sizeof(long) ) {
	switch ( *((long *)mp->b_rptr) )
	{
		case LMI_INFO_ACK:			rtn = lmi_info_ack			(s, mp); break;
		case LMI_OK_ACK:			rtn = lmi_ok_ack			(s, mp); break;
		case LMI_ERROR_ACK:			rtn = lmi_error_ack			(s, mp); break;
		case LMI_ENABLE_CON:			rtn = lmi_enable_con			(s, mp); break;
		case LMI_DISABLE_CON:			rtn = lmi_disable_con			(s, mp); break;
		case LMI_OPTMGMT_ACK:			rtn = lmi_optmgmt_ack			(s, mp); break;
		case LMI_ERROR_IND:			rtn = lmi_error_ind			(s, mp); break;
		case LMI_STATS_IND:			rtn = lmi_stats_ind			(s, mp); break;
		case LMI_EVENT_IND:			rtn = lmi_event_ind			(s, mp); break;
		case SDL_DAEDR_RECEIVED_BITS_IND:	rtn = sdl_daedr_received_bits_ind	(s, mp); break;
		case SDL_DAEDR_CORRECT_SU_IND:		rtn = sdl_daedr_correct_su_ind		(s, mp); break;
		case SDL_DAEDR_SU_IN_ERROR_IND:		rtn = sdl_daedr_su_in_error_ind		(s, mp); break;
		case SDL_DAEDT_TRANSMISSION_REQUEST_IND:rtn = sdl_daedt_transmission_request_ind(s, mp); break;
		default:				rtn = -EOPNOTSUPP;				 break;
	}
	} else { rare(); rtn = -EMSGSIZE; }
	if ( rtn < 0 ) { rare(); }
	return(rtn);
}
/*
 *  -------------------------------------------------------------------------
 *
 *  M_DATA Handling
 *
 *  -------------------------------------------------------------------------
 */
static int
sdt_w_data(queue_t *q, mblk_t *mp)
{
	sdt_t *s = (sdt_t *)q->q_ptr;
	return sdt_daedt_transmission(s, mp);
}
static int
sdt_r_data(queue_t *q, mblk_t *mp)
{
	sdt_t *s = (sdt_t *)q->q_ptr;
	return sdt_daedr_received_bits(s, mp);
}
/*
 *  -------------------------------------------------------------------------
 *
 *  M_FLUSH Handling
 *
 *  -------------------------------------------------------------------------
 */
static int
sdt_w_flush(queue_t *q, mblk_t *mp)
{
	(void)q; (void)mp;
	return(3);
}
static int
sdt_r_flush(queue_t *q, mblk_t *mp)
{
	(void)q; (void)mp;
	return(3);
}
/*
 *  -------------------------------------------------------------------------
 *
 *  M_ERROR Handling
 *
 *  -------------------------------------------------------------------------
 */
static int
sdt_r_error(queue_t *q, mblk_t *mp)
{
	(void)q; (void)mp;
	return(4);
}
/*
 *  -------------------------------------------------------------------------
 *
 *  M_HANGUP Handling
 *
 *  -------------------------------------------------------------------------
 */
static int
sdt_r_hangup(queue_t *q, mblk_t *mp)
{
	(void)q; (void)mp;
	return(4);
}
/*
 *  -------------------------------------------------------------------------
 *
 *  Other messages (e.g. M_IOCACK)
 *
 *  -------------------------------------------------------------------------
 */
static int
sdt_w_other(queue_t *q, mblk_t *mp)
{
	(void)q; (void)mp;
	return(4);
}
static int
sdt_r_other(queue_t *q, mblk_t *mp)
{
	(void)q; (void)mp;
	return(4);
}

/*
 *  =========================================================================
 *
 *  PUT and SRV
 *
 *  =========================================================================
 */
/*
 *  Write PUT
 */
static INT
sdt_wput(queue_t *q, mblk_t *mp)
{
	int rtn;
	ensure( q,  return((INT)(-EFAULT)) );
	ensuer( mp, return((INT)(-EFAULT)) );
	switch ( mp->b_datap->db_type )
	{
		case M_DATA:	rtn = sdt_w_data    (q, mp); break;
		case M_PROTO:
		case M_PCPROTO:	rtn = sdt_w_proto   (q, mp); break;
		case M_FLUSH:	rtn = sdt_w_flush   (q, mp); break;
		case M_IOCTL:	rtn = sdt_w_ioctl   (q, mp); break;
		case M_IOCDATA:	rtn = sdt_w_iocdata (q, mp); break;
		default:	rtn = sdt_w_other   (q, mp); break;
	}
	switch ( rtn )
	{
		case 0:	freemsg(mp);
		case 1:	break;
		case 2:	freeb(mp);
			break;
		case 3:
		case 4:	putnext(q, mp);
			break;
		default:
			ptrace(("Error = %d\n", rtn));
			freemsg(mp);
			return(INT)(rtn);
	}
	return(INT)(0);
}
/*
 *  Read PUT
 */
static INT
sdt_rput(queue_t *q, mblk_t *mp)
{
	int rtn;
	ensure( q,  return((INT)(-EFAULT)) );
	ensuer( mp, return((INT)(-EFAULT)) );
	switch ( mp->b_datap->db_type )
	{
		case M_DATA:	rtn = sdt_r_data    (q, mp); break;
		case M_PROTO:
		case M_PCPROTO:	rtn = sdt_r_proto   (q, mp); break;
		case M_FLUSH:	rtn = sdt_r_flush   (q, mp); break;
		case M_ERROR:	rtn = sdt_r_error   (q, mp); break;
		case M_HANGUP:	rtn = sdt_r_hangup  (q, mp); break;
		default:	rtn = sdt_r_other   (q, mp); break;
	}
	switch ( rtn )
	{
		case 0:	freemsg(mp);
		case 1:	break;
		case 2:	freeb(mp);
			break;
		case 3:
		case 4:	putnext(q, mp);
			break;
		default:
			ptrace(("Error = %d\n", rtn));
			freemsg(mp);
			return(INT)(rtn);
	}
	return(INT)(0);
}
/*
 *  =========================================================================
 *
 *  Private Structure allocation, deallocation and cache
 *
 *  =========================================================================
 */
kmem_cache_t *sdt_cachep = NULL;

static void
sdt_init_caches(void)
{
	if ( !(sdt_cachep) )
	if ( !(sdt_cachep = kmem_find_general_cachep(sizeof(sdt_t))) )
	if ( !(sdt_cachep = kmem_cache_create("sdt_cachep", sizeof(sdt_t),
					0, SLAB_HWCACHE_ALIGN, NULL, NULL)) )
		panic(__FUNCTION__ ":Cannot alloc sdt_cachep\n");
	return;
}
static void
sdt_term_caches(void)
{
	/*
	 *  Don't attempt to shrink cache.
	 */
}
static sdt_t *
sdt_alloc_priv(queue_t *q)
{
	sdt_t *s;
	if ( (s = kmem_cache_alloc(st_cachep, SLAB_ATOMIC)) )
	{
		bzero(s, sizeof(*s));
		RD(q)->q_ptr = WR(q)->q_ptr = s;
		s->rq = RD(q);
		s->wq = WR(q);
		s->i_state = LMI_DISABLED;
	}
	return(s);
}
static void
sdt_free_priv(queue_t *q)
{
	sdt_t *s = (sdt_t *)q->q_ptr;
	untimeout(s->timer_t8);
	kmem_cache_free(sdt_cachep, s);
	return;
}

/*
 *  =========================================================================
 *
 *  OPEN and CLOSE
 *
 *  =========================================================================
 */
static int
sdt_open(queue_t *q, dev_t *devp, int flag, int sflag, cred_t *crp)
{
	(void)crp;
	if ( q->q_ptr != NULL )	    /* already open */
		return(0);
	if ( sflag == MODOPEN || WR(q)->q_next != NULL )
	{
		fixme(("Check module we are being pushed over\n"));
		if ( !sdt_alloc_priv(q) )
			return ENOMEM;
		return(0);
	}
	return EIO;
}
static int
sdt_close(queue_t *q, int flag, cred_t *crp)
{
	(void)flag;
	(void)crp;
	sdt_free_priv(q);
	return(0);
}
/*
 *  =========================================================================
 *
 *  LiS Module Initialization
 *
 *  =========================================================================
 */
void
sdt_init(void)
{
	int modnum;
	unless( sdt_minfo.mi_idnum, return );
	cmn_err(CE_NOTE, SDT_BANNER);	/* console splash */
	sdt_init_caches();
	if ( !(modnum = lis_register_strmod(&sdt_info, sdt_minfo.mi_idnum)) )
	{
		sdt_minfo.mi_idnum = 0;
		cmn_err(CE_WARN, "sdt: couldn't register as module\n");
		return;
	}
	sdt_minfo.mi_idnum = modnum;
	return;
}
void
sdt_terminate(void)
{
	ensure( sdt_minfo.mi_idnum, return );
	if ( (sdt_minfo.mi_idnum = lis_register_strmod(&sdt_info)) )
		cmn_err(CE_WARN, "sdt: couldn't unregister module\n");
	sdt_term_caches();
	return;
}
/*
 *  =========================================================================
 *
 *  Kernel Module Initialization
 *
 *  =========================================================================
 */
int init_module(void)
{
	sdt_init();
	return(0);
}
void cleanup_module(void)
{
	sdt_terminate();
	return;
}