?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
kernel - VM PAGER part 1/2 - Remove vm_page_alloc()
[dragonfly.git] / usr.sbin / atm / scspd / scsp_cafsm.c
blobefa2e60b46b878b583e42c2db9a53a64f89ffc57
1 /*
2 *
3 * ===================================
4 * HARP | Host ATM Research Platform
5 * ===================================
6 *
7 *
8 * This Host ATM Research Platform ("HARP") file (the "Software") is
9 * made available by Network Computing Services, Inc. ("NetworkCS")
10 * "AS IS". NetworkCS does not provide maintenance, improvements or
11 * support of any kind.
12 *
13 * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED,
14 * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
15 * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE
16 * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE.
17 * In no event shall NetworkCS be responsible for any damages, including
18 * but not limited to consequential damages, arising from or relating to
19 * any use of the Software or related support.
20 *
21 * Copyright 1994-1998 Network Computing Services, Inc.
22 *
23 * Copies of this Software may be made, however, the above copyright
24 * notice must be reproduced on all copies.
25 *
26 * @(#) $FreeBSD: src/usr.sbin/atm/scspd/scsp_cafsm.c,v 1.3 1999/08/28 01:15:32 peter Exp $
27 * @(#) $DragonFly: src/usr.sbin/atm/scspd/scsp_cafsm.c,v 1.5 2004/12/18 22:48:02 swildner Exp $
28 */
29
30
31 /*
32 * Server Cache Synchronization Protocol (SCSP) Support
33 * ----------------------------------------------------
34 *
35 * Cache Alignment finite state machine
36 *
37 */
38
39 #include <sys/types.h>
40 #include <sys/param.h>
41 #include <sys/socket.h>
42 #include <net/if.h>
43 #include <netinet/in.h>
44 #include <netatm/port.h>
45 #include <netatm/queue.h>
46 #include <netatm/atm.h>
47 #include <netatm/atm_if.h>
48 #include <netatm/atm_sap.h>
49 #include <netatm/atm_sys.h>
50 #include <netatm/atm_ioctl.h>
51
52 #include <errno.h>
53 #include <libatm.h>
54 #include <stdio.h>
55 #include <stdlib.h>
56 #include <string.h>
57 #include <syslog.h>
58
59 #include "scsp_msg.h"
60 #include "scsp_if.h"
61 #include "scsp_var.h"
62
63 /*
64 * CA FSM actions
65 */
66 #define CA_ACTION_CNT 20
67 int scsp_ca_act_00(Scsp_dcs *, void *);
68 int scsp_ca_act_01(Scsp_dcs *, void *);
69 int scsp_ca_act_02(Scsp_dcs *, void *);
70 int scsp_ca_act_03(Scsp_dcs *, void *);
71 int scsp_ca_act_04(Scsp_dcs *, void *);
72 int scsp_ca_act_05(Scsp_dcs *, void *);
73 int scsp_ca_act_06(Scsp_dcs *, void *);
74 int scsp_ca_act_07(Scsp_dcs *, void *);
75 int scsp_ca_act_08(Scsp_dcs *, void *);
76 int scsp_ca_act_09(Scsp_dcs *, void *);
77 int scsp_ca_act_10(Scsp_dcs *, void *);
78 int scsp_ca_act_11(Scsp_dcs *, void *);
79 int scsp_ca_act_12(Scsp_dcs *, void *);
80 int scsp_ca_act_13(Scsp_dcs *, void *);
81 int scsp_ca_act_14(Scsp_dcs *, void *);
82 int scsp_ca_act_15(Scsp_dcs *, void *);
83 int scsp_ca_act_16(Scsp_dcs *, void *);
84 int scsp_ca_act_17(Scsp_dcs *, void *);
85 int scsp_ca_act_18(Scsp_dcs *, void *);
86 int scsp_ca_act_19(Scsp_dcs *, void *);
87
88 static int (*scsp_ca_act_vec[CA_ACTION_CNT])() = {
89 scsp_ca_act_00,
90 scsp_ca_act_01,
91 scsp_ca_act_02,
92 scsp_ca_act_03,
93 scsp_ca_act_04,
94 scsp_ca_act_05,
95 scsp_ca_act_06,
96 scsp_ca_act_07,
97 scsp_ca_act_08,
98 scsp_ca_act_09,
99 scsp_ca_act_10,
100 scsp_ca_act_11,
101 scsp_ca_act_12,
102 scsp_ca_act_13,
103 scsp_ca_act_14,
104 scsp_ca_act_15,
105 scsp_ca_act_16,
106 scsp_ca_act_17,
107 scsp_ca_act_18,
108 scsp_ca_act_19
109 };
110
111 /*
112 * CA FSM state table
113 */
114 static int ca_state_table[SCSP_CAFSM_EVENT_CNT][SCSP_CAFSM_STATE_CNT] = {
115 /* 0 1 2 3 4 5 */
116 { 1, 1, 1, 1, 1, 1 }, /* 0 */
117 { 2, 2, 2, 2, 2, 2 }, /* 1 */
118 { 0, 3, 4, 5, 15, 15 }, /* 2 */
119 { 0, 17, 17, 17, 7, 7 }, /* 3 */
120 { 0, 17, 17, 17, 8, 8 }, /* 4 */
121 { 0, 17, 17, 17, 10, 10 }, /* 5 */
122 { 0, 6, 6, 0, 9, 9 }, /* 6 */
123 { 0, 0, 0, 0, 12, 12 }, /* 7 */
124 { 0, 0, 0, 0, 13, 13 }, /* 8 */
125 { 18, 14, 14, 14, 11, 11 }, /* 9 */
126 { 0, 19, 0, 0, 16, 16 }, /* 10 */
127 };
128
129
130 /*
131 * Cache Alignment finite state machine
132 *
133 * Arguments:
134 * dcsp pointer to a DCS control block for the neighbor
135 * event the event which has occurred
136 * p pointer to further parameter, if there is one
137 *
138 * Returns:
139 * 0 success
140 * errno error encountered
141 *
142 */
143 int
144 scsp_cafsm(Scsp_dcs *dcsp, int event, void *p)
145 {
146 int action, rc, state;
147
148 /*
149 * Select an action from the state table
150 */
151 state = dcsp->sd_ca_state;
152 action = ca_state_table[event][state];
153 if (scsp_trace_mode & SCSP_TRACE_CAFSM) {
154 scsp_trace("CAFSM: state=%d, event=%d, action=%d\n",
155 state, event, action);
156 }
157 if (action >= CA_ACTION_CNT || action < 0) {
158 scsp_log(LOG_ERR, "CA FSM--invalid action state=%d, event=%d, action=%d",
159 state, event, action);
160 abort();
161 }
162
163 /*
164 * Perform the selected action
165 */
166 rc = scsp_ca_act_vec[action](dcsp, p);
167
168 return(rc);
169 }
170
171
172 /*
173 * CA finite state machine action 0
174 * Unexpected action -- log an error message and go to Master/Slave
175 * Negotiation. The unexpected action is probably from a protocol
176 * error.
177 *
178 * Arguments:
179 * dcsp pointer to DCS control block
180 * p ignored
181 *
182 * Returns:
183 * EOPNOTSUPP always returns EOPNOTSUPP
184 *
185 */
186 int
187 scsp_ca_act_00(Scsp_dcs *dcsp, void *p)
188 {
189 int rc;
190
191 /*
192 * Log an error message
193 */
194 scsp_log(LOG_ERR, "CA FSM error--unexpected action, state=%d",
195 dcsp->sd_ca_state);
196
197 /*
198 * Set the new state
199 */
200 dcsp->sd_ca_state = SCSP_CAFSM_NEG;
201
202 /*
203 * Clear out the DCS block
204 */
205 scsp_dcs_cleanup(dcsp);
206
207 /*
208 * Notify the client I/F FSM
209 */
210 rc = scsp_cfsm(dcsp, SCSP_CIFSM_CA_DOWN, NULL, NULL);
211
212 return(rc);
213 }
214
215
216 /*
217 * CA finite state machine action 1
218 * Hello FSM has reached Bidirectional state -- go to Master/Slave
219 * Negotiation state, make a copy of the client's cache, send first CA
220 * message.
221 *
222 * Arguments:
223 * dcsp pointer to DCS control block
224 * p ignored
225 *
226 * Returns:
227 * 0 success
228 * errno error encountered
229 *
230 */
231 int
232 scsp_ca_act_01(Scsp_dcs *dcsp, void *p)
233 {
234 int i, rc;
235 Scsp_cse *csep, *dupp;
236
237 /*
238 * Set the new state
239 */
240 dcsp->sd_ca_state = SCSP_CAFSM_NEG;
241
242 /*
243 * Make a copy of client's cache entries for cache alignment
244 */
245 for (i = 0; i < SCSP_HASHSZ; i++) {
246 for (csep = dcsp->sd_server->ss_cache[i];
247 csep; csep = csep->sc_next) {
248 dupp = scsp_dup_cse(csep);
249 LINK2TAIL(dupp, Scsp_cse, dcsp->sd_ca_csas,
250 sc_next);
251 }
252 }
253
254 /*
255 * Select an initial sequence number
256 */
257 dcsp->sd_ca_seq = (int)time(NULL);
258
259 /*
260 * Send a CA message
261 */
262 rc = scsp_send_ca(dcsp);
263 if (rc == 0) {
264 HARP_TIMER(&dcsp->sd_ca_rexmt_t, dcsp->sd_ca_rexmt_int,
265 scsp_ca_retran_timeout);
266 }
267
268 return(rc);
269 }
270
271
272 /*
273 * CA finite state machine action 2
274 * Hello FSM has gone down -- go to Down state
275 *
276 * Arguments:
277 * dcsp pointer to DCS control block
278 * p ignored
279 *
280 * Returns:
281 * 0 success
282 * errno error encountered
283 *
284 */
285 int
286 scsp_ca_act_02(Scsp_dcs *dcsp, void *p)
287 {
288 int rc;
289
290 /*
291 * Set the new state
292 */
293 dcsp->sd_ca_state = SCSP_CAFSM_DOWN;
294
295 /*
296 * Clear out the DCS block
297 */
298 scsp_dcs_cleanup(dcsp);
299
300 /*
301 * Notify the client I/F FSM
302 */
303 rc = scsp_cfsm(dcsp, SCSP_CIFSM_CA_DOWN, NULL, NULL);
304
305 return(rc);
306 }
307
308
309 /*
310 * CA finite state machine action 3
311 * CA message received -- select Cache Summarize Master or Slave state
312 *
313 * Arguments:
314 * dcsp pointer to DCS control block
315 * p pointer to received message
316 *
317 * Returns:
318 * 0 success
319 * errno error encountered
320 *
321 */
322 int
323 scsp_ca_act_03(Scsp_dcs *dcsp, void *p)
324 {
325 int rc = 0;
326 Scsp_msg *msg = (Scsp_msg *)p;
327
328 /*
329 * Check for slave role for LS
330 */
331 if (msg->sc_ca->ca_m &&
332 msg->sc_ca->ca_i &&
333 msg->sc_ca->ca_o &&
334 msg->sc_ca->ca_mcp.rec_cnt == 0 &&
335 scsp_cmp_id(&msg->sc_ca->ca_mcp.sid,
336 &msg->sc_ca->ca_mcp.rid) > 0) {
337
338 /*
339 * Stop the retransmit timer
340 */
341 HARP_CANCEL(&dcsp->sd_ca_rexmt_t);
342
343 /*
344 * Set the new state
345 */
346 dcsp->sd_ca_state = SCSP_CAFSM_SLAVE;
347 scsp_cfsm(dcsp, SCSP_CIFSM_CA_SUMM, NULL, NULL);
348
349 /*
350 * Save the master's sequence number
351 */
352 dcsp->sd_ca_seq = msg->sc_ca->ca_seq;
353
354 /*
355 * Send a CA message
356 */
357 rc = scsp_send_ca(dcsp);
358 } else
359 /*
360 * Check for master role for LS
361 */
362 if (!msg->sc_ca->ca_m &&
363 !msg->sc_ca->ca_i &&
364 scsp_cmp_id(&msg->sc_ca->ca_mcp.sid,
365 &msg->sc_ca->ca_mcp.rid) < 0) {
366 /*
367 * Stop the retransmit timer
368 */
369 HARP_CANCEL(&dcsp->sd_ca_rexmt_t);
370
371 /*
372 * Set the new state
373 */
374 dcsp->sd_ca_state = SCSP_CAFSM_MASTER;
375 rc = scsp_cfsm(dcsp, SCSP_CIFSM_CA_SUMM, NULL, NULL);
376
377 /*
378 * Process the CA message
379 */
380 scsp_process_ca(dcsp, msg->sc_ca);
381
382 /*
383 * Increment the sequence number
384 */
385 dcsp->sd_ca_seq++;
386
387 /*
388 * Send a CA in reply
389 */
390 rc = scsp_send_ca(dcsp);
391 if (rc == 0) {
392 HARP_TIMER(&dcsp->sd_ca_rexmt_t,
393 dcsp->sd_ca_rexmt_int,
394 scsp_ca_retran_timeout);
395 }
396 } else {
397 /*
398 * Ignore the message, go to Master/Slave Negotiation
399 */
400 dcsp->sd_ca_state = SCSP_CAFSM_NEG;
401 }
402
403 return(rc);
404 }
405
406
407 /*
408 * CA finite state machine action 4
409 * CA message received while in Cache Summarize Master state -- process
410 * CA message
411 *
412 * Arguments:
413 * dcsp pointer to DCS control block
414 * p pointer to received message
415 *
416 * Returns:
417 * 0 success
418 * errno error encountered
419 *
420 */
421 int
422 scsp_ca_act_04(Scsp_dcs *dcsp, void *p)
423 {
424 int rc = 0;
425 Scsp_msg *msg = (Scsp_msg *)p;
426
427 /*
428 * If the other side thinks he's the master, or if the
429 * initialization bit is set, or if the message is out
430 * of sequence, go back to Master/Slave Negotiation state
431 */
432 if (msg->sc_ca->ca_m || msg->sc_ca->ca_i ||
433 msg->sc_ca->ca_seq < dcsp->sd_ca_seq - 1 ||
434 msg->sc_ca->ca_seq > dcsp->sd_ca_seq) {
435 HARP_CANCEL(&dcsp->sd_ca_rexmt_t);
436 dcsp->sd_ca_state = SCSP_CAFSM_NEG;
437 scsp_dcs_cleanup(dcsp);
438 return(scsp_ca_act_01(dcsp, NULL));
439 }
440
441 /*
442 * Ignore any duplicate messages
443 */
444 if (msg->sc_ca->ca_seq == dcsp->sd_ca_seq - 1) {
445 return(0);
446 }
447
448 /*
449 * Stop the retransmission timer
450 */
451 HARP_CANCEL(&dcsp->sd_ca_rexmt_t);
452
453 /*
454 * Process the CA message
455 */
456 scsp_process_ca(dcsp, msg->sc_ca);
457
458 /*
459 * Increment the CA sequence number
460 */
461 dcsp->sd_ca_seq++;
462
463 /*
464 * If we have no more CSAS records to send and the slave sent
465 * a message with the 'O' bit off, we're done with Summarize
466 * state
467 */
468 if (!dcsp->sd_ca_csas && !msg->sc_ca->ca_o) {
469 /*
470 * Free any CA message saved for retransmission
471 */
472 if (dcsp->sd_ca_rexmt_msg) {
473 scsp_free_msg(dcsp->sd_ca_rexmt_msg);
474 dcsp->sd_ca_rexmt_msg = NULL;
475 }
476
477 /*
478 * If the CRL is empty, we go directly to Aligned state;
479 * otherwise, we go to Update Cache and send a CSUS
480 */
481 if (!dcsp->sd_crl) {
482 /*
483 * Go to Aligned state
484 */
485 dcsp->sd_ca_state = SCSP_CAFSM_ALIGNED;
486 rc = scsp_cfsm(dcsp, SCSP_CIFSM_CA_ALIGN, NULL, NULL);
487 } else {
488 /*
489 * Go to Cache Update state
490 */
491 dcsp->sd_ca_state = SCSP_CAFSM_UPDATE;
492 scsp_cfsm(dcsp, SCSP_CIFSM_CA_UPD, NULL, NULL);
493 rc = scsp_send_csus(dcsp);
494 }
495 } else {
496 /*
497 * There are more CSAS records to be exchanged--
498 * continue the cache exchange
499 */
500 rc = scsp_send_ca(dcsp);
501 }
502
503 return(rc);
504 }
505
506
507 /*
508 * CA finite state machine action 5
509 * CA message received while in Cache Summarize Slave state -- process
510 * CA message
511 *
512 * Arguments:
513 * dcsp pointer to DCS control block
514 * p pointer to received message
515 *
516 * Returns:
517 * 0 success
518 * errno error encountered
519 *
520 */
521 int
522 scsp_ca_act_05(Scsp_dcs *dcsp, void *p)
523 {
524 int rc = 0;
525 Scsp_msg *msg = (Scsp_msg *)p;
526
527 /*
528 * If the other side thinks we're the master, or if the
529 * initialization bit is set, or if the message is out
530 * of sequence, go back to Master/Slave Negotiation state
531 */
532 if (!msg->sc_ca->ca_m || msg->sc_ca->ca_i ||
533 msg->sc_ca->ca_seq < dcsp->sd_ca_seq ||
534 msg->sc_ca->ca_seq > dcsp->sd_ca_seq + 1) {
535 HARP_CANCEL(&dcsp->sd_ca_rexmt_t);
536 dcsp->sd_ca_state = SCSP_CAFSM_NEG;
537 scsp_dcs_cleanup(dcsp);
538 return(scsp_ca_act_01(dcsp, NULL));
539 }
540
541 /*
542 * If this is a duplicate, retransmit the last message
543 */
544 if (msg->sc_ca->ca_seq == dcsp->sd_ca_seq) {
545 if (dcsp->sd_ca_rexmt_msg) {
546 rc = scsp_send_msg(dcsp, dcsp->sd_ca_rexmt_msg);
547 if (rc == 0) {
548 HARP_TIMER(&dcsp->sd_ca_rexmt_t,
549 dcsp->sd_ca_rexmt_int,
550 scsp_ca_retran_timeout);
551 }
552 }
553 return(rc);
554 }
555
556 /*
557 * Free the last CA message
558 */
559 if (dcsp->sd_ca_rexmt_msg) {
560 scsp_free_msg(dcsp->sd_ca_rexmt_msg);
561 dcsp->sd_ca_rexmt_msg = NULL;
562 }
563
564 /*
565 * Process the CA message
566 */
567 scsp_process_ca(dcsp, msg->sc_ca);
568
569 /*
570 * Increment the CA sequence number
571 */
572 dcsp->sd_ca_seq++;
573
574 /*
575 * Answer the CA message
576 */
577 rc = scsp_send_ca(dcsp);
578 if (rc)
579 return(rc);
580
581 /*
582 * If we're done sending CSAS records and the other side is,
583 * too, we're done with Summarize state
584 */
585 if (!dcsp->sd_ca_csas && !msg->sc_ca->ca_o) {
586 /*
587 * If the CRL is empty, we go directly to Aligned state;
588 * otherwise, we go to Update Cache and send a CSUS
589 */
590 if (!dcsp->sd_crl) {
591 /*
592 * Go to Aligned state
593 */
594 dcsp->sd_ca_state = SCSP_CAFSM_ALIGNED;
595 rc = scsp_cfsm(dcsp, SCSP_CIFSM_CA_ALIGN, NULL, NULL);
596 } else {
597 /*
598 * Go to Cache Update state
599 */
600 dcsp->sd_ca_state = SCSP_CAFSM_UPDATE;
601 HARP_CANCEL(&dcsp->sd_ca_rexmt_t);
602 HARP_TIMER(&dcsp->sd_ca_rexmt_t,
603 dcsp->sd_ca_rexmt_int,
604 scsp_ca_retran_timeout);
605 scsp_cfsm(dcsp, SCSP_CIFSM_CA_UPD, NULL, NULL);
606 rc = scsp_send_csus(dcsp);
607 }
608 }
609
610 return(rc);
611 }
612
613
614 /*
615 * CA finite state machine action 6
616 * Retransmit timer expired -- retransmit last CA message
617 *
618 * Arguments:
619 * dcsp pointer to DCS control block
620 * p ignored
621 *
622 * Returns:
623 * 0 success
624 * errno error encountered
625 *
626 */
627 int
628 scsp_ca_act_06(Scsp_dcs *dcsp, void *p)
629 {
630 int rc;
631
632 /*
633 * Resend the CA message
634 */
635 rc = scsp_send_msg(dcsp, dcsp->sd_ca_rexmt_msg);
636
637 /*
638 * Restart the retransmit timer
639 */
640 if (rc == 0) {
641 HARP_TIMER(&dcsp->sd_ca_rexmt_t, dcsp->sd_ca_rexmt_int,
642 scsp_ca_retran_timeout);
643 }
644
645 return(rc);
646 }
647
648
649 /*
650 * CA finite state machine action 7
651 * CSU Solicit received -- send it to the client interface FSM
652 *
653 * Arguments:
654 * dcsp pointer to DCS control block
655 * p pointer to received message
656 *
657 * Returns:
658 * 0 success
659 * errno error encountered
660 *
661 */
662 int
663 scsp_ca_act_07(Scsp_dcs *dcsp, void *p)
664 {
665 int rc;
666 Scsp_msg *msg = (Scsp_msg *)p;
667
668 /*
669 * Cancel the CA retransmit timer and free any CA message
670 * saved for retransmission
671 */
672 if (dcsp->sd_ca_rexmt_msg) {
673 HARP_CANCEL(&dcsp->sd_ca_rexmt_t);
674 scsp_free_msg(dcsp->sd_ca_rexmt_msg);
675 dcsp->sd_ca_rexmt_msg = NULL;
676 }
677
678 /*
679 * Pass the CSUS to the client interface FSM
680 */
681 rc = scsp_cfsm(dcsp, SCSP_CIFSM_CSU_SOL, msg, NULL);
682
683 return(rc);
684 }
685
686
687 /*
688 * CA finite state machine action 8
689 * CSU Request received -- pass it to the client interface FSM
690 *
691 * Arguments:
692 * dcsp pointer to DCS control block
693 * p pointer to received message
694 *
695 * Returns:
696 * 0 success
697 * errno error encountered
698 *
699 */
700 int
701 scsp_ca_act_08(Scsp_dcs *dcsp, void *p)
702 {
703 int rc;
704 Scsp_msg *msg = (Scsp_msg *)p;
705 Scsp_csa *csap;
706
707 /*
708 * Check whether this messages answers a CSUS
709 */
710 scsp_csus_ack(dcsp, msg);
711
712 /*
713 * If all CSAs requestd in CSUS messages have been
714 * received, the cache is aligned, so go to Aligned State
715 */
716 if (!dcsp->sd_csus_rexmt_msg && !dcsp->sd_crl &&
717 dcsp->sd_ca_state != SCSP_CAFSM_ALIGNED) {
718 dcsp->sd_ca_state = SCSP_CAFSM_ALIGNED;
719 rc = scsp_cfsm(dcsp, SCSP_CIFSM_CA_ALIGN, NULL, NULL);
720 }
721
722 /*
723 * Pass the CSU Req to the client interface FSM
724 */
725 rc = scsp_cfsm(dcsp, SCSP_CIFSM_CSU_REQ, msg, NULL);
726
727 /*
728 * Move the CSA chain from the message to the list of
729 * requests that need acknowledgements
730 */
731 for (csap = msg->sc_csu_msg->csu_csa_rec; csap;
732 csap = csap->next) {
733 LINK2TAIL(csap, Scsp_csa, dcsp->sd_csu_ack_pend, next);
734 }
735 msg->sc_csu_msg->csu_csa_rec = NULL;
736
737 return(rc);
738 }
739
740
741 /*
742 * CA finite state machine action 9
743 * CA Retransmit timer expired in Update Cache or Aligned state--free
744 * the saved CA message
745 *
746 * Arguments:
747 * dcsp pointer to DCS control block
748 * p ignored
749 *
750 * Returns:
751 * 0 success
752 * errno error encountered
753 *
754 */
755 int
756 scsp_ca_act_09(Scsp_dcs *dcsp, void *p)
757 {
758 /*
759 * Free any CA message saved for retransmission
760 */
761 if (dcsp->sd_ca_rexmt_msg) {
762 scsp_free_msg(dcsp->sd_ca_rexmt_msg);
763 dcsp->sd_ca_rexmt_msg = NULL;
764 }
765
766 return(0);
767 }
768
769
770 /*
771 * CA finite state machine action 10
772 * CSU Reply received -- Process the message
773 *
774 * Arguments:
775 * dcsp pointer to DCS control block
776 * p pointer to received message
777 *
778 * Returns:
779 * 0 success
780 * errno error encountered
781 *
782 */
783 int
784 scsp_ca_act_10(Scsp_dcs *dcsp, void *p)
785 {
786 int rc = 0;
787 Scsp_msg *msg = (Scsp_msg *)p;
788 Scsp_csu_rexmt *rxp, *next_rxp;
789 Scsp_csa *csap, *next_csap, *mcp;
790
791 /*
792 * Dequeue acknowledged CSAs. For each CSAS in the received
793 * message, find the corresponding CSA on the CSU Request
794 * retransmit queue. Remove the CSA from the queue; if this
795 * results in the retransmit queue entry being empty, delete
796 * the entry. If the DCS has a newer CSA, send a CSUS to
797 * request it.
798 *
799 * Caution--potentially confusing lack of indentation ahead.
800 */
801 for (mcp = msg->sc_csu_msg->csu_csa_rec; mcp;
802 mcp = mcp->next) {
803 for (rxp = dcsp->sd_csu_rexmt; rxp; rxp = next_rxp) {
804 next_rxp = rxp->sr_next;
805 for (csap = rxp->sr_csa; csap; csap = next_csap) {
806 next_csap = csap->next;
807 if (scsp_cmp_key(&csap->key, &mcp->key) ||
808 scsp_cmp_id(&csap->oid, &mcp->oid))
809 continue;
810 /*
811 * Found a CSA whose key and ID are equal to
812 * those in the CSU Reply
813 */
814 if (csap->seq == mcp->seq) {
815 /*
816 * The queued seq no is equal to the
817 * received seq no--the CSA is acknowledged
818 */
819 UNLINK(csap, Scsp_csa, rxp->sr_csa, next);
820 SCSP_FREE_CSA(csap);
821 } else if (csap->seq < mcp->seq) {
822 /*
823 * Queued seq no is less than received.
824 * We must dequeue the CSA and send a
825 * CSUS to request the more-up-to-date
826 * cache entry.
827 */
828 UNLINK(mcp, Scsp_csa,
829 msg->sc_csu_msg->csu_csa_rec,
830 next);
831 LINK2TAIL(mcp, Scsp_csa, dcsp->sd_crl, next);
832 UNLINK(csap, Scsp_csa, rxp->sr_csa, next);
833 SCSP_FREE_CSA(csap);
834 if (!dcsp->sd_csus_rexmt_msg) {
835 rc = scsp_send_csus(dcsp);
836 if (rc) {
837 return(rc);
838 }
839 }
840 }
841 /*
842 * Queued seq no is greater than
843 * received. Ignore the received CSAS.
844 */
845
846 /*
847 * If the retransmission block is empty, stop the
848 * timer and free it
849 */
850 if (!rxp->sr_csa) {
851 HARP_CANCEL(&rxp->sr_t);
852 UNLINK(rxp, Scsp_csu_rexmt,
853 dcsp->sd_csu_rexmt, sr_next);
854 UM_FREE(rxp);
855 }
856
857 break;
858 } /* for (csap = ... */
859 } /* for (rxp = ... */
860 } /* for (mcp = ... */
861
862 return(rc);
863 }
864
865
866 /*
867 * CA finite state machine action 11
868 * Updated cache entry -- update the summary cache and send a
869 * CSU Request
870 *
871 * Arguments:
872 * dcsp pointer to DCS control block
873 * p pointer to CSA describing new cache entry
874 *
875 * Returns:
876 * 0 success
877 * errno error encountered
878 *
879 */
880 int
881 scsp_ca_act_11(Scsp_dcs *dcsp, void *p)
882 {
883 int rc, state;
884 Scsp_csa *csap = (Scsp_csa *)p;
885 Scsp_cse *csep;
886
887 /*
888 * Get the state of the CSA
889 */
890 switch(dcsp->sd_server->ss_pid) {
891 case SCSP_PROTO_ATMARP:
892 state = csap->atmarp_data->sa_state;
893 break;
894 default:
895 SCSP_FREE_CSA(csap);
896 return(EINVAL);
897 }
898
899 if (state < SCSP_ASTATE_NEW || state > SCSP_ASTATE_DEL) {
900 SCSP_FREE_CSA(csap);
901 return(EINVAL);
902 }
903
904 /*
905 * Look up the cache summary entry for the CSA
906 */
907 SCSP_LOOKUP(dcsp->sd_server, &csap->key, csep);
908
909 /*
910 * Process ATMARP entries
911 */
912 if (dcsp->sd_server->ss_pid == SCSP_PROTO_ATMARP) {
913 switch(state) {
914 case SCSP_ASTATE_NEW:
915 case SCSP_ASTATE_UPD:
916 /*
917 * Add the entry if we don't have it already
918 */
919 if (!csep) {
920 csep = (Scsp_cse *)UM_ALLOC(
921 sizeof(Scsp_cse));
922 if (!csep)
923 scsp_mem_err("scsp_ca_act_11: sizeof(Scsp_cse)");
924 UM_ZERO(csep, sizeof(Scsp_cse));
925
926 csep->sc_key = csap->key;
927 SCSP_ADD(dcsp->sd_server, csep);
928 }
929
930 /*
931 * Update the cache summary entry
932 */
933 csep->sc_seq = csap->seq;
934 csep->sc_oid = csap->oid;
935 break;
936 case SCSP_ASTATE_DEL:
937 /*
938 * Delete any entry, but don't send the
939 * delete to the DCS
940 */
941 if (csep) {
942 SCSP_DELETE(dcsp->sd_server, csep);
943 UM_FREE(csep);
944 }
945
946 SCSP_FREE_CSA(csap);
947 return(0);
948 }
949 }
950
951 /*
952 * Send the CSA in a CSU Request
953 */
954 csap->trans_ct = 0;
955 rc = scsp_send_csu_req(dcsp, csap);
956
957 return(rc);
958 }
959
960
961 /*
962 * CA finite state machine action 12
963 * CSUS retransmit timer expired--send a CSUS with any pending CSA
964 * records
965 *
966 * Arguments:
967 * dcsp pointer to DCS control block
968 * p ignored
969 *
970 * Returns:
971 * 0 success
972 * errno error encountered
973 *
974 */
975 int
976 scsp_ca_act_12(Scsp_dcs *dcsp, void *p)
977 {
978 int rc;
979
980 rc = scsp_send_csus(dcsp);
981
982 return(rc);
983 }
984
985
986 /*
987 * CA finite state machine action 13
988 * CSU retransmit timer fired in Update or Aligned state--
989 * retransmit CSU Req
990 *
991 * Arguments:
992 * dcsp pointer to DCS control block
993 * p pointer to retransmission block whose timer fired
994 *
995 * Returns:
996 * 0 success
997 * errno error encountered
998 *
999 */
1000 int
1001 scsp_ca_act_13(Scsp_dcs *dcsp, void *p)
1002 {
1003 int rc = 0;
1004 Scsp_csu_rexmt *rxp = (Scsp_csu_rexmt *)p;
1005 Scsp_csa *csap, *csap1, *next_csap;
1006
1007 /*
1008 * Unlink and free the retransmit request block
1009 */
1010 csap = rxp->sr_csa;
1011 UNLINK(rxp, Scsp_csu_rexmt, dcsp->sd_csu_rexmt, sr_next);
1012 UM_FREE(rxp);
1013
1014 /*
1015 * Increment the transmission count for the CSAs in the request
1016 */
1017 for (csap1 = csap; csap1; csap1 = next_csap) {
1018 next_csap = csap1->next;
1019 csap1->trans_ct++;
1020 if (csap1->trans_ct >= dcsp->sd_csu_rexmt_max) {
1021 /*
1022 * We've already sent this as many times as
1023 * the limit allows. Drop this CSA.
1024 */
1025 UNLINK(csap1, Scsp_csa, csap, next);
1026 SCSP_FREE_CSA(csap1);
1027 }
1028 }
1029
1030 /*
1031 * Send another CSU Request with the CSA list, if it isn't
1032 * empty now
1033 */
1034 if (csap) {
1035 rc = scsp_send_csu_req(dcsp, csap);
1036 }
1037
1038 return(rc);
1039 }
1040
1041
1042 /*
1043 * CA finite state machine action 14
1044 * Updated cache entry in Master/Slave Negotiation, Master, or
1045 * Slave state--add entry to cache and CSA list
1046 *
1047 * Arguments:
1048 * dcsp pointer to DCS control block
1049 * p pointer to new cache summary entry
1050 *
1051 * Returns:
1052 * 0 success
1053 * errno error encountered
1054 *
1055 */
1056 int
1057 scsp_ca_act_14(Scsp_dcs *dcsp, void *p)
1058 {
1059 Scsp_csa *csap = (Scsp_csa *)p;
1060 Scsp_cse *csep, *csep1;
1061
1062 /*
1063 * Check to see whether we already have this
1064 */
1065 SCSP_LOOKUP(dcsp->sd_server, &csap->key, csep);
1066
1067 /*
1068 * If we don't already have it and it's not being deleted,
1069 * build a new cache summary entry
1070 */
1071 if (!csep && !csap->null) {
1072 /*
1073 * Get memory for a new entry
1074 */
1075 csep = (Scsp_cse *)UM_ALLOC(sizeof(Scsp_cse));
1076 if (!csep) {
1077 scsp_mem_err("scsp_ca_act_14: sizeof(Scsp_cse)");
1078 }
1079 UM_ZERO(csep, sizeof(Scsp_cse));
1080
1081 /*
1082 * Fill out the new cache entry
1083 */
1084 csep->sc_seq = csap->seq;
1085 csep->sc_key = csap->key;
1086 csep->sc_oid = csap->oid;
1087
1088 /*
1089 * Duplicate the new cache entry
1090 */
1091 csep1 = scsp_dup_cse(csep);
1092
1093 /*
1094 * Add entry to the summary cache and the CSAS list
1095 */
1096 SCSP_ADD(dcsp->sd_server, csep);
1097 LINK2TAIL(csep1, Scsp_cse, dcsp->sd_ca_csas, sc_next);
1098 } else {
1099 /*
1100 * We already have the entry. Find it on the CSAS
1101 * list.
1102 */
1103 for (csep1 = dcsp->sd_ca_csas; csep1;
1104 csep1 = csep1->sc_next) {
1105 if (scsp_cmp_key(&csep->sc_key,
1106 &csep1->sc_key) == 0)
1107 break;
1108 }
1109
1110 /*
1111 * Update or delete the entry
1112 */
1113 if (csap->null) {
1114 /*
1115 * The null flag is set--delete the entry
1116 */
1117 SCSP_DELETE(dcsp->sd_server, csep);
1118 UM_FREE(csep);
1119 if (csep1) {
1120 UNLINK(csep1, Scsp_cse,
1121 dcsp->sd_ca_csas,
1122 sc_next);
1123 UM_FREE(csep1);
1124 }
1125 } else {
1126 /*
1127 * Update the entry
1128 */
1129 csep->sc_seq = csap->seq;
1130 csep->sc_oid = csap->oid;
1131 if (!csep1) {
1132 csep1 = scsp_dup_cse(csep);
1133 LINK2TAIL(csep1, Scsp_cse,
1134 dcsp->sd_ca_csas, sc_next);
1135 } else {
1136 csep1->sc_seq = csap->seq;
1137 csep1->sc_oid = csap->oid;
1138 }
1139 }
1140 }
1141
1142 return(0);
1143 }
1144
1145
1146 /*
1147 * CA finite state machine action 15
1148 * CA message received in Update Cache state--if we have a saved CA
1149 * message, retransmit it; otherwise, go to Master/Slave Negotiation
1150 * state
1151 *
1152 * Arguments:
1153 * dcsp pointer to DCS control block
1154 * p ignored
1155 *
1156 * Returns:
1157 * 0 success
1158 * errno error encountered
1159 *
1160 */
1161 int
1162 scsp_ca_act_15(Scsp_dcs *dcsp, void *p)
1163 {
1164 int rc;
1165 Scsp_msg *msg = (Scsp_msg *)p;
1166
1167 /*
1168 * If we don't have a saved CA message, or the sequence no. in
1169 * the received message isn't right, fall back to Master/Slave
1170 * Negotiation state
1171 */
1172 if (!dcsp->sd_ca_rexmt_msg ||
1173 msg->sc_ca->ca_seq != dcsp->sd_ca_seq) {
1174 dcsp->sd_ca_state = SCSP_CAFSM_NEG;
1175 scsp_dcs_cleanup(dcsp);
1176 rc = scsp_ca_act_01(dcsp, NULL);
1177 } else {
1178 /*
1179 * Retransmit the saved CA message and reset the
1180 * CA timer
1181 */
1182 rc = scsp_send_msg(dcsp, dcsp->sd_ca_rexmt_msg);
1183 if (rc == 0) {
1184 HARP_CANCEL(&dcsp->sd_ca_rexmt_t);
1185 HARP_TIMER(&dcsp->sd_ca_rexmt_t,
1186 dcsp->sd_ca_rexmt_int,
1187 scsp_ca_retran_timeout);
1188 }
1189 }
1190
1191 return(rc);
1192 }
1193
1194
1195 /*
1196 * CA finite state machine action 16
1197 * Update Response received from client in Update Cache or Aligned
1198 * state. Move the acknowledged CSA to the acknowledged queue. If
1199 * the list of CSAs pending acknowledgement is empty, send a CSU
1200 * Reply.
1201 *
1202 * Arguments:
1203 * dcsp pointer to DCS control block
1204 * p pointer to message from client
1205 *
1206 * Returns:
1207 * 0 success
1208 * errno error encountered
1209 *
1210 */
1211 int
1212 scsp_ca_act_16(Scsp_dcs *dcsp, void *p)
1213 {
1214 int found, rc = 0;
1215 Scsp_if_msg *cmsg = (Scsp_if_msg *)p;
1216 Scsp_csa *csap;
1217
1218 /*
1219 * Find the acknowledged CSA
1220 */
1221 for (csap = dcsp->sd_csu_ack_pend, found = 0; csap && !found;
1222 csap = csap->next) {
1223 switch (dcsp->sd_server->ss_pid) {
1224 case SCSP_PROTO_ATMARP:
1225 found = ((scsp_cmp_key(&csap->key,
1226 &cmsg->si_atmarp.sa_key) == 0) &&
1227 (scsp_cmp_id(&csap->oid,
1228 &cmsg->si_atmarp.sa_oid) == 0));
1229 break;
1230 default:
1231 /*
1232 * Protocol not implemented
1233 */
1234 return(EPROTONOSUPPORT);
1235 }
1236 if (found)
1237 break;
1238 }
1239
1240 if (!found) {
1241 if (scsp_trace_mode & SCSP_TRACE_CAFSM) {
1242 scsp_trace("scsp_ca_act_16: can't find CSA entry for Update Response\n");
1243 }
1244 return(0);
1245 }
1246
1247 if (cmsg->si_rc == SCSP_RSP_OK) {
1248 /*
1249 * The server accepted the cache entry
1250 */
1251
1252 /*
1253 * Update SCSP's cache
1254 */
1255 scsp_update_cache(dcsp, csap);
1256
1257 /*
1258 * Send this CSA to any other DCSs in the server group
1259 */
1260 rc = scsp_propagate_csa(dcsp, csap);
1261 }
1262
1263 /*
1264 * Move the CSA from the ACK pending queue to the
1265 * acknowledged queue
1266 */
1267 UNLINK(csap, Scsp_csa, dcsp->sd_csu_ack_pend, next);
1268 LINK2TAIL(csap, Scsp_csa, dcsp->sd_csu_ack, next);
1269 if (!dcsp->sd_csu_ack_pend) {
1270 /*
1271 * ACK pending list is empty--send a CSU Reply
1272 */
1273 csap = dcsp->sd_csu_ack;
1274 dcsp->sd_csu_ack = NULL;
1275 rc = scsp_send_csu_reply(dcsp, csap);
1276 }
1277
1278 return(rc);
1279 }
1280
1281
1282 /*
1283 * CA finite state machine action 17
1284 * Ignore an event.
1285 *
1286 * Arguments:
1287 * dcsp pointer to DCS control block
1288 * p ignored
1289 *
1290 * Returns:
1291 * always returns 0
1292 *
1293 */
1294 int
1295 scsp_ca_act_17(Scsp_dcs *dcsp, void *p)
1296 {
1297 return(0);
1298 }
1299
1300
1301 /*
1302 * CA finite state machine action 18
1303 * Updated cache entry in Down state--add entry to summary cache
1304 *
1305 * Arguments:
1306 * dcsp pointer to DCS control block
1307 * p pointer to new cache summary entry
1308 *
1309 * Returns:
1310 * 0 success
1311 * errno error encountered
1312 *
1313 */
1314 int
1315 scsp_ca_act_18(Scsp_dcs *dcsp, void *p)
1316 {
1317 Scsp_csa *csap = (Scsp_csa *)p;
1318
1319 /*
1320 * Update the cache as appropriate
1321 */
1322 scsp_update_cache(dcsp, csap);
1323
1324 return(0);
1325 }
1326
1327
1328 /*
1329 * CA finite state machine action 19
1330 * Update Response received from client in Master/Slave Negotiation
1331 * state. Update the cache as appropriate.
1332 *
1333 * Arguments:
1334 * dcsp pointer to DCS control block
1335 * p pointer to message from client
1336 *
1337 * Returns:
1338 * 0 success
1339 * errno error encountered
1340 *
1341 */
1342 int
1343 scsp_ca_act_19(Scsp_dcs *dcsp, void *p)
1344 {
1345 Scsp_if_msg *cmsg = (Scsp_if_msg *)p;
1346 Scsp_csa *csap;
1347
1348 /*
1349 * Ignore the message if the client rejected the update
1350 */
1351 if (cmsg->si_rc != SCSP_RSP_OK) {
1352 return(0);
1353 }
1354
1355 /*
1356 * Create a CSAS from the client's update
1357 */
1358 csap = (Scsp_csa *)UM_ALLOC(sizeof(Scsp_csa));
1359 if (!csap) {
1360 scsp_mem_err("scsp_ca_act_19: sizeof(Scsp_csa)");
1361 }
1362 UM_ZERO(csap, sizeof(Scsp_csa));
1363
1364 csap->hops = 1;
1365 switch (dcsp->sd_server->ss_pid) {
1366 case SCSP_PROTO_ATMARP:
1367 csap->null = cmsg->si_atmarp.sa_state ==
1368 SCSP_ASTATE_DEL;
1369 csap->seq = cmsg->si_atmarp.sa_seq;
1370 csap->key = cmsg->si_atmarp.sa_key;
1371 csap->oid = cmsg->si_atmarp.sa_oid;
1372 break;
1373 default:
1374 return(EINVAL);
1375 }
1376
1377 /*
1378 * Update SCSP's cache
1379 */
1380 scsp_update_cache(dcsp, csap);
1381
1382 return(0);
1383 }
DragonFly BSD