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