1 /******************************************************************************
2  *
3  *	(C)Copyright 1998,1999 SysKonnect,
4  *	a business unit of Schneider & Koch & Co. Datensysteme GmbH.
5  *
6  *	See the file "skfddi.c" for further information.
7  *
8  *	This program is free software; you can redistribute it and/or modify
9  *	it under the terms of the GNU General Public License as published by
10  *	the Free Software Foundation; either version 2 of the License, or
11  *	(at your option) any later version.
12  *
13  *	The information in this file is provided "AS IS" without warranty.
14  *
15  ******************************************************************************/
16 
17 /*
18 	SMT 7.2 Status Response Frame Implementation
19 	SRF state machine and frame generation
20 */
21 
22 #include "h/types.h"
23 #include "h/fddi.h"
24 #include "h/smc.h"
25 #include "h/smt_p.h"
26 
27 #define KERNEL
28 #include "h/smtstate.h"
29 
30 #ifndef	SLIM_SMT
31 #ifndef	BOOT
32 
33 #ifndef	lint
34 static const char ID_sccs[] = "@(#)srf.c	1.18 97/08/04 (C) SK " ;
35 #endif
36 
37 
38 /*
39  * function declarations
40  */
41 static void clear_all_rep(struct s_smc *smc);
42 static void clear_reported(struct s_smc *smc);
43 static void smt_send_srf(struct s_smc *smc);
44 static struct s_srf_evc *smt_get_evc(struct s_smc *smc, int code, int index);
45 
46 #define MAX_EVCS	ARRAY_SIZE(smc->evcs)
47 
48 struct evc_init {
49 	u_char code ;
50 	u_char index ;
51 	u_char n ;
52 	u_short	para ;
53 }  ;
54 
55 static const struct evc_init evc_inits[] = {
56 	{ SMT_COND_SMT_PEER_WRAP,		0,1,SMT_P1048	} ,
57 
58 	{ SMT_COND_MAC_DUP_ADDR,		INDEX_MAC, NUMMACS,SMT_P208C } ,
59 	{ SMT_COND_MAC_FRAME_ERROR,		INDEX_MAC, NUMMACS,SMT_P208D } ,
60 	{ SMT_COND_MAC_NOT_COPIED,		INDEX_MAC, NUMMACS,SMT_P208E } ,
61 	{ SMT_EVENT_MAC_NEIGHBOR_CHANGE,	INDEX_MAC, NUMMACS,SMT_P208F } ,
62 	{ SMT_EVENT_MAC_PATH_CHANGE,		INDEX_MAC, NUMMACS,SMT_P2090 } ,
63 
64 	{ SMT_COND_PORT_LER,			INDEX_PORT,NUMPHYS,SMT_P4050 } ,
65 	{ SMT_COND_PORT_EB_ERROR,		INDEX_PORT,NUMPHYS,SMT_P4052 } ,
66 	{ SMT_EVENT_PORT_CONNECTION,		INDEX_PORT,NUMPHYS,SMT_P4051 } ,
67 	{ SMT_EVENT_PORT_PATH_CHANGE,		INDEX_PORT,NUMPHYS,SMT_P4053 } ,
68 } ;
69 
70 #define MAX_INIT_EVC	ARRAY_SIZE(evc_inits)
71 
smt_init_evc(struct s_smc * smc)72 void smt_init_evc(struct s_smc *smc)
73 {
74 	struct s_srf_evc	*evc ;
75 	const struct evc_init 	*init ;
76 	int			i ;
77 	int			index ;
78 	int			offset ;
79 
80 	static u_char		fail_safe = FALSE ;
81 
82 	memset((char *)smc->evcs,0,sizeof(smc->evcs)) ;
83 
84 	evc = smc->evcs ;
85 	init = evc_inits ;
86 
87 	for (i = 0 ; (unsigned) i < MAX_INIT_EVC ; i++) {
88 		for (index = 0 ; index < init->n ; index++) {
89 			evc->evc_code = init->code ;
90 			evc->evc_para = init->para ;
91 			evc->evc_index = init->index + index ;
92 #ifndef	DEBUG
93 			evc->evc_multiple = &fail_safe ;
94 			evc->evc_cond_state = &fail_safe ;
95 #endif
96 			evc++ ;
97 		}
98 		init++ ;
99 	}
100 
101 	if ((unsigned) (evc - smc->evcs) > MAX_EVCS) {
102 		SMT_PANIC(smc,SMT_E0127, SMT_E0127_MSG) ;
103 	}
104 
105 	/*
106 	 * conditions
107 	 */
108 	smc->evcs[0].evc_cond_state = &smc->mib.fddiSMTPeerWrapFlag ;
109 	smc->evcs[1].evc_cond_state =
110 		&smc->mib.m[MAC0].fddiMACDuplicateAddressCond ;
111 	smc->evcs[2].evc_cond_state =
112 		&smc->mib.m[MAC0].fddiMACFrameErrorFlag ;
113 	smc->evcs[3].evc_cond_state =
114 		&smc->mib.m[MAC0].fddiMACNotCopiedFlag ;
115 
116 	/*
117 	 * events
118 	 */
119 	smc->evcs[4].evc_multiple = &smc->mib.m[MAC0].fddiMACMultiple_N ;
120 	smc->evcs[5].evc_multiple = &smc->mib.m[MAC0].fddiMACMultiple_P ;
121 
122 	offset = 6 ;
123 	for (i = 0 ; i < NUMPHYS ; i++) {
124 		/*
125 		 * conditions
126 		 */
127 		smc->evcs[offset + 0*NUMPHYS].evc_cond_state =
128 			&smc->mib.p[i].fddiPORTLerFlag ;
129 		smc->evcs[offset + 1*NUMPHYS].evc_cond_state =
130 			&smc->mib.p[i].fddiPORTEB_Condition ;
131 
132 		/*
133 		 * events
134 		 */
135 		smc->evcs[offset + 2*NUMPHYS].evc_multiple =
136 			&smc->mib.p[i].fddiPORTMultiple_U ;
137 		smc->evcs[offset + 3*NUMPHYS].evc_multiple =
138 			&smc->mib.p[i].fddiPORTMultiple_P ;
139 		offset++ ;
140 	}
141 #ifdef	DEBUG
142 	for (i = 0, evc = smc->evcs ; (unsigned) i < MAX_EVCS ; i++, evc++) {
143 		if (SMT_IS_CONDITION(evc->evc_code)) {
144 			if (!evc->evc_cond_state) {
145 				SMT_PANIC(smc,SMT_E0128, SMT_E0128_MSG) ;
146 			}
147 			evc->evc_multiple = &fail_safe ;
148 		}
149 		else {
150 			if (!evc->evc_multiple) {
151 				SMT_PANIC(smc,SMT_E0129, SMT_E0129_MSG) ;
152 			}
153 			evc->evc_cond_state = &fail_safe ;
154 		}
155 	}
156 #endif
157 	smc->srf.TSR = smt_get_time() ;
158 	smc->srf.sr_state = SR0_WAIT ;
159 }
160 
smt_get_evc(struct s_smc * smc,int code,int index)161 static struct s_srf_evc *smt_get_evc(struct s_smc *smc, int code, int index)
162 {
163 	int			i ;
164 	struct s_srf_evc	*evc ;
165 
166 	for (i = 0, evc = smc->evcs ; (unsigned) i < MAX_EVCS ; i++, evc++) {
167 		if (evc->evc_code == code && evc->evc_index == index)
168 			return evc;
169 	}
170 	return NULL;
171 }
172 
173 #define THRESHOLD_2	(2*TICKS_PER_SECOND)
174 #define THRESHOLD_32	(32*TICKS_PER_SECOND)
175 
176 #ifdef	DEBUG
177 static const char * const srf_names[] = {
178 	"None","MACPathChangeEvent",	"MACNeighborChangeEvent",
179 	"PORTPathChangeEvent",		"PORTUndesiredConnectionAttemptEvent",
180 	"SMTPeerWrapCondition",		"SMTHoldCondition",
181 	"MACFrameErrorCondition",	"MACDuplicateAddressCondition",
182 	"MACNotCopiedCondition",	"PORTEBErrorCondition",
183 	"PORTLerCondition"
184 } ;
185 #endif
186 
smt_srf_event(struct s_smc * smc,int code,int index,int cond)187 void smt_srf_event(struct s_smc *smc, int code, int index, int cond)
188 {
189 	struct s_srf_evc	*evc ;
190 	int			cond_asserted = 0 ;
191 	int			cond_deasserted = 0 ;
192 	int			event_occurred = 0 ;
193 	int			tsr ;
194 	int			T_Limit = 2*TICKS_PER_SECOND ;
195 
196 	if (code == SMT_COND_MAC_DUP_ADDR && cond) {
197 		RS_SET(smc,RS_DUPADDR) ;
198 	}
199 
200 	if (code) {
201 		DB_SMT("SRF: %s index %d\n",srf_names[code],index) ;
202 
203 		if (!(evc = smt_get_evc(smc,code,index))) {
204 			DB_SMT("SRF : smt_get_evc() failed\n",0,0) ;
205 			return ;
206 		}
207 		/*
208 		 * ignore condition if no change
209 		 */
210 		if (SMT_IS_CONDITION(code)) {
211 			if (*evc->evc_cond_state == cond)
212 				return ;
213 		}
214 
215 		/*
216 		 * set transition time stamp
217 		 */
218 		smt_set_timestamp(smc,smc->mib.fddiSMTTransitionTimeStamp) ;
219 		if (SMT_IS_CONDITION(code)) {
220 			DB_SMT("SRF: condition is %s\n",cond ? "ON":"OFF",0) ;
221 			if (cond) {
222 				*evc->evc_cond_state = TRUE ;
223 				evc->evc_rep_required = TRUE ;
224 				smc->srf.any_report = TRUE ;
225 				cond_asserted = TRUE ;
226 			}
227 			else {
228 				*evc->evc_cond_state = FALSE ;
229 				cond_deasserted = TRUE ;
230 			}
231 		}
232 		else {
233 			if (evc->evc_rep_required) {
234 				*evc->evc_multiple  = TRUE ;
235 			}
236 			else {
237 				evc->evc_rep_required = TRUE ;
238 				*evc->evc_multiple  = FALSE ;
239 			}
240 			smc->srf.any_report = TRUE ;
241 			event_occurred = TRUE ;
242 		}
243 #ifdef	FDDI_MIB
244 		snmp_srf_event(smc,evc) ;
245 #endif	/* FDDI_MIB */
246 	}
247 	tsr = smt_get_time() - smc->srf.TSR ;
248 
249 	switch (smc->srf.sr_state) {
250 	case SR0_WAIT :
251 		/* SR01a */
252 		if (cond_asserted && tsr < T_Limit) {
253 			smc->srf.SRThreshold = THRESHOLD_2 ;
254 			smc->srf.sr_state = SR1_HOLDOFF ;
255 			break ;
256 		}
257 		/* SR01b */
258 		if (cond_deasserted && tsr < T_Limit) {
259 			smc->srf.sr_state = SR1_HOLDOFF ;
260 			break ;
261 		}
262 		/* SR01c */
263 		if (event_occurred && tsr < T_Limit) {
264 			smc->srf.sr_state = SR1_HOLDOFF ;
265 			break ;
266 		}
267 		/* SR00b */
268 		if (cond_asserted && tsr >= T_Limit) {
269 			smc->srf.SRThreshold = THRESHOLD_2 ;
270 			smc->srf.TSR = smt_get_time() ;
271 			smt_send_srf(smc) ;
272 			break ;
273 		}
274 		/* SR00c */
275 		if (cond_deasserted && tsr >= T_Limit) {
276 			smc->srf.TSR = smt_get_time() ;
277 			smt_send_srf(smc) ;
278 			break ;
279 		}
280 		/* SR00d */
281 		if (event_occurred && tsr >= T_Limit) {
282 			smc->srf.TSR = smt_get_time() ;
283 			smt_send_srf(smc) ;
284 			break ;
285 		}
286 		/* SR00e */
287 		if (smc->srf.any_report && (u_long) tsr >=
288 			smc->srf.SRThreshold) {
289 			smc->srf.SRThreshold *= 2 ;
290 			if (smc->srf.SRThreshold > THRESHOLD_32)
291 				smc->srf.SRThreshold = THRESHOLD_32 ;
292 			smc->srf.TSR = smt_get_time() ;
293 			smt_send_srf(smc) ;
294 			break ;
295 		}
296 		/* SR02 */
297 		if (!smc->mib.fddiSMTStatRptPolicy) {
298 			smc->srf.sr_state = SR2_DISABLED ;
299 			break ;
300 		}
301 		break ;
302 	case SR1_HOLDOFF :
303 		/* SR10b */
304 		if (tsr >= T_Limit) {
305 			smc->srf.sr_state = SR0_WAIT ;
306 			smc->srf.TSR = smt_get_time() ;
307 			smt_send_srf(smc) ;
308 			break ;
309 		}
310 		/* SR11a */
311 		if (cond_asserted) {
312 			smc->srf.SRThreshold = THRESHOLD_2 ;
313 		}
314 		/* SR11b */
315 		/* SR11c */
316 		/* handled above */
317 		/* SR12 */
318 		if (!smc->mib.fddiSMTStatRptPolicy) {
319 			smc->srf.sr_state = SR2_DISABLED ;
320 			break ;
321 		}
322 		break ;
323 	case SR2_DISABLED :
324 		if (smc->mib.fddiSMTStatRptPolicy) {
325 			smc->srf.sr_state = SR0_WAIT ;
326 			smc->srf.TSR = smt_get_time() ;
327 			smc->srf.SRThreshold = THRESHOLD_2 ;
328 			clear_all_rep(smc) ;
329 			break ;
330 		}
331 		break ;
332 	}
333 }
334 
clear_all_rep(struct s_smc * smc)335 static void clear_all_rep(struct s_smc *smc)
336 {
337 	struct s_srf_evc	*evc ;
338 	int			i ;
339 
340 	for (i = 0, evc = smc->evcs ; (unsigned) i < MAX_EVCS ; i++, evc++) {
341 		evc->evc_rep_required = FALSE ;
342 		if (SMT_IS_CONDITION(evc->evc_code))
343 			*evc->evc_cond_state = FALSE ;
344 	}
345 	smc->srf.any_report = FALSE ;
346 }
347 
clear_reported(struct s_smc * smc)348 static void clear_reported(struct s_smc *smc)
349 {
350 	struct s_srf_evc	*evc ;
351 	int			i ;
352 
353 	smc->srf.any_report = FALSE ;
354 	for (i = 0, evc = smc->evcs ; (unsigned) i < MAX_EVCS ; i++, evc++) {
355 		if (SMT_IS_CONDITION(evc->evc_code)) {
356 			if (*evc->evc_cond_state == FALSE)
357 				evc->evc_rep_required = FALSE ;
358 			else
359 				smc->srf.any_report = TRUE ;
360 		}
361 		else {
362 			evc->evc_rep_required = FALSE ;
363 			*evc->evc_multiple = FALSE ;
364 		}
365 	}
366 }
367 
368 /*
369  * build and send SMT SRF frame
370  */
smt_send_srf(struct s_smc * smc)371 static void smt_send_srf(struct s_smc *smc)
372 {
373 
374 	struct smt_header	*smt ;
375 	struct s_srf_evc	*evc ;
376 	SK_LOC_DECL(struct s_pcon,pcon) ;
377 	SMbuf			*mb ;
378 	int			i ;
379 
380 	static const struct fddi_addr SMT_SRF_DA = {
381 		{ 0x80, 0x01, 0x43, 0x00, 0x80, 0x08 }
382 	} ;
383 
384 	/*
385 	 * build SMT header
386 	 */
387 	if (!smc->r.sm_ma_avail)
388 		return ;
389 	if (!(mb = smt_build_frame(smc,SMT_SRF,SMT_ANNOUNCE,0)))
390 		return ;
391 
392 	RS_SET(smc,RS_SOFTERROR) ;
393 
394 	smt = smtod(mb, struct smt_header *) ;
395 	smt->smt_dest = SMT_SRF_DA ;		/* DA == SRF multicast */
396 
397 	/*
398 	 * setup parameter status
399 	 */
400 	pcon.pc_len = SMT_MAX_INFO_LEN ;	/* max para length */
401 	pcon.pc_err = 0 ;			/* no error */
402 	pcon.pc_badset = 0 ;			/* no bad set count */
403 	pcon.pc_p = (void *) (smt + 1) ;	/* paras start here */
404 
405 	smt_add_para(smc,&pcon,(u_short) SMT_P1033,0,0) ;
406 	smt_add_para(smc,&pcon,(u_short) SMT_P1034,0,0) ;
407 
408 	for (i = 0, evc = smc->evcs ; (unsigned) i < MAX_EVCS ; i++, evc++) {
409 		if (evc->evc_rep_required) {
410 			smt_add_para(smc,&pcon,evc->evc_para,
411 				(int)evc->evc_index,0) ;
412 		}
413 	}
414 	smt->smt_len = SMT_MAX_INFO_LEN - pcon.pc_len ;
415 	mb->sm_len = smt->smt_len + sizeof(struct smt_header) ;
416 
417 	DB_SMT("SRF: sending SRF at %x, len %d\n",smt,mb->sm_len) ;
418 	DB_SMT("SRF: state SR%d Threshold %d\n",
419 		smc->srf.sr_state,smc->srf.SRThreshold/TICKS_PER_SECOND) ;
420 #ifdef	DEBUG
421 	dump_smt(smc,smt,"SRF Send") ;
422 #endif
423 	smt_send_frame(smc,mb,FC_SMT_INFO,0) ;
424 	clear_reported(smc) ;
425 }
426 
427 #endif	/* no BOOT */
428 #endif	/* no SLIM_SMT */
429 
430