?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
initial seqno
[cor_2_6_31.git] / net / cor / kpacket_gen.c
blob814f8c99f96dc1f42a780a6f562eb246464cfc4a
1 /*
2 * Connection oriented routing
3 * Copyright (C) 2007-2010 Michael Blizek
4 *
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License
7 * as published by the Free Software Foundation; either version 2
8 * of the License, or (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
18 * 02110-1301, USA.
19 */
20
21 #include <asm/byteorder.h>
22
23 #include "cor.h"
24
25 /* not sent over the network - internal meaning only */
26 #define MSGTYPE_PONG 1
27 #define MSGTYPE_ACK 2
28 #define MSGTYPE_ACK_CONN 3
29 #define MSGTYPE_ACK_CONN_OOO 4
30 #define MSGTYPE_CONNECT 5
31 #define MSGTYPE_CONNECT_SUCCESS 6
32 #define MSGTYPE_RESET_CONN 7
33 #define MSGTYPE_CONNDATA 8
34 #define MSGTYPE_PING_CONN 9
35 #define MSGTYPE_CONNID_UNKNOWN 10
36 #define MSGTYPE_PING_ALL_CONNS 11
37 #define MSGTYPE_SET_MAX_CMSG_DELAY 12
38 #define MSGTYPE_SET_CREDITS 13
39
40 struct control_msg_out{
41 struct list_head lh; /* either neighbor or control_retrans_packet */
42 struct neighbor *nb;
43
44 __u32 length;
45
46 __u8 type;
47 union{
48 struct{
49 __u32 cookie;
50 unsigned long time_enqueued; /* jiffies */
51 int sent;
52 }pong;
53
54 struct{
55 __u32 seqno;
56 }ack;
57
58 struct{
59 struct conn *rconn;
60 __u32 conn_id;
61 __u32 seqno;
62 }ack_conn;
63
64 struct{
65 struct conn *rconn;
66 __u32 conn_id;
67 __u32 seqno;
68 __u32 seqno_ooo;
69 __u32 length;
70 }ack_conn_ooo;
71
72 struct{
73 __u32 conn_id;
74 __u32 init_seqno;
75 struct conn *sconn;
76 }connect;
77
78 struct{
79 __u32 rcvd_conn_id;
80 __u32 gen_conn_id;
81 __u32 init_seqno;
82 struct conn *rconn;
83 }connect_success;
84
85 struct{
86 __u32 conn_id;
87 }reset;
88
89 struct{
90 __u32 conn_id;
91 __u32 seqno;
92 char *data_orig;
93 char *data;
94 __u32 datalen;
95 }conn_data;
96
97 struct{
98 __u32 conn_id;
99 }ping_conn;
100
101 struct{
102 __u32 conn_id;
103 }connid_unknown;
104
105 struct{
106 __u32 delay;
107 }set_max_cmsg_delay;
108 }msg;
109 };
110
111 struct control_retrans {
112 struct kref ref;
113
114 struct neighbor *nb;
115 __u32 seqno;
116
117 unsigned long timeout;
118
119 struct list_head msgs;
120
121 struct htab_entry htab_entry;
122 struct list_head timeout_list;
123 };
124
125 struct kmem_cache *controlmsg_slab;
126 struct kmem_cache *controlretrans_slab;
127
128 static struct htable retransmits;
129
130 atomic_t cmcnt = ATOMIC_INIT(0);
131
132 static void add_control_msg(struct control_msg_out *msg, int retrans);
133
134 static inline int isurgent(struct control_msg_out *cm)
135 {
136 if (unlikely(cm->type == MSGTYPE_PONG || cm->type == MSGTYPE_ACK))
137 return 1;
138 return 0;
139 }
140
141 static struct control_msg_out *__alloc_control_msg(void)
142 {
143 struct control_msg_out *cm = kmem_cache_alloc(controlmsg_slab,
144 GFP_KERNEL);
145 if (unlikely(cm == 0))
146 return 0;
147 cm->lh.next = LIST_POISON1;
148 cm->lh.prev = LIST_POISON2;
149 return cm;
150 }
151
152 static int calc_limit(int limit, int priority)
153 {
154 if (priority == ACM_PRIORITY_LOW)
155 return (limit+1)/2;
156 else if (priority == ACM_PRIORITY_MED)
157 return (limit*3 + 3)/4;
158 else if (priority == ACM_PRIORITY_HIGH)
159 return limit;
160 else
161 BUG();
162 }
163
164 static struct control_msg_out *_alloc_control_msg(struct neighbor *nb,
165 int priority, int urgent)
166 {
167 struct control_msg_out *cm = 0;
168
169 BUG_ON(nb == 0);
170
171 if (urgent == 0) {
172 long packets1 = atomic_inc_return(&(nb->cmcnt));
173 long packets2 = atomic_inc_return(&(cmcnt));
174
175 BUG_ON(packets1 <= 0);
176 BUG_ON(packets2 <= 0);
177
178 if (packets1 <= calc_limit(GUARANTEED_CMSGS_PER_NEIGH,
179 priority))
180 goto alloc;
181
182 if (unlikely(unlikely(packets2 > calc_limit(MAX_CMSGS_PER_NEIGH,
183 priority)) || unlikely(packets1 > (
184 calc_limit(MAX_CMSGS_PER_NEIGH, priority) *
185 (MAX_CMSGS - packets2) / MAX_CMSGS))))
186 goto full;
187 }
188
189 alloc:
190 cm = __alloc_control_msg();
191 if (unlikely(cm == 0))
192 goto full;
193 cm->nb = nb;
194
195 if (0) {
196 full:
197 if (urgent == 0) {
198 atomic_dec(&(nb->cmcnt));
199 atomic_dec(&(cmcnt));
200 }
201 }
202 return cm;
203 }
204
205 struct control_msg_out *alloc_control_msg(struct neighbor *nb, int priority)
206 {
207 return _alloc_control_msg(nb, priority, 0);
208 }
209
210 void free_control_msg(struct control_msg_out *cm)
211 {
212 if (isurgent(cm) == 0) {
213 atomic_dec(&(cm->nb->cmcnt));
214 atomic_dec(&(cmcnt));
215 }
216
217 if (cm->type == MSGTYPE_ACK_CONN) {
218 BUG_ON(cm->msg.ack_conn.rconn == 0);
219 kref_put(&(cm->msg.ack_conn.rconn->ref), free_conn);
220 cm->msg.ack_conn.rconn = 0;
221 } else if (cm->type == MSGTYPE_ACK_CONN_OOO) {
222 BUG_ON(cm->msg.ack_conn_ooo.rconn == 0);
223 kref_put(&(cm->msg.ack_conn_ooo.rconn->ref), free_conn);
224 cm->msg.ack_conn_ooo.rconn = 0;
225 } else if (cm->type == MSGTYPE_CONNECT) {
226 BUG_ON(cm->msg.connect.sconn == 0);
227 kref_put(&(cm->msg.connect.sconn->ref), free_conn);
228 cm->msg.connect.sconn = 0;
229 } else if (cm->type == MSGTYPE_CONNECT_SUCCESS) {
230 BUG_ON(cm->msg.connect_success.rconn == 0);
231 kref_put(&(cm->msg.connect_success.rconn->ref), free_conn);
232 cm->msg.connect_success.rconn = 0;
233 }
234
235 kmem_cache_free(controlmsg_slab, cm);
236 }
237
238 static void free_control_retrans(struct kref *ref)
239 {
240 struct control_retrans *cr = container_of(ref, struct control_retrans,
241 ref);
242
243 while (list_empty(&(cr->msgs)) == 0) {
244 struct control_msg_out *cm = container_of(cr->msgs.next,
245 struct control_msg_out, lh);
246 list_del(&(cm->lh));
247 free_control_msg(cm);
248 }
249
250 kmem_cache_free(controlretrans_slab, cr);
251 }
252
253 struct retransmit_matchparam {
254 struct neighbor *nb;
255 __u32 seqno;
256 };
257
258 static __u32 rm_to_key(struct retransmit_matchparam *rm)
259 {
260 return ((__u32)((long) rm->nb)) ^ rm->seqno;
261 }
262
263 static void set_retrans_timeout(struct control_retrans *cr, struct neighbor *nb)
264 {
265 cr->timeout = jiffies + usecs_to_jiffies(100000 +
266 ((__u32) atomic_read(&(nb->latency))) * 2 +
267 ((__u32) atomic_read(&(nb->max_remote_cmsg_delay))));
268 }
269
270 void retransmit_timerfunc(struct work_struct *work)
271 {
272 unsigned long iflags;
273
274 struct neighbor *nb = container_of(to_delayed_work(work),
275 struct neighbor, retrans_timer);
276
277 int nbstate;
278 int nbput = 0;
279
280 spin_lock_irqsave( &(nb->state_lock), iflags );
281 nbstate = nb->state;
282 spin_unlock_irqrestore( &(nb->state_lock), iflags );
283
284 while (1) {
285 struct control_retrans *cr = 0;
286 struct retransmit_matchparam rm;
287
288 spin_lock_irqsave( &(nb->retrans_lock), iflags );
289
290 if (list_empty(&(nb->retrans_list))) {
291 nb->retrans_timer_running = 0;
292 nbput = 1;
293 break;
294 }
295
296 cr = container_of(nb->retrans_list.next,
297 struct control_retrans, timeout_list);
298
299 BUG_ON(cr->nb != nb);
300
301 rm.seqno = cr->seqno;
302 rm.nb = nb;
303
304 list_del(&(cr->timeout_list));
305
306 if (unlikely(nbstate == NEIGHBOR_STATE_KILLED)) {
307 spin_unlock_irqrestore( &(nb->retrans_lock), iflags );
308
309 htable_delete(&retransmits, rm_to_key(&rm), &rm,
310 free_control_retrans);
311 kref_put(&(cr->ref), free_control_retrans);
312 continue;
313 }
314
315 if (time_after(cr->timeout, jiffies)) {
316 list_add(&(cr->timeout_list), &(nb->retrans_list));
317 schedule_delayed_work(&(nb->retrans_timer),
318 cr->timeout - jiffies);
319 break;
320 }
321
322 if (unlikely(htable_delete(&retransmits, rm_to_key(&rm), &rm,
323 free_control_retrans)))
324 BUG();
325
326 spin_unlock_irqrestore( &(nb->retrans_lock), iflags );
327
328 while (list_empty(&(cr->msgs)) == 0) {
329 struct control_msg_out *cm = container_of(cr->msgs.next,
330 struct control_msg_out, lh);
331 list_del(&(cm->lh));
332 add_control_msg(cm, 1);
333 }
334
335 kref_put(&(cr->ref), free_control_retrans);
336 }
337
338 spin_unlock_irqrestore( &(nb->retrans_lock), iflags );
339
340 if (nbput)
341 kref_put(&(nb->ref), neighbor_free);
342 }
343
344 static void schedule_retransmit(struct control_retrans *cr, struct neighbor *nb)
345 {
346 unsigned long iflags;
347
348 struct retransmit_matchparam rm;
349 int first;
350
351 rm.seqno = cr->seqno;
352 rm.nb = nb;
353
354 set_retrans_timeout(cr, nb);
355
356 spin_lock_irqsave( &(nb->retrans_lock), iflags );
357 htable_insert(&retransmits, (char *) cr, rm_to_key(&rm));
358 first = list_empty(&(nb->retrans_list));
359 list_add_tail(&(cr->timeout_list), &(nb->retrans_list));
360
361 if (first && nb->retrans_timer_running == 0) {
362 schedule_delayed_work(&(nb->retrans_timer),
363 cr->timeout - jiffies);
364 nb->retrans_timer_running = 1;
365 kref_get(&(nb->ref));
366 }
367
368 spin_unlock_irqrestore( &(nb->retrans_lock), iflags );
369 }
370
371 void kern_ack_rcvd(struct neighbor *nb, __u32 seqno)
372 {
373 unsigned long iflags;
374
375 struct control_retrans *cr = 0;
376 struct retransmit_matchparam rm;
377
378 rm.seqno = seqno;
379 rm.nb = nb;
380
381 spin_lock_irqsave( &(nb->retrans_lock), iflags );
382
383 cr = (struct control_retrans *) htable_get(&retransmits, rm_to_key(&rm),
384 &rm);
385
386 if (cr == 0) {
387 printk(KERN_ERR "bogus/duplicate ack received");
388 goto out;
389 }
390
391 if (unlikely(htable_delete(&retransmits, rm_to_key(&rm), &rm,
392 free_control_retrans)))
393 BUG();
394
395 BUG_ON(cr->nb != nb);
396
397 list_del(&(cr->timeout_list));
398
399 out:
400 spin_unlock_irqrestore( &(nb->retrans_lock), iflags );
401 }
402
403 static void padding(struct sk_buff *skb, int length)
404 {
405 char *dst;
406 if (length <= 0)
407 return;
408 dst = skb_put(skb, length);
409 BUG_ON(dst == 0);
410 memset(dst, KP_PADDING, length);
411 }
412
413 static int add_ack(struct sk_buff *skb, struct control_retrans *cr,
414 struct control_msg_out *cm, int spaceleft)
415 {
416 char *dst;
417
418 if (unlikely(spaceleft < 5))
419 return 0;
420
421 dst = skb_put(skb, 5);
422 BUG_ON(dst == 0);
423
424 dst[0] = KP_ACK;
425 put_u32(dst + 1, cm->msg.ack.seqno, 1);
426
427 atomic_dec(&(cm->nb->ucmcnt));
428 free_control_msg(cm);
429
430 return 5;
431 }
432
433 static int add_ack_conn(struct sk_buff *skb, struct control_retrans *cr,
434 struct control_msg_out *cm, int spaceleft)
435 {
436 char *dst;
437
438 if (unlikely(spaceleft < 10))
439 return 0;
440
441 dst = skb_put(skb, 10);
442 BUG_ON(dst == 0);
443
444 dst[0] = KP_ACK_CONN;
445 put_u32(dst + 1, cm->msg.ack_conn.conn_id, 1);
446 put_u32(dst + 5, cm->msg.ack_conn.seqno, 1);
447 BUG_ON(cm->msg.ack_conn.rconn == 0);
448 dst[9] = enc_window(get_window(cm->msg.ack_conn.rconn));
449
450 list_add_tail(&(cm->lh), &(cr->msgs));
451
452 return 10;
453 }
454
455 static int add_ack_conn_ooo(struct sk_buff *skb, struct control_retrans *cr,
456 struct control_msg_out *cm, int spaceleft)
457 {
458 char *dst;
459
460 if (unlikely(spaceleft < 18))
461 return 0;
462
463 dst = skb_put(skb, 18);
464 BUG_ON(dst == 0);
465
466 dst[0] = KP_ACK_CONN_OOO;
467 put_u32(dst + 1, cm->msg.ack_conn_ooo.conn_id, 1);
468 put_u32(dst + 5, cm->msg.ack_conn_ooo.seqno, 1);
469 BUG_ON(cm->msg.ack_conn_ooo.rconn == 0);
470 dst[9] = enc_window(get_window(cm->msg.ack_conn_ooo.rconn));
471 put_u32(dst + 10, cm->msg.ack_conn_ooo.seqno_ooo, 1);
472 put_u32(dst + 14, cm->msg.ack_conn_ooo.length, 1);
473
474 list_add_tail(&(cm->lh), &(cr->msgs));
475
476 return 18;
477 }
478
479 static int add_ping(struct sk_buff *skb, __u32 cookie,
480 int spaceleft)
481 {
482 char *dst;
483
484 if (unlikely(spaceleft < 5))
485 return 0;
486
487 dst = skb_put(skb, 5);
488 BUG_ON(dst == 0);
489
490 dst[0] = KP_PING;
491 put_u32(dst + 1, cookie, 0);
492
493 return 5;
494 }
495
496 static int add_pong(struct sk_buff *skb, struct control_retrans *cr,
497 struct control_msg_out *cm, int spaceleft)
498 {
499 char *dst;
500
501 if (unlikely(spaceleft < 9))
502 return 0;
503
504 dst = skb_put(skb, 9);
505 BUG_ON(dst == 0);
506
507 dst[0] = KP_PONG;
508 put_u32(dst + 1, cm->msg.pong.cookie, 0);
509 put_u32(dst + 5, 1000 * jiffies_to_msecs(jiffies -
510 cm->msg.pong.time_enqueued), 1);
511
512
513 atomic_dec(&(cm->nb->ucmcnt));
514 list_add_tail(&(cm->lh), &(cr->msgs));
515
516 return 9;
517 }
518
519 static int add_connect(struct sk_buff *skb, struct control_retrans *cr,
520 struct control_msg_out *cm, int spaceleft)
521 {
522 char *dst;
523
524 if (unlikely(spaceleft < 10))
525 return 0;
526
527 dst = skb_put(skb, 10);
528 BUG_ON(dst == 0);
529
530 dst[0] = KP_CONNECT;
531 put_u32(dst + 1, cm->msg.connect.conn_id, 1);
532 put_u32(dst + 5, cm->msg.connect.init_seqno, 1);
533 BUG_ON(cm->msg.connect.sconn == 0);
534 dst[9] = enc_window(get_window(cm->msg.connect.sconn));
535
536 list_add_tail(&(cm->lh), &(cr->msgs));
537
538 return 5;
539 }
540
541 static int add_connect_success(struct sk_buff *skb, struct control_retrans *cr,
542 struct control_msg_out *cm, int spaceleft)
543 {
544 char *dst;
545
546 if (unlikely(spaceleft < 14))
547 return 0;
548
549 dst = skb_put(skb, 14);
550 BUG_ON(dst == 0);
551
552 dst[0] = KP_CONNECT_SUCCESS;
553 put_u32(dst + 1, cm->msg.connect_success.rcvd_conn_id, 1);
554 put_u32(dst + 5, cm->msg.connect_success.gen_conn_id, 1);
555 put_u32(dst + 9, cm->msg.connect_success.init_seqno, 1);
556 BUG_ON(cm->msg.connect_success.rconn == 0);
557 dst[13] = enc_window(get_window(cm->msg.connect_success.rconn));
558
559 list_add_tail(&(cm->lh), &(cr->msgs));
560
561 return 9;
562 }
563
564 static int add_reset_conn(struct sk_buff *skb, struct control_retrans *cr,
565 struct control_msg_out *cm, int spaceleft)
566 {
567 char *dst;
568
569 if (unlikely(spaceleft < 5))
570 return 0;
571
572 dst = skb_put(skb, 5);
573 BUG_ON(dst == 0);
574
575 dst[0] = KP_RESET_CONN;
576 put_u32(dst + 1, cm->msg.reset.conn_id, 1);
577
578 list_add_tail(&(cm->lh), &(cr->msgs));
579
580 return 5;
581 }
582
583 static int add_conndata(struct sk_buff *skb, struct control_retrans *cr,
584 struct control_msg_out *cm, int spaceleft,
585 struct control_msg_out **split_conndata, __u32 *sc_sendlen)
586 {
587 char *dst;
588
589 int totallen = cm->msg.conn_data.datalen + 11;
590 int putlen = min(totallen, spaceleft);
591 int dataputlen = putlen - 11;
592
593 BUG_ON(split_conndata == 0);
594 BUG_ON(sc_sendlen == 0);
595
596 if (dataputlen < 1 || (spaceleft < 25 && spaceleft < totallen))
597 return 0;
598
599 dst = skb_put(skb, putlen);
600 BUG_ON(dst == 0);
601
602 dst[0] = KP_CONN_DATA;
603 put_u32(dst + 1, cm->msg.conn_data.conn_id, 1);
604 put_u32(dst + 5, cm->msg.conn_data.seqno, 1);
605 put_u16(dst + 9, dataputlen, 1);
606
607 memcpy(dst + 11, cm->msg.conn_data.data, dataputlen);
608
609 if (cm->msg.conn_data.datalen == dataputlen) {
610 list_add_tail(&(cm->lh), &(cr->msgs));
611 } else {
612 *split_conndata = cm;
613 *sc_sendlen = dataputlen;
614 }
615
616 return putlen;
617 }
618
619 static int add_ping_conn(struct sk_buff *skb, struct control_retrans *cr,
620 struct control_msg_out *cm, int spaceleft)
621 {
622 char *dst;
623
624 if (unlikely(spaceleft < 5))
625 return 0;
626
627 dst = skb_put(skb, 5);
628 BUG_ON(dst == 0);
629
630 dst[0] = KP_PING_CONN;
631 put_u32(dst + 1, cm->msg.ping_conn.conn_id, 1);
632
633 list_add_tail(&(cm->lh), &(cr->msgs));
634
635 return 5;
636 }
637
638 static int add_connid_unknown(struct sk_buff *skb, struct control_retrans *cr,
639 struct control_msg_out *cm, int spaceleft)
640 {
641 char *dst;
642
643 if (unlikely(spaceleft < 5))
644 return 0;
645
646 dst = skb_put(skb, 5);
647 BUG_ON(dst == 0);
648
649 dst[0] = KP_CONNID_UNKNOWN;
650 put_u32(dst + 1, cm->msg.connid_unknown.conn_id, 1);
651
652 list_add_tail(&(cm->lh), &(cr->msgs));
653
654 return 5;
655 }
656
657 static int add_ping_all_conns(struct sk_buff *skb, struct control_retrans *cr,
658 struct control_msg_out *cm, int spaceleft)
659 {
660 char *dst;
661
662 if (unlikely(spaceleft < 1))
663 return 0;
664
665 dst = skb_put(skb, 1);
666 BUG_ON(dst == 0);
667
668 dst[0] = KP_PING_ALL_CONNS;
669
670 list_add_tail(&(cm->lh), &(cr->msgs));
671
672 return 1;
673 }
674
675 static int add_set_max_cmsg_dly(struct sk_buff *skb, struct control_retrans *cr,
676 struct control_msg_out *cm, int spaceleft)
677 {
678 char *dst;
679
680 if (unlikely(spaceleft < 5))
681 return 0;
682
683 dst = skb_put(skb, 5);
684 BUG_ON(dst == 0);
685
686 dst[0] = KP_SET_MAX_CMSG_DELAY;
687 put_u32(dst + 1, cm->msg.set_max_cmsg_delay.delay, 1);
688
689 list_add_tail(&(cm->lh), &(cr->msgs));
690
691 return 5;
692 }
693
694 static int add_credits(struct sk_buff *skb, struct control_retrans *cr,
695 struct control_msg_out *cm, int spaceleft)
696 {
697 unsigned long iflags;
698 char *dst;
699
700 if (unlikely(spaceleft < 21))
701 return 0;
702
703 dst = skb_put(skb, 21);
704 BUG_ON(dst == 0);
705
706 dst[0] = KP_SET_CREDITS;
707
708 spin_lock_irqsave( &(cm->nb->credits_lock), iflags );
709
710 refresh_credits_state(cm->nb);
711
712 put_u64(dst + 1, cm->nb->debits, 1);
713 put_u32(dst + 9, cm->nb->debitrate_initial +
714 cm->nb->debitrate_initial_adj, 1);
715 put_u32(dst + 13, cm->nb->debitrate_earning, 1);
716 put_u32(dst + 17, cm->nb->debitrate_spending, 1);
717
718 spin_unlock_irqrestore( &(cm->nb->credits_lock), iflags );
719
720 list_add_tail(&(cm->lh), &(cr->msgs));
721
722 return 21;
723 }
724
725 static int add_message(struct sk_buff *skb, struct control_retrans *cr,
726 struct control_msg_out *cm, int spaceleft,
727 struct control_msg_out **split_conndata, __u32 *sc_sendlen)
728 {
729 BUG_ON(split_conndata != 0 && *split_conndata != 0);
730 BUG_ON(sc_sendlen != 0 && *sc_sendlen != 0);
731
732 switch (cm->type) {
733 case MSGTYPE_ACK:
734 return add_ack(skb, cr, cm, spaceleft);
735 case MSGTYPE_ACK_CONN:
736 return add_ack_conn(skb, cr, cm, spaceleft);
737 case MSGTYPE_ACK_CONN_OOO:
738 return add_ack_conn_ooo(skb, cr, cm, spaceleft);
739 case MSGTYPE_PONG:
740 return add_pong(skb, cr, cm, spaceleft);
741 case MSGTYPE_CONNECT:
742 return add_connect(skb, cr, cm, spaceleft);
743 case MSGTYPE_CONNECT_SUCCESS:
744 return add_connect_success(skb, cr, cm, spaceleft);
745 case MSGTYPE_RESET_CONN:
746 return add_reset_conn(skb, cr, cm, spaceleft);
747 case MSGTYPE_CONNDATA:
748 return add_conndata(skb, cr, cm, spaceleft, split_conndata,
749 sc_sendlen);
750 case MSGTYPE_PING_CONN:
751 return add_ping_conn(skb, cr, cm, spaceleft);
752 case MSGTYPE_CONNID_UNKNOWN:
753 return add_connid_unknown(skb, cr, cm, spaceleft);
754 case MSGTYPE_PING_ALL_CONNS:
755 return add_ping_all_conns(skb, cr, cm, spaceleft);
756 case MSGTYPE_SET_MAX_CMSG_DELAY:
757 return add_set_max_cmsg_dly(skb, cr, cm, spaceleft);
758 case MSGTYPE_SET_CREDITS:
759 return add_credits(skb, cr, cm, spaceleft);
760 default:
761 BUG();
762 }
763 BUG();
764 return 0;
765 }
766
767 static __u32 recount_ping_conns(struct neighbor *nb)
768 {
769 __u32 cnt;
770 struct list_head *curr = nb->next_ping_conn->target.out.nb_list.next;
771 while (curr != &(nb->snd_conn_list)) {
772 cnt++;
773 BUG_ON(cnt > 1000000000);
774 }
775 return cnt;
776 }
777
778 static __u32 __send_messages_pc(struct neighbor *nb, struct sk_buff *skb,
779 struct control_retrans *cr, int spaceleft)
780 {
781 __u32 length = 0;
782 mutex_lock(&(nb->conn_list_lock));
783 while (nb->next_ping_conn != 0) {
784 struct conn *rconn;
785 struct conn *sconn;
786 struct list_head *next;
787 struct control_msg_out *cm;
788 int rc;
789
790 rconn = nb->next_ping_conn;
791 sconn = rconn->reversedir;
792
793 BUG_ON(rconn->targettype != TARGET_OUT);
794 BUG_ON(sconn->sourcetype != SOURCE_IN);
795
796 if (unlikely(rconn->target.out.conn_id))
797 goto next;
798
799 if (nb->ping_conns_remaining == 0) {
800 atomic_set(&(sconn->source.in.pong_awaiting), 1);
801 nb->pong_conns_expected++;
802 nb->ping_conns_remaining--;
803 if (unlikely(nb->ping_conns_remaining == 0))
804 nb->ping_conns_remaining =
805 recount_ping_conns(nb);
806 } else {
807 if (likely(atomic_read(&(
808 sconn->source.in.pong_awaiting)) == 0))
809 goto next;
810 nb->ping_conns_remaining--;
811 if (unlikely(nb->ping_conns_retrans_remaining == 0))
812 nb->ping_conns_retrans_remaining =
813 recount_ping_conns(nb);
814 }
815
816 cm = alloc_control_msg(nb, ACM_PRIORITY_LOW);
817 cm->length = 5;
818 cm->type = MSGTYPE_PING_CONN;
819 cm->msg.ping_conn.conn_id = rconn->target.out.conn_id;
820 rc = add_message(skb, cr, cm, spaceleft - length, 0, 0);
821 if (rc == 0)
822 break;
823
824 length = rc;
825 next:
826 next = rconn->target.out.nb_list.next;
827 nb->next_ping_conn = container_of(next, struct conn,
828 target.out.nb_list);
829 if (next == &(nb->snd_conn_list)) {
830 nb->next_ping_conn = 0;
831 nb->ping_conns_remaining = 0;
832 }
833 }
834 if (unlikely(length != 0)) {
835 nb->ping_conn_completed = jiffies;
836 }
837 mutex_unlock(&(nb->conn_list_lock));
838 return length;
839 }
840
841 static __u32 __send_messages(struct neighbor *nb, struct sk_buff *skb,
842 struct control_retrans *cr, int spaceleft, int urgentonly,
843 struct control_msg_out **split_conndata, __u32 *sc_sendlen)
844 {
845 __u32 length = 0;
846 while (!list_empty(&(nb->ucontrol_msgs_out)) || (!urgentonly &&
847 !list_empty(&(nb->control_msgs_out)))) {
848 int rc;
849
850 int urgent = !list_empty(&(nb->ucontrol_msgs_out));
851
852 struct control_msg_out *cm;
853
854 if (urgent)
855 cm = container_of(nb->ucontrol_msgs_out.next,
856 struct control_msg_out, lh);
857 else
858 cm = container_of(nb->control_msgs_out.next,
859 struct control_msg_out, lh);
860
861 list_del(&(cm->lh));
862 if (urgent)
863 nb->ucmlength -= cm->length;
864 else
865 nb->cmlength -= cm->length;
866 mutex_unlock(&(nb->cmsg_lock));
867 rc = add_message(skb, cr, cm, spaceleft - length,
868 split_conndata, sc_sendlen);
869 mutex_lock(&(nb->cmsg_lock));
870
871 if (rc == 0) {
872 if (urgent) {
873 list_add(&(cm->lh), &(nb->ucontrol_msgs_out));
874 nb->ucmlength += cm->length;
875 } else {
876 list_add(&(cm->lh), &(nb->control_msgs_out));
877 nb->cmlength += cm->length;
878 }
879 break;
880 }
881
882 length += rc;
883 }
884
885 return length;
886 }
887
888 static int msgtype_present(struct neighbor *nb, __u8 type)
889 {
890 struct list_head *curr;
891
892 curr = nb->control_msgs_out.next;
893 while (curr != &(nb->control_msgs_out)) {
894 struct control_msg_out *cm = container_of(curr,
895 struct control_msg_out, lh);
896
897 if (cm->type == MSGTYPE_PING_ALL_CONNS)
898 return 1;
899
900 curr = curr->next;
901 }
902
903 return 0;
904 }
905
906 static int ping_all_conns_needed(struct neighbor *nb)
907 {
908 if (likely(nb->ping_all_conns == 0))
909 return 0;
910
911 if (msgtype_present(nb, MSGTYPE_PING_ALL_CONNS))
912 return 0;
913
914 return 1;
915 }
916
917 static int __send_messages_cred(struct neighbor *nb, struct sk_buff *skb,
918 struct control_retrans *cr, int spaceleft)
919 {
920 struct control_msg_out *cm;
921 int rc;
922
923 cm = alloc_control_msg(nb, ACM_PRIORITY_MED);
924
925 if (unlikely(cm == 0))
926 return 0;
927
928 cm->type = MSGTYPE_SET_CREDITS;
929 cm->length = 21;
930
931 rc = add_message(skb, cr, cm, spaceleft, 0, 0);
932
933 nb->send_credits = 0;
934 return rc;
935 }
936
937 static int __send_messages_smcd(struct neighbor *nb, struct sk_buff *skb,
938 struct control_retrans *cr, int spaceleft)
939 {
940 struct control_msg_out *cm;
941 int rc;
942
943 cm = alloc_control_msg(nb, ACM_PRIORITY_MED);
944
945 if (unlikely(cm == 0))
946 return 0;
947
948 cm->type = MSGTYPE_SET_MAX_CMSG_DELAY;
949 cm->msg.set_max_cmsg_delay.delay = CMSG_INTERVAL_MS * 10;
950 cm->length = 5;
951
952 rc = add_message(skb, cr, cm, spaceleft, 0, 0);
953
954 nb->max_cmsg_delay_sent = 1;
955 return rc;
956 }
957
958 static int __send_messages_pac(struct neighbor *nb, struct sk_buff *skb,
959 struct control_retrans *cr, int spaceleft)
960 {
961 struct control_msg_out *cm;
962 int rc;
963
964 cm = alloc_control_msg(nb, ACM_PRIORITY_MED);
965
966 if (unlikely(cm == 0))
967 return 0;
968
969 cm->type = MSGTYPE_PING_ALL_CONNS;
970 cm->length = 1;
971
972 rc = add_message(skb, cr, cm, spaceleft, 0, 0);
973
974 nb->ping_all_conns = 0;
975 return rc;
976 }
977
978
979 static int _send_messages(struct neighbor *nb, struct sk_buff *skb, int ping,
980 struct control_retrans *cr, int spaceleft, int urgentonly)
981 {
982 int rc;
983 int length = 0;
984 __u32 pingcookie = 0;
985 struct control_msg_out *split_conndata = 0;
986 __u32 sc_sendlen = 0;
987
988 mutex_lock(&(nb->cmsg_lock));
989
990 if (ping != 0) {
991 int rc;
992 pingcookie = add_ping_req(nb);
993 rc = add_ping(skb, pingcookie, spaceleft - length);
994 BUG_ON(rc == 0);
995 length += rc;
996 }
997
998 if (likely(urgentonly == 0) && unlikely(ping_all_conns_needed(nb) != 0))
999 length += __send_messages_pac(nb, skb, cr, spaceleft - length);
1000
1001 if (likely(urgentonly == 0) && unlikely(nb->max_cmsg_delay_sent == 0))
1002 length += __send_messages_smcd(nb, skb, cr, spaceleft - length);
1003
1004 if (likely(urgentonly == 0) && unlikely(nb->send_credits != 0) &&
1005 msgtype_present(nb, MSGTYPE_SET_CREDITS) == 0)
1006 length += __send_messages_cred(nb, skb, cr, spaceleft - length);
1007
1008
1009 length += __send_messages(nb, skb, cr, spaceleft - length, urgentonly,
1010 &split_conndata, &sc_sendlen);
1011
1012 if (likely(urgentonly == 0))
1013 length += __send_messages_pc(nb, skb, cr, spaceleft - length);
1014
1015 mutex_unlock(&(nb->cmsg_lock));
1016
1017 if (unlikely(length > spaceleft))
1018 printk(KERN_ERR "error cor/kpacket_gen: length > spaceleft!?");
1019
1020 padding(skb, spaceleft - length);
1021
1022 rc = dev_queue_xmit(skb);
1023
1024 if (rc != 0) {
1025 unadd_ping_req(nb, pingcookie);
1026
1027 while (list_empty(&(cr->msgs)) == 0) {
1028 struct control_msg_out *cm = container_of(cr->msgs.prev,
1029 struct control_msg_out, lh);
1030 list_del(&(cm->lh));
1031 add_control_msg(cm, 1);
1032 }
1033
1034 if (split_conndata != 0) {
1035 add_control_msg(split_conndata, 1);
1036 }
1037
1038 kref_put(&(cr->ref), free_control_retrans);
1039 } else {
1040 struct list_head *curr = cr->msgs.next;
1041
1042 while(curr != &(cr->msgs)) {
1043 struct control_msg_out *cm = container_of(curr,
1044 struct control_msg_out, lh);
1045
1046 curr = curr->next;
1047
1048 if (cm->type == MSGTYPE_CONNDATA) {
1049 list_del(&(cm->lh));
1050 kfree(cm->msg.conn_data.data_orig);
1051 free_control_msg(cm);
1052 }
1053 }
1054
1055 if (split_conndata != 0) {
1056 BUG_ON(sc_sendlen == 0);
1057 BUG_ON(sc_sendlen >=
1058 split_conndata->msg.conn_data.datalen);
1059
1060 split_conndata->msg.conn_data.data += sc_sendlen;
1061 split_conndata->msg.conn_data.datalen -= sc_sendlen;
1062
1063 send_conndata(split_conndata,
1064 split_conndata->msg.conn_data.conn_id,
1065 split_conndata->msg.conn_data.seqno,
1066 split_conndata->msg.conn_data.data_orig,
1067 split_conndata->msg.conn_data.data,
1068 split_conndata->msg.conn_data.datalen);
1069 }
1070
1071
1072 if (list_empty(&(cr->msgs)))
1073 kref_put(&(cr->ref), free_control_retrans);
1074 else
1075 schedule_retransmit(cr, nb);
1076 }
1077
1078 return rc;
1079 }
1080
1081 static __u32 get_total_messages_length(struct neighbor *nb, int ping,
1082 int urgentonly)
1083 {
1084 __u32 length = nb->ucmlength;
1085 if (likely(nb->send_credits == 0) && unlikely(debit_adj_needed(nb)))
1086 nb->send_credits = 1;
1087
1088 if (likely(urgentonly == 0)) {
1089 length += nb->cmlength + nb->ping_conns_remaining * 5;
1090 if (likely(nb->ping_conns_remaining == 0)) {
1091 if (likely(nb->ping_conns_retrans_remaining == 0) &&
1092 unlikely(nb->pong_conns_expected !=0) &&
1093 time_before(nb->ping_conn_completed,
1094 jiffies + msecs_to_jiffies(
1095 PING_ALL_CONNS_TIMEOUT) +
1096 usecs_to_jiffies(((__u32) atomic_read(&(
1097 nb->latency))) * 2 + ((__u32)
1098 atomic_read(&(nb->max_remote_cmsg_delay)
1099 )))))
1100 nb->ping_conns_retrans_remaining =
1101 nb->pong_conns_expected;
1102
1103 if (unlikely(nb->ping_conns_retrans_remaining >
1104 nb->pong_conns_expected))
1105 nb->ping_conns_retrans_remaining =
1106 nb->pong_conns_expected;
1107
1108 length += nb->ping_conns_retrans_remaining * 5;
1109 }
1110 if (unlikely(ping_all_conns_needed(nb) != 0))
1111 length += 1;
1112 if (unlikely(nb->max_cmsg_delay_sent == 0))
1113 length += 5;
1114 if (unlikely(nb->send_credits == 2) &&
1115 msgtype_present(nb, MSGTYPE_SET_CREDITS) == 0)
1116 length += 21;
1117 }
1118 if (ping == 2 || (length > 0 && ping != 0))
1119 length += 5;
1120 if (likely(urgentonly == 0) && length > 0 &&
1121 unlikely(nb->send_credits == 1) &&
1122 msgtype_present(nb, MSGTYPE_SET_CREDITS) == 0)
1123 length += 21;
1124
1125 return length;
1126 }
1127
1128 static int send_messages(struct neighbor *nb, int allmsgs, int resume)
1129 {
1130 int rc = 0;
1131 int ping;
1132 int targetmss = mss(nb);
1133
1134 int nbstate = get_neigh_state(nb);
1135 int urgentonly = (nbstate != NEIGHBOR_STATE_ACTIVE);
1136
1137 check_credit_state(nb);
1138
1139 mutex_lock(&(nb->cmsg_lock));
1140
1141 if (resume)
1142 allmsgs = nb->kp_allmsgs;
1143
1144 ping = time_to_send_ping(nb);
1145
1146 while (1) {
1147 __u32 length;
1148
1149 __u32 seqno;
1150 struct sk_buff *skb;
1151 struct control_retrans *cr;
1152
1153 BUG_ON(list_empty(&(nb->control_msgs_out)) &&
1154 (nb->cmlength != 0));
1155 BUG_ON((list_empty(&(nb->control_msgs_out)) == 0) &&
1156 (nb->cmlength == 0));
1157 BUG_ON(list_empty(&(nb->ucontrol_msgs_out)) &&
1158 (nb->ucmlength != 0));
1159 BUG_ON((list_empty(&(nb->ucontrol_msgs_out)) == 0) &&
1160 (nb->ucmlength == 0));
1161 BUG_ON(nb->cmlength < 0);
1162 BUG_ON(nb->ucmlength < 0);
1163
1164 length = get_total_messages_length(nb, ping, urgentonly);
1165
1166 if (length == 0)
1167 break;
1168
1169 if (length < targetmss && allmsgs == 0)
1170 break;
1171
1172 seqno = atomic_add_return(1, &(nb->kpacket_seqno));
1173
1174 if (length > targetmss)
1175 length = targetmss;
1176
1177 mutex_unlock(&(nb->cmsg_lock));
1178 skb = create_packet(nb, length, GFP_KERNEL, 0, seqno);
1179 if (unlikely(skb == 0)) {
1180 printk(KERN_ERR "cor: send_messages: cannot allocate "
1181 "skb (out of memory?)");
1182 goto oom;
1183 }
1184
1185 cr = kmem_cache_alloc(controlretrans_slab, GFP_KERNEL);
1186 if (unlikely(cr == 0)) {
1187 kfree_skb(skb);
1188 printk(KERN_ERR "cor: send_messages: cannot allocate "
1189 "control_retrans (out of memory?)");
1190 goto oom;
1191 }
1192 memset(cr, 0, sizeof(struct control_retrans));
1193 kref_init(&(cr->ref));
1194 cr->nb = nb;
1195 cr->seqno = seqno;
1196 INIT_LIST_HEAD(&(cr->msgs));
1197
1198 rc = _send_messages(nb, skb, ping, cr, length, urgentonly);
1199 ping = 0;
1200
1201 mutex_lock(&(nb->cmsg_lock));
1202
1203 if (rc != 0)
1204 break;
1205 }
1206
1207 if (0) {
1208 oom:
1209 mutex_lock(&(nb->cmsg_lock));
1210 }
1211
1212 if (rc != 0) {
1213 if (resume == 0) {
1214 nb->kp_allmsgs = nb->kp_allmsgs || allmsgs;
1215 qos_enqueue_kpacket(nb);
1216 }
1217 } else if (allmsgs) {
1218 nb->kp_allmsgs = 0;
1219 }
1220
1221 mutex_unlock(&(nb->cmsg_lock));
1222
1223 if (allmsgs)
1224 schedule_controlmsg_timerfunc(nb);
1225
1226 return rc;
1227 }
1228
1229 int resume_send_messages(struct neighbor *nb)
1230 {
1231 return send_messages(nb, 0, 1);
1232 }
1233
1234 static void controlmsg_timerfunc(struct work_struct *work)
1235 {
1236 struct neighbor *nb = container_of(to_delayed_work(work),
1237 struct neighbor, cmsg_timer);
1238 __u64 jiffies = get_jiffies_64();
1239
1240 mutex_lock(&(nb->cmsg_lock));
1241
1242 if (nb->timeout > jiffies) {
1243 INIT_DELAYED_WORK(&(nb->cmsg_timer), controlmsg_timerfunc);
1244 schedule_delayed_work(&(nb->cmsg_timer), nb->timeout - jiffies);
1245 mutex_unlock(&(nb->cmsg_lock));
1246 return;
1247 }
1248
1249 mutex_unlock(&(nb->cmsg_lock));
1250
1251 send_messages(nb, 1, 0);
1252 kref_put(&(nb->ref), neighbor_free);
1253 }
1254
1255 void schedule_controlmsg_timerfunc(struct neighbor *nb)
1256 {
1257 __u64 jiffies = get_jiffies_64();
1258 long long delay;
1259
1260 int state = get_neigh_state(nb);
1261
1262 if (unlikely(state == NEIGHBOR_STATE_KILLED))
1263 return;
1264
1265 mutex_lock(&(nb->cmsg_lock));
1266 nb->timeout += msecs_to_jiffies(CMSG_INTERVAL_MS);
1267
1268 delay = nb->timeout - jiffies;
1269 if (delay < 0) {
1270 delay = 1;
1271 nb->timeout = jiffies;
1272 }
1273
1274 INIT_DELAYED_WORK(&(nb->cmsg_timer), controlmsg_timerfunc);
1275 schedule_delayed_work(&(nb->cmsg_timer), delay);
1276 mutex_unlock(&(nb->cmsg_lock));
1277 kref_get(&(nb->ref));
1278 }
1279
1280 static void free_oldest_ucm(struct neighbor *nb)
1281 {
1282 struct control_msg_out *cm = container_of(nb->ucontrol_msgs_out.next,
1283 struct control_msg_out, lh);
1284
1285 BUG_ON(list_empty(&(nb->ucontrol_msgs_out)));
1286 BUG_ON(isurgent(cm) == 0);
1287
1288 list_del(&(cm->lh));
1289 nb->ucmlength -= cm->length;
1290 atomic_dec(&(nb->ucmcnt));
1291 free_control_msg(cm);
1292 }
1293
1294 static void add_control_msg(struct control_msg_out *cm, int retrans)
1295 {
1296 int nbstate;
1297
1298 BUG_ON(cm->nb == 0);
1299
1300 nbstate = get_neigh_state(cm->nb);
1301
1302 BUG_ON(cm == 0);
1303 BUG_ON(cm->lh.next != LIST_POISON1 || cm->lh.prev != LIST_POISON2);
1304
1305 mutex_lock(&(cm->nb->cmsg_lock));
1306
1307 if (isurgent(cm)) {
1308 long msgs;
1309
1310 msgs = atomic_inc_return(&(cm->nb->ucmcnt));
1311 BUG_ON(msgs <= 0);
1312
1313 if (unlikely(retrans)) {
1314 if (msgs > MAX_URGENT_CMSGS_PER_NEIGH_RETRANSALLOW ||
1315 msgs > MAX_URGENT_CMSGS_PER_NEIGH) {
1316 atomic_dec(&(cm->nb->ucmcnt));
1317 free_control_msg(cm);
1318 goto out;
1319 }
1320
1321 cm->nb->ucmlength += cm->length;
1322 list_add(&(cm->lh), &(cm->nb->ucontrol_msgs_out));
1323 } else {
1324 if (msgs > MAX_URGENT_CMSGS_PER_NEIGH) {
1325 free_oldest_ucm(cm->nb);
1326 }
1327
1328 cm->nb->ucmlength += cm->length;
1329 list_add_tail(&(cm->lh), &(cm->nb->ucontrol_msgs_out));
1330 }
1331 } else {
1332 cm->nb->cmlength += cm->length;
1333 list_add_tail(&(cm->lh), &(cm->nb->control_msgs_out));
1334 }
1335
1336 if (unlikely((nbstate == NEIGHBOR_STATE_ACTIVE ? cm->nb->cmlength : 0)+
1337 cm->nb->ucmlength >= mss(cm->nb)))
1338 send_messages(cm->nb, 0, 0);
1339
1340 out:
1341 mutex_unlock(&(cm->nb->cmsg_lock));
1342 }
1343
1344 void send_pong(struct neighbor *nb, __u32 cookie)
1345 {
1346 struct control_msg_out *cm = _alloc_control_msg(nb, 0, 1);
1347
1348 if (unlikely(cm == 0))
1349 return;
1350
1351 cm->nb = nb;
1352 cm->type = MSGTYPE_PONG;
1353 cm->msg.pong.cookie = cookie;
1354 cm->msg.pong.time_enqueued = jiffies;
1355 cm->length = 9;
1356 add_control_msg(cm, 0);
1357 }
1358
1359 void send_reset_conn(struct control_msg_out *cm, __u32 conn_id)
1360 {
1361 cm->type = MSGTYPE_RESET_CONN;
1362 cm->msg.reset.conn_id = conn_id;
1363 cm->length = 5;
1364 add_control_msg(cm, 0);
1365 }
1366
1367 void send_ack(struct neighbor *nb, __u32 seqno)
1368 {
1369 struct control_msg_out *cm = _alloc_control_msg(nb, 0, 1);
1370
1371 if (unlikely(cm == 0))
1372 return;
1373
1374 cm->nb = nb;
1375 cm->type = MSGTYPE_ACK;
1376 cm->msg.ack.seqno = seqno;
1377 cm->length = 5;
1378 add_control_msg(cm, 0);
1379 }
1380
1381 void send_ack_conn(struct control_msg_out *cm, struct conn *rconn,
1382 __u32 conn_id, __u32 seqno)
1383 {
1384 cm->type = MSGTYPE_ACK_CONN;
1385 kref_get(&(rconn->ref));
1386 cm->msg.ack_conn.rconn = rconn;
1387 cm->msg.ack_conn.conn_id = conn_id;
1388 cm->msg.ack_conn.seqno = seqno;
1389
1390 cm->length = 10;
1391 add_control_msg(cm, 0);
1392 }
1393
1394 void send_ack_conn_ooo(struct control_msg_out *cm, struct conn *rconn,
1395 __u32 conn_id, __u32 seqno, __u32 seqno_ooo, __u32 length)
1396 {
1397 cm->type = MSGTYPE_ACK_CONN_OOO;
1398 kref_get(&(rconn->ref));
1399 cm->msg.ack_conn_ooo.rconn = rconn;
1400 cm->msg.ack_conn_ooo.conn_id = conn_id;
1401 cm->msg.ack_conn_ooo.seqno = seqno;
1402 cm->msg.ack_conn_ooo.seqno_ooo = seqno_ooo;
1403 cm->msg.ack_conn_ooo.length = length;
1404 cm->length = 18;
1405 add_control_msg(cm, 0);
1406 }
1407
1408 void send_connect_success(struct control_msg_out *cm, __u32 rcvd_conn_id,
1409 __u32 gen_conn_id, __u32 init_seqno, struct conn *rconn)
1410 {
1411 cm->type = MSGTYPE_CONNECT_SUCCESS;
1412 cm->msg.connect_success.rcvd_conn_id = rcvd_conn_id;
1413 cm->msg.connect_success.gen_conn_id = gen_conn_id;
1414 cm->msg.connect_success.init_seqno = init_seqno;
1415 kref_get(&(rconn->ref));
1416 cm->msg.connect_success.rconn = rconn;
1417 cm->length = 14;
1418 add_control_msg(cm, 0);
1419 }
1420
1421 void send_connect_nb(struct control_msg_out *cm, __u32 conn_id,
1422 __u32 init_seqno, struct conn *sconn)
1423 {
1424 cm->type = MSGTYPE_CONNECT;
1425 cm->msg.connect.conn_id = conn_id;
1426 cm->msg.connect.init_seqno = init_seqno;
1427 kref_get(&(sconn->ref));
1428 cm->msg.connect.sconn = sconn;
1429 cm->length = 10;
1430 add_control_msg(cm, 0);
1431 }
1432
1433 void send_conndata(struct control_msg_out *cm, __u32 conn_id, __u32 seqno,
1434 char *data_orig, char *data, __u32 datalen)
1435 {
1436 cm->type = MSGTYPE_CONNDATA;
1437 cm->msg.conn_data.conn_id = conn_id;
1438 cm->msg.conn_data.seqno = seqno;
1439 cm->msg.conn_data.data_orig = data_orig;
1440 cm->msg.conn_data.data = data;
1441 cm->msg.conn_data.datalen = datalen;
1442 cm->length = 11 + datalen;
1443 add_control_msg(cm, 0);
1444 }
1445
1446 void send_ping_conn(struct control_msg_out *cm, __u32 conn_id)
1447 {
1448 cm->type = MSGTYPE_PING_CONN;
1449 cm->msg.ping_conn.conn_id = conn_id;
1450 cm->length = 5;
1451 add_control_msg(cm, 0);
1452 }
1453
1454
1455 void send_connid_unknown(struct control_msg_out *cm, __u32 conn_id)
1456 {
1457 cm->type = MSGTYPE_CONNID_UNKNOWN;
1458 cm->msg.connid_unknown.conn_id = conn_id;
1459 cm->length = 5;
1460 add_control_msg(cm, 0);
1461 }
1462
1463 void send_ping_all_conns(struct neighbor *nb)
1464 {
1465 mutex_lock(&(nb->cmsg_lock));
1466 nb->ping_all_conns = 1;
1467 mutex_unlock(&(nb->cmsg_lock));
1468 }
1469
1470 void send_credits(struct neighbor *nb)
1471 {
1472 mutex_lock(&(nb->cmsg_lock));
1473 nb->send_credits = 2;
1474 mutex_unlock(&(nb->cmsg_lock));
1475 }
1476
1477 static int matches_connretrans(void *htentry, void *searcheditem)
1478 {
1479 struct control_retrans *cr = (struct control_retrans *) htentry;
1480 struct retransmit_matchparam *rm = (struct retransmit_matchparam *)
1481 searcheditem;
1482
1483 return rm->nb == cr->nb && rm->seqno == cr->seqno;
1484 }
1485
1486 void __init cor_kgen_init(void)
1487 {
1488 controlmsg_slab = kmem_cache_create("cor_controlmsg",
1489 sizeof(struct control_msg_out), 8, 0, 0);
1490 controlretrans_slab = kmem_cache_create("cor_controlretransmsg",
1491 sizeof(struct control_retrans), 8, 0, 0);
1492 htable_init(&retransmits, matches_connretrans,
1493 offsetof(struct control_retrans, htab_entry),
1494 offsetof(struct control_retrans, ref));
1495 }
connection oriented routing - ARCHIVE NO UPDATES HERE