m2pa_slm.c

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

					return(err);
			ptrace(("Link failed: Received SIE\n"));
			return(0);
	}
	ptrace(("Received status PROVING_EMERGENCY in unexpected state %u\n",sl->state));
	return(-EPROTO);
}

static int sl_t1_expiry(sl_t *sl) 
{
	int err;
	if ( (err = sl_lsc_out_of_service(sl, SL_FAIL_T1_TIMEOUT)) )
		return(err);
	if ( sl->notify.events & SL_EVT_FAIL_T1_TIMEOUT )
		if ( (err = lmi_event_ind(sl, SL_EVT_FAIL_T1_TIMEOUT, 0, NULL, 0)) )
			return(err);
	ptrace(("Link failed: T1 Timeout\n"));
	sl->stats.sl_fail_align_or_proving++;
	return(0);
}

static int sl_t3_expiry(sl_t *sl) 
{
	int err;
	if ( sl->state == MS_ALIGNED ) {
		if ( (err = sl_lsc_out_of_service(sl, SL_FAIL_ALIGNMENT_NOT_POSSIBLE)) )
			return(err);
		if ( sl->notify.events & SL_EVT_FAIL_ALIGNMENT )
			if ( (err = lmi_event_ind(sl, SL_EVT_FAIL_ALIGNMENT, 0, NULL, 0)) )
				return(err);
		ptrace(("Link failed: T3 Timeout\n"));
		sl->stats.sl_fail_align_or_proving++;
		return(0);
	}
	return(0);
}

static int sl_t4_expiry(sl_t *sl) 
{
	int err;
	if ( sl->state == MS_PROVING )
	{
		sl_aerm_stop(sl);
		sl->flags &= ~MF_LOC_EMERG;
		sl->flags &= ~MF_REM_EMERG;
		sl_suerm_start(sl);
		sl->flags |= MF_LOC_INS;
		if ( sl->flags & MF_LPO )
		{
			if ( (err = sl_send_status(sl, M2PA_STATUS_PROCESSOR_OUTAGE)) )
				return(err);
			if ( sl->flags & MF_REM_INS )
			{
				if ( (err = sl_in_service_ind(sl)) )
					return(err);
				sl->flags &= ~MF_SEND_MSU;
				sl->flags &= ~MF_RECV_MSU;
				sl_oos_stats(sl);
				sl->state = MS_PROCESSOR_OUTAGE;
			}
			else
			{
				sl_timer_start(sl, t1);
				sl->state = MS_ALIGNED_NOT_READY;
			}
		}
		else
		{
			mblk_t *mp;
			if ( (mp = sl->tb.q_head) )
			{
				if ( (err = sl_send_data(sl, mp)) )
					return(err);
				sl->tmsu++;
				sl->fsnt++;
				bufq_queue(&sl->rtb, bufq_dequeue(&sl->tb));
				sl->tmsu--; sl->tack++;
				sl->stats.sl_tran_msus++;
				sl->stats.sl_tran_sio_sif_octets += mp->b_wptr - mp->b_rptr - 1;
				if ( sl->rtb.q_msgs >= sl->config.N1
						|| sl->rtb.q_count >= sl->config.N2
						|| sl->tmsu+sl->tack > 0x7ffffff )
					sl->flags |= MF_RTB_FULL;
			}
			else
			{
				if ( (err = sl_send_status(sl, M2PA_STATUS_IN_SERVICE)) )
					return(err);
			}
			if ( sl->flags & MF_REM_INS )
			{
				if ( (err = sl_in_service_ind(sl)) )
					return(err);
				sl->flags |= MF_SEND_MSU;
				sl->flags |= MF_RECV_MSU;
				sl_is_stats(sl);
				sl->state = MS_IN_SERVICE;
			}
			else
			{
				sl_timer_start(sl, t1);
				sl->state = MS_ALIGNED_READY;
			}
		}
		return(0);
	}
	ptrace(("Received timeout t4 in unexpected state %u\n",sl->state));
	return(-EPROTO);
}

