slpmod.c

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

	}
	return (-ENOBUFS);
}
#if 0
static inline int
sl_optmgmt_ack(struct sl *sl, struct lk *lk, queue_t *q, mblk_t *msg)
{
	sl_optmgmt_ack_t *p;
	mblk_t *mp;

	if (likely(!!(mp = sl_allocb(q, sizeof(*p), BPRI_MED)))) {
		mp->b_datap->db_type = M_PROTO;
		p = (typeof(p)) mp->b_wptr;
		p->sl_primitive = SL_OPTMGMT_ACK;
		mp->b_wptr += sizeof(*p);
		freemsg(msg);
		strlog(sl->mid, sl->sid, SLLOGTX, SL_TRACE, "<- SL_OPTMGMT_ACK");
		putnext(lk->oq, mp);
		return (0);
	}
	return (-ENOBUFS);
}
static inline int
sl_notify_ind(struct sl *sl, struct lk *lk, queue_t *q, mblk_t *msg)
{
	sl_notify_ind_t *p;
	mblk_t *mp;

	if (likely(!!(mp = sl_allocb(q, sizeof(*p), BPRI_MED)))) {
		mp->b_datap->db_type = M_PROTO;
		p = (typeof(p)) mp->b_wptr;
		p->sl_primitive = SL_NOTIFY_IND;
		mp->b_wptr += sizeof(*p);
		freemsg(msg);
		strlog(sl->mid, sl->sid, SLLOGTX, SL_TRACE, "<- SL_NOTIFY_IND");
		putnext(lk->oq, mp);
		return (0);
	}
	return (-ENOBUFS);
}
#endif
static inline int
sl_local_processor_outage_ind(struct sl *sl, struct lk *lk, queue_t *q, mblk_t *msg)
{
	sl_loc_proc_out_ind_t *p;
	mblk_t *mp;

	if (likely(!!(mp = sl_allocb(q, sizeof(*p), BPRI_MED)))) {
		mp->b_datap->db_type = M_PROTO;
		p = (typeof(p)) mp->b_wptr;
		p->sl_primitive = SL_LOCAL_PROCESSOR_OUTAGE_IND;
		p->sl_timestamp = drv_hztomsec(jiffies);
		mp->b_wptr += sizeof(*p);
		freemsg(msg);
		strlog(sl->mid, sl->sid, SLLOGTX, SL_TRACE, "<- SL_LOCAL_PROCESSOR_OUTAGE_IND");
		putnext(lk->oq, mp);
		return (0);
	}
	return (-ENOBUFS);
}
static inline int
sl_local_processor_recovered_ind(struct sl *sl, struct lk *lk, queue_t *q, mblk_t *msg)
{
	sl_loc_proc_recovered_ind_t *p;
	mblk_t *mp;

	if (likely(!!(mp = sl_allocb(q, sizeof(*p), BPRI_MED)))) {
		mp->b_datap->db_type = M_PROTO;
		p = (typeof(p)) mp->b_wptr;
		p->sl_primitive = SL_LOCAL_PROCESSOR_RECOVERED_IND;
		p->sl_timestamp = drv_hztomsec(jiffies);
		mp->b_wptr += sizeof(*p);
		freemsg(msg);
		strlog(sl->mid, sl->sid, SLLOGTX, SL_TRACE, "<- SL_LOCAL_PROCESSOR_RECOVERED_IND");
		putnext(lk->oq, mp);
		return (0);
	}
	return (-ENOBUFS);
}

static int
lmi_info_req(struct sl *sl, struct lk *loc, queue_t *q, mblk_t *mp)
{
	return lmi_info_ack(sl, loc, q, mp);
}
static int
lmi_attach_req(struct sl *sl, struct lk *loc, queue_t *q, mblk_t *mp)
{
	/* always style 1 */
	return lmi_error_ack(sl, loc, q, mp, LMI_ATTACH_REQ, LMI_NOTSUPP);
}
static int
lmi_detach_req(struct sl *sl, struct lk *loc, queue_t *q, mblk_t *mp)
{
	/* always style 1 */
	return lmi_error_ack(sl, loc, q, mp, LMI_DETACH_REQ, LMI_NOTSUPP);
}
static int
lmi_enable_req(struct sl *sl, struct lk *loc, queue_t *q, mblk_t *mp)
{
	if (sl_get_l_state(loc) != LMI_DISABLED)
		goto outstate;
	sl_set_l_state(sl, loc, LMI_ENABLE_PENDING);
	return lmi_enable_con(sl, loc, q, mp);
      outstate:
	return lmi_error_ack(sl, loc, q, mp, LMI_ENABLE_REQ, LMI_OUTSTATE);
}
static int
lmi_disable_req(struct sl *sl, struct lk *loc, queue_t *q, mblk_t *mp)
{
	if (sl_get_l_state(loc) != LMI_ENABLED)
		goto outstate;
	sl_set_l_state(sl, loc, LMI_DISABLE_PENDING);
	return lmi_disable_con(sl, loc, q, mp);
      outstate:
	return lmi_error_ack(sl, loc, q, mp, LMI_DISABLE_REQ, LMI_OUTSTATE);
}
static int
lmi_optmgmt_req(struct sl *sl, struct lk *loc, queue_t *q, mblk_t *mp)
{
	return lmi_error_ack(sl, loc, q, mp, LMI_OPTMGMT_REQ, LMI_NOTSUPP);
}
static int
sl_pdu_req(struct sl *sl, struct lk *loc, queue_t *q, mblk_t *mp)
{
	struct lk *rem = loc->other;

	if (sl_get_l_state(loc) != LMI_ENABLED)
		goto outstate;
	if (sl_get_i_state(loc) != SL_IN_SERVICE)
		goto putback;
	if (!bcanputnext(rem->oq, mp->b_band))
		goto busy;
	*(sl_ulong *) mp->b_rptr = SL_PDU_IND;
	putnext(rem->oq, mp);
	return (0);
      busy:
	return (-EBUSY);
      putback:
	noenable(q);
	return (-EAGAIN);
      outstate:
	return lmi_error_ack(sl, loc, q, mp, SL_PDU_REQ, LMI_OUTSTATE);
}
static int
sl_emergency_req(struct sl *sl, struct lk *loc, queue_t *q, mblk_t *mp)
{
	if (sl_get_l_state(loc) != LMI_ENABLED)
		goto outstate;
	sl_set_flags(sl, loc, SL_EMERGENCY);
      outstate:
	freemsg(mp);
	return (0);
}
static int
sl_emergency_ceases_req(struct sl *sl, struct lk *loc, queue_t *q, mblk_t *mp)
{
	if (sl_get_l_state(loc) != LMI_ENABLED)
		goto outstate;
	sl_clr_flags(sl, loc, SL_EMERGENCY);
      outstate:
	freemsg(mp);
	return (0);
}
static int
sl_start_req(struct sl *sl, struct lk *loc, queue_t *q, mblk_t *mp)
{
	struct lk *rem = loc->other;
	int err;

	if (sl_get_l_state(loc) != LMI_ENABLED)
		goto outstate;
	switch (sl_get_i_state(loc)) {
	case SL_POWER_OFF:
		goto outstate;
	case SL_OUT_OF_SERVICE:
		sl_set_i_state(sl, loc, SL_ALIGNMENT);
		sl_timer_start(loc, 1, 20000);
		switch (sl_get_i_state(rem)) {
		case SL_POWER_OFF:
			break;
		case SL_ALIGNMENT:
			sl_timer_stop(loc, 1);
			if (sl_get_flags(loc) & (SL_LOC_PROC_OUT | SL_REM_PROC_OUT)) {
				sl_set_i_state(sl, loc, SL_ALIGNED_NOT_READY);
				if ((err = sl_remote_processor_outage_ind(sl, rem, q, mp)))
					return (err);
			} else {
				sl_set_i_state(sl, loc, SL_ALIGNED_READY);
				if ((err = sl_in_service_ind(sl, rem, q, mp)))
					return (err);
			}
			if (sl_get_flags(rem) & (SL_LOC_PROC_OUT | SL_REM_PROC_OUT)) {
				sl_set_i_state(sl, rem, SL_ALIGNED_NOT_READY);
				if ((err = sl_remote_processor_outage_ind(sl, loc, q, mp)))
					return (err);
			} else {
				sl_set_i_state(sl, rem, SL_ALIGNED_READY);
				if ((err = sl_in_service_ind(sl, loc, q, mp)))
					return (err);
			}
			break;
		case SL_ALIGNED_READY:
		case SL_ALIGNED_NOT_READY:
		case SL_IN_SERVICE:
		default:
			goto outstate;
		}
		break;
	case SL_ALIGNMENT:
	case SL_ALIGNED_READY:
	case SL_ALIGNED_NOT_READY:
	case SL_IN_SERVICE:
		goto discard;
	default:
		goto outstate;
	}
      discard:
      outstate:
	freemsg(mp);
	return (0);
}
static int
sl_stop_req(struct sl *sl, struct lk *loc, queue_t *q, mblk_t *mp)
{
	struct lk *rem = loc->other;
	int err;

	if (sl_get_l_state(loc) != LMI_ENABLED)
		goto outstate;
	switch (sl_get_i_state(loc)) {
	case SL_POWER_OFF:
		goto discard;
	case SL_OUT_OF_SERVICE:
		goto discard;
	case SL_ALIGNMENT:
	case SL_ALIGNED_READY:
	case SL_ALIGNED_NOT_READY:
	case SL_IN_SERVICE:
	default:
		sl_timer_stop(loc, 1);
		sl_set_i_state(sl, loc, SL_OUT_OF_SERVICE);
		switch (sl_get_i_state(rem)) {
		case SL_POWER_OFF:
		case SL_OUT_OF_SERVICE:
			break;
		case SL_ALIGNMENT:
		case SL_ALIGNED_READY:
		case SL_ALIGNED_NOT_READY:
		case SL_IN_SERVICE:
		default:
			sl_timer_stop(rem, 1);
			sl_set_i_state(sl, rem, SL_OUT_OF_SERVICE);
			if ((err = sl_out_of_service_ind(sl, rem, q, mp, 0)))
				return (err);
			break;
		}
		break;
	}
      discard:
      outstate:
	freemsg(mp);
	return (0);
}
static int
sl_retrieve_bsnt_req(struct sl *sl, struct lk *loc, queue_t *q, mblk_t *mp)
{
	if (sl_get_l_state(loc) != LMI_ENABLED)
		goto outstate;
	return sl_bsnt_not_retrievable_ind(sl, loc, q, mp);
      outstate:
	return lmi_error_ack(sl, loc, q, mp, SL_RETRIEVE_BSNT_REQ, LMI_OUTSTATE);
}
static int
sl_retrieval_request_and_fsnc_req(struct sl *sl, struct lk *loc, queue_t *q, mblk_t *mp)
{
	if (sl_get_l_state(loc) != LMI_ENABLED)
		goto outstate;
	return sl_retrieval_not_possible_ind(sl, loc, q, mp);
      outstate:
	return lmi_error_ack(sl, loc, q, mp, SL_RETRIEVAL_REQUEST_AND_FSNC_REQ, LMI_OUTSTATE);
}
static int
sl_clear_buffers_req(struct sl *sl, struct lk *loc, queue_t *q, mblk_t *mp)
{
	if (sl_get_l_state(loc) != LMI_ENABLED)
		goto outstate;
	return sl_rb_cleared_ind(sl, loc, q, mp);
      outstate:
	return lmi_error_ack(sl, loc, q, mp, SL_CLEAR_BUFFERS_REQ, LMI_OUTSTATE);
}
static int
sl_clear_rtb_req(struct sl *sl, struct lk *loc, queue_t *q, mblk_t *mp)
{
	if (sl_get_l_state(loc) != LMI_ENABLED)
		goto outstate;
	return sl_rtb_cleared_ind(sl, loc, q, mp);
      outstate:
	return lmi_error_ack(sl, loc, q, mp, SL_CLEAR_RTB_REQ, LMI_OUTSTATE);
}
static int
sl_continue_req(struct sl *sl, struct lk *loc, queue_t *q, mblk_t *mp)
{
	struct lk *rem = loc->other;

	if (sl_get_l_state(loc) != LMI_ENABLED)
		goto outstate;
	if (!(sl_get_flags(loc) & SL_LOC_PROC_OUT))
		goto discard;
	sl_clr_flags(sl, loc, SL_LOC_PROC_OUT);
	if (sl_get_i_state(loc) == SL_ALIGNED_NOT_READY) {
		sl_set_i_state(sl, loc, SL_IN_SERVICE);
		if (sl_get_i_state(rem) == SL_ALIGNED_READY) {
			sl_set_i_state(sl, rem, SL_IN_SERVICE);
			return sl_in_service_ind(sl, rem, q, mp);
		}
	}
	return sl_remote_processor_recovered_ind(sl, rem, q, mp);
      discard:
	freemsg(mp);
	return (0);
      outstate:
	return lmi_error_ack(sl, loc, q, mp, SL_CONTINUE_REQ, LMI_OUTSTATE);
}
static int
sl_local_processor_outage_req(struct sl *sl, struct lk *loc, queue_t *q, mblk_t *mp)
{
	struct lk *rem = loc->other;

	if (sl_get_l_state(loc) != LMI_ENABLED)
		goto outstate;
	if ((sl_get_flags(loc) & SL_LOC_PROC_OUT))
		goto discard;
	sl_set_flags(sl, loc, SL_LOC_PROC_OUT);
	sl_set_flags(sl, rem, SL_REM_PROC_OUT);
	return sl_remote_processor_outage_ind(sl, rem, q, mp);
      discard:
	freemsg(mp);
	return (0);
      outstate:
	return lmi_error_ack(sl, loc, q, mp, SL_LOCAL_PROCESSOR_OUTAGE_REQ, LMI_OUTSTATE);
}
static int
sl_resume_req(struct sl *sl, struct lk *loc, queue_t *q, mblk_t *mp)
{
	struct lk *rem = loc->other;

	if (sl_get_l_state(loc) != LMI_ENABLED)
		goto outstate;
	if (!(sl_get_flags(loc) & SL_LOC_PROC_OUT))
		goto discard;
	sl_clr_flags(sl, loc, SL_LOC_PROC_OUT);
	if (sl_get_i_state(loc) == SL_ALIGNED_NOT_READY) {
		sl_set_i_state(sl, loc, SL_IN_SERVICE);
		if (sl_get_i_state(rem) == SL_ALIGNED_READY) {
			sl_set_i_state(sl, rem, SL_IN_SERVICE);
			return sl_in_service_ind(sl, rem, q, mp);
		}
	}
	return sl_remote_processor_recovered_ind(sl, rem, q, mp);
      discard:
	freemsg(mp);
	return (0);
      outstate:
	return lmi_error_ack(sl, loc, q, mp, SL_RESUME_REQ, LMI_OUTSTATE);
}
static int
sl_congestion_discard_req(struct sl *sl, struct lk *loc, queue_t *q, mblk_t *mp)
{
	if (sl_get_l_state(loc) != LMI_ENABLED)
		goto outstate;
	sl_set_flags(sl, loc, SL_CONG_DISCARD);
	freemsg(mp);
	return (0);
      outstate:
	return lmi_error_ack(sl, loc, q, mp, SL_CONGESTION_DISCARD_REQ, LMI_OUTSTATE);
}
static int
sl_congestion_accept_req(struct sl *sl, struct lk *loc, queue_t *q, mblk_t *mp)
{
	if (sl_get_l_state(loc) != LMI_ENABLED)
		goto outstate;
	sl_set_flags(sl, loc, SL_CONG_ACCEPT);
	freemsg(mp);
	return (0);
      outstate:
	return lmi_error_ack(sl, loc, q, mp, SL_CONGESTION_ACCEPT_REQ, LMI_OUTSTATE);
}
static int
sl_no_congestion_req(struct sl *sl, struct lk *loc, queue_t *q, mblk_t *mp)
{
	struct lk *rem = loc->other;

	if (sl_get_l_state(loc) != LMI_ENABLED)
		goto outstate;
	sl_clr_flags(sl, loc, (SL_CONG_DISCARD | SL_CONG_ACCEPT));
	canenable(rem->oq);
	qenable(rem->oq);
	freemsg(mp);
	return (0);
      outstate:
	return lmi_error_ack(sl, loc, q, mp, SL_NO_CONGESTION_REQ, LMI_OUTSTATE);
}
static int
sl_power_on_req(struct sl *sl, struct lk *loc, queue_t *q, mblk_t *mp)
{
	if (sl_get_l_state(loc) != LMI_ENABLED)
		goto outstate;
	if (sl_get_i_state(loc) != SL_POWER_OFF)
		goto outstate;
	sl_set_i_state(sl, loc, SL_OUT_OF_SERVICE);
	freemsg(mp);
	return (0);
      outstate:
	return lmi_error_ack(sl, loc, q, mp, SL_POWER_ON_REQ, LMI_OUTSTATE);
}
static int
sl_optmgmt_req(struct sl *sl, struct lk *loc, queue_t *q, mblk_t *mp)
{
	freemsg(mp);
	return (0);
}
static int
sl_notify_req(struct sl *sl, struct lk *loc, queue_t *q, mblk_t *mp)
{
	freemsg(mp);
	return (0);
}
static int
sl_other_req(struct sl *sl, struct lk *loc, queue_t *q, mblk_t *mp)
{
	if (mp->b_datap->db_type >= QPCTL || bcanputnext(q, mp->b_band)) {
		putnext(q, mp);
		return (0);
	}
	return (-EBUSY);
}
static int
sl_t1_timeout(struct sl *sl, struct lk *loc, queue_t *q)
{
	if (sl_get_l_state(loc) != LMI_ENABLED)
		goto outstate;
	if (sl_get_i_state(loc) != SL_ALIGNMENT)
		goto outstate;