sl.c

OpenSS7 This the fourth public release of the OpenSS7 Master Package. See README in the release for

			sl_daedt_msu(q, sl, mp);
		}
		spin_unlock(&sl->tb.q_lock);
		return (mp);
	}
}

STATIC INLINE int
sl_daedr_start(queue_t *q, struct sl *sl)
{
	return sdt_daedr_start_req(q, sl);
}

STATIC INLINE int
sl_rc_start(queue_t *q, struct sl *sl)
{
	int err;
	if (sl->statem.rc_state == SL_STATE_IDLE) {
		sl->statem.rx.X.fsn = 0;
		sl->statem.rx.X.fib = sl->statem.ib_mask;
		sl->statem.rx.F.fsn = 0;
		sl->statem.rx.T.fsn = sl->statem.sn_mask;
		sl->statem.rtr = 0;	/* Basic only (note 1). */
		if (sl->option.pvar == SS7_PVAR_ANSI_92)
			sl->statem.msu_fisu_accepted = 1;
		else
			sl->statem.msu_fisu_accepted = 0;
		sl->statem.abnormal_bsnr = 0;
		sl->statem.abnormal_fibr = 0;	/* Basic only (note 1). */
		sl->statem.congestion_discard = 0;
		sl->statem.congestion_accept = 0;
		if ((err = sl_daedr_start(q, sl)))
			return (err);
		sl->statem.rc_state = SL_STATE_IN_SERVICE;
		/* 
		 *   Note 1 - Although rtr and abnormal_fibr are only
		 *   applicable to the Basic procedure (and not PCR), these
		 *   state machine variables are never examined by PCR
		 *   routines, so PCR and basic can share the same start
		 *   procedures.
		 */
	}
	return (QR_DONE);
}

STATIC INLINE void
sl_rc_reject_msu_fisu(queue_t *q, struct sl *sl)
{
	sl->statem.msu_fisu_accepted = 0;
}

STATIC INLINE void
sl_rc_accept_msu_fisu(queue_t *q, struct sl *sl)
{
	sl->statem.msu_fisu_accepted = 1;
}

STATIC INLINE void
sl_rc_retrieve_fsnx(queue_t *q, struct sl *sl)
{
	sl_txc_fsnx_value(q, sl);	/* error in 93 spec */
	sl->statem.congestion_discard = 0;
	sl->statem.congestion_accept = 0;
	sl_cc_normal(q, sl);
	sl->statem.rtr = 0;	/* basic only */
}

STATIC INLINE void
sl_rc_align_fsnx(queue_t *q, struct sl *sl)
{
	sl_txc_fsnx_value(q, sl);
}

STATIC INLINE int
sl_rc_clear_rb(queue_t *q, struct sl *sl)
{
	bufq_purge(&sl->rb);
	// flushq(sl->oq, FLUSHDATA);
	sl->statem.Cr = 0;
	return sl_rb_cleared_ind(q, sl);
}

STATIC INLINE int
sl_rc_retrieve_bsnt(queue_t *q, struct sl *sl)
{
	sl->statem.rx.T.bsn = (sl->statem.rx.X.fsn - 1) & 0x7F;
	return sl_bsnt_ind(q, sl, sl->statem.rx.T.bsn);
}

STATIC INLINE void
sl_cc_busy(queue_t *q, struct sl *sl)
{
	if (sl->statem.cc_state == SL_STATE_NORMAL) {
		sl_txc_send_sib(q, sl);
		sl_timer_start(sl, t5);
		sl->statem.cc_state = SL_STATE_BUSY;
	}
}

STATIC INLINE void
sl_rc_congestion_discard(queue_t *q, struct sl *sl)
{
	sl->statem.congestion_discard = 1;
	sl_cc_busy(q, sl);
}

STATIC INLINE void
sl_rc_congestion_accept(queue_t *q, struct sl *sl)
{
	sl->statem.congestion_accept = 1;
	sl_cc_busy(q, sl);
}

STATIC INLINE void
sl_rc_no_congestion(queue_t *q, struct sl *sl)
{
	sl->statem.congestion_discard = 0;
	sl->statem.congestion_accept = 0;
	sl_cc_normal(q, sl);
	sl_txc_fsnx_value(q, sl);
	if (sl->statem.rtr == 1) {	/* rtr never set for PCR */
		ctrace(sl_txc_nack_to_be_sent(q, sl));
		sl->statem.rx.X.fib = sl->statem.rx.X.fib ? 0 : sl->statem.ib_mask;
	}
}

STATIC INLINE void
sl_lsc_congestion_discard(queue_t *q, struct sl *sl)
{
	sl_rc_congestion_discard(q, sl);
	sl->statem.l3_congestion_detect = 1;
}

STATIC INLINE void
sl_lsc_congestion_accept(queue_t *q, struct sl *sl)
{
	sl_rc_congestion_accept(q, sl);
	sl->statem.l3_congestion_detect = 1;
}

STATIC INLINE void
sl_lsc_no_congestion(queue_t *q, struct sl *sl)
{
	sl_rc_no_congestion(q, sl);
	sl->statem.l3_congestion_detect = 0;
}

STATIC INLINE int
sl_lsc_sio(queue_t *q, struct sl *sl)
{
	int err;
	switch (sl->statem.lsc_state) {
	case SL_STATE_OUT_OF_SERVICE:
	case SL_STATE_INITIAL_ALIGNMENT:
		break;
	default:
		sl_timer_stop(sl, t1);	/* ok if not running */
		sl_out_of_service_ind(q, sl, SL_FAIL_RECEIVED_SIO);
		sl->statem.failure_reason = SL_FAIL_RECEIVED_SIO;
		sl_rc_stop(q, sl);
		if ((err = sl_suerm_stop(q, sl)))
			return (err);
		sl_poc_stop(q, sl);	/* ok if ANSI */
		sl_txc_send_sios(q, sl);
		sl->statem.emergency = 0;
		/* 
		   FIXME: reinspect */
		sl->statem.local_processor_outage = 0;
		sl->statem.remote_processor_outage = 0;	/* ok if ITUT */
		sl->statem.lsc_state = SL_STATE_OUT_OF_SERVICE;
		break;
	}
	return (QR_DONE);
}

STATIC INLINE int
sl_lsc_alignment_not_possible(queue_t *q, struct sl *sl)
{
	int err;
	if ((err = sl_out_of_service_ind(q, sl, SL_FAIL_ALIGNMENT_NOT_POSSIBLE)))
		return (err);
	sl->statem.failure_reason = SL_FAIL_ALIGNMENT_NOT_POSSIBLE;
	sl_rc_stop(q, sl);
	sl_txc_send_sios(q, sl);
	sl->statem.local_processor_outage = 0;
	sl->statem.emergency = 0;
	sl->statem.lsc_state = SL_STATE_OUT_OF_SERVICE;
	return (QR_DONE);
}

STATIC INLINE int
sl_iac_sio(queue_t *q, struct sl *sl)
{
	int err;
	switch (sl->statem.iac_state) {
	case SL_STATE_NOT_ALIGNED:
		sl_timer_stop(sl, t2);
		if (sl->statem.emergency) {
			sl->statem.t4v = sl->config.t4e;
			printd(("%s: Sending SIE at %lu\n", MOD_NAME, jiffies));
			sl_txc_send_sie(q, sl);
		} else {
			sl->statem.t4v = sl->config.t4n;
			sl_txc_send_sin(q, sl);
		}
		sl_timer_start(sl, t3);
		sl->statem.iac_state = SL_STATE_ALIGNED;
		break;
	case SL_STATE_PROVING:
		sl_timer_stop(sl, t4);
		if ((err = sl_aerm_stop(q, sl)))
			return (err);
		sl_timer_start(sl, t3);
		sl->statem.iac_state = SL_STATE_ALIGNED;
		break;
	}
	return (QR_DONE);
}

STATIC INLINE int
sl_iac_sios(queue_t *q, struct sl *sl)
{
	int err;
	switch (sl->statem.iac_state) {
	case SL_STATE_ALIGNED:
	case SL_STATE_PROVING:
		sl_timer_stop(sl, t4);	/* ok if not running */
		if ((err = sl_lsc_alignment_not_possible(q, sl)))
			return (err);
		if ((err = sl_aerm_stop(q, sl)))	/* ok if not running */
			return (err);
		sl_timer_stop(sl, t3);	/* ok if not running */
		sl->statem.emergency = 0;
		sl->statem.iac_state = SL_STATE_IDLE;
		break;
	}
	return (QR_DONE);
}

STATIC INLINE int
sl_lsc_sios(queue_t *q, struct sl *sl)
{
	int err;
	switch (sl->statem.lsc_state) {
	case SL_STATE_ALIGNED_READY:
	case SL_STATE_ALIGNED_NOT_READY:
		sl_timer_stop(sl, t1);	/* ok to stop if not running */
	case SL_STATE_IN_SERVICE:
	case SL_STATE_PROCESSOR_OUTAGE:
		sl_out_of_service_ind(q, sl, SL_FAIL_RECEIVED_SIOS);
		sl->statem.failure_reason = SL_FAIL_RECEIVED_SIOS;
		if ((err = sl_suerm_stop(q, sl)))	/* ok to stop if not running */
			return (err);
		sl_rc_stop(q, sl);
		sl_poc_stop(q, sl);	/* ok if ANSI */
		sl_txc_send_sios(q, sl);
		sl->statem.emergency = 0;
		sl->statem.local_processor_outage = 0;
		sl->statem.remote_processor_outage = 0;	/* ok if ITU */
		sl->statem.lsc_state = SL_STATE_OUT_OF_SERVICE;
		break;
	}
	return (QR_DONE);
}

STATIC INLINE void
sl_lsc_no_processor_outage(queue_t *q, struct sl *sl)
{
	if (sl->statem.lsc_state == SL_STATE_PROCESSOR_OUTAGE) {
		sl->statem.processor_outage = 0;
		if (!sl->statem.l3_indication_received)
			return;
		sl->statem.l3_indication_received = 0;
		sl_txc_send_msu(q, sl);
		sl->statem.local_processor_outage = 0;
		sl_rc_accept_msu_fisu(q, sl);
		sl->statem.lsc_state = SL_STATE_IN_SERVICE;
	}
}

STATIC INLINE void
sl_poc_remote_processor_recovered(queue_t *q, struct sl *sl)
{
	switch (sl->statem.poc_state) {
	case SL_STATE_REMOTE_PROCESSOR_OUTAGE:
		sl_lsc_no_processor_outage(q, sl);
		sl->statem.poc_state = SL_STATE_IDLE;
		return;
	case SL_STATE_BOTH_PROCESSORS_OUT:
		sl->statem.poc_state = SL_STATE_LOCAL_PROCESSOR_OUTAGE;
		return;
	}
}

STATIC INLINE int
sl_lsc_fisu_msu_received(queue_t *q, struct sl *sl)
{
	int err;
	switch (sl->statem.lsc_state) {
	case SL_STATE_ALIGNED_READY:
		if ((err = sl_in_service_ind(q, sl)))
			return (err);
		if (sl->option.pvar == SS7_PVAR_ITUT_93)
			sl_rc_accept_msu_fisu(q, sl);	/* unnecessary */
		sl_timer_stop(sl, t1);
		sl_txc_send_msu(q, sl);
		sl->statem.lsc_state = SL_STATE_IN_SERVICE;
		break;
	case SL_STATE_ALIGNED_NOT_READY:
		if ((err = sl_in_service_ind(q, sl)))
			return (err);
		sl_timer_stop(sl, t1);
		sl->statem.lsc_state = SL_STATE_PROCESSOR_OUTAGE;
		break;
	case SL_STATE_PROCESSOR_OUTAGE:
		if ((sl->option.pvar & SS7_PVAR_MASK) != SS7_PVAR_ANSI) {
			sl_poc_remote_processor_recovered(q, sl);
			return sl_remote_processor_recovered_ind(q, sl);
		} else {
#if 0
			sl->statem.remote_processor_outage = 0;
			return sl_remote_processor_recovered_ind(q, sl);
#else
			/* 
			 *  A deviation from the SDLs has been placed here to
			 *  limit the number of remote processor recovered
			 *  indications which are delivered to L3.  One
			 *  indication is sufficient.
			 */
			if (sl->statem.remote_processor_outage) {
				sl->statem.remote_processor_outage = 0;
				return sl_remote_processor_recovered_ind(q, sl);
			}
#endif
		}
		break;
	}
	return (QR_DONE);
}

STATIC INLINE void
sl_poc_remote_processor_outage(queue_t *q, struct sl *sl)
{
	switch (sl->statem.poc_state) {
	case SL_STATE_IDLE:
		sl->statem.poc_state = SL_STATE_REMOTE_PROCESSOR_OUTAGE;
		return;
	case SL_STATE_LOCAL_PROCESSOR_OUTAGE:
		sl->statem.poc_state = SL_STATE_BOTH_PROCESSORS_OUT;
		return;
	}
}

STATIC INLINE void
sl_lsc_sib(queue_t *q, struct sl *sl)
{
	switch (sl->statem.lsc_state) {
	case SL_STATE_IN_SERVICE:
	case SL_STATE_PROCESSOR_OUTAGE:
		sl_txc_sib_received(q, sl);
		break;
	}
}

STATIC INLINE int
sl_lsc_sipo(queue_t *q, struct sl *sl)
{
	int err;
	switch (sl->statem.lsc_state) {
	case SL_STATE_ALIGNED_READY:
		if ((sl->option.pvar & SS7_PVAR_MASK) != SS7_PVAR_ANSI) {
			sl_timer_stop(sl, t1);
			if ((err = sl_remote_processor_outage_ind(q, sl)))
				return (err);
			sl_poc_remote_processor_outage(q, sl);
			sl->statem.lsc_state = SL_STATE_PROCESSOR_OUTAGE;
		} else {
			sl_timer_stop(sl, t1);
			if ((err = sl_remote_processor_outage_ind(q, sl)))
				return (err);
			sl->statem.remote_processor_outage = 1;
			sl->statem.lsc_state = SL_STATE_PROCESSOR_OUTAGE;
		}
		break;
	case SL_STATE_ALIGNED_NOT_READY:
		if ((sl->option.pvar & SS7_PVAR_MASK) != SS7_PVAR_ANSI) {
			if ((err = sl_remote_processor_outage_ind(q, sl)))
				return (err);
			sl_poc_remote_processor_outage(q, sl);
			sl_timer_stop(sl, t1);
			sl->statem.lsc_state = SL_STATE_PROCESSOR_OUTAGE;
		} else {
			if ((err = sl_remote_processor_outage_ind(q, sl)))
				return (err);
			sl->statem.remote_processor_outage = 1;
			sl_timer_stop(sl, t1);
			sl->statem.lsc_state = SL_STATE_PROCESSOR_OUTAGE;
		}
		break;
	case SL_STATE_IN_SERVICE:
		if ((sl->option.pvar & SS7_PVAR_MASK) != SS7_PVAR_ANSI) {
			sl_txc_send_fisu(q, sl);
			if ((err = sl_remote_processor_outage_ind(q, sl)))
				return (err);
			sl_poc_remote_processor_outage(q, sl);
			sl->statem.processor_outage = 1;	/* remote? */
			sl->statem.lsc_state = SL_STATE_PROCESSOR_OUTAGE;
		} else {
			sl_txc_send_fisu(q, sl);
			if ((err = sl_remote_processor_outage_ind(q, sl)))
				return (err);
			sl->statem.remote_processor_outage = 1;
			sl_rc_align_fsnx(q, sl);
			sl_cc_stop(q, sl);
			sl->statem.lsc_state = SL_STATE_PROCESSOR_OUTAGE;
		}
		break;
	case SL_STATE_PROCESSOR_OUTAGE:
		if ((sl->option.pvar & SS7_PVAR_MASK) != SS7_PVAR_ANSI) {
			if ((err = sl_remote_processor_outage_ind(q, sl)))
				return (err);
			sl_poc_remote_processor_outage(q, sl);
		} else {
#if 0
			sl->statem.remote_processor_outage = 1;
			return sl_remote_processor_outage_ind(q, sl);
#else
			/* 
			 *  A deviation from the SDLs has been placed here to
			 *  limit the number of remote processor outage
			 *  indications which are delivered to L3.  One
			 *  indication is sufficient.
			 */
			if (!sl->statem.remote_processor_outage) {
				sl->statem.remote_processor_outage = 1;
				return sl_remote_processor_outage_ind(q, sl);
			}
#endif
		}
		break;
	}
	return (QR_DONE);
}

STATIC INLINE void
sl_poc_local_processor_outage(queue_t *q, struct sl *sl)
{
	switch (sl->statem.poc_state) {
	case SL_STATE_IDLE:
		sl->statem.poc_state = SL_STATE_LOCAL_PROCESSOR_OUTAGE;
		return;
	case SL_STATE_REMOTE_PROCESSOR_OUTAGE:
		sl->statem.poc_state = SL_STATE_BOTH_PROCESSORS_OUT;
		return;
	}
}

STATIC INLINE int
sl_suerm_start(queue_t *q, struct sl *sl)
{
	return sdt_suerm_start_req(q, sl);
}

STATIC INLINE int
sl_lsc_alignment_complete(queue_t *q, struct sl *sl)
{
	int err;
	if (sl->statem.lsc_state == SL_STATE_INITIAL_ALIGNMENT) {
		if ((err = sl_suerm_start(q, sl)))
			return (err);
		sl_timer_start(sl, t1);
		if (sl->statem.local_processor_outage) {
			if (sl->option.pvar != SS7_PVAR_ANSI_92)
				sl_poc_local_processor_outage(q, sl);
			sl_txc_send_sipo(q, sl);
			if (sl->option.pvar != SS7_PVAR_ITUT_93)	/* possible error */
				sl_rc_reject_msu_fisu(q, sl);
			sl->statem.lsc_state = SL_STATE_ALIGNED_NOT_READY;
		} else {
			sl_txc_send_msu(q, sl);	/* changed from send_fisu for Q.781 */
			sl_rc_accept_msu_fisu(q, sl);	/* error in ANSI spec? */
			sl->statem.lsc_state = SL_STATE_ALIGNED_READY;
		}
	}
	return (QR_DONE);
}

STATIC INLINE int
sl_lsc_sin(queue_t *q, struct sl *sl)
{
	int err;
	switch (sl->statem.lsc_state) {
	case SL_STATE_IN_SERVICE:
		sl_out_of_service_ind(q, sl, SL_FAIL_RECE