static int sl_lsc_status_in_service(sl_t *sl) 
{
	int err;
	switch ( sl->state )
	{
		case MS_ALIGNED:
		case MS_PROVING:
			sl->flags |= MF_REM_INS;
			return(0);
		case MS_ALIGNED_NOT_READY:
			if ( (err = sl_in_service_ind(sl)) )
				return(err);
			sl_timer_stop(sl, t1);
			sl->flags &= ~MF_SEND_MSU;
			sl->flags &= ~MF_RECV_MSU;
			sl_oos_stats(sl);
			sl->state = MS_PROCESSOR_OUTAGE;
			return(0);
		case MS_ALIGNED_READY:
			if ( (err = sl_in_service_ind(sl)) )
				return(err);
			sl_timer_stop(sl, t1);
			sl->flags |= MF_SEND_MSU;
			sl->flags |= MF_RECV_MSU;
			sl_is_stats(sl);
			sl->state = MS_IN_SERVICE;
			return(0);
		case MS_IN_SERVICE:
		case MS_PROCESSOR_OUTAGE:
		case MS_OUT_OF_SERVICE:
			printd(("Received status IN_SERVICE in unusual state %u\n",sl->state));
			return(0);
	}
	ptrace(("Received status IN_SERVICE in unexpected state %u\n",sl->state));
	return(-EPROTO);
}

static int sl_rb_congestion_function(sl_t *sl);

static int sl_rx_wakeup(queue_t *q)
{
	int err;
	mblk_t *mp;
	sl_t *sl = (sl_t *)q->q_ptr;
	ensure( q,  return((INT)(-EFAULT)) );
	ensure( sl, return((INT)(-EFAULT)) );
	switch ( sl->state )
	{
		default:
			if ( sl->flags & MF_RECV_MSU
					&& sl->rb.q_head
					&& canputnext(sl->rq) )
			{
				while( (mp = bufq_dequeue(&sl->rb)) )
				{
					if ( (err = sl_pdu_ind(sl, mp)) ) {
						bufq_queue_head(&sl->rb, mp);
						rare();
						return(err);
					}
					sl->stats.sl_recv_msus++;
					sl->stats.sl_recv_sio_sif_octets += mp->b_wptr - mp->b_rptr - 1;
					sl->rmsu++;
					sl->fsnr++;
					sl_rb_congestion_function(sl);
					if ( !(sl->flags & MF_CONG_ACCEPT) )
						sl->rack += xchg(&sl->rmsu,0);
				}
			}
		case MS_POWER_OFF:
		case MS_OUT_OF_SERVICE:
			return(0);
	}
}

static int sl_rc_signal_unit(sl_t *sl, mblk_t *mp) 
{
	int err;
	switch ( sl->state )
	{
		case MS_ALIGNED_READY:
			if ( (err = sl_in_service_ind(sl)) )
				return(err);
			sl_timer_stop(sl, t1);
			sl->flags |= MF_SEND_MSU;
			sl->flags |= MF_RECV_MSU;
			sl_is_stats(sl);
			sl->state = MS_IN_SERVICE;
		default:
			if ( sl->flags & MF_RECV_MSU 
					&& !(sl->flags & MF_CONG_DISCARD) )
			{
				bufq_queue(&sl->rb, mp);
				sl_rb_congestion_function(sl);
				return(0);
			}
			else seldom();
			return(-EBUSY);
		case MS_POWER_OFF:
		case MS_OUT_OF_SERVICE:
			seldom();
			return(0);
	}
}

static int sl_tx_wakeup(queue_t *q)
{
	int err;
	mblk_t *mp;
	sl_t *sl = (sl_t *)q->q_ptr;
	ensure( q,  return((INT)(-EFAULT)) );
	ensure( sl, return((INT)(-EFAULT)) );
	switch ( sl->state )
	{
		default:
			if ( sl->rack )
			{
				if ( (err = sl_send_ack(sl, sl->rack)) )
					return(err);
				sl->rack = 0;
			}
			if ( sl->flags & MF_SEND_MSU && sl->tb.q_head
					&& !(sl->flags & MF_RTB_FULL) )
			{
				if ( !sl->rtb.q_count ) {
					if ( sl->flags & MF_REM_BUSY )
						sl_timer_start(sl, t6);
					else	sl_timer_start(sl, t7);
				}
				while ( (mp = sl->tb.q_head) )
				{
					if ( (err = sl_send_data(sl, mp)) )
						return(err);
					sl->tmsu++;
					sl->fsnt++;
					bufq_queue(&sl->rtb, bufq_dequeue(&sl->tb));
					sl->tmsu--; sl->tack++;
					sl->stats.sl_tran_msus++;
					sl->stats.sl_tran_sio_sif_octets += mp->b_wptr - mp->b_rptr - 1;
					if ( sl->rtb.q_msgs >= sl->config.N1
							|| sl->rtb.q_count >= sl->config.N2
							|| sl->tmsu+sl->tack > 0x7ffffff )
					{
						sl->flags |= MF_RTB_FULL;
						break;
					}
				}
			}
			return(0);
		case MS_POWER_OFF:
		case MS_OUT_OF_SERVICE:
			return(0);
	}
}

