m2pa_sl.c

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

{
	sl_t *sl = (sl_t *)data;
	if ( !sl->timer_t3 ) return; else sl->timer_t3 = 0;
	putctl1(sl->rq, M_CTL, SL_EVENT_T3_EXPIRY);
}
#define SL_EVENT_T4_EXPIRY	t4
static void sl_t4_timeout(caddr_t data)
{
	sl_t *sl = (sl_t *)data;
	if ( !sl->timer_t4 ) return; else sl->timer_t4 = 0;
	putctl1(sl->rq, M_CTL, SL_EVENT_T4_EXPIRY);
}
#if 0
#define SL_EVENT_T5_EXPIRY	t5
static void sl_t5_timeout(caddr_t data)
{
	sl_t *sl = (sl_t *)data;
	if ( !sl->timer_t5 ) return; else sl->timer_t5 = 0;
	putctl1(sl->rq, M_CTL, SL_EVENT_T5_EXPIRY);
}
#endif
#define SL_EVENT_T6_EXPIRY	t6
static void sl_t6_timeout(caddr_t data)
{
	sl_t *sl = (sl_t *)data;
	if ( !sl->timer_t6 ) return; else sl->timer_t6 = 0;
	putctl1(sl->rq, M_CTL, SL_EVENT_T6_EXPIRY);
}
#define SL_EVENT_T7_EXPIRY	t7
static void sl_t7_timeout(caddr_t data)
{
	sl_t *sl = (sl_t *)data;
	if ( !sl->timer_t7 ) return; else sl->timer_t7 = 0;
	putctl1(sl->rq, M_CTL, SL_EVENT_T7_EXPIRY);
}
#if 0
#define SL_EVENT_T8_EXPIRY	t8
static void sl_t8_timeout(caddr_t data)
{
	sl_t *sl = (sl_t *)data;
	if ( !sl->timer_t8 ) return; else sl->timer_t8 = 0;
	putctl1(sl->rq, M_CTL, SL_EVENT_T8_EXPIRY);
}
#define SL_EVENT_T9_EXPIRY	t9
static void sl_t9_timeout(caddr_t data)
{
	sl_t *sl = (sl_t *)data;
	if ( !sl->timer_t9 ) return; else sl->timer_t9 = 0;
	putctl1(sl->rq, M_CTL, SL_EVENT_T9_EXPIRY);
}
#endif

static inline void sl_timer_stop(sl_t *sl, uint t)
{
	switch ( t )
	{
		case t1: if ( sl->timer_t1 ) untimeout(xchg(&sl->timer_t1,0)); break;
		case t2: if ( sl->timer_t2 ) untimeout(xchg(&sl->timer_t2,0)); break;
		case t3: if ( sl->timer_t3 ) untimeout(xchg(&sl->timer_t3,0)); break;
		case t4: if ( sl->timer_t4 ) untimeout(xchg(&sl->timer_t4,0)); break;
#if 0
		case t5: if ( sl->timer_t5 ) untimeout(xchg(&sl->timer_t5,0)); break;
#endif
		case t6: if ( sl->timer_t6 ) untimeout(xchg(&sl->timer_t6,0)); break;
		case t7: if ( sl->timer_t7 ) untimeout(xchg(&sl->timer_t7,0)); break;
#if 0
		case t8: if ( sl->timer_t8 ) untimeout(xchg(&sl->timer_t8,0)); break;
		case t9: if ( sl->timer_t9 ) untimeout(xchg(&sl->timer_t9,0)); break;
#endif
	}
}
static inline void sl_timer_start(sl_t *sl, uint t)
{
	switch ( t )
	{
		case t1: sl_timer_stop(sl, t); sl->timer_t1 = timeout(&sl_t1_timeout, (caddr_t)sl, sl->config.t1); break;
		case t2: sl_timer_stop(sl, t); sl->timer_t2 = timeout(&sl_t2_timeout, (caddr_t)sl, sl->config.t2); break;
		case t3: sl_timer_stop(sl, t); sl->timer_t3 = timeout(&sl_t3_timeout, (caddr_t)sl, sl->config.t3); break;
		case t4: sl_timer_stop(sl, t);
			 if ( sl->flags & (MF_LOC_EMERG|MF_REM_EMERG) )
				sl->timer_t4 = timeout(&sl_t4_timeout, (caddr_t)sl, sl->config.t4e);
			 else	sl->timer_t4 = timeout(&sl_t4_timeout, (caddr_t)sl, sl->config.t4n);
			 break;
#if 0
		case t5: sl_timer_stop(sl, t); sl->timer_t5 = timeout(&sl_t5_timeout, (caddr_t)sl, sl->config.t5); break;
#endif
		case t6: sl_timer_stop(sl, t); sl->timer_t6 = timeout(&sl_t6_timeout, (caddr_t)sl, sl->config.t6); break;
		case t7: sl_timer_stop(sl, t); sl->timer_t7 = timeout(&sl_t7_timeout, (caddr_t)sl, sl->config.t7); break;
#if 0
		case t8: sl_timer_stop(sl, t); sl->timer_t8 = timeout(&sl_t8_timeout, (caddr_t)sl, 1); break;
		case t9: sl_timer_stop(sl, t); sl->timer_t9 = timeout(&sl_t9_timeout, (caddr_t)sl, 1); break;
#endif
	}
}

/*
 *  -------------------------------------------------------------------------
 *
 *  Error Monitoring
 *
 *  -------------------------------------------------------------------------
 */

static void sl_suerm_start(sl_t *sl)
{
	/* SCTP does this for us */
	return;
}
static void sl_suerm_stop(sl_t *sl)
{
	/* SCTP does this for us */
	return;
}
static void sl_aerm_start(sl_t *sl)
{
	(void)sl_send_proving;
	printd(("Start Proving...\n"));
	return;
}
static void sl_aerm_stop(sl_t *sl)
{
	printd(("Stop Proving...\n"));
	return;
}
static int sl_lsc_out_of_service(sl_t *sl, ulong reason);
#if 0
static int sl_iac_abort_proving(sl_t *sl) 
{
	int err;
	if ( sl->state == MS_PROVING )
	{
		sl->statem.Cp++;
		sl_timer_stop(sl, t4);
		sl_aerm_stop(sl);
		if ( sl->statem.Cp == sl->config.M ) {
			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: Alignement not possible\n"));
			sl->stats.sl_fail_align_or_proving++;
			return(0);
		}
		sl_timer_start(sl, t4);
		sl_aerm_start(sl);
		return(0);
	}
	ptrace(("Received signal iac-abort-proving in unexpected state %u.\n", sl->state));
	return(-EFAULT);
}
#endif

#if 0
static int sl_t5_expiry(sl_t *sl)
{
	return(-EOPNOTSUPP);
}

static int sl_t8_expiry(sl_t *sl)
{
	return(-EOPNOTSUPP);
}

static int sl_t9_expiry(sl_t *sl)
{
	(void)sl_iac_abort_proving;
	return(-EOPNOTSUPP);
}
#endif

/*
 *  -----------------------------------------------------------------------
 *
 *  STATE MACHINES:- The order of the state machine primitives below may seem
 *  somewhat disorganized at first glance; however, they have been ordered by
 *  dependency because they are all inline functions.  You see, the L2 state
 *  machine does not required multiple threading because there is never a
 *  requirement to invoke the individual state machines concurrently.  This
 *  works out good for the driver, because a primitive action expands inline
 *  to the necessary procedure, while the source still takes the appearance of
 *  the SDL diagrams in the SS7 specification for inspection and debugging.
 *
 *  -----------------------------------------------------------------------
 */

/*
 *  -----------------------------------------------------------------------
 *
 *  Duration Statistics
 *
 *  -----------------------------------------------------------------------
 */

static void sl_is_stats(sl_t *sl)
{
	if ( sl->stamp.sl_dur_unavail		)
		sl->stats.sl_dur_unavail
			+= jiffies - xchg(&sl->stamp.sl_dur_unavail,0);
	if ( sl->stamp.sl_dur_unavail_rpo	)
		sl->stats.sl_dur_unavail_rpo
			+= jiffies - xchg(&sl->stamp.sl_dur_unavail_rpo,0);
	if ( sl->stamp.sl_dur_unavail_failed	)
		sl->stats.sl_dur_unavail_failed
			+= jiffies - xchg(&sl->stamp.sl_dur_unavail_failed,0);
	sl->stamp.sl_dur_in_service = jiffies;
}
static void sl_oos_stats(sl_t *sl)
{
	if ( sl->stamp.sl_dur_in_service	)
		sl->stats.sl_dur_in_service
			+= jiffies - xchg(&sl->stamp.sl_dur_in_service,0);
	if ( sl->stamp.sl_dur_unavail_rpo	)
		sl->stats.sl_dur_unavail_rpo
			+= jiffies - xchg(&sl->stamp.sl_dur_unavail_rpo,0);
	if ( sl->stamp.sl_dur_unavail_failed	)
		sl->stats.sl_dur_unavail_failed
			+= jiffies - xchg(&sl->stamp.sl_dur_unavail_failed,0);
	sl->stamp.sl_dur_unavail = jiffies;
}
static void sl_rpo_stats(sl_t *sl)
{
	if ( sl->stamp.sl_dur_in_service	)
		sl->stats.sl_dur_in_service
			+= jiffies - xchg(&sl->stamp.sl_dur_in_service,0);
	sl->stamp.sl_dur_unavail_rpo = jiffies;
}
static void sl_rpr_stats(sl_t *sl)
{
	if ( sl->stamp.sl_dur_unavail_rpo	)
		sl->stats.sl_dur_unavail_rpo
			+= jiffies - xchg(&sl->stamp.sl_dur_unavail_rpo,0);
}

static int sl_lsc_stop(sl_t *sl)
{
	int err;
	if ( sl->state != MS_OUT_OF_SERVICE )
	{
		if ( (err = sl_send_status(sl, M2PA_STATUS_OUT_OF_SERVICE)) )
			return(err);
		sl_timer_stop(sl, t1);
		sl_timer_stop(sl, t2);
		sl_timer_stop(sl, t3);
		sl_timer_stop(sl, t4);
		sl_timer_stop(sl, t6);
		sl_timer_stop(sl, t7);
		sl_aerm_stop(sl);
		sl_suerm_stop(sl);
		sl->flags &= ~MF_LPO;
		if ( sl->flags & MF_RPO ) {
			if ( sl->notify.events & SL_EVT_RPO_END )
				if ( (err = lmi_event_ind(sl, SL_EVT_RPO_END, 0, NULL, 0)) )
					return(err);
			ptrace(("RPO Ends\n"));
			sl_rpr_stats(sl);
			sl->flags &= ~MF_RPO;
		}
		sl->flags &= ~MF_LOC_INS;
		sl->flags &= ~MF_REM_INS;
		sl->flags &= ~MF_LOC_BUSY;
		sl->flags &= ~MF_REM_BUSY;
		sl->flags &= ~MF_LOC_EMERG;
		sl->flags &= ~MF_REM_EMERG;
		sl_oos_stats(sl);
		sl->state = MS_OUT_OF_SERVICE;
		return(0);
	}
	return(0);
}

static int sl_lsc_out_of_service(sl_t *sl, ulong reason)
{
	int err;
	if ( sl->state != MS_OUT_OF_SERVICE )
	{
		if ( (err = sl_out_of_service_ind(sl, reason)) )
			return(err);
		if ( (err = sl_lsc_stop(sl)) )
			return(err);
		sl->stamp.sl_dur_unavail_failed = jiffies;
		return(0);
	}
	return(0);
}

static int sl_lsc_power_on(sl_t *sl) 
{
	int err;
	if ( sl->state == MS_POWER_OFF )
	{
		sl->flags = 0;
		if ( (err = sl_send_status(sl, M2PA_STATUS_OUT_OF_SERVICE)) )
			return(err);
		sl->state = MS_OUT_OF_SERVICE;
		return(0);
	}
	ptrace(("Received primitive SL_POWER_ON_REQ in unexpected state %u\n",sl->state));
	return(-EPROTO);
}

static int sl_lsc_start(sl_t *sl)
{
	int err;
	if ( sl->state == MS_OUT_OF_SERVICE )
	{
		sl->rmsu = 0;
		sl->rack = 0;
		sl->fsnr = 0;
		sl->tmsu = 0;
		sl->tack = 0;
		sl->fsnt = 0;
		sl->back = 0;
//		sl->flags = 0;
		if ( (err = sl_send_status(sl, M2PA_STATUS_ALIGNMENT)) )
			return(err);
		sl_timer_start(sl, t2);
		sl->state = MS_NOT_ALIGNED;
		return(0);
	}
	ptrace(("Received primitive SL_START_REQ in unexpected state %u\n",sl->state));
	return(-EPROTO);
}

static int sl_t2_expiry(sl_t *sl) 
{
	int err;
	if ( sl->state == MS_NOT_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: Alignment not possible\n"));
		sl->stats.sl_fail_align_or_proving++;
		return(0);
	}
	return(0);
}

static int sl_lsc_status_alignment(sl_t *sl) 
{
	int err;
	switch ( sl->state)
	{
		case MS_OUT_OF_SERVICE:
			return(0);
		case MS_NOT_ALIGNED:
			if ( sl->flags & MF_LOC_EMERG )
				err = sl_send_status(sl, M2PA_STATUS_PROVING_EMERGENCY);
			else	err = sl_send_status(sl, M2PA_STATUS_PROVING_NORMAL);
			if ( err ) return(err);
			sl_timer_stop(sl, t2);
			sl_timer_start(sl, t3);
			sl->state = MS_ALIGNED;
			return(0);
		case MS_ALIGNED:
			return(0);
		case MS_PROVING:
			sl_aerm_stop(sl);
			sl_timer_stop(sl, t4);
			sl_timer_start(sl, t3);
			sl->state = MS_ALIGNED;
			return(0);
		default:
			if ( (err = sl_lsc_out_of_service(sl, SL_FAIL_RECEIVED_SIO)) )
				return(err);
			if ( sl->notify.events & SL_EVT_FAIL_RECEIVED_SIO )
				if ( (err = lmi_event_ind(sl, SL_EVT_FAIL_RECEIVED_SIO, 0, NULL, 0)) )
					return(err);
			ptrace(("Link failed: Received SIO\n"));
			return(0);
	}
}

static int sl_lsc_emergency(sl_t *sl)
{
	int err;
	sl->flags |= MF_LOC_EMERG;
	switch ( sl->state )
	{
		case MS_PROVING:
			if ( (err = sl_send_status(sl, M2PA_STATUS_PROVING_EMERGENCY)) )
				return(err);
			sl_timer_stop(sl, t4);
			sl_aerm_stop(sl);
			sl_timer_start(sl, t4);
			sl_aerm_start(sl);
			return(0);
		case MS_ALIGNED:
			if ( (err = sl_send_status(sl, M2PA_STATUS_PROVING_EMERGENCY)) )
				return(err);
			return(0);
	}
	ptrace(("Received primitive SL_EMERGENCY_REQ in unexpected state %u\n", sl->state));
	return(-EPROTO);
}

static int sl_lsc_emergency_ceases(sl_t *sl)
{
	sl->flags &= ~MF_LOC_EMERG;
	return(0);
}

static int sl_lsc_status_proving_normal(sl_t *sl) 
{
	int err;
	switch ( sl->state )
	{
		case MS_NOT_ALIGNED:
			if ( sl->flags & MF_LOC_EMERG )
				err = sl_send_status(sl, M2PA_STATUS_PROVING_EMERGENCY);
			else	err = sl_send_status(sl, M2PA_STATUS_PROVING_NORMAL);
			if ( err ) return(err);
			sl_timer_stop(sl, t2);
			sl_timer_start(sl, t3);
			sl->state = MS_ALIGNED;
			/* fall thru */
		case MS_ALIGNED:
			sl->flags &= ~MF_REM_EMERG;
			sl_timer_stop(sl, t3);
			sl_aerm_start(sl);
			sl_timer_start(sl, t4);
			sl->statem.Cp = 0;
			sl->state = MS_PROVING;
			return(0);
		case MS_IN_SERVICE:
		case MS_PROCESSOR_OUTAGE:
			if ( (err = sl_lsc_out_of_service(sl, SL_FAIL_RECEIVED_SIN)) )
				return(err);
			if ( sl->notify.events & SL_EVT_FAIL_RECEIVED_SIN )
				if ( (err = lmi_event_ind(sl, SL_EVT_FAIL_RECEIVED_SIN, 0, NULL, 0)) )
					return(err);
			ptrace(("Link failed: Received SIN\n"));
			return(0);
	}
	ptrace(("Received status PROVING_NORMAL in unexpected state %u\n",sl->state));
	return(-EPROTO);
}

static int sl_lsc_status_proving_emergency(sl_t *sl) 
{
	int err;
	switch ( sl->state )
	{
		case MS_NOT_ALIGNED:
			sl_timer_stop(sl, t2);
			if ( sl->flags & MF_LOC_EMERG )
				err = sl_send_status(sl, M2PA_STATUS_PROVING_EMERGENCY);
			else	err = sl_send_status(sl, M2PA_STATUS_PROVING_NORMAL);
			if ( err ) return(err);
			sl_timer_start(sl, t3);
			sl->state = MS_ALIGNED;
			/* fall thru */
		case MS_ALIGNED:
			sl->flags |= MF_REM_EMERG;
			sl_timer_stop(sl, t3);
			sl_aerm_start(sl);
			sl_timer_start(sl, t4);
			sl->statem.Cp = 0;
			sl->state = MS_PROVING;
			return(0);
		case MS_PROVING:
			sl->flags |= MF_REM_EMERG;
			sl_timer_stop(sl, t4);
			sl_aerm_stop(sl);
			sl_timer_start(sl, t4);
			sl_aerm_start(sl);
			return(0);
		case MS_IN_SERVICE:
		case MS_PROCESSOR_OUTAGE :
			if ( (err = sl_lsc_out_of_service(sl, SL_FAIL_RECEIVED_SIE)) )
				return(err);
			if ( sl->notify.events & SL_EVT_FAIL_RECEIVED_SIE )
				if ( (err = lmi_event_ind(sl, SL_EVT_FAIL_RECEIVED_SIE, 0, NULL, 0)) )
					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);
}