?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
double send_reset race, free_ack_conns on reset, lock both conn sides on reset, skip...
[cor_2_6_31.git] / net / cor / kpacket_gen.c
blobca4ccd798974880983cb1236fc5888cbb2e05cac
1 /**
2 * Connection oriented routing
3 * Copyright (C) 2007-2011 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_CONNECT 4
30 #define MSGTYPE_CONNECT_SUCCESS 5
31 #define MSGTYPE_RESET_CONN 6
32 #define MSGTYPE_CONNDATA 7
33 #define MSGTYPE_CONNID_UNKNOWN 8
34 #define MSGTYPE_SET_MAX_CMSG_DELAY 9
35
36 #define MSGTYPE_PONG_TIMEENQUEUED 1
37 #define MSGTYPE_PONG_RESPDELAY 2
38
39 struct control_msg_out{
40 struct list_head lh; /* either neighbor or control_retrans_packet */
41 struct neighbor *nb;
42
43 struct kref ref;
44
45 unsigned long timeout;
46
47 __u32 length;
48
49 __u8 type;
50 union{
51 struct{
52
53 __u32 cookie;
54 __u8 type;
55
56 union {
57 ktime_t time_enqueued;
58 __u32 respdelay;
59 } delaycomp;
60 }pong;
61
62 struct{
63 __u32 seqno;
64 }ack;
65
66 struct{
67 struct conn *src_in;
68 struct list_head conn_acks;
69 __u32 conn_id;
70 __u32 seqno;
71 __u32 seqno_ooo;
72 __u32 length;
73
74 __u16 decaytime;
75 __u8 decaytime_seqno;
76
77 __u8 flags;
78
79 __u32 ack_seqno;
80 }ack_conn;
81
82 struct{
83 __u32 conn_id;
84 __u32 init_seqno;
85 struct conn *src_in;
86 }connect;
87
88 struct{
89 __u32 rcvd_conn_id;
90 __u32 gen_conn_id;
91 __u32 init_seqno;
92 struct conn *src_in;
93 }connect_success;
94
95 struct{
96 struct htab_entry htab_entry;
97 __u32 conn_id_reset;
98 __u32 conn_id_unknown;
99 }reset_connidunknown;
100
101 struct{
102 __u32 conn_id;
103 __u32 seqno;
104 char *data_orig;
105 char *data;
106 __u32 datalen;
107 }conn_data;
108
109 struct{
110 __u32 delay;
111 }set_max_cmsg_delay;
112 }msg;
113 };
114
115 struct control_retrans {
116 struct kref ref;
117
118 struct neighbor *nb;
119 __u32 seqno;
120
121 unsigned long timeout;
122
123 struct list_head msgs;
124
125 struct htab_entry htab_entry;
126 struct list_head timeout_list;
127 };
128
129 struct unknownconnid_matchparam {
130 struct neighbor *nb;
131 __u32 conn_id;
132 };
133
134 struct retransmit_matchparam {
135 struct neighbor *nb;
136 __u32 seqno;
137 };
138
139
140 struct kmem_cache *controlmsg_slab;
141 struct kmem_cache *controlretrans_slab;
142
143 static struct htable retransmits;
144
145 DEFINE_SPINLOCK(unknown_connids_lock);
146 static struct htable unknown_connids;
147
148 atomic_t cmcnt = ATOMIC_INIT(0);
149
150
151 static void add_control_msg(struct control_msg_out *msg, int retrans);
152
153 static void try_merge_ackconns(struct conn *src_in_l,
154 struct control_msg_out *cm);
155
156 static void mergeadd_ackconn(struct conn *src_in_l, struct control_msg_out *cm);
157
158
159 static __u32 ucm_to_key(struct unknownconnid_matchparam *ucm)
160 {
161 return ((__u32)((long) ucm->nb)) ^ ucm->conn_id;
162 }
163
164 static __u32 rm_to_key(struct retransmit_matchparam *rm)
165 {
166 return ((__u32)((long) rm->nb)) ^ rm->seqno;
167 }
168
169 static inline int isurgent(struct control_msg_out *cm)
170 {
171 if (unlikely(cm->type == MSGTYPE_PONG || cm->type == MSGTYPE_ACK))
172 return 1;
173 return 0;
174 }
175
176 static struct control_msg_out *__alloc_control_msg(void)
177 {
178 struct control_msg_out *cm = kmem_cache_alloc(controlmsg_slab,
179 GFP_KERNEL);
180 if (unlikely(cm == 0))
181 return 0;
182 memset(cm, 0, sizeof(struct control_msg_out));
183 cm->lh.next = LIST_POISON1;
184 cm->lh.prev = LIST_POISON2;
185 kref_init(&(cm->ref));
186 return cm;
187 }
188
189 static int calc_limit(int limit, int priority)
190 {
191 if (priority == ACM_PRIORITY_LOW)
192 return (limit+2)/3;
193 else if (priority == ACM_PRIORITY_MED)
194 return (limit * 2 + 1)/3;
195 else if (priority == ACM_PRIORITY_HIGH)
196 return limit;
197 else
198 BUG();
199 }
200
201 int may_alloc_control_msg(struct neighbor *nb, int priority)
202 {
203 long packets1 = atomic_read(&(nb->cmcnt));
204 long packets2 = atomic_read(&(cmcnt));
205
206 BUG_ON(packets1 < 0);
207 BUG_ON(packets2 < 0);
208
209 if (packets1 < calc_limit(GUARANTEED_CMSGS_PER_NEIGH, priority))
210 return 1;
211
212 if (unlikely(unlikely(packets2 >= calc_limit(MAX_CMSGS_PER_NEIGH,
213 priority)) || unlikely(packets1 >= (
214 calc_limit(MAX_CMSGS_PER_NEIGH, priority) *
215 (MAX_CMSGS - packets2) / MAX_CMSGS))))
216 return 0;
217 return 1;
218 }
219
220 static struct control_msg_out *_alloc_control_msg(struct neighbor *nb,
221 int priority, int urgent)
222 {
223 struct control_msg_out *cm = 0;
224
225 BUG_ON(nb == 0);
226
227 if (urgent == 0) {
228 long packets1 = atomic_inc_return(&(nb->cmcnt));
229 long packets2 = atomic_inc_return(&(cmcnt));
230
231 BUG_ON(packets1 <= 0);
232 BUG_ON(packets2 <= 0);
233
234 if (packets1 <= calc_limit(GUARANTEED_CMSGS_PER_NEIGH,
235 priority))
236 goto alloc;
237
238 if (unlikely(unlikely(packets2 > calc_limit(MAX_CMSGS_PER_NEIGH,
239 priority)) || unlikely(packets1 > (
240 calc_limit(MAX_CMSGS_PER_NEIGH, priority) *
241 (MAX_CMSGS - packets2) / MAX_CMSGS))))
242 goto full;
243 }
244
245 alloc:
246 cm = __alloc_control_msg();
247 if (unlikely(cm == 0))
248 goto full;
249 cm->nb = nb;
250
251 if (0) {
252 full:
253 if (urgent == 0) {
254 atomic_dec(&(nb->cmcnt));
255 atomic_dec(&(cmcnt));
256 }
257 }
258 return cm;
259 }
260
261 struct control_msg_out *alloc_control_msg(struct neighbor *nb, int priority)
262 {
263 return _alloc_control_msg(nb, priority, 0);
264 }
265
266 static void cmsg_kref_free(struct kref *ref)
267 {
268 struct control_msg_out *cm = container_of(ref, struct control_msg_out,
269 ref);
270 kmem_cache_free(controlmsg_slab, cm);
271 }
272
273 void free_control_msg(struct control_msg_out *cm)
274 {
275 if (isurgent(cm) == 0) {
276 atomic_dec(&(cm->nb->cmcnt));
277 atomic_dec(&(cmcnt));
278 }
279
280 if (cm->type == MSGTYPE_ACK_CONN) {
281 struct conn *trgt_out = cm->msg.ack_conn.src_in->reversedir;
282 BUG_ON(cm->msg.ack_conn.src_in == 0);
283 mutex_lock(&(trgt_out->rcv_lock));
284 BUG_ON(trgt_out->targettype != TARGET_OUT);
285 if ((cm->msg.ack_conn.flags & KP_ACK_CONN_FLAGS_CREDITS) != 0 &&
286 trgt_out->target.out.decaytime_send_allowed !=
287 0) {
288 trgt_out->target.out.decaytime_send_allowed = 1;
289 mutex_unlock(&(trgt_out->rcv_lock));
290 refresh_conn_credits(trgt_out, 0, 0);
291 } else {
292 mutex_unlock(&(trgt_out->rcv_lock));
293 }
294
295 kref_put(&(cm->msg.ack_conn.src_in->ref), free_conn);
296 cm->msg.ack_conn.src_in = 0;
297 } else if (cm->type == MSGTYPE_CONNECT) {
298 BUG_ON(cm->msg.connect.src_in == 0);
299 kref_put(&(cm->msg.connect.src_in->ref), free_conn);
300 cm->msg.connect.src_in = 0;
301 } else if (cm->type == MSGTYPE_CONNECT_SUCCESS) {
302 BUG_ON(cm->msg.connect_success.src_in == 0);
303 kref_put(&(cm->msg.connect_success.src_in->ref), free_conn);
304 cm->msg.connect_success.src_in = 0;
305 } else if (cm->type == MSGTYPE_RESET_CONN ||
306 cm->type == MSGTYPE_CONNID_UNKNOWN) {
307 struct unknownconnid_matchparam ucm;
308
309 ucm.nb = cm->nb;
310 ucm.conn_id = cm->msg.reset_connidunknown.conn_id_unknown;
311
312 htable_delete(&unknown_connids, ucm_to_key(&ucm), &ucm,
313 cmsg_kref_free);
314 }
315
316 kref_put(&(cm->ref), cmsg_kref_free);
317 }
318
319 static void free_control_retrans(struct kref *ref)
320 {
321 struct control_retrans *cr = container_of(ref, struct control_retrans,
322 ref);
323
324 while (list_empty(&(cr->msgs)) == 0) {
325 struct control_msg_out *cm = container_of(cr->msgs.next,
326 struct control_msg_out, lh);
327 list_del(&(cm->lh));
328 free_control_msg(cm);
329 }
330
331 kmem_cache_free(controlretrans_slab, cr);
332 }
333
334
335 static void set_retrans_timeout(struct control_retrans *cr, struct neighbor *nb)
336 {
337 cr->timeout = jiffies + usecs_to_jiffies(100000 +
338 ((__u32) atomic_read(&(nb->latency))) * 2 +
339 ((__u32) atomic_read(&(nb->max_remote_cmsg_delay))));
340 }
341
342 static void remove_connack_oooflag_ifold(struct conn *src_in_l,
343 struct control_msg_out *cm)
344 {
345 if (ooolen(cm->msg.ack_conn.flags) != 0 && seqno_before_eq(
346 cm->msg.ack_conn.seqno_ooo +
347 cm->msg.ack_conn.length,
348 src_in_l->source.in.next_seqno)) {
349 cm->msg.ack_conn.length = 0;
350 cm->msg.ack_conn.flags = (cm->msg.ack_conn.flags &
351 (~KP_ACK_CONN_FLAGS_OOO));
352 }
353 }
354
355 static int ackconn_prepare_readd(struct conn *cn_l,
356 struct control_msg_out *cm)
357 {
358 if (unlikely(unlikely(cn_l->sourcetype != SOURCE_IN) ||
359 unlikely(cn_l->source.in.nb != cm->nb) ||
360 unlikely(cn_l->reversedir->target.out.conn_id !=
361 cm->msg.ack_conn.conn_id) ||
362 unlikely(cn_l->isreset != 0)))
363 return 0;
364
365 remove_connack_oooflag_ifold(cn_l, cm);
366
367 if (cm->msg.ack_conn.ack_seqno != cn_l->source.in.ack_seqno)
368 cm->msg.ack_conn.flags = (cm->msg.ack_conn.flags &
369 (~KP_ACK_CONN_FLAGS_SEQNO) &
370 (~KP_ACK_CONN_FLAGS_WINDOW));
371
372 if (cm->msg.ack_conn.flags == 0)
373 return 0;
374
375 cm->length = 6 + ack_conn_len(cm->msg.ack_conn.flags);
376
377 return 1;
378 }
379
380 static void readd_control_retrans(struct control_retrans *cr)
381 {
382 while (list_empty(&(cr->msgs)) == 0) {
383 struct control_msg_out *cm = container_of(cr->msgs.next,
384 struct control_msg_out, lh);
385 list_del(&(cm->lh));
386 if (cm->type == MSGTYPE_ACK_CONN) {
387 struct conn *cn_l = cm->msg.ack_conn.src_in;
388 mutex_lock(&(cn_l->rcv_lock));
389 if (unlikely(ackconn_prepare_readd(cn_l, cm) == 0)) {
390 free_control_msg(cm);
391 } else {
392 mergeadd_ackconn(cn_l, cm);
393 }
394
395 mutex_unlock(&(cn_l->rcv_lock));
396 } else {
397 add_control_msg(cm, 1);
398 }
399 }
400 }
401
402 void retransmit_timerfunc(struct work_struct *work)
403 {
404 unsigned long iflags;
405
406 struct neighbor *nb = container_of(to_delayed_work(work),
407 struct neighbor, retrans_timer);
408
409 int nbstate;
410 int nbput = 0;
411
412 spin_lock_irqsave(&(nb->state_lock), iflags);
413 nbstate = nb->state;
414 spin_unlock_irqrestore(&(nb->state_lock), iflags);
415
416 while (1) {
417 struct control_retrans *cr = 0;
418 struct retransmit_matchparam rm;
419
420 spin_lock_irqsave(&(nb->retrans_lock), iflags);
421
422 if (list_empty(&(nb->retrans_list))) {
423 nb->retrans_timer_running = 0;
424 nbput = 1;
425 break;
426 }
427
428 cr = container_of(nb->retrans_list.next,
429 struct control_retrans, timeout_list);
430
431 BUG_ON(cr->nb != nb);
432
433 rm.seqno = cr->seqno;
434 rm.nb = nb;
435
436 list_del(&(cr->timeout_list));
437
438 if (unlikely(nbstate == NEIGHBOR_STATE_KILLED)) {
439 spin_unlock_irqrestore(&(nb->retrans_lock), iflags);
440
441 htable_delete(&retransmits, rm_to_key(&rm), &rm,
442 free_control_retrans);
443 kref_put(&(cr->ref), free_control_retrans);
444 continue;
445 }
446
447 if (time_after(cr->timeout, jiffies)) {
448 list_add(&(cr->timeout_list), &(nb->retrans_list));
449 schedule_delayed_work(&(nb->retrans_timer),
450 cr->timeout - jiffies);
451 break;
452 }
453
454 if (unlikely(htable_delete(&retransmits, rm_to_key(&rm), &rm,
455 free_control_retrans)))
456 BUG();
457
458 spin_unlock_irqrestore(&(nb->retrans_lock), iflags);
459
460 readd_control_retrans(cr);
461
462 kref_put(&(cr->ref), free_control_retrans);
463 }
464
465 spin_unlock_irqrestore(&(nb->retrans_lock), iflags);
466
467 if (nbput)
468 kref_put(&(nb->ref), neighbor_free);
469 }
470
471 static void schedule_retransmit(struct control_retrans *cr, struct neighbor *nb)
472 {
473 unsigned long iflags;
474
475 struct retransmit_matchparam rm;
476 int first;
477
478 rm.seqno = cr->seqno;
479 rm.nb = nb;
480
481 set_retrans_timeout(cr, nb);
482
483 spin_lock_irqsave(&(nb->retrans_lock), iflags);
484 htable_insert(&retransmits, (char *) cr, rm_to_key(&rm));
485 first = list_empty(&(nb->retrans_list));
486 list_add_tail(&(cr->timeout_list), &(nb->retrans_list));
487
488 if (first && nb->retrans_timer_running == 0) {
489 schedule_delayed_work(&(nb->retrans_timer),
490 cr->timeout - jiffies);
491 nb->retrans_timer_running = 1;
492 kref_get(&(nb->ref));
493 }
494
495 spin_unlock_irqrestore(&(nb->retrans_lock), iflags);
496 }
497
498 void kern_ack_rcvd(struct neighbor *nb, __u32 seqno)
499 {
500 unsigned long iflags;
501
502 struct control_retrans *cr = 0;
503 struct retransmit_matchparam rm;
504
505 rm.seqno = seqno;
506 rm.nb = nb;
507
508 spin_lock_irqsave(&(nb->retrans_lock), iflags);
509
510 cr = (struct control_retrans *) htable_get(&retransmits, rm_to_key(&rm),
511 &rm);
512
513 if (cr == 0) {
514 printk(KERN_ERR "bogus/duplicate ack received");
515 goto out;
516 }
517
518 if (unlikely(htable_delete(&retransmits, rm_to_key(&rm), &rm,
519 free_control_retrans)))
520 BUG();
521
522 BUG_ON(cr->nb != nb);
523
524 list_del(&(cr->timeout_list));
525
526 out:
527 spin_unlock_irqrestore(&(nb->retrans_lock), iflags);
528
529 if (cr != 0) {
530 kref_put(&(cr->ref), free_control_retrans); /* htable_get */
531 kref_put(&(cr->ref), free_control_retrans); /* list */
532 }
533 }
534
535 static void padding(struct sk_buff *skb, int length)
536 {
537 char *dst;
538 if (length <= 0)
539 return;
540 dst = skb_put(skb, length);
541 BUG_ON(dst == 0);
542 memset(dst, KP_PADDING, length);
543 }
544
545 static int add_ack(struct sk_buff *skb, struct control_retrans *cr,
546 struct control_msg_out *cm, int spaceleft)
547 {
548 char *dst;
549
550 if (unlikely(spaceleft < 5))
551 return 0;
552
553 dst = skb_put(skb, 5);
554 BUG_ON(dst == 0);
555
556 dst[0] = KP_ACK;
557 put_u32(dst + 1, cm->msg.ack.seqno, 1);
558
559 atomic_dec(&(cm->nb->ucmcnt));
560 free_control_msg(cm);
561
562 return 5;
563 }
564
565 static int add_ack_conn(struct sk_buff *skb, struct control_retrans *cr,
566 struct control_msg_out *cm, int spaceleft)
567 {
568 char *dst;
569 int offset = 0;
570
571 if (unlikely(spaceleft < cm->length))
572 return 0;
573
574 dst = skb_put(skb, cm->length);
575 BUG_ON(dst == 0);
576
577 dst[offset] = KP_ACK_CONN;
578 offset++;
579 put_u32(dst + offset, cm->msg.ack_conn.conn_id, 1);
580 offset += 4;
581 dst[offset] = cm->msg.ack_conn.flags;
582 offset++;
583
584 if ((cm->msg.ack_conn.flags & KP_ACK_CONN_FLAGS_SEQNO) != 0) {
585 put_u32(dst + offset, cm->msg.ack_conn.seqno, 1);
586 offset += 4;
587
588 if ((cm->msg.ack_conn.flags & KP_ACK_CONN_FLAGS_WINDOW) != 0) {
589 BUG_ON(cm->msg.ack_conn.src_in == 0);
590 dst[offset] = get_window(cm->msg.ack_conn.src_in,
591 cm->nb, cm->msg.ack_conn.conn_id, 1);
592 offset++;
593 }
594 }
595
596 if (ooolen(cm->msg.ack_conn.flags) != 0) {
597 put_u32(dst + offset, cm->msg.ack_conn.seqno_ooo, 1);
598 offset += 4;
599 if (ooolen(cm->msg.ack_conn.flags) == 1) {
600 BUG_ON(cm->msg.ack_conn.length > 255);
601 dst[offset] = cm->msg.ack_conn.length;
602 offset += 1;
603 } else if (ooolen(cm->msg.ack_conn.flags) == 2) {
604 BUG_ON(cm->msg.ack_conn.length <= 255);
605 BUG_ON(cm->msg.ack_conn.length > 65535);
606 put_u16(dst + offset, cm->msg.ack_conn.length, 1);
607 offset += 2;
608 } else if (ooolen(cm->msg.ack_conn.flags) == 4) {
609 BUG_ON(cm->msg.ack_conn.length <= 65535);
610 put_u32(dst + offset, cm->msg.ack_conn.length, 1);
611 offset += 4;
612 } else {
613 BUG();
614 }
615 }
616
617 if ((cm->msg.ack_conn.flags & KP_ACK_CONN_FLAGS_CREDITS) != 0) {
618 __u16 value = cm->msg.ack_conn.decaytime + (
619 cm->msg.ack_conn.decaytime_seqno << 10);
620
621 BUG_ON(cm->msg.ack_conn.decaytime >= 1024);
622 BUG_ON(cm->msg.ack_conn.decaytime_seqno >= 64);
623
624 put_u16(dst + offset, value, 1);
625 offset += 2;
626 }
627
628 list_add_tail(&(cm->lh), &(cr->msgs));
629
630 BUG_ON(offset != cm->length);
631 return offset;
632 }
633
634 static int add_ping(struct sk_buff *skb, __u32 cookie,
635 int spaceleft)
636 {
637 char *dst;
638
639 if (unlikely(spaceleft < 5))
640 return 0;
641
642 dst = skb_put(skb, 5);
643 BUG_ON(dst == 0);
644
645 dst[0] = KP_PING;
646 put_u32(dst + 1, cookie, 0);
647
648 return 5;
649 }
650
651 static int add_pong(struct sk_buff *skb, struct control_retrans *cr,
652 struct control_msg_out *cm, int spaceleft)
653 {
654 char *dst;
655
656 if (unlikely(spaceleft < 9))
657 return 0;
658
659 if (cm->msg.pong.type == MSGTYPE_PONG_TIMEENQUEUED) {
660 __s64 now = ktime_to_ns(ktime_get());
661 __s64 enq = ktime_to_ns(cm->msg.pong.delaycomp.time_enqueued);
662 __s64 respdelay = (now - enq + 500) / 1000;
663 if (unlikely(respdelay >= (1LL << 32)))
664 respdelay = (1LL << 32) - 1;
665 cm->msg.pong.type = MSGTYPE_PONG_RESPDELAY;
666 cm->msg.pong.delaycomp.respdelay = (__u32) respdelay;
667 }
668
669 BUG_ON(cm->msg.pong.type != MSGTYPE_PONG_RESPDELAY);
670
671 dst = skb_put(skb, 9);
672 BUG_ON(dst == 0);
673
674 dst[0] = KP_PONG;
675 put_u32(dst + 1, cm->msg.pong.cookie, 0);
676 put_u32(dst + 5, cm->msg.pong.delaycomp.respdelay, 1);
677
678
679 atomic_dec(&(cm->nb->ucmcnt));
680 list_add_tail(&(cm->lh), &(cr->msgs));
681
682 return 9;
683 }
684
685 static __u16 get_credits(struct conn *sconn)
686 {
687 __u16 ret;
688 mutex_lock(&(sconn->reversedir->rcv_lock));
689 BUG_ON(sconn->reversedir->targettype != TARGET_OUT);
690
691 BUG_ON(sconn->reversedir->target.out.decaytime_last >= 1024);
692 BUG_ON(sconn->reversedir->target.out.decaytime_seqno >= 64);
693 ret = sconn->reversedir->target.out.decaytime_last + (
694 sconn->reversedir->target.out.decaytime_seqno <<
695 10);
696 mutex_unlock(&(sconn->reversedir->rcv_lock));
697
698 return ret;
699 }
700
701 static int add_connect(struct sk_buff *skb, struct control_retrans *cr,
702 struct control_msg_out *cm, int spaceleft)
703 {
704 char *dst;
705
706 if (unlikely(spaceleft < 12))
707 return 0;
708
709 dst = skb_put(skb, 12);
710 BUG_ON(dst == 0);
711
712 dst[0] = KP_CONNECT;
713 put_u32(dst + 1, cm->msg.connect.conn_id, 1);
714 put_u32(dst + 5, cm->msg.connect.init_seqno, 1);
715 BUG_ON(cm->msg.connect.src_in == 0);
716 dst[9] = get_window(cm->msg.connect.src_in, cm->nb, 0, 1);
717 put_u16(dst + 10, get_credits(cm->msg.connect.src_in), 1);
718
719 list_add_tail(&(cm->lh), &(cr->msgs));
720
721 return 12;
722 }
723
724 static int add_connect_success(struct sk_buff *skb, struct control_retrans *cr,
725 struct control_msg_out *cm, int spaceleft)
726 {
727 char *dst;
728
729 if (unlikely(spaceleft < 16))
730 return 0;
731
732 dst = skb_put(skb, 16);
733 BUG_ON(dst == 0);
734
735 dst[0] = KP_CONNECT_SUCCESS;
736 put_u32(dst + 1, cm->msg.connect_success.rcvd_conn_id, 1);
737 put_u32(dst + 5, cm->msg.connect_success.gen_conn_id, 1);
738 put_u32(dst + 9, cm->msg.connect_success.init_seqno, 1);
739 BUG_ON(cm->msg.connect_success.src_in == 0);
740 dst[13] = get_window(cm->msg.connect_success.src_in, cm->nb,
741 cm->msg.connect_success.rcvd_conn_id, 1);
742 put_u16(dst + 14, get_credits(cm->msg.connect_success.src_in), 1);
743
744 list_add_tail(&(cm->lh), &(cr->msgs));
745
746 return 16;
747 }
748
749 static int add_reset_conn(struct sk_buff *skb, struct control_retrans *cr,
750 struct control_msg_out *cm, int spaceleft)
751 {
752 char *dst;
753
754 if (unlikely(spaceleft < 5))
755 return 0;
756
757 dst = skb_put(skb, 5);
758 BUG_ON(dst == 0);
759
760 dst[0] = KP_RESET_CONN;
761 put_u32(dst + 1, cm->msg.reset_connidunknown.conn_id_reset, 1);
762
763 list_add_tail(&(cm->lh), &(cr->msgs));
764
765 return 5;
766 }
767
768 static int add_conndata(struct sk_buff *skb, struct control_retrans *cr,
769 struct control_msg_out *cm, int spaceleft,
770 struct control_msg_out **split_conndata, __u32 *sc_sendlen)
771 {
772 char *dst;
773
774 int totallen = cm->msg.conn_data.datalen + 11;
775 int putlen = min(totallen, spaceleft);
776 int dataputlen = putlen - 11;
777
778 BUG_ON(split_conndata == 0);
779 BUG_ON(sc_sendlen == 0);
780
781 if (dataputlen < 1 || (spaceleft < 25 && spaceleft < totallen))
782 return 0;
783
784 dst = skb_put(skb, putlen);
785 BUG_ON(dst == 0);
786
787 dst[0] = KP_CONN_DATA;
788 put_u32(dst + 1, cm->msg.conn_data.conn_id, 1);
789 put_u32(dst + 5, cm->msg.conn_data.seqno, 1);
790 put_u16(dst + 9, dataputlen, 1);
791
792 memcpy(dst + 11, cm->msg.conn_data.data, dataputlen);
793
794 if (cm->msg.conn_data.datalen == dataputlen) {
795 list_add_tail(&(cm->lh), &(cr->msgs));
796 } else {
797 *split_conndata = cm;
798 *sc_sendlen = dataputlen;
799 }
800
801 return putlen;
802 }
803
804 static int add_connid_unknown(struct sk_buff *skb, struct control_retrans *cr,
805 struct control_msg_out *cm, int spaceleft)
806 {
807 char *dst;
808
809 if (unlikely(spaceleft < 5))
810 return 0;
811
812 dst = skb_put(skb, 5);
813 BUG_ON(dst == 0);
814
815 dst[0] = KP_CONNID_UNKNOWN;
816 put_u32(dst + 1, cm->msg.reset_connidunknown.conn_id_unknown, 1);
817
818 list_add_tail(&(cm->lh), &(cr->msgs));
819
820 return 5;
821 }
822
823 static int add_set_max_cmsg_dly(struct sk_buff *skb, struct control_retrans *cr,
824 struct control_msg_out *cm, int spaceleft)
825 {
826 char *dst;
827
828 if (unlikely(spaceleft < 5))
829 return 0;
830
831 dst = skb_put(skb, 5);
832 BUG_ON(dst == 0);
833
834 dst[0] = KP_SET_MAX_CMSG_DELAY;
835 put_u32(dst + 1, cm->msg.set_max_cmsg_delay.delay, 1);
836
837 list_add_tail(&(cm->lh), &(cr->msgs));
838
839 return 5;
840 }
841
842 static int add_message(struct sk_buff *skb, struct control_retrans *cr,
843 struct control_msg_out *cm, int spaceleft,
844 struct control_msg_out **split_conndata, __u32 *sc_sendlen)
845 {
846 BUG_ON(split_conndata != 0 && *split_conndata != 0);
847 BUG_ON(sc_sendlen != 0 && *sc_sendlen != 0);
848
849 switch (cm->type) {
850 case MSGTYPE_ACK:
851 return add_ack(skb, cr, cm, spaceleft);
852 case MSGTYPE_ACK_CONN:
853 return add_ack_conn(skb, cr, cm, spaceleft);
854 case MSGTYPE_PONG:
855 return add_pong(skb, cr, cm, spaceleft);
856 case MSGTYPE_CONNECT:
857 return add_connect(skb, cr, cm, spaceleft);
858 case MSGTYPE_CONNECT_SUCCESS:
859 return add_connect_success(skb, cr, cm, spaceleft);
860 case MSGTYPE_RESET_CONN:
861 return add_reset_conn(skb, cr, cm, spaceleft);
862 case MSGTYPE_CONNDATA:
863 return add_conndata(skb, cr, cm, spaceleft, split_conndata,
864 sc_sendlen);
865 case MSGTYPE_CONNID_UNKNOWN:
866 return add_connid_unknown(skb, cr, cm, spaceleft);
867 case MSGTYPE_SET_MAX_CMSG_DELAY:
868 return add_set_max_cmsg_dly(skb, cr, cm, spaceleft);
869 default:
870 BUG();
871 }
872 BUG();
873 return 0;
874 }
875
876 static void requeue_message(struct control_msg_out *cm)
877 {
878 if (cm->type == MSGTYPE_ACK_CONN) {
879 struct conn *cn_l = cm->msg.ack_conn.src_in;
880
881 mutex_lock(&(cn_l->rcv_lock));
882 if (unlikely(ackconn_prepare_readd(cn_l, cm) == 0)) {
883 free_control_msg(cm);
884 } else {
885 mutex_lock(&(cm->nb->cmsg_lock));
886
887 list_add(&(cm->lh), &(cm->nb->control_msgs_out));
888 cm->nb->cmlength += cm->length;
889
890 list_add(&(cm->msg.ack_conn.conn_acks),
891 &(cn_l->source.in.acks_pending));
892 try_merge_ackconns(cn_l, cm);
893
894 mutex_unlock(&(cm->nb->cmsg_lock));
895 }
896 mutex_unlock(&(cn_l->rcv_lock));
897 return;
898 }
899
900 if (isurgent(cm)) {
901 list_add(&(cm->lh), &(cm->nb->ucontrol_msgs_out));
902 cm->nb->ucmlength += cm->length;
903 } else {
904 list_add(&(cm->lh), &(cm->nb->control_msgs_out));
905 cm->nb->cmlength += cm->length;
906 }
907 }
908
909 static struct control_msg_out *dequeue_message(struct neighbor *nb,
910 int urgentonly)
911 {
912 struct control_msg_out *cm;
913
914 if (list_empty(&(nb->ucontrol_msgs_out)) == 0) {
915 cm = container_of(nb->ucontrol_msgs_out.next,
916 struct control_msg_out, lh);
917 nb->ucmlength -= cm->length;
918 } else if (urgentonly) {
919 return 0;
920 } else {
921 if (list_empty(&(nb->control_msgs_out)))
922 return 0;
923
924 cm = container_of(nb->control_msgs_out.next,
925 struct control_msg_out, lh);
926 nb->cmlength -= cm->length;
927 }
928
929 BUG_ON(cm->nb != nb);
930
931 list_del(&(cm->lh));
932 if (cm->type == MSGTYPE_ACK_CONN)
933 list_del(&(cm->msg.ack_conn.conn_acks));
934
935 return cm;
936 }
937
938 static __u32 __send_messages(struct neighbor *nb, struct sk_buff *skb,
939 struct control_retrans *cr, int spaceleft, int urgentonly,
940 struct control_msg_out **split_conndata, __u32 *sc_sendlen)
941 {
942 __u32 length = 0;
943 while (1) {
944 int rc;
945 struct control_msg_out *cm;
946
947 mutex_lock(&(nb->cmsg_lock));
948 cm = dequeue_message(nb, urgentonly);
949 mutex_unlock(&(nb->cmsg_lock));
950
951 if (cm == 0)
952 break;
953
954 rc = add_message(skb, cr, cm, spaceleft - length,
955 split_conndata, sc_sendlen);
956 if (rc == 0) {
957 requeue_message(cm);
958 break;
959 }
960
961 length += rc;
962 }
963
964 return length;
965 }
966
967 static __u32 __send_messages_smcd(struct neighbor *nb, struct sk_buff *skb,
968 struct control_retrans *cr, int spaceleft)
969 {
970 struct control_msg_out *cm;
971 int rc;
972
973 cm = alloc_control_msg(nb, ACM_PRIORITY_LOW);
974
975 if (unlikely(cm == 0))
976 return 0;
977
978 cm->type = MSGTYPE_SET_MAX_CMSG_DELAY;
979 cm->msg.set_max_cmsg_delay.delay = CMSG_INTERVAL_MS * 10;
980 cm->length = 5;
981
982 rc = add_message(skb, cr, cm, spaceleft, 0, 0);
983
984 nb->max_cmsg_delay_sent = 1;
985
986 return rc;
987 }
988
989 static int _send_messages(struct neighbor *nb, struct sk_buff *skb, int ping,
990 struct control_retrans *cr, int spaceleft, int urgentonly)
991 {
992 int rc;
993 __u32 length = 0;
994 __u32 pinglen = 0;
995 __u32 pingcookie = 0;
996 unsigned long last_ping_time;
997 struct control_msg_out *split_conndata = 0;
998 __u32 sc_sendlen = 0;
999
1000 mutex_lock(&(nb->cmsg_lock));
1001
1002 if (ping != 0) {
1003 int rc;
1004 pingcookie = add_ping_req(nb, &last_ping_time);
1005 rc = add_ping(skb, pingcookie, spaceleft - length);
1006 BUG_ON(rc == 0);
1007 pinglen = rc;
1008 length += rc;
1009 }
1010
1011 if (likely(urgentonly == 0) && unlikely(nb->max_cmsg_delay_sent == 0))
1012 length += __send_messages_smcd(nb, skb, cr, spaceleft - length);
1013
1014 mutex_unlock(&(nb->cmsg_lock));
1015
1016 length += __send_messages(nb, skb, cr, spaceleft - length, urgentonly,
1017 &split_conndata, &sc_sendlen);
1018
1019 BUG_ON(length > spaceleft);
1020
1021 if (likely(ping != 2) && unlikely(length == pinglen)) {
1022 unadd_ping_req(nb, pingcookie, last_ping_time);
1023 kfree_skb(skb);
1024
1025 BUG_ON(list_empty(&(cr->msgs)) == 0);
1026 kref_put(&(cr->ref), free_control_retrans);
1027
1028 atomic_sub(1, &(nb->kpacket_seqno));
1029 return 0;
1030 }
1031
1032 padding(skb, spaceleft - length);
1033
1034 rc = dev_queue_xmit(skb);
1035
1036 if (rc != 0) {
1037 unadd_ping_req(nb, pingcookie, last_ping_time);
1038
1039 while (list_empty(&(cr->msgs)) == 0) {
1040 struct control_msg_out *cm = container_of(cr->msgs.prev,
1041 struct control_msg_out, lh);
1042 list_del(&(cm->lh));
1043 add_control_msg(cm, 1);
1044 }
1045
1046 if (split_conndata != 0) {
1047 add_control_msg(split_conndata, 1);
1048 }
1049
1050 kref_put(&(cr->ref), free_control_retrans);
1051 } else {
1052 struct list_head *curr = cr->msgs.next;
1053
1054 while(curr != &(cr->msgs)) {
1055 struct control_msg_out *cm = container_of(curr,
1056 struct control_msg_out, lh);
1057
1058 curr = curr->next;
1059
1060 if (cm->type == MSGTYPE_CONNDATA) {
1061 list_del(&(cm->lh));
1062 kfree(cm->msg.conn_data.data_orig);
1063 free_control_msg(cm);
1064 }
1065 }
1066
1067 if (split_conndata != 0) {
1068 BUG_ON(sc_sendlen == 0);
1069 BUG_ON(sc_sendlen >=
1070 split_conndata->msg.conn_data.datalen);
1071
1072 split_conndata->msg.conn_data.data += sc_sendlen;
1073 split_conndata->msg.conn_data.datalen -= sc_sendlen;
1074
1075 send_conndata(split_conndata,
1076 split_conndata->msg.conn_data.conn_id,
1077 split_conndata->msg.conn_data.seqno,
1078 split_conndata->msg.conn_data.data_orig,
1079 split_conndata->msg.conn_data.data,
1080 split_conndata->msg.conn_data.datalen);
1081 }
1082
1083
1084 if (list_empty(&(cr->msgs)))
1085 kref_put(&(cr->ref), free_control_retrans);
1086 else
1087 schedule_retransmit(cr, nb);
1088 }
1089
1090 return rc;
1091 }
1092
1093 static __u32 get_total_messages_length(struct neighbor *nb, int ping,
1094 int urgentonly)
1095 {
1096 __u32 length = nb->ucmlength;
1097
1098 if (likely(urgentonly == 0)) {
1099 length += nb->cmlength;
1100
1101 if (unlikely(nb->max_cmsg_delay_sent == 0))
1102 length += 5;
1103 }
1104 if (ping == 2 || (length > 0 && ping != 0))
1105 length += 5;
1106
1107 return length;
1108 }
1109
1110 static int reset_timeouted_conn_needed(struct neighbor *nb,
1111 struct conn *src_in_l)
1112 {
1113 if (unlikely(unlikely(src_in_l->sourcetype != SOURCE_IN) ||
1114 unlikely(src_in_l->source.in.nb != nb) ||
1115 unlikely(src_in_l->isreset != 0)))
1116 return 0;
1117 else if (likely(time_after(src_in_l->source.in.jiffies_last_act +
1118 CONN_ACTIVITY_UPDATEINTERVAL_SEC * HZ +
1119 CONN_INACTIVITY_TIMEOUT_SEC * HZ, jiffies)))
1120 return 0;
1121
1122 return 1;
1123 }
1124
1125 static int reset_timeouted_conn(struct neighbor *nb, struct conn *src_in)
1126 {
1127 int resetted = 0;
1128
1129 if (src_in->is_client) {
1130 mutex_lock(&(src_in->rcv_lock));
1131 mutex_lock(&(src_in->reversedir->rcv_lock));
1132 } else {
1133 mutex_lock(&(src_in->reversedir->rcv_lock));
1134 mutex_lock(&(src_in->rcv_lock));
1135 }
1136
1137 resetted = reset_timeouted_conn_needed(nb, src_in);
1138 if (unlikely(resetted == 0))
1139 goto unlock;
1140
1141 resetted = (send_reset_conn(nb, src_in->reversedir->target.out.conn_id,
1142 src_in->source.in.conn_id, 1) == 0);
1143 if (unlikely(resetted == 0))
1144 goto unlock;
1145
1146
1147 BUG_ON(src_in->reversedir->isreset != 0);
1148 src_in->reversedir->isreset = 1;
1149
1150 unlock:
1151 if (src_in->is_client) {
1152 mutex_unlock(&(src_in->rcv_lock));
1153 mutex_unlock(&(src_in->reversedir->rcv_lock));
1154 } else {
1155 mutex_unlock(&(src_in->reversedir->rcv_lock));
1156 mutex_unlock(&(src_in->rcv_lock));
1157 }
1158
1159 if (resetted)
1160 reset_conn(src_in);
1161
1162 return resetted;
1163 }
1164
1165 static void reset_timeouted_conns(struct neighbor *nb)
1166 {
1167 int i;
1168 for (i=0;i<10000;i++) {
1169 unsigned long iflags;
1170 struct conn *src_in;
1171
1172 int resetted = 1;
1173
1174 spin_lock_irqsave(&(nb->conn_list_lock), iflags);
1175
1176 if (list_empty(&(nb->rcv_conn_list))) {
1177 spin_unlock_irqrestore(&(nb->conn_list_lock), iflags);
1178 break;
1179 }
1180
1181 src_in = container_of(nb->rcv_conn_list.next, struct conn,
1182 source.in.nb_list);
1183 kref_get(&(src_in->ref));
1184
1185 spin_unlock_irqrestore(&(nb->conn_list_lock), iflags);
1186
1187
1188 mutex_lock(&(src_in->rcv_lock));
1189 resetted = reset_timeouted_conn_needed(nb, src_in);
1190 mutex_unlock(&(src_in->rcv_lock));
1191 if (likely(resetted == 0))
1192 goto put;
1193
1194 resetted = reset_timeouted_conn(nb, src_in);
1195
1196 put:
1197 kref_put(&(src_in->ref), free_conn);
1198
1199 if (likely(resetted == 0))
1200 break;
1201 }
1202 }
1203
1204 int send_messages(struct neighbor *nb, int resume)
1205 {
1206 int i;
1207 int rc = 0;
1208 int ping;
1209 int targetmss = mss(nb);
1210
1211 int nbstate = get_neigh_state(nb);
1212 int urgentonly = (nbstate != NEIGHBOR_STATE_ACTIVE);
1213
1214 if (likely(urgentonly == 0))
1215 reset_timeouted_conns(nb);
1216
1217 mutex_lock(&(nb->send_cmsg_lock));
1218 mutex_lock(&(nb->cmsg_lock));
1219
1220 ping = time_to_send_ping(nb);
1221
1222 for (i=0;1;i++) {
1223 __u32 length;
1224
1225 __u32 seqno;
1226 struct sk_buff *skb;
1227 struct control_retrans *cr;
1228
1229 BUG_ON(list_empty(&(nb->control_msgs_out)) &&
1230 (nb->cmlength != 0));
1231 BUG_ON((list_empty(&(nb->control_msgs_out)) == 0) &&
1232 (nb->cmlength == 0));
1233 BUG_ON(list_empty(&(nb->ucontrol_msgs_out)) &&
1234 (nb->ucmlength != 0));
1235 BUG_ON((list_empty(&(nb->ucontrol_msgs_out)) == 0) &&
1236 (nb->ucmlength == 0));
1237 BUG_ON(nb->cmlength < 0);
1238 BUG_ON(nb->ucmlength < 0);
1239
1240 length = get_total_messages_length(nb, ping, urgentonly);
1241
1242 if (length == 0)
1243 break;
1244
1245 if (length < targetmss && i > 0)
1246 break;
1247
1248 seqno = atomic_add_return(1, &(nb->kpacket_seqno));
1249
1250 if (length > targetmss)
1251 length = targetmss;
1252
1253 mutex_unlock(&(nb->cmsg_lock));
1254 skb = create_packet(nb, length, GFP_KERNEL, 0, seqno);
1255 if (unlikely(skb == 0)) {
1256 printk(KERN_ERR "cor: send_messages: cannot allocate "
1257 "skb (out of memory?)");
1258 goto oom;
1259 }
1260
1261 cr = kmem_cache_alloc(controlretrans_slab, GFP_KERNEL);
1262 if (unlikely(cr == 0)) {
1263 kfree_skb(skb);
1264 printk(KERN_ERR "cor: send_messages: cannot allocate "
1265 "control_retrans (out of memory?)");
1266 goto oom;
1267 }
1268 memset(cr, 0, sizeof(struct control_retrans));
1269 kref_init(&(cr->ref));
1270 cr->nb = nb;
1271 cr->seqno = seqno;
1272 INIT_LIST_HEAD(&(cr->msgs));
1273
1274 rc = _send_messages(nb, skb, ping, cr, length, urgentonly);
1275 ping = 0;
1276
1277 mutex_lock(&(nb->cmsg_lock));
1278
1279 if (rc != 0)
1280 break;
1281 }
1282
1283 if (0) {
1284 oom:
1285 mutex_lock(&(nb->cmsg_lock));
1286 }
1287
1288 if (rc != 0) {
1289 if (resume == 0)
1290 qos_enqueue(nb->dev, &(nb->rb_kp), QOS_CALLER_KPACKET);
1291 } else {
1292 atomic_set(&(nb->cmsg_work_scheduled), 0);
1293 schedule_controlmsg_timer(nb);
1294 }
1295
1296 mutex_unlock(&(nb->cmsg_lock));
1297 mutex_unlock(&(nb->send_cmsg_lock));
1298
1299 if (rc == 0)
1300 kref_put(&(nb->ref), neighbor_free);
1301
1302 return rc;
1303 }
1304
1305 void controlmsg_workfunc(struct work_struct *work)
1306 {
1307 struct neighbor *nb = container_of(work, struct neighbor, cmsg_work);
1308 send_messages(nb, 0);
1309 }
1310
1311 static void schedule_cmsg_work(struct neighbor *nb)
1312 {
1313 if (atomic_cmpxchg(&(nb->cmsg_work_scheduled), 0, 1) == 0) {
1314 kref_get(&(nb->ref));
1315 atomic_cmpxchg(&(nb->cmsg_timer_running), 1, 2);
1316 schedule_work(&(nb->cmsg_work));
1317 }
1318 }
1319
1320 void controlmsg_timerfunc(unsigned long arg)
1321 {
1322 struct neighbor *nb = (struct neighbor *) arg;
1323
1324 int oldval = atomic_xchg(&(nb->cmsg_timer_running), 0);
1325
1326 BUG_ON(oldval == 0);
1327
1328 if (likely(oldval == 1))
1329 schedule_cmsg_work(nb);
1330 kref_put(&(nb->ref), neighbor_free);
1331 }
1332
1333 static unsigned long get_cmsg_timeout(struct neighbor *nb, int nbstate)
1334 {
1335 unsigned long timeout = get_next_ping_time(nb);
1336
1337 if (likely(nbstate == NEIGHBOR_STATE_ACTIVE) &&
1338 list_empty(&(nb->control_msgs_out)) == 0) {
1339 struct control_msg_out *first = container_of(
1340 nb->control_msgs_out.next,
1341 struct control_msg_out, lh);
1342 if (time_before(first->timeout, jiffies +
1343 usecs_to_jiffies(nb->cmsg_interval)))
1344 timeout = jiffies;
1345 else if (time_before(first->timeout, timeout))
1346 timeout = first->timeout;
1347 }
1348
1349 if (list_empty(&(nb->ucontrol_msgs_out)) == 0) {
1350 struct control_msg_out *first = container_of(
1351 nb->ucontrol_msgs_out.next,
1352 struct control_msg_out, lh);
1353 if (time_before(first->timeout, jiffies +
1354 usecs_to_jiffies(nb->cmsg_interval)))
1355 timeout = jiffies;
1356 else if (time_before(first->timeout, timeout))
1357 timeout = first->timeout;
1358 }
1359
1360 return timeout;
1361 }
1362
1363 static int cmsg_full_packet(struct neighbor *nb, int nbstate)
1364 {
1365 int ping = time_to_send_ping(nb);
1366 int urgentonly = (nbstate != NEIGHBOR_STATE_ACTIVE);
1367 __u32 len = get_total_messages_length(nb, ping, urgentonly);
1368
1369 if (len == 0)
1370 return 0;
1371 if (len < mss(nb))
1372 return 0;
1373
1374 return 1;
1375 }
1376
1377 void schedule_controlmsg_timer(struct neighbor *nb)
1378 {
1379 unsigned long timeout;
1380 int state = get_neigh_state(nb);
1381
1382 if (unlikely(state == NEIGHBOR_STATE_KILLED)) {
1383 atomic_cmpxchg(&(nb->cmsg_timer_running), 1, 2);
1384 return;
1385 }
1386
1387 if (unlikely(atomic_read(&(nb->cmsg_work_scheduled)) == 1))
1388 return;
1389
1390 if (cmsg_full_packet(nb, state))
1391 goto now;
1392
1393 timeout = get_cmsg_timeout(nb, state);
1394
1395 if (time_before_eq(timeout, jiffies)) {
1396 now:
1397 schedule_cmsg_work(nb);
1398 } else {
1399 if (atomic_xchg(&(nb->cmsg_timer_running), 1) == 0)
1400 kref_get(&(nb->ref));
1401 mod_timer(&(nb->cmsg_timer), timeout);
1402 }
1403 }
1404
1405 static void free_oldest_ucm(struct neighbor *nb)
1406 {
1407 struct control_msg_out *cm = container_of(nb->ucontrol_msgs_out.next,
1408 struct control_msg_out, lh);
1409
1410 BUG_ON(list_empty(&(nb->ucontrol_msgs_out)));
1411 BUG_ON(isurgent(cm) == 0);
1412
1413 list_del(&(cm->lh));
1414 nb->ucmlength -= cm->length;
1415 atomic_dec(&(nb->ucmcnt));
1416 free_control_msg(cm);
1417 }
1418
1419 static void add_control_msg(struct control_msg_out *cm, int retrans)
1420 {
1421 int nbstate;
1422 __u64 newinterval;
1423 unsigned long jiffies_tmp;
1424
1425 BUG_ON(cm->nb == 0);
1426
1427 nbstate = get_neigh_state(cm->nb);
1428
1429 BUG_ON(cm == 0);
1430 BUG_ON(cm->lh.next != LIST_POISON1 || cm->lh.prev != LIST_POISON2);
1431
1432 cm->timeout = jiffies + msecs_to_jiffies(CMSG_INTERVAL_MS);
1433
1434 mutex_lock(&(cm->nb->cmsg_lock));
1435
1436 if (isurgent(cm)) {
1437 long msgs;
1438
1439 msgs = atomic_inc_return(&(cm->nb->ucmcnt));
1440 BUG_ON(msgs <= 0);
1441
1442 if (unlikely(retrans)) {
1443 if (msgs > MAX_URGENT_CMSGS_PER_NEIGH_RETRANSALLOW ||
1444 msgs > MAX_URGENT_CMSGS_PER_NEIGH) {
1445 atomic_dec(&(cm->nb->ucmcnt));
1446 free_control_msg(cm);
1447 goto out;
1448 }
1449
1450 cm->nb->ucmlength += cm->length;
1451 list_add(&(cm->lh), &(cm->nb->ucontrol_msgs_out));
1452 } else {
1453 if (msgs > MAX_URGENT_CMSGS_PER_NEIGH) {
1454 free_oldest_ucm(cm->nb);
1455 }
1456
1457 cm->nb->ucmlength += cm->length;
1458 list_add_tail(&(cm->lh), &(cm->nb->ucontrol_msgs_out));
1459 }
1460 } else {
1461 cm->nb->cmlength += cm->length;
1462 list_add_tail(&(cm->lh), &(cm->nb->control_msgs_out));
1463 }
1464
1465 jiffies_tmp = jiffies;
1466 newinterval = (((__u64) cm->nb->cmsg_interval) * 255 +
1467 jiffies_to_usecs(jiffies_tmp -
1468 cm->nb->jiffies_last_cmsg)) / 256;
1469 cm->nb->jiffies_last_cmsg = jiffies_tmp;
1470 if (unlikely(newinterval > (1LL << 32) - 1))
1471 cm->nb->cmsg_interval = (__u32) ((1LL << 32) - 1);
1472 else
1473 cm->nb->cmsg_interval = newinterval;
1474
1475 schedule_controlmsg_timer(cm->nb);
1476
1477 out:
1478 mutex_unlock(&(cm->nb->cmsg_lock));
1479 }
1480
1481 void send_pong(struct neighbor *nb, __u32 cookie)
1482 {
1483 struct control_msg_out *cm = _alloc_control_msg(nb, 0, 1);
1484
1485 if (unlikely(cm == 0))
1486 return;
1487
1488 cm->nb = nb;
1489 cm->type = MSGTYPE_PONG;
1490 cm->msg.pong.cookie = cookie;
1491 cm->msg.pong.type = MSGTYPE_PONG_TIMEENQUEUED;
1492 cm->msg.pong.delaycomp.time_enqueued = ktime_get();
1493 cm->length = 9;
1494 add_control_msg(cm, 0);
1495 }
1496
1497 int send_reset_conn(struct neighbor *nb, __u32 conn_id_reset,
1498 __u32 conn_id_unknown, int lowprio)
1499 {
1500 unsigned long iflags;
1501 int killed;
1502 struct control_msg_out *cm;
1503 struct unknownconnid_matchparam ucm;
1504
1505 spin_lock_irqsave(&(nb->state_lock), iflags);
1506 killed = (nb->state == NEIGHBOR_STATE_KILLED);
1507 spin_unlock_irqrestore(&(nb->state_lock), iflags);
1508
1509 if (unlikely(killed))
1510 return 0;
1511
1512 cm = alloc_control_msg(nb, lowprio ?
1513 ACM_PRIORITY_LOW : ACM_PRIORITY_HIGH);
1514
1515 if (unlikely(cm == 0))
1516 return 1;
1517
1518 cm->type = MSGTYPE_RESET_CONN;
1519 cm->msg.reset_connidunknown.conn_id_reset = conn_id_reset;
1520 cm->msg.reset_connidunknown.conn_id_unknown = conn_id_unknown;
1521 cm->length = 5;
1522
1523 if (conn_id_unknown != 0) {
1524 ucm.nb = nb;
1525 ucm.conn_id = conn_id_unknown;
1526
1527 spin_lock_irqsave(&unknown_connids_lock, iflags);
1528 BUG_ON(htable_get(&unknown_connids, ucm_to_key(&ucm), &ucm) !=
1529 0);
1530 htable_insert(&unknown_connids, (char *) cm, ucm_to_key(&ucm));
1531 spin_unlock_irqrestore(&unknown_connids_lock, iflags);
1532 }
1533
1534 add_control_msg(cm, 0);
1535
1536 return 0;
1537 }
1538
1539 void send_ack(struct neighbor *nb, __u32 seqno)
1540 {
1541 struct control_msg_out *cm = _alloc_control_msg(nb, 0, 1);
1542
1543 if (unlikely(cm == 0))
1544 return;
1545
1546 cm->nb = nb;
1547 cm->type = MSGTYPE_ACK;
1548 cm->msg.ack.seqno = seqno;
1549 cm->length = 5;
1550 add_control_msg(cm, 0);
1551 }
1552
1553 static void set_ooolen_flags(struct control_msg_out *cm)
1554 {
1555 cm->msg.ack_conn.flags = (cm->msg.ack_conn.flags &
1556 (~KP_ACK_CONN_FLAGS_OOO));
1557 cm->msg.ack_conn.flags = (cm->msg.ack_conn.flags |
1558 ooolen_to_flags(cm->msg.ack_conn.length));
1559 }
1560
1561 /* cmsg_lock must be held */
1562 static void remove_pending_ackconn(struct control_msg_out *cm)
1563 {
1564 cm->nb->cmlength -= cm->length;
1565 list_del(&(cm->lh));
1566
1567 list_del(&(cm->msg.ack_conn.conn_acks));
1568 kref_put(&(cm->msg.ack_conn.src_in->ref), free_conn);
1569 cm->msg.ack_conn.src_in = 0;
1570
1571 cm->type = 0;
1572 free_control_msg(cm);
1573 }
1574
1575 /* cmsg_lock must be held */
1576 static void recalc_scheduled_ackconn_size(struct control_msg_out *cm)
1577 {
1578 cm->nb->cmlength -= cm->length;
1579 cm->length = 6 + ack_conn_len(cm->msg.ack_conn.flags);
1580 cm->nb->cmlength += cm->length;
1581 }
1582
1583 /* cmsg_lock must be held */
1584 static int _try_merge_ackconn(struct conn *src_in_l,
1585 struct control_msg_out *fromcm, struct control_msg_out *tocm,
1586 int from_newack)
1587 {
1588 if (ooolen(fromcm->msg.ack_conn.flags) != 0 &&
1589 ooolen(tocm->msg.ack_conn.flags) != 0) {
1590 __u32 tocmseqno = tocm->msg.ack_conn.seqno_ooo;
1591 __u32 tocmlength = tocm->msg.ack_conn.length;
1592 __u32 fromcmseqno = fromcm->msg.ack_conn.seqno_ooo;
1593 __u32 fromcmlength = fromcm->msg.ack_conn.length;
1594
1595 if (tocmseqno == fromcmseqno) {
1596 if (fromcmlength > tocmlength)
1597 tocm->msg.ack_conn.length = fromcmlength;
1598 } else if (seqno_after(fromcmseqno, tocmseqno) &&
1599 seqno_before_eq(fromcmseqno, tocmseqno +
1600 tocmlength)) {
1601 tocm->msg.ack_conn.length = fromcmseqno + fromcmlength -
1602 tocmseqno;
1603 } else if (seqno_before(fromcmseqno, tocmseqno) &&
1604 seqno_after_eq(fromcmseqno, tocmseqno)) {
1605 tocm->msg.ack_conn.seqno_ooo = fromcmseqno;
1606 tocm->msg.ack_conn.length = tocmseqno + tocmlength -
1607 fromcmseqno;
1608 } else {
1609 return 1;
1610 }
1611 set_ooolen_flags(tocm);
1612 }
1613
1614 if ((fromcm->msg.ack_conn.flags &
1615 KP_ACK_CONN_FLAGS_SEQNO) != 0) {
1616 if ((tocm->msg.ack_conn.flags & KP_ACK_CONN_FLAGS_SEQNO) == 0)
1617 goto setseqno;
1618
1619 BUG_ON(fromcm->msg.ack_conn.ack_seqno ==
1620 tocm->msg.ack_conn.ack_seqno);
1621 if ((tocm->msg.ack_conn.ack_seqno -
1622 fromcm->msg.ack_conn.ack_seqno) < (1 << 31)) {
1623 BUG_ON(seqno_after(fromcm->msg.ack_conn.seqno,
1624 tocm->msg.ack_conn.seqno));
1625 goto skipseqno;
1626 }
1627
1628 BUG_ON(seqno_before(fromcm->msg.ack_conn.seqno,
1629 tocm->msg.ack_conn.seqno));
1630
1631 setseqno:
1632 tocm->msg.ack_conn.flags = (tocm->msg.ack_conn.flags |
1633 KP_ACK_CONN_FLAGS_SEQNO);
1634 tocm->msg.ack_conn.seqno = fromcm->msg.ack_conn.seqno;
1635 tocm->msg.ack_conn.ack_seqno = fromcm->msg.ack_conn.ack_seqno;
1636
1637 skipseqno:
1638 if ((fromcm->msg.ack_conn.flags &
1639 KP_ACK_CONN_FLAGS_WINDOW) != 0)
1640 tocm->msg.ack_conn.flags = (tocm->msg.ack_conn.flags |
1641 KP_ACK_CONN_FLAGS_WINDOW);
1642 }
1643
1644
1645 if (ooolen(fromcm->msg.ack_conn.flags) != 0) {
1646 tocm->msg.ack_conn.seqno_ooo = fromcm->msg.ack_conn.seqno_ooo;
1647 tocm->msg.ack_conn.length = fromcm->msg.ack_conn.length;
1648 set_ooolen_flags(tocm);
1649 }
1650
1651 if ((fromcm->msg.ack_conn.flags & KP_ACK_CONN_FLAGS_CREDITS) != 0) {
1652 BUG_ON((tocm->msg.ack_conn.flags &
1653 KP_ACK_CONN_FLAGS_CREDITS) != 0);
1654 tocm->msg.ack_conn.decaytime_seqno =
1655 fromcm->msg.ack_conn.decaytime_seqno;
1656 tocm->msg.ack_conn.decaytime =
1657 fromcm->msg.ack_conn.decaytime;
1658 }
1659
1660 recalc_scheduled_ackconn_size(tocm);
1661 if (from_newack)
1662 kref_put(&(fromcm->msg.ack_conn.src_in->ref), free_conn);
1663 else
1664 remove_pending_ackconn(fromcm);
1665
1666 return 0;
1667 }
1668
1669 /* cmsg_lock must be held */
1670 static void try_merge_ackconns(struct conn *src_in_l,
1671 struct control_msg_out *cm)
1672 {
1673 struct list_head *currlh = cm->msg.ack_conn.conn_acks.next;
1674
1675 while (currlh != &(src_in_l->source.in.acks_pending)) {
1676 struct control_msg_out *currcm = container_of(currlh,
1677 struct control_msg_out,
1678 msg.ack_conn.conn_acks);
1679 currlh = currlh->next;
1680 remove_connack_oooflag_ifold(src_in_l, currcm);
1681 _try_merge_ackconn(src_in_l, currcm, cm, 0);
1682 }
1683 }
1684
1685 static void mergeadd_ackconn(struct conn *src_in_l, struct control_msg_out *cm)
1686 {
1687 struct list_head *currlh;
1688
1689 BUG_ON(src_in_l->sourcetype != SOURCE_IN);
1690
1691 mutex_lock(&(cm->nb->cmsg_lock));
1692
1693 currlh = src_in_l->source.in.acks_pending.next;
1694
1695 while (currlh != &(src_in_l->source.in.acks_pending)) {
1696 struct control_msg_out *currcm = container_of(currlh,
1697 struct control_msg_out,
1698 msg.ack_conn.conn_acks);
1699
1700 BUG_ON(currcm->nb != cm->nb);
1701 BUG_ON(currcm->type != MSGTYPE_ACK_CONN);
1702 BUG_ON(cm->msg.ack_conn.src_in != src_in_l);
1703 BUG_ON(currcm->msg.ack_conn.conn_id !=
1704 cm->msg.ack_conn.conn_id);
1705
1706 if (_try_merge_ackconn(src_in_l, cm, currcm, 1) == 0) {
1707 try_merge_ackconns(src_in_l, currcm);
1708 schedule_controlmsg_timer(currcm->nb);
1709 mutex_unlock(&(currcm->nb->cmsg_lock));
1710 return;
1711 }
1712
1713 currlh = currlh->next;
1714 }
1715
1716 list_add_tail(&(cm->msg.ack_conn.conn_acks),
1717 &(src_in_l->source.in.acks_pending));
1718
1719 mutex_unlock(&(cm->nb->cmsg_lock));
1720
1721 add_control_msg(cm, 0);
1722 }
1723
1724 static int try_update_ackconn_seqno(struct conn *src_in_l)
1725 {
1726 int rc = 1;
1727
1728 mutex_lock(&(src_in_l->source.in.nb->cmsg_lock));
1729
1730 if (list_empty(&(src_in_l->source.in.acks_pending)) == 0) {
1731 struct control_msg_out *cm = container_of(
1732 src_in_l->source.in.acks_pending.next,
1733 struct control_msg_out,
1734 msg.ack_conn.conn_acks);
1735 BUG_ON(cm->nb != src_in_l->source.in.nb);
1736 BUG_ON(cm->type != MSGTYPE_ACK_CONN);
1737 BUG_ON(cm->msg.ack_conn.src_in != src_in_l);
1738 BUG_ON(cm->msg.ack_conn.conn_id !=
1739 src_in_l->reversedir->target.out.conn_id);
1740
1741 cm->msg.ack_conn.flags = (cm->msg.ack_conn.flags |
1742 KP_ACK_CONN_FLAGS_SEQNO |
1743 KP_ACK_CONN_FLAGS_WINDOW);
1744 cm->msg.ack_conn.seqno = src_in_l->source.in.next_seqno;
1745
1746 src_in_l->source.in.ack_seqno++;
1747 cm->msg.ack_conn.ack_seqno = src_in_l->source.in.ack_seqno;
1748
1749 remove_connack_oooflag_ifold(src_in_l, cm);
1750 recalc_scheduled_ackconn_size(cm);
1751
1752 try_merge_ackconns(src_in_l, cm);
1753
1754 rc = 0;
1755 }
1756
1757 mutex_unlock(&(src_in_l->source.in.nb->cmsg_lock));
1758
1759 return rc;
1760 }
1761
1762 void send_ack_conn_ifneeded(struct conn *src_in_l)
1763 {
1764 struct control_msg_out *cm;
1765
1766 BUG_ON(src_in_l->sourcetype != SOURCE_IN);
1767
1768 if (src_in_l->source.in.inorder_ack_needed == 0 &&
1769 ((src_in_l->source.in.window_seqnolimit -
1770 src_in_l->source.in.next_seqno)/2) <
1771 (src_in_l->source.in.window_seqnolimit_remote -
1772 src_in_l->source.in.next_seqno))
1773 return;
1774
1775 if (try_update_ackconn_seqno(src_in_l) == 0)
1776 goto out;
1777
1778 cm = alloc_control_msg(src_in_l->source.in.nb, ACM_PRIORITY_LOW);
1779 if (cm == 0)
1780 return;
1781
1782 cm->type = MSGTYPE_ACK_CONN;
1783 cm->msg.ack_conn.flags = KP_ACK_CONN_FLAGS_SEQNO |
1784 KP_ACK_CONN_FLAGS_WINDOW;
1785 kref_get(&(src_in_l->ref));
1786 cm->msg.ack_conn.src_in = src_in_l;
1787 cm->msg.ack_conn.conn_id = src_in_l->reversedir->target.out.conn_id;
1788 cm->msg.ack_conn.seqno = src_in_l->source.in.next_seqno;
1789 src_in_l->source.in.ack_seqno++;
1790 cm->msg.ack_conn.ack_seqno = src_in_l->source.in.ack_seqno;
1791 cm->length = 6 + ack_conn_len(cm->msg.ack_conn.flags);
1792
1793 mergeadd_ackconn(src_in_l, cm);
1794
1795 out:
1796 src_in_l->source.in.inorder_ack_needed = 0;
1797 src_in_l->source.in.window_seqnolimit_remote =
1798 src_in_l->source.in.window_seqnolimit;
1799 }
1800
1801 void send_ack_conn_ooo(struct control_msg_out *cm, struct conn *src_in_l,
1802 __u32 conn_id, __u32 seqno_ooo, __u32 length)
1803 {
1804 cm->type = MSGTYPE_ACK_CONN;
1805 kref_get(&(src_in_l->ref));
1806 BUG_ON(src_in_l->sourcetype != SOURCE_IN);
1807 cm->msg.ack_conn.flags = 0;
1808 cm->msg.ack_conn.src_in = src_in_l;
1809 cm->msg.ack_conn.conn_id = conn_id;
1810 cm->msg.ack_conn.seqno_ooo = seqno_ooo;
1811 cm->msg.ack_conn.length = length;
1812 set_ooolen_flags(cm);
1813 cm->length = 6 + ack_conn_len(cm->msg.ack_conn.flags);
1814
1815 mergeadd_ackconn(src_in_l, cm);
1816 }
1817
1818 static int try_add_decaytime(struct conn *trgt_out_l, __u16 decaytime)
1819 {
1820 int rc = 1;
1821 struct conn *src_in = trgt_out_l->reversedir;
1822
1823 mutex_lock(&(trgt_out_l->target.out.nb->cmsg_lock));
1824
1825 if (list_empty(&(src_in->source.in.acks_pending)) == 0) {
1826 struct control_msg_out *cm = container_of(
1827 src_in->source.in.acks_pending.next,
1828 struct control_msg_out,
1829 msg.ack_conn.conn_acks);
1830 BUG_ON(cm->nb != trgt_out_l->target.out.nb);
1831 BUG_ON(cm->type != MSGTYPE_ACK_CONN);
1832 BUG_ON(cm->msg.ack_conn.src_in != trgt_out_l->reversedir);
1833 BUG_ON(cm->msg.ack_conn.conn_id !=
1834 trgt_out_l->target.out.conn_id);
1835
1836 BUG_ON((cm->msg.ack_conn.flags & KP_ACK_CONN_FLAGS_CREDITS) !=
1837 0);
1838 cm->msg.ack_conn.flags = (cm->msg.ack_conn.flags |
1839 KP_ACK_CONN_FLAGS_CREDITS);
1840 cm->msg.ack_conn.decaytime_seqno =
1841 trgt_out_l->target.out.decaytime_seqno;
1842 cm->msg.ack_conn.decaytime = decaytime;
1843 recalc_scheduled_ackconn_size(cm);
1844
1845 rc = 0;
1846 }
1847
1848 mutex_unlock(&(trgt_out_l->target.out.nb->cmsg_lock));
1849
1850 return rc;
1851 }
1852
1853 void send_decaytime(struct conn *trgt_out_l, int force, __u16 decaytime)
1854 {
1855 struct control_msg_out *cm;
1856
1857 if (try_add_decaytime(trgt_out_l, decaytime) == 0)
1858 goto out;
1859
1860 if (force == 0)
1861 return;
1862
1863 cm = alloc_control_msg(trgt_out_l->target.out.nb, ACM_PRIORITY_LOW);
1864
1865 if (cm == 0)
1866 return;
1867
1868 cm->type = MSGTYPE_ACK_CONN;
1869 cm->msg.ack_conn.flags = KP_ACK_CONN_FLAGS_CREDITS;
1870 kref_get(&(trgt_out_l->reversedir->ref));
1871 BUG_ON(trgt_out_l->targettype != TARGET_OUT);
1872 cm->msg.ack_conn.src_in = trgt_out_l->reversedir;
1873 cm->msg.ack_conn.conn_id = trgt_out_l->target.out.conn_id;
1874 cm->msg.ack_conn.decaytime_seqno =
1875 trgt_out_l->target.out.decaytime_seqno;
1876 cm->msg.ack_conn.decaytime = decaytime;
1877
1878 cm->length = 6 + ack_conn_len(cm->msg.ack_conn.flags);
1879 mergeadd_ackconn(trgt_out_l, cm);
1880
1881 out:
1882 trgt_out_l->target.out.decaytime_last = decaytime;
1883 trgt_out_l->target.out.decaytime_seqno =
1884 (trgt_out_l->target.out.decaytime_seqno + 1) % 64;
1885 trgt_out_l->target.out.decaytime_send_allowed = 0;
1886 }
1887
1888 void free_ack_conns(struct conn *src_in_l)
1889 {
1890 int changed = 0;
1891 mutex_lock(&(src_in_l->source.in.nb->cmsg_lock));
1892 while (list_empty(&(src_in_l->source.in.acks_pending)) == 0) {
1893 struct list_head *currlh =
1894 src_in_l->source.in.acks_pending.next;
1895 struct control_msg_out *currcm = container_of(currlh,
1896 struct control_msg_out,
1897 msg.ack_conn.conn_acks);
1898
1899 remove_pending_ackconn(currcm);
1900 changed = 1;
1901 }
1902 if (changed)
1903 schedule_controlmsg_timer(src_in_l->source.in.nb);
1904 mutex_unlock(&(src_in_l->source.in.nb->cmsg_lock));
1905 }
1906
1907 void send_connect_success(struct control_msg_out *cm, __u32 rcvd_conn_id,
1908 __u32 gen_conn_id, __u32 init_seqno, struct conn *src_in)
1909 {
1910 cm->type = MSGTYPE_CONNECT_SUCCESS;
1911 cm->msg.connect_success.rcvd_conn_id = rcvd_conn_id;
1912 cm->msg.connect_success.gen_conn_id = gen_conn_id;
1913 cm->msg.connect_success.init_seqno = init_seqno;
1914 kref_get(&(src_in->ref));
1915 cm->msg.connect_success.src_in = src_in;
1916 cm->length = 16;
1917 add_control_msg(cm, 0);
1918 }
1919
1920 void send_connect_nb(struct control_msg_out *cm, __u32 conn_id,
1921 __u32 init_seqno, struct conn *src_in)
1922 {
1923 cm->type = MSGTYPE_CONNECT;
1924 cm->msg.connect.conn_id = conn_id;
1925 cm->msg.connect.init_seqno = init_seqno;
1926 kref_get(&(src_in->ref));
1927 BUG_ON(src_in->sourcetype != SOURCE_IN);
1928 cm->msg.connect.src_in = src_in;
1929 cm->length = 12;
1930 add_control_msg(cm, 0);
1931 }
1932
1933 #warning todo ref to buf instead
1934 void send_conndata(struct control_msg_out *cm, __u32 conn_id, __u32 seqno,
1935 char *data_orig, char *data, __u32 datalen)
1936 {
1937 cm->type = MSGTYPE_CONNDATA;
1938 cm->msg.conn_data.conn_id = conn_id;
1939 cm->msg.conn_data.seqno = seqno;
1940 cm->msg.conn_data.data_orig = data_orig;
1941 cm->msg.conn_data.data = data;
1942 cm->msg.conn_data.datalen = datalen;
1943 cm->length = 11 + datalen;
1944 add_control_msg(cm, 0);
1945 }
1946
1947 void send_connid_unknown(struct neighbor *nb, __u32 conn_id)
1948 {
1949 unsigned long iflags;
1950 char *ret;
1951 struct unknownconnid_matchparam ucm;
1952
1953 struct control_msg_out *cm = alloc_control_msg(nb, ACM_PRIORITY_HIGH);
1954
1955 if (unlikely(cm == 0))
1956 return;
1957
1958 cm->type = MSGTYPE_CONNID_UNKNOWN;
1959 cm->msg.reset_connidunknown.conn_id_unknown = conn_id;
1960 cm->length = 5;
1961
1962 ucm.nb = nb;
1963 ucm.conn_id = conn_id;
1964
1965 spin_lock_irqsave(&unknown_connids_lock, iflags);
1966 ret = htable_get(&unknown_connids, ucm_to_key(&ucm), &ucm);
1967 if (ret == 0)
1968 htable_insert(&unknown_connids, (char *) cm, ucm_to_key(&ucm));
1969 spin_unlock_irqrestore(&unknown_connids_lock, iflags);
1970
1971 if (ret != 0) {
1972 struct control_msg_out *cm2 = (struct control_msg_out *) ret;
1973
1974 BUG_ON(cm2->type != MSGTYPE_RESET_CONN &&
1975 cm2->type != MSGTYPE_CONNID_UNKNOWN);
1976
1977 kref_put(&(cm2->ref), cmsg_kref_free);
1978
1979 cm->type = 0;
1980 free_control_msg(cm);
1981 } else {
1982 add_control_msg(cm, 0);
1983 }
1984 }
1985
1986
1987 static int matches_connretrans(void *htentry, void *searcheditem)
1988 {
1989 struct control_retrans *cr = (struct control_retrans *) htentry;
1990 struct retransmit_matchparam *rm = (struct retransmit_matchparam *)
1991 searcheditem;
1992
1993 return rm->nb == cr->nb && rm->seqno == cr->seqno;
1994 }
1995
1996 static int matches_unknownconnid(void *htentry, void *searcheditem)
1997 {
1998 struct control_msg_out *cm = (struct control_msg_out *) htentry;
1999
2000 struct unknownconnid_matchparam *ucm =
2001 (struct unknownconnid_matchparam *)searcheditem;
2002
2003 BUG_ON(cm->type != MSGTYPE_RESET_CONN &&
2004 cm->type != MSGTYPE_CONNID_UNKNOWN);
2005
2006 return ucm->nb == cm->nb && ucm->conn_id ==
2007 cm->msg.reset_connidunknown.conn_id_unknown;
2008 }
2009
2010 void __init cor_kgen_init(void)
2011 {
2012 controlmsg_slab = kmem_cache_create("cor_controlmsg",
2013 sizeof(struct control_msg_out), 8, 0, 0);
2014 controlretrans_slab = kmem_cache_create("cor_controlretransmsg",
2015 sizeof(struct control_retrans), 8, 0, 0);
2016 htable_init(&retransmits, matches_connretrans,
2017 offsetof(struct control_retrans, htab_entry),
2018 offsetof(struct control_retrans, ref));
2019 htable_init(&unknown_connids, matches_unknownconnid,
2020 offsetof(struct control_msg_out,
2021 msg.reset_connidunknown.htab_entry),
2022 offsetof(struct control_msg_out, ref));
2023 }
2024
2025 MODULE_LICENSE("GPL");
connection oriented routing - ARCHIVE NO UPDATES HERE