static int sl_check_congestion(sl_t *sl);

static int sl_txc_datack(sl_t *sl, ulong count) 
{
	int err;
	switch ( sl->state )
	{
		case MS_IN_SERVICE:
		case MS_PROCESSOR_OUTAGE:
		case MS_ALIGNED_READY:
		case MS_ALIGNED_NOT_READY:
			while ( count-- )
			{
				if ( sl->rtb.q_head ) {
					freemsg(bufq_dequeue(&sl->rtb));
					sl->tack--;
					qenable(sl->wq);
				} else {
					if ( sl->back )
					{
						if ( (err = sl_lsc_out_of_service(sl, SL_FAIL_ABNORMAL_FIBR)) )
							return(err);
						if ( sl->notify.events & SL_EVT_FAIL_ABNORMAL_FIBR )
							if ( (err = lmi_event_ind(sl, SL_EVT_FAIL_ABNORMAL_FIBR, 0, NULL, 0)) )
								return(err);
						ptrace(("Link failed: Abnormal FIBR\n"));
						return(0);
					}
					ptrace(("Received bad acknowledgement acks = %lu\n",count+1));
					sl->back++;
					return(0);
				}
			}
			sl->back = 0;
			if ( sl->rtb.q_count == 0 )
			{
				sl_timer_stop(sl, t7);
				sl_timer_stop(sl, t6);
			}
			else
			if ( !(sl->flags & MF_REM_BUSY) )
				sl_timer_start(sl, t7);
			sl->flags &= ~MF_RTB_FULL;
			sl_check_congestion(sl);
			return(0);
			/* let tx_wakeup clear up new transmissions later */
		default:
			seldom();
			return(0);
	}
}

static int sl_lsc_pdu(sl_t *sl, mblk_t *mp)
{
	int err;
	bufq_queue(&sl->tb, mp);
	if ( (err = sl_check_congestion(sl)) )
		return(err);
	return(0);
	/* let tx_wakeup clear up the tb later */
}

static int sl_t7_expiry(sl_t *sl) 
{
	int err;
	if ( (err = sl_lsc_out_of_service(sl, SL_FAIL_ACK_TIMEOUT)) )
		return(err);
	if ( sl->notify.events & SL_EVT_FAIL_ACK_TIMEOUT )
		if ( (err = lmi_event_ind(sl, SL_EVT_FAIL_ACK_TIMEOUT, 0, NULL, 0)) )
			return(err);
	ptrace(("Link failed: T7 Timeout\n"));
	return(0);
}

static int sl_lsc_status_busy(sl_t *sl)
{
	switch ( sl->state )
	{
		case MS_IN_SERVICE:
			if ( !(sl->flags & MF_REM_BUSY) ) {
				sl->flags |= MF_REM_BUSY;
				if ( sl->rtb.q_count )
					sl_timer_start(sl, t6);
				sl_timer_stop(sl, t7);
			}
			return(0);
		case MS_PROCESSOR_OUTAGE:
			sl->flags |= MF_REM_BUSY;
			return(0);
		case MS_POWER_OFF:
		case MS_OUT_OF_SERVICE:
			return(0);
	}
	ptrace(("Received status BUSY in unexpected state %u\n",sl->state));
	return(-EPROTO);
}

static int sl_lsc_congestion_discard(sl_t *sl) 
{
	int err;
	if ( !(sl->flags & MF_LOC_BUSY) ) {
		if ( (err = sl_send_status(sl, M2PA_STATUS_BUSY)) )
			return(err);
		sl->stats.sl_sibs_sent++;
		sl->flags |= MF_LOC_BUSY;
	}
	sl->flags |= MF_CONG_DISCARD;
	sl->flags |= MF_L3_CONG_DETECT;
	return(0);
}

static int sl_lsc_congestion_accept(sl_t *sl) 
{
	int err;
	if ( !(sl->flags & MF_LOC_BUSY) ) {
		if ( (err = sl_send_status(sl, M2PA_STATUS_BUSY)) )
			return(err);
		sl->stats.sl_sibs_sent++;
		sl->flags |= MF_LOC_BUSY;
	}
	sl->flags |= MF_CONG_ACCEPT;
	sl->flags |= MF_L3_CONG_DETECT;
	return(0);
}

static int sl_lsc_status_busy_ended(sl_t *sl)
{
	switch ( sl->state )
	{
		default:
			ptrace(("Received status BUSY_ENDED in unexpected state %u\n",sl->state));
		case MS_IN_SERVICE:
			sl->flags &= ~MF_REM_BUSY;
			sl_timer_stop(sl, t6);
			if ( sl->rtb.q_count )
				sl_timer_start(sl, t7);
			return(0);
		case MS_POWER_OFF:
		case MS_OUT_OF_SERVICE:
			return(0);
	}
}

static int sl_t6_expiry(sl_t *sl) 
{
	int err;
	if ( (err = sl_lsc_out_of_service(sl, SL_FAIL_CONG_TIMEOUT)) )
		return(err);
	if ( sl->notify.events & SL_EVT_FAIL_CONG_TIMEOUT )
		if ( (err = lmi_event_ind(sl, SL_EVT_FAIL_CONG_TIMEOUT, 0, NULL, 0)) )
			return(err);
	ptrace(("Link failed: T6 Timeout\n"));
	return(0);
}

static int sl_lsc_no_congestion(sl_t *sl) 
{
	int err;
	if ( sl->flags & MF_LOC_BUSY )
		if ( (err = sl_send_status(sl, M2PA_STATUS_BUSY_ENDED)) )
			return(err);
	sl->flags &= ~MF_LOC_BUSY;
	sl->flags &= ~MF_CONG_DISCARD;
	sl->flags &= ~MF_CONG_ACCEPT;
	sl->flags &= ~MF_L3_CONG_DETECT;
	sl->rack += xchg(&sl->rmsu,0);
	return(0);
}

static int sl_lsc_status_processor_outage(sl_t *sl) 
{
	int err;
	switch ( sl->state )
	{
		case MS_OUT_OF_SERVICE:
		case MS_NOT_ALIGNED:
		case MS_ALIGNED:
		case MS_PROVING:
			/* just remember for later */
			if ( sl->notify.events & SL_EVT_RPO_BEGIN )
				if ( (err = lmi_event_ind(sl, SL_EVT_RPO_BEGIN, 0, NULL, 0)) )
					return(err);
			sl->flags |= MF_RPO;
			ptrace(("RPO Begins\n"));
			return(0);
		case MS_ALIGNED_READY:
		case MS_ALIGNED_NOT_READY:
			if ( !(sl->flags & MF_RPO) ) {
				if ( (err = sl_remote_processor_outage_ind(sl)) )
					return(err);
				sl->flags |= MF_RPO;
			}
			if ( sl->notify.events & SL_EVT_RPO_BEGIN )
				if ( (err = lmi_event_ind(sl, SL_EVT_RPO_BEGIN, 0, NULL, 0)) )
					return(err);
			sl_rpo_stats(sl);
			ptrace(("RPO Begins\n"));
			sl_timer_stop(sl, t1);
			sl->state = MS_PROCESSOR_OUTAGE;
			return(0);
		case MS_IN_SERVICE:
			if ( !(sl->flags & MF_RPO) ) {
				if ( (err = sl_remote_processor_outage_ind(sl)) )
					return(err);
				sl->flags |= MF_RPO;
			}
			if ( sl->notify.events & SL_EVT_RPO_BEGIN )
				if ( (err = lmi_event_ind(sl, SL_EVT_RPO_BEGIN, 0, NULL, 0)) )
					return(err);
			ptrace(("RPO Begins\n"));
			sl_timer_stop(sl, t7);
			sl_timer_stop(sl, t6);
			sl->flags &= ~MF_SEND_MSU;
			switch ( sl->option.pvar )
			{
				default:
				case SS7_PVAR_ITUT_93:
				case SS7_PVAR_ITUT_96:
					sl->flags &= ~MF_CONTINUE;
					break;
				case SS7_PVAR_ANSI_92:
					sl->rack += xchg(&sl->rmsu,0);
					fixme(("Bad idea\n"));
					if ( sl->flags & MF_LOC_BUSY )
						if ( (err = sl_send_status(sl, M2PA_STATUS_BUSY_ENDED)) )
							return(err);
					sl->flags &= ~MF_LOC_BUSY;
					break;
			}
			sl_rpo_stats(sl);
			sl->state = MS_PROCESSOR_OUTAGE;