开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
srf.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：10k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

srf.c：源码内容
  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.  ******************************************************************************/
  17. /*
  18. SMT 7.2 Status Response Frame Implementation
  19. SRF state machine and frame generation
  20. */
  22. #include "h/types.h"
  23. #include "h/fddi.h"
  24. #include "h/smc.h"
  25. #include "h/smt_p.h"
  27. #define KERNEL
  28. #include "h/smtstate.h"
  30. #ifndef SLIM_SMT
  31. #ifndef BOOT
  33. #ifndef lint
  34. static const char ID_sccs[] = "@(#)srf.c 1.18 97/08/04 (C) SK " ;
  35. #endif
  38. /*
  39.  * function declarations
  40.  */
  41. static void clear_all_rep() ;
  42. static void clear_reported() ;
  43. static void smt_send_srf() ;
  44. static struct s_srf_evc *smt_get_evc() ;
  46. #define MAX_EVCS (sizeof(smc->evcs)/sizeof(smc->evcs[0]))
  48. struct evc_init {
  49. u_char code ;
  50. u_char index ;
  51. u_char n ;
  52. u_short para ;
  53. }  ;
  55. static const struct evc_init evc_inits[] = {
  56. { SMT_COND_SMT_PEER_WRAP, 0,1,SMT_P1048 } ,
  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 } ,
  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. } ;
  70. #define MAX_INIT_EVC (sizeof(evc_inits)/sizeof(evc_inits[0]))
  72. void smt_init_evc(smc)
  73. struct s_smc *smc ;
  74. {
  75. struct s_srf_evc *evc ;
  76. const struct evc_init  *init ;
  77. int i ;
  78. int index ;
  79. int offset ;
  81. static u_char fail_safe = FALSE ;
  83. memset((char *)smc->evcs,0,sizeof(smc->evcs)) ;
  85. evc = smc->evcs ;
  86. init = evc_inits ;
  88. for (i = 0 ; (unsigned) i < MAX_INIT_EVC ; i++) {
  89. for (index = 0 ; index < init->n ; index++) {
  90. evc->evc_code = init->code ;
  91. evc->evc_para = init->para ;
  92. evc->evc_index = init->index + index ;
  93. #ifndef DEBUG
  94. evc->evc_multiple = &fail_safe ;
  95. evc->evc_cond_state = &fail_safe ;
  96. #endif
  97. evc++ ;
  98. }
  99. init++ ;
  100. }
  102. if ((unsigned) (evc - smc->evcs) > MAX_EVCS) {
  103. SMT_PANIC(smc,SMT_E0127, SMT_E0127_MSG) ;
  104. }
  106. /*
  107.  * conditions
  108.  */
  109. smc->evcs[0].evc_cond_state = &smc->mib.fddiSMTPeerWrapFlag ;
  110. smc->evcs[1].evc_cond_state =
  111. &smc->mib.m[MAC0].fddiMACDuplicateAddressCond ;
  112. smc->evcs[2].evc_cond_state =
  113. &smc->mib.m[MAC0].fddiMACFrameErrorFlag ;
  114. smc->evcs[3].evc_cond_state =
  115. &smc->mib.m[MAC0].fddiMACNotCopiedFlag ;
  117. /*
  118.  * events
  119.  */
  120. smc->evcs[4].evc_multiple = &smc->mib.m[MAC0].fddiMACMultiple_N ;
  121. smc->evcs[5].evc_multiple = &smc->mib.m[MAC0].fddiMACMultiple_P ;
  123. offset = 6 ;
  124. for (i = 0 ; i < NUMPHYS ; i++) {
  125. /*
  126.  * conditions
  127.  */
  128. smc->evcs[offset + 0*NUMPHYS].evc_cond_state =
  129. &smc->mib.p[i].fddiPORTLerFlag ;
  130. smc->evcs[offset + 1*NUMPHYS].evc_cond_state =
  131. &smc->mib.p[i].fddiPORTEB_Condition ;
  133. /*
  134.  * events
  135.  */
  136. smc->evcs[offset + 2*NUMPHYS].evc_multiple =
  137. &smc->mib.p[i].fddiPORTMultiple_U ;
  138. smc->evcs[offset + 3*NUMPHYS].evc_multiple =
  139. &smc->mib.p[i].fddiPORTMultiple_P ;
  140. offset++ ;
  141. }
  142. #ifdef DEBUG
  143. for (i = 0, evc = smc->evcs ; (unsigned) i < MAX_EVCS ; i++, evc++) {
  144. if (SMT_IS_CONDITION(evc->evc_code)) {
  145. if (!evc->evc_cond_state) {
  146. SMT_PANIC(smc,SMT_E0128, SMT_E0128_MSG) ;
  147. }
  148. evc->evc_multiple = &fail_safe ;
  149. }
  150. else {
  151. if (!evc->evc_multiple) {
  152. SMT_PANIC(smc,SMT_E0129, SMT_E0129_MSG) ;
  153. }
  154. evc->evc_cond_state = &fail_safe ;
  155. }
  156. }
  157. #endif
  158. smc->srf.TSR = smt_get_time() ;
  159. smc->srf.sr_state = SR0_WAIT ;
  160. }
  162. static struct s_srf_evc *smt_get_evc(smc,code,index)
  163. struct s_smc *smc ;
  164. int code ;
  165. int index ;
  166. {
  167. int i ;
  168. struct s_srf_evc *evc ;
  170. for (i = 0, evc = smc->evcs ; (unsigned) i < MAX_EVCS ; i++, evc++) {
  171. if (evc->evc_code == code && evc->evc_index == index)
  172. return(evc) ;
  173. }
  174. return(0) ;
  175. }
  177. #define THRESHOLD_2 (2*TICKS_PER_SECOND)
  178. #define THRESHOLD_32 (32*TICKS_PER_SECOND)
  180. #ifdef DEBUG
  181. static const char * const srf_names[] = {
  182. "None","MACPathChangeEvent", "MACNeighborChangeEvent",
  183. "PORTPathChangeEvent", "PORTUndesiredConnectionAttemptEvent",
  184. "SMTPeerWrapCondition", "SMTHoldCondition",
  185. "MACFrameErrorCondition", "MACDuplicateAddressCondition",
  186. "MACNotCopiedCondition", "PORTEBErrorCondition",
  187. "PORTLerCondition"
  188. } ;
  189. #endif
  191. void smt_srf_event(smc,code,index,cond)
  192. struct s_smc *smc ;
  193. int code ;
  194. int index ;
  195. int cond ;
  196. {
  197. struct s_srf_evc *evc ;
  198. int cond_asserted = 0 ;
  199. int cond_deasserted = 0 ;
  200. int event_occurred = 0 ;
  201. int tsr ;
  202. int T_Limit = 2*TICKS_PER_SECOND ;
  204. if (code == SMT_COND_MAC_DUP_ADDR && cond) {
  205. RS_SET(smc,RS_DUPADDR) ;
  206. }
  208. if (code) {
  209. DB_SMT("SRF: %s index %dn",srf_names[code],index) ;
  211. if (!(evc = smt_get_evc(smc,code,index))) {
  212. DB_SMT("SRF : smt_get_evc() failedn",0,0) ;
  213. return ;
  214. }
  215. /*
  216.  * ignore condition if no change
  217.  */
  218. if (SMT_IS_CONDITION(code)) {
  219. if (*evc->evc_cond_state == cond)
  220. return ;
  221. }
  223. /*
  224.  * set transition time stamp
  225.  */
  226. smt_set_timestamp(smc,smc->mib.fddiSMTTransitionTimeStamp) ;
  227. if (SMT_IS_CONDITION(code)) {
  228. DB_SMT("SRF: condition is %sn",cond ? "ON":"OFF",0) ;
  229. if (cond) {
  230. *evc->evc_cond_state = TRUE ;
  231. evc->evc_rep_required = TRUE ;
  232. smc->srf.any_report = TRUE ;
  233. cond_asserted = TRUE ;
  234. }
  235. else {
  236. *evc->evc_cond_state = FALSE ;
  237. cond_deasserted = TRUE ;
  238. }
  239. }
  240. else {
  241. if (evc->evc_rep_required) {
  242. *evc->evc_multiple  = TRUE ;
  243. }
  244. else {
  245. evc->evc_rep_required = TRUE ;
  246. *evc->evc_multiple  = FALSE ;
  247. }
  248. smc->srf.any_report = TRUE ;
  249. event_occurred = TRUE ;
  250. }
  251. #ifdef FDDI_MIB
  252. snmp_srf_event(smc,evc) ;
  253. #endif /* FDDI_MIB */
  254. }
  255. tsr = smt_get_time() - smc->srf.TSR ;
  257. switch (smc->srf.sr_state) {
  258. case SR0_WAIT :
  259. /* SR01a */
  260. if (cond_asserted && tsr < T_Limit) {
  261. smc->srf.SRThreshold = THRESHOLD_2 ;
  262. smc->srf.sr_state = SR1_HOLDOFF ;
  263. break ;
  264. }
  265. /* SR01b */
  266. if (cond_deasserted && tsr < T_Limit) {
  267. smc->srf.sr_state = SR1_HOLDOFF ;
  268. break ;
  269. }
  270. /* SR01c */
  271. if (event_occurred && tsr < T_Limit) {
  272. smc->srf.sr_state = SR1_HOLDOFF ;
  273. break ;
  274. }
  275. /* SR00b */
  276. if (cond_asserted && tsr >= T_Limit) {
  277. smc->srf.SRThreshold = THRESHOLD_2 ;
  278. smc->srf.TSR = smt_get_time() ;
  279. smt_send_srf(smc) ;
  280. break ;
  281. }
  282. /* SR00c */
  283. if (cond_deasserted && tsr >= T_Limit) {
  284. smc->srf.TSR = smt_get_time() ;
  285. smt_send_srf(smc) ;
  286. break ;
  287. }
  288. /* SR00d */
  289. if (event_occurred && tsr >= T_Limit) {
  290. smc->srf.TSR = smt_get_time() ;
  291. smt_send_srf(smc) ;
  292. break ;
  293. }
  294. /* SR00e */
  295. if (smc->srf.any_report && (u_long) tsr >=
  296. smc->srf.SRThreshold) {
  297. smc->srf.SRThreshold *= 2 ;
  298. if (smc->srf.SRThreshold > THRESHOLD_32)
  299. smc->srf.SRThreshold = THRESHOLD_32 ;
  300. smc->srf.TSR = smt_get_time() ;
  301. smt_send_srf(smc) ;
  302. break ;
  303. }
  304. /* SR02 */
  305. if (!smc->mib.fddiSMTStatRptPolicy) {
  306. smc->srf.sr_state = SR2_DISABLED ;
  307. break ;
  308. }
  309. break ;
  310. case SR1_HOLDOFF :
  311. /* SR10b */
  312. if (tsr >= T_Limit) {
  313. smc->srf.sr_state = SR0_WAIT ;
  314. smc->srf.TSR = smt_get_time() ;
  315. smt_send_srf(smc) ;
  316. break ;
  317. }
  318. /* SR11a */
  319. if (cond_asserted) {
  320. smc->srf.SRThreshold = THRESHOLD_2 ;
  321. }
  322. /* SR11b */
  323. /* SR11c */
  324. /* handled above */
  325. /* SR12 */
  326. if (!smc->mib.fddiSMTStatRptPolicy) {
  327. smc->srf.sr_state = SR2_DISABLED ;
  328. break ;
  329. }
  330. break ;
  331. case SR2_DISABLED :
  332. if (smc->mib.fddiSMTStatRptPolicy) {
  333. smc->srf.sr_state = SR0_WAIT ;
  334. smc->srf.TSR = smt_get_time() ;
  335. smc->srf.SRThreshold = THRESHOLD_2 ;
  336. clear_all_rep(smc) ;
  337. break ;
  338. }
  339. break ;
  340. }
  341. }
  343. static void clear_all_rep(smc)
  344. struct s_smc *smc ;
  345. {
  346. struct s_srf_evc *evc ;
  347. int i ;
  349. for (i = 0, evc = smc->evcs ; (unsigned) i < MAX_EVCS ; i++, evc++) {
  350. evc->evc_rep_required = FALSE ;
  351. if (SMT_IS_CONDITION(evc->evc_code))
  352. *evc->evc_cond_state = FALSE ;
  353. }
  354. smc->srf.any_report = FALSE ;
  355. }
  357. static void clear_reported(smc)
  358. struct s_smc *smc ;
  359. {
  360. struct s_srf_evc *evc ;
  361. int i ;
  363. smc->srf.any_report = FALSE ;
  364. for (i = 0, evc = smc->evcs ; (unsigned) i < MAX_EVCS ; i++, evc++) {
  365. if (SMT_IS_CONDITION(evc->evc_code)) {
  366. if (*evc->evc_cond_state == FALSE)
  367. evc->evc_rep_required = FALSE ;
  368. else
  369. smc->srf.any_report = TRUE ;
  370. }
  371. else {
  372. evc->evc_rep_required = FALSE ;
  373. *evc->evc_multiple = FALSE ;
  374. }
  375. }
  376. }
  378. extern SMbuf *smt_build_frame() ;
  380. /*
  381.  * build and send SMT SRF frame
  382.  */
  383. static void smt_send_srf(smc)
  384. struct s_smc *smc ;
  385. {
  387. struct smt_header *smt ;
  388. struct s_srf_evc *evc ;
  389. SK_LOC_DECL(struct s_pcon,pcon) ;
  390. SMbuf *mb ;
  391. int i ;
  393. static const struct fddi_addr SMT_SRF_DA = {
  394. { 0x80, 0x01, 0x43, 0x00, 0x80, 0x08 }
  395. } ;
  397. /*
  398.  * build SMT header
  399.  */
  400. if (!smc->r.sm_ma_avail)
  401. return ;
  402. if (!(mb = smt_build_frame(smc,SMT_SRF,SMT_ANNOUNCE,0)))
  403. return ;
  405. RS_SET(smc,RS_SOFTERROR) ;
  407. smt = smtod(mb, struct smt_header *) ;
  408. smt->smt_dest = SMT_SRF_DA ; /* DA == SRF multicast */
  410. /*
  411.  * setup parameter status
  412.  */
  413. pcon.pc_len = SMT_MAX_INFO_LEN ; /* max para length */
  414. pcon.pc_err = 0 ; /* no error */
  415. pcon.pc_badset = 0 ; /* no bad set count */
  416. pcon.pc_p = (void *) (smt + 1) ; /* paras start here */
  418. smt_add_para(smc,&pcon,(u_short) SMT_P1033,0,0) ;
  419. smt_add_para(smc,&pcon,(u_short) SMT_P1034,0,0) ;
  421. for (i = 0, evc = smc->evcs ; (unsigned) i < MAX_EVCS ; i++, evc++) {
  422. if (evc->evc_rep_required) {
  423. smt_add_para(smc,&pcon,evc->evc_para,
  424. (int)evc->evc_index,0) ;
  425. }
  426. }
  427. smt->smt_len = SMT_MAX_INFO_LEN - pcon.pc_len ;
  428. mb->sm_len = smt->smt_len + sizeof(struct smt_header) ;
  430. DB_SMT("SRF: sending SRF at %x, len %d n",smt,mb->sm_len) ;
  431. DB_SMT("SRF: state SR%d Threshold %dn",
  432. smc->srf.sr_state,smc->srf.SRThreshold/TICKS_PER_SECOND) ;
  433. #ifdef DEBUG
  434. dump_smt(smc,smt,"SRF Send") ;
  435. #endif
  436. smt_send_frame(smc,mb,FC_SMT_INFO,0) ;
  437. clear_reported(smc) ;
  438. }
  440. #endif /* no BOOT */
  441. #endif /* no SLIM_SMT */