?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
remove nbstalled_list
[cor.git] / net / cor / conn_trgt_out.c
blobcb81e22a3f85372d58ad20532327cd51a222d8de
1 /**
2 * Connection oriented routing
3 * Copyright (C) 2007-2021 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 <linux/gfp.h>
22 #include <linux/jiffies.h>
23 #include <linux/slab.h>
24
25 #include "cor.h"
26
27 static struct kmem_cache *cor_connretrans_slab;
28
29
30 void cor_free_connretrans(struct kref *ref)
31 {
32 struct cor_conn_retrans *cr = container_of(ref, struct cor_conn_retrans,
33 ref);
34 struct cor_conn *cn = cr->trgt_out_o;
35
36 BUG_ON(cr->state != CONN_RETRANS_ACKED);
37
38 kmem_cache_free(cor_connretrans_slab, cr);
39 cor_conn_kref_put(cn, "conn_retrans");
40 }
41
42 static struct cor_conn_retrans *cor_peek_next_conn_retrans(
43 struct cor_neighbor *nb_retransconnlocked)
44 {
45 struct cor_conn_retrans *cr1 = 0;
46 struct cor_conn_retrans *cr2 = 0;
47
48 if (list_empty(&(nb_retransconnlocked->retrans_conn_lowlatency_list)) == 0)
49 cr1 = container_of(
50 nb_retransconnlocked->retrans_conn_lowlatency_list.next,
51 struct cor_conn_retrans, timeout_list);
52
53 if (list_empty(&(nb_retransconnlocked->retrans_conn_highlatency_list)) == 0)
54 cr2 = container_of(
55 nb_retransconnlocked->retrans_conn_highlatency_list.next,
56 struct cor_conn_retrans, timeout_list);
57
58 if (cr1 == 0)
59 return cr2;
60 if (cr2 == 0)
61 return cr1;
62
63 if (time_before_eq(cr1->timeout, jiffies))
64 return cr1;
65
66 if (time_before_eq(cr1->timeout, cr2->timeout))
67 return cr1;
68
69 return cr2;
70 }
71
72 void cor_reschedule_conn_retrans_timer(
73 struct cor_neighbor *nb_retransconnlocked)
74 {
75 struct cor_conn_retrans *cr =
76 cor_peek_next_conn_retrans(nb_retransconnlocked);
77
78 if (cr == 0)
79 return;
80
81 if (time_before_eq(cr->timeout, jiffies)) {
82 cor_qos_enqueue(nb_retransconnlocked->queue,
83 &(nb_retransconnlocked->rb_cr), 0,
84 ns_to_ktime(0), QOS_CALLER_CONN_RETRANS, 0);
85 } else {
86 if (mod_timer(&(nb_retransconnlocked->retrans_conn_timer),
87 cr->timeout) == 0) {
88 kref_get(&(nb_retransconnlocked->ref));
89 }
90 }
91 }
92
93 /**
94 * caller must also call kref_get/put, see cor_reschedule_conn_retrans_timer
95 */
96 static void cor_cancel_conn_retrans(struct cor_neighbor *nb_retransconnlocked,
97 struct cor_conn *trgt_out_lx, struct cor_conn_retrans *cr,
98 __u64 *bytes_acked)
99 {
100 if (unlikely(cr->state == CONN_RETRANS_ACKED))
101 return;
102
103 if (cr->state == CONN_RETRANS_SCHEDULED) {
104 list_del(&(cr->timeout_list));
105 kref_put(&(cr->ref), cor_kreffree_bug);
106 } else if (cr->state == CONN_RETRANS_LOWWINDOW) {
107 BUG_ON(trgt_out_lx->target.out.retrans_lowwindow == 0);
108 if (likely(trgt_out_lx->target.out.retrans_lowwindow != 65535))
109 trgt_out_lx->target.out.retrans_lowwindow--;
110 }
111
112 if (cr->state != CONN_RETRANS_INITIAL)
113 *bytes_acked += cr->length;
114
115 list_del(&(cr->conn_list));
116 cr->state = CONN_RETRANS_ACKED;
117
118 kref_put(&(cr->ref), cor_free_connretrans); /* conn_list */
119 }
120
121 /**
122 * nb->retrans_conn_lock must be held when calling this
123 * (see cor_schedule_retransmit_conn())
124 */
125 static void cor_cancel_acked_conn_retrans(struct cor_conn *trgt_out_l,
126 __u64 *bytes_acked)
127 {
128 __u64 seqno_acked = trgt_out_l->target.out.seqno_acked;
129
130 while (list_empty(&(trgt_out_l->target.out.retrans_list)) == 0) {
131 struct cor_conn_retrans *cr = container_of(
132 trgt_out_l->target.out.retrans_list.next,
133 struct cor_conn_retrans, conn_list);
134
135 if (cor_seqno_after(cr->seqno + cr->length, seqno_acked)) {
136 if (cor_seqno_before(cr->seqno, seqno_acked)) {
137 *bytes_acked += cor_seqno_clean(seqno_acked -
138 cr->seqno);
139 cr->length -= cor_seqno_clean(seqno_acked -
140 cr->seqno);
141 cr->seqno = seqno_acked;
142 }
143 break;
144 }
145
146 cor_cancel_conn_retrans(trgt_out_l->target.out.nb, trgt_out_l,
147 cr, bytes_acked);
148 }
149
150 cor_reschedule_conn_retrans_timer(trgt_out_l->target.out.nb);
151 }
152
153 void cor_cancel_all_conn_retrans(struct cor_conn *trgt_out_lx)
154 {
155 struct cor_neighbor *nb = trgt_out_lx->target.out.nb;
156 __u64 bytes_acked = 0;
157
158 spin_lock_bh(&(nb->retrans_conn_lock));
159
160 while (list_empty(&(trgt_out_lx->target.out.retrans_list)) == 0) {
161 struct cor_conn_retrans *cr = container_of(
162 trgt_out_lx->target.out.retrans_list.next,
163 struct cor_conn_retrans, conn_list);
164 BUG_ON(cr->trgt_out_o != trgt_out_lx);
165
166 cor_cancel_conn_retrans(nb, trgt_out_lx, cr, &bytes_acked);
167 }
168
169 cor_reschedule_conn_retrans_timer(nb);
170
171 spin_unlock_bh(&(nb->retrans_conn_lock));
172
173 if (bytes_acked > 0)
174 cor_nbcongwin_data_acked(nb, bytes_acked);
175 }
176
177 static void _cor_cancel_all_conn_retrans_nb(struct cor_neighbor *nb,
178 struct list_head *retrans_list, __u64 *bytes_acked)
179 {
180 while (1) {
181 struct cor_conn_retrans *cr;
182
183 spin_lock_bh(&(nb->retrans_conn_lock));
184
185 if (list_empty(retrans_list)) {
186 spin_unlock_bh(&(nb->retrans_conn_lock));
187 break;
188 }
189
190 cr = container_of(retrans_list->next, struct cor_conn_retrans,
191 timeout_list);
192
193 kref_get(&(cr->ref));
194
195 spin_unlock_bh(&(nb->retrans_conn_lock));
196
197
198 spin_lock_bh(&(cr->trgt_out_o->rcv_lock));
199 spin_lock_bh(&(nb->retrans_conn_lock));
200
201 if (likely(cr == container_of(retrans_list->next,
202 struct cor_conn_retrans, timeout_list)))
203 cor_cancel_conn_retrans(nb, cr->trgt_out_o, cr,
204 bytes_acked);
205
206 spin_unlock_bh(&(nb->retrans_conn_lock));
207 spin_unlock_bh(&(cr->trgt_out_o->rcv_lock));
208
209 kref_put(&(cr->ref), cor_free_connretrans);
210 }
211 }
212
213 static void cor_cancel_all_conn_retrans_nb(struct cor_neighbor *nb)
214 {
215 __u64 bytes_acked = 0;
216
217 _cor_cancel_all_conn_retrans_nb(nb,
218 &(nb->retrans_conn_lowlatency_list), &bytes_acked);
219 _cor_cancel_all_conn_retrans_nb(nb,
220 &(nb->retrans_conn_highlatency_list), &bytes_acked);
221
222 if (bytes_acked > 0)
223 cor_nbcongwin_data_acked(nb, bytes_acked);
224 }
225
226 static struct cor_conn_retrans *cor_prepare_conn_retrans(
227 struct cor_conn *trgt_out_l, __u64 seqno, __u32 len,
228 __u8 windowused, struct cor_conn_retrans *cr_splitted,
229 int retransconnlocked)
230 {
231 struct cor_neighbor *nb = trgt_out_l->target.out.nb;
232
233 struct cor_conn_retrans *cr = kmem_cache_alloc(cor_connretrans_slab,
234 GFP_ATOMIC);
235
236 if (unlikely(cr == 0))
237 return 0;
238
239 BUG_ON(trgt_out_l->isreset != 0);
240
241 memset(cr, 0, sizeof (struct cor_conn_retrans));
242 cr->trgt_out_o = trgt_out_l;
243 cor_conn_kref_get(trgt_out_l, "conn_retrans");
244 cr->seqno = seqno;
245 cr->length = len;
246 cr->windowused = windowused;
247 kref_init(&(cr->ref));
248
249 if (retransconnlocked == 0)
250 spin_lock_bh(&(nb->retrans_conn_lock));
251
252 if (cr_splitted != 0)
253 list_add(&(cr->conn_list), &(cr_splitted->conn_list));
254 else
255 list_add_tail(&(cr->conn_list),
256 &(cr->trgt_out_o->target.out.retrans_list));
257 kref_get(&(cr->ref)); /* conn_list */
258
259 if (retransconnlocked == 0)
260 spin_unlock_bh(&(nb->retrans_conn_lock));
261
262 return cr;
263 }
264
265 #define RC_SENDRETRANS_OK 0
266 #define RC_SENDRETRANS_OOM 1
267 #define RC_SENDRETRANS_QUEUEFULL 2
268 #define RC_SENDRETRANS_QUEUEFULLDROPPED 3
269
270 static int __cor_send_retrans(struct cor_neighbor *nb,
271 struct cor_conn *trgt_out_l, struct cor_conn_retrans *cr,
272 __u64 *bytes_sent)
273 {
274 __u8 flush = 0;
275
276 BUG_ON(cr->length == 0);
277
278 if (trgt_out_l->flush != 0 && cor_seqno_eq(cr->seqno + cr->length,
279 trgt_out_l->target.out.seqno_nextsend) &&
280 trgt_out_l->data_buf.read_remaining == 0)
281 flush = 1;
282
283 if (cor_send_conndata_as_skb(nb, cr->length)) {
284 struct sk_buff *skb;
285 char *dst;
286 int rc;
287
288 skb = cor_create_packet_conndata(nb, cr->length, GFP_ATOMIC,
289 trgt_out_l->target.out.conn_id, cr->seqno,
290 cr->windowused, flush);
291 if (unlikely(skb == 0))
292 return RC_SENDRETRANS_OOM;
293
294 dst = skb_put(skb, cr->length);
295
296 cor_databuf_pullold(trgt_out_l, cr->seqno, dst, cr->length);
297
298 rc = cor_dev_queue_xmit(skb, nb->queue,
299 QOS_CALLER_CONN_RETRANS);
300 if (rc == NET_XMIT_DROP)
301 return RC_SENDRETRANS_QUEUEFULLDROPPED;
302 cor_schedule_retransmit_conn(cr, 1, 0);
303 if (rc != NET_XMIT_SUCCESS)
304 return RC_SENDRETRANS_QUEUEFULL;
305
306 } else {
307 struct cor_control_msg_out *cm;
308 char *buf;
309
310 buf = kmalloc(cr->length, GFP_ATOMIC);
311 if (unlikely(buf == 0))
312 return RC_SENDRETRANS_OOM;
313
314 cm = cor_alloc_control_msg(nb, ACM_PRIORITY_LOW);
315 if (unlikely(cm == 0)) {
316 kfree(buf);
317 return RC_SENDRETRANS_OOM;
318 }
319
320 cor_databuf_pullold(trgt_out_l, cr->seqno, buf, cr->length);
321
322 cor_send_conndata(cm, trgt_out_l->target.out.conn_id,
323 cr->seqno, buf, buf, cr->length, cr->windowused,
324 flush, trgt_out_l->is_highlatency, cr);
325 }
326
327 *bytes_sent += cr->length;
328
329 return RC_SENDRETRANS_OK;
330 }
331
332 static int _cor_send_retrans_splitcr_ifneeded(
333 struct cor_neighbor *nb_retransconnlocked,
334 struct cor_conn *trgt_out_l, struct cor_conn_retrans *cr)
335 {
336 __u32 targetmss = cor_mss_conndata(nb_retransconnlocked,
337 trgt_out_l->is_highlatency != 0);
338 __u64 windowlimit = cor_seqno_clean(
339 trgt_out_l->target.out.seqno_windowlimit -
340 cr->seqno);
341 __u32 maxsize = targetmss;
342 if (windowlimit < maxsize)
343 maxsize = windowlimit;
344
345 if (unlikely(cr->length > maxsize)) {
346 struct cor_conn_retrans *cr2 = cor_prepare_conn_retrans(
347 trgt_out_l, cr->seqno + maxsize,
348 cr->length - maxsize, cr->windowused, cr, 1);
349 if (unlikely(cr2 == 0))
350 return RC_SENDRETRANS_OOM;
351
352 cr2->timeout = cr->timeout;
353
354 if (trgt_out_l->is_highlatency)
355 list_add(&(cr2->timeout_list),
356 &(nb_retransconnlocked->retrans_conn_highlatency_list));
357 else
358 list_add(&(cr2->timeout_list),
359 &(nb_retransconnlocked->retrans_conn_lowlatency_list));
360 /* cr2: kref from alloc goes to kref for timeout_list */
361 cr2->state = CONN_RETRANS_SCHEDULED;
362
363 cr->length = maxsize;
364 }
365
366 return RC_SENDRETRANS_OK;
367 }
368
369 static int _cor_send_retrans(struct cor_neighbor *nb,
370 struct cor_conn_retrans *cr, __u64 *bytes_sent)
371 {
372
373 struct cor_conn *trgt_out_o = cr->trgt_out_o;
374 int rc;
375
376 spin_lock_bh(&(trgt_out_o->rcv_lock));
377
378 BUG_ON(trgt_out_o->targettype != TARGET_OUT);
379 BUG_ON(trgt_out_o->target.out.nb != nb);
380
381 spin_lock_bh(&(nb->retrans_conn_lock));
382 if (unlikely(cr->state == CONN_RETRANS_ACKED)) {
383 spin_unlock_bh(&(nb->retrans_conn_lock));
384 spin_unlock_bh(&(trgt_out_o->rcv_lock));
385 return 0;
386 }
387
388 BUG_ON(trgt_out_o->isreset != 0);
389
390 BUG_ON(cor_seqno_before(cr->seqno, trgt_out_o->target.out.seqno_acked));
391
392 if (cor_seqno_after_eq(cr->seqno,
393 trgt_out_o->target.out.seqno_windowlimit)) {
394 BUG_ON(cr->state != CONN_RETRANS_SENDING);
395 cr->state = CONN_RETRANS_LOWWINDOW;
396 if (likely(trgt_out_o->target.out.retrans_lowwindow != 65535))
397 trgt_out_o->target.out.retrans_lowwindow++;
398
399 spin_unlock_bh(&(nb->retrans_conn_lock));
400 spin_unlock_bh(&(trgt_out_o->rcv_lock));
401 return 0;
402 }
403
404 rc = _cor_send_retrans_splitcr_ifneeded(nb, trgt_out_o, cr);
405
406 spin_unlock_bh(&(nb->retrans_conn_lock));
407
408 cor_conn_kref_get(trgt_out_o, "stack");
409
410 if (rc == RC_SENDRETRANS_OK)
411 rc = __cor_send_retrans(nb, trgt_out_o, cr, bytes_sent);
412
413 if (rc == RC_SENDRETRANS_OOM || rc == RC_SENDRETRANS_QUEUEFULLDROPPED) {
414 spin_lock_bh(&(nb->retrans_conn_lock));
415 if (unlikely(cr->state == CONN_RETRANS_ACKED)) {
416 } else if (likely(cr->state == CONN_RETRANS_SENDING)) {
417 if (rc == RC_SENDRETRANS_OOM)
418 cr->timeout = jiffies + 1;
419 if (trgt_out_o->is_highlatency)
420 list_add(&(cr->timeout_list),
421 &(nb->retrans_conn_highlatency_list));
422 else
423 list_add(&(cr->timeout_list),
424 &(nb->retrans_conn_lowlatency_list));
425 kref_get(&(cr->ref));
426 cr->state = CONN_RETRANS_SCHEDULED;
427 } else {
428 BUG();
429 }
430 spin_unlock_bh(&(nb->retrans_conn_lock));
431 }
432
433 spin_unlock_bh(&(trgt_out_o->rcv_lock));
434
435 cor_conn_kref_put(trgt_out_o, "stack");
436
437 return (rc == RC_SENDRETRANS_OOM ||
438 rc == RC_SENDRETRANS_QUEUEFULL ||
439 rc == RC_SENDRETRANS_QUEUEFULLDROPPED);
440 }
441
442 int cor_send_retrans(struct cor_neighbor *nb, int *sent)
443 {
444 int queuefull = 0;
445 int nbstate = cor_get_neigh_state(nb);
446 __u64 bytes_sent = 0;
447
448 if (unlikely(nbstate == NEIGHBOR_STATE_STALLED)) {
449 return QOS_RESUME_DONE;
450 } else if (unlikely(nbstate == NEIGHBOR_STATE_KILLED)) {
451 /**
452 * cor_cancel_all_conn_retrans_nb should not be needed, because
453 * cor_reset_all_conns calls cor_cancel_all_conn_retrans
454 */
455 cor_cancel_all_conn_retrans_nb(nb);
456 return QOS_RESUME_DONE;
457 }
458
459 while (1) {
460 struct cor_conn_retrans *cr = 0;
461
462 spin_lock_bh(&(nb->retrans_conn_lock));
463
464 cr = cor_peek_next_conn_retrans(nb);
465 if (cr == 0) {
466 spin_unlock_bh(&(nb->retrans_conn_lock));
467 break;
468 }
469
470 BUG_ON(cr->state != CONN_RETRANS_SCHEDULED);
471
472 if (time_after(cr->timeout, jiffies)) {
473 cor_reschedule_conn_retrans_timer(nb);
474 spin_unlock_bh(&(nb->retrans_conn_lock));
475 break;
476 }
477
478 list_del(&(cr->timeout_list));
479 cr->state = CONN_RETRANS_SENDING;
480
481 spin_unlock_bh(&(nb->retrans_conn_lock));
482
483 queuefull = _cor_send_retrans(nb, cr, &bytes_sent);
484 kref_put(&(cr->ref), cor_free_connretrans); /* timeout_list */
485 if (queuefull) {
486 break;
487 } else {
488 *sent = 1;
489 }
490 }
491
492 if (bytes_sent > 0)
493 cor_nbcongwin_data_retransmitted(nb, bytes_sent);
494
495 return queuefull ? QOS_RESUME_CONG : QOS_RESUME_DONE;
496 }
497
498 void cor_retransmit_conn_timerfunc(struct timer_list *retrans_conn_timer)
499 {
500 struct cor_neighbor *nb = container_of(retrans_conn_timer,
501 struct cor_neighbor, retrans_conn_timer);
502 cor_qos_enqueue(nb->queue, &(nb->rb_cr), 0, ns_to_ktime(0),
503 QOS_CALLER_CONN_RETRANS, 0);
504 kref_put(&(nb->ref), cor_neighbor_free);
505 }
506
507 static void cor_conn_ack_ooo_rcvd_splitcr(struct cor_conn *trgt_out_l,
508 struct cor_conn_retrans *cr, __u64 seqno_ooo, __u32 length,
509 __u64 *bytes_acked)
510 {
511 struct cor_conn_retrans *cr2;
512 __u64 seqno_cr2start;
513 __u32 oldcrlenght = cr->length;
514
515 if (cr->state != CONN_RETRANS_SCHEDULED &&
516 cr->state != CONN_RETRANS_LOWWINDOW)
517 return;
518
519 seqno_cr2start = seqno_ooo+length;
520 cr2 = cor_prepare_conn_retrans(trgt_out_l, seqno_cr2start,
521 cor_seqno_clean(cr->seqno + cr->length -
522 seqno_cr2start),
523 cr->windowused, cr, 1);
524
525 if (unlikely(cr2 == 0))
526 return;
527
528 BUG_ON(cr2->length > cr->length);
529
530 cr2->timeout = cr->timeout;
531 cr2->state = cr->state;
532
533 if (cr->state != CONN_RETRANS_SCHEDULED) {
534 list_add(&(cr2->timeout_list), &(cr->timeout_list));
535 kref_get(&(cr2->ref));
536 }
537
538 BUG_ON(cor_seqno_clean(seqno_ooo - cr->seqno) > cr->length);
539
540 cr->length -= cor_seqno_clean(seqno_ooo - cr->seqno);
541 BUG_ON(cr->length + length + cr2->length != oldcrlenght);
542 kref_put(&(cr2->ref), cor_kreffree_bug); /* alloc */
543
544 *bytes_acked += length;
545 }
546
547 void cor_conn_ack_ooo_rcvd(struct cor_neighbor *nb, __u32 conn_id,
548 struct cor_conn *trgt_out, __u64 seqno_ooo, __u32 length,
549 __u64 *bytes_acked)
550 {
551 struct list_head *curr;
552
553 if (unlikely(length == 0))
554 return;
555
556 spin_lock_bh(&(trgt_out->rcv_lock));
557
558 if (unlikely(trgt_out->targettype != TARGET_OUT))
559 goto out;
560 if (unlikely(trgt_out->target.out.nb != nb))
561 goto out;
562 if (unlikely(trgt_out->target.out.conn_id != conn_id))
563 goto out;
564
565 kref_get(&(nb->ref));
566 spin_lock_bh(&(nb->retrans_conn_lock));
567
568 curr = trgt_out->target.out.retrans_list.next;
569 while (curr != &(trgt_out->target.out.retrans_list)) {
570 struct cor_conn_retrans *cr = container_of(curr,
571 struct cor_conn_retrans, conn_list);
572
573 int ack_covers_start = cor_seqno_after_eq(cr->seqno, seqno_ooo);
574 int ack_covers_end = cor_seqno_before_eq(cr->seqno + cr->length,
575 seqno_ooo + length);
576
577 curr = curr->next;
578
579 if (cor_seqno_before(cr->seqno + cr->length, seqno_ooo))
580 continue;
581
582 if (cor_seqno_after(cr->seqno, seqno_ooo + length))
583 break;
584
585 if (likely(ack_covers_start && ack_covers_end)) {
586 cor_cancel_conn_retrans(nb, trgt_out, cr, bytes_acked);
587 cor_reschedule_conn_retrans_timer(nb);
588 } else if (ack_covers_start) {
589 __u32 diff = seqno_ooo + length - cr->seqno -
590 cr->length;
591 BUG_ON(diff >= cr->length);
592 cr->seqno += diff;
593 cr->length -= diff;
594 *bytes_acked =+ diff;
595 } else if (ack_covers_end) {
596 __u32 diff = seqno_ooo + length - cr->seqno;
597 BUG_ON(diff >= length);
598 cr->length -= diff;
599 *bytes_acked += diff;
600 } else {
601 cor_conn_ack_ooo_rcvd_splitcr(trgt_out, cr, seqno_ooo,
602 length, bytes_acked);
603 break;
604 }
605 }
606
607 if (unlikely(list_empty(&(trgt_out->target.out.retrans_list)) == 0)) {
608 trgt_out->target.out.seqno_acked =
609 trgt_out->target.out.seqno_nextsend;
610 } else {
611 struct cor_conn_retrans *cr = container_of(
612 trgt_out->target.out.retrans_list.next,
613 struct cor_conn_retrans, conn_list);
614 if (cor_seqno_after(cr->seqno,
615 trgt_out->target.out.seqno_acked))
616 trgt_out->target.out.seqno_acked = cr->seqno;
617 }
618
619 spin_unlock_bh(&(nb->retrans_conn_lock));
620 kref_put(&(nb->ref), cor_neighbor_free);
621
622 out:
623 spin_unlock_bh(&(trgt_out->rcv_lock));
624 }
625
626 static void _cor_conn_ack_rcvd_nosendwin(struct cor_conn *trgt_out_l)
627 {
628 if (trgt_out_l->bufsize.state == BUFSIZE_INCR ||
629 trgt_out_l->bufsize.state == BUFSIZE_INCR_FAST)
630 trgt_out_l->bufsize.state = BUFSIZE_NOACTION;
631
632 if (trgt_out_l->bufsize.state == BUFSIZE_NOACTION)
633 trgt_out_l->bufsize.act.noact.bytesleft = max(
634 trgt_out_l->bufsize.act.noact.bytesleft,
635 (__u32) BUF_OUT_WIN_NOK_NOINCR);
636
637 trgt_out_l->bufsize.ignore_rcv_lowbuf = max(
638 trgt_out_l->bufsize.ignore_rcv_lowbuf,
639 (__u32) BUF_OUT_WIN_NOK_NOINCR);
640 }
641
642 /**
643 * nb->retrans_conn_lock must be held when calling this
644 * (see cor_schedule_retransmit_conn())
645 */
646 static void cor_reschedule_lowwindow_retrans(struct cor_conn *trgt_out_l)
647 {
648 struct list_head *lh = trgt_out_l->target.out.retrans_list.next;
649 int cnt = 0;
650
651 while (trgt_out_l->target.out.retrans_lowwindow > 0 && cnt < 100) {
652 struct cor_conn_retrans *cr;
653
654 if (unlikely(lh == &(trgt_out_l->target.out.retrans_list))) {
655 BUG_ON(trgt_out_l->target.out.retrans_lowwindow !=
656 65535);
657 trgt_out_l->target.out.retrans_lowwindow = 0;
658 break;
659 }
660
661 cr = container_of(lh, struct cor_conn_retrans, conn_list);
662
663 if (cor_seqno_after_eq(cr->seqno,
664 trgt_out_l->target.out.seqno_windowlimit)) {
665 break;
666 }
667
668 if (cr->state == CONN_RETRANS_LOWWINDOW)
669 cor_schedule_retransmit_conn(cr, 1, 1);
670
671 lh = lh->next;
672 cnt++;
673 }
674 }
675
676 void cor_conn_ack_rcvd(struct cor_neighbor *nb, __u32 conn_id,
677 struct cor_conn *trgt_out, __u64 seqno, int setwindow,
678 __u16 window, __u8 bufsize_changerate, __u64 *bytes_acked)
679 {
680 int seqno_advanced = 0;
681 int window_enlarged = 0;
682
683 spin_lock_bh(&(trgt_out->rcv_lock));
684
685 if (unlikely(trgt_out->isreset != 0))
686 goto out;
687 if (unlikely(trgt_out->targettype != TARGET_OUT))
688 goto out;
689 if (unlikely(trgt_out->target.out.nb != nb))
690 goto out;
691 if (unlikely(cor_get_connid_reverse(trgt_out->target.out.conn_id) !=
692 conn_id))
693 goto out;
694
695 if (unlikely(cor_seqno_after(seqno,
696 trgt_out->target.out.seqno_nextsend) ||
697 cor_seqno_before(seqno,
698 trgt_out->target.out.seqno_acked)))
699 goto out;
700
701 if (setwindow) {
702 __u64 windowdec = cor_dec_window(window);
703 if (likely(cor_seqno_after(seqno,
704 trgt_out->target.out.seqno_acked)) ||
705 cor_seqno_after(seqno + windowdec,
706 trgt_out->target.out.seqno_windowlimit)) {
707 trgt_out->target.out.seqno_windowlimit = seqno +
708 windowdec;
709 window_enlarged = 1;
710 }
711 trgt_out->target.out.remote_bufsize_changerate =
712 bufsize_changerate;
713 }
714
715 if (cor_seqno_after(seqno, trgt_out->target.out.seqno_acked))
716 seqno_advanced = 1;
717
718 if (seqno_advanced == 0 && window_enlarged == 0)
719 goto out;
720
721 kref_get(&(nb->ref));
722 spin_lock_bh(&(nb->retrans_conn_lock));
723
724 if (seqno_advanced) {
725 trgt_out->target.out.seqno_acked = seqno;
726 cor_cancel_acked_conn_retrans(trgt_out, bytes_acked);
727 }
728
729 if (window_enlarged)
730 cor_reschedule_lowwindow_retrans(trgt_out);
731
732 spin_unlock_bh(&(nb->retrans_conn_lock));
733 kref_put(&(nb->ref), cor_neighbor_free);
734
735 if (seqno_advanced)
736 cor_databuf_ack(trgt_out, trgt_out->target.out.seqno_acked);
737
738 if (cor_seqno_eq(trgt_out->target.out.seqno_acked,
739 trgt_out->target.out.seqno_nextsend))
740 _cor_conn_ack_rcvd_nosendwin(trgt_out);
741
742 out:
743 if (seqno_advanced || window_enlarged)
744 cor_flush_buf(trgt_out);
745
746 spin_unlock_bh(&(trgt_out->rcv_lock));
747
748 cor_wake_sender(trgt_out);
749 }
750
751 static void cor_try_combine_conn_retrans_prev(
752 struct cor_neighbor *nb_retransconnlocked,
753 struct cor_conn *trgt_out_lx, struct cor_conn_retrans *cr)
754 {
755 struct cor_conn_retrans *cr_prev;
756 __u64 bytes_dummyacked = 0;
757
758 BUG_ON(cr->state != CONN_RETRANS_SCHEDULED);
759
760 if (cr->conn_list.prev == &(trgt_out_lx->target.out.retrans_list))
761 return;
762
763 cr_prev = container_of(cr->conn_list.prev, struct cor_conn_retrans,
764 conn_list);
765
766 if (cr_prev->state != CONN_RETRANS_SCHEDULED)
767 return;
768 if (cr_prev->timeout != cr->timeout)
769 return;
770 if (!cor_seqno_eq(cr_prev->seqno + cr_prev->length, cr->seqno))
771 return;
772
773 cr->seqno -= cr_prev->length;
774 cr->length += cr_prev->length;
775
776 cor_cancel_conn_retrans(nb_retransconnlocked, trgt_out_lx, cr_prev,
777 &bytes_dummyacked);
778 }
779
780 static void cor_try_combine_conn_retrans_next(
781 struct cor_neighbor *nb_retranslocked,
782 struct cor_conn *trgt_out_lx, struct cor_conn_retrans *cr)
783 {
784 struct cor_conn_retrans *cr_next;
785 __u64 bytes_dummyacked = 0;
786
787 BUG_ON(cr->state != CONN_RETRANS_SCHEDULED);
788
789 if (cr->conn_list.next == &(trgt_out_lx->target.out.retrans_list))
790 return;
791
792 cr_next = container_of(cr->conn_list.next, struct cor_conn_retrans,
793 conn_list);
794
795 if (cr_next->state != CONN_RETRANS_SCHEDULED)
796 return;
797 if (cr_next->timeout != cr->timeout)
798 return;
799 if (!cor_seqno_eq(cr->seqno + cr->length, cr_next->seqno))
800 return;
801
802 cr->length += cr_next->length;
803
804 cor_cancel_conn_retrans(nb_retranslocked, trgt_out_lx, cr_next,
805 &bytes_dummyacked);
806 }
807
808 void cor_schedule_retransmit_conn(struct cor_conn_retrans *cr, int connlocked,
809 int nbretransconn_locked)
810 {
811 struct cor_conn *trgt_out_o = cr->trgt_out_o;
812 struct cor_neighbor *nb;
813 int first;
814
815 if (connlocked == 0)
816 spin_lock_bh(&(trgt_out_o->rcv_lock));
817
818 BUG_ON(trgt_out_o->targettype != TARGET_OUT);
819 nb = trgt_out_o->target.out.nb;
820
821 if (trgt_out_o->is_highlatency)
822 cr->timeout = cor_calc_timeout(atomic_read(&(nb->latency_retrans_us)),
823 atomic_read(&(nb->latency_stddev_retrans_us)),
824 atomic_read(&(nb->max_remote_ackconn_lowlat_delay_us)));
825 else
826 cr->timeout = cor_calc_timeout(atomic_read(&(nb->latency_retrans_us)),
827 atomic_read(&(nb->latency_stddev_retrans_us)),
828 atomic_read(&(nb->max_remote_ackconn_highlat_delay_us)));
829
830 if (nbretransconn_locked == 0)
831 spin_lock_bh(&(nb->retrans_conn_lock));
832
833 kref_get(&(nb->ref));
834
835 BUG_ON(cr->state == CONN_RETRANS_SCHEDULED);
836
837 if (unlikely(cr->state == CONN_RETRANS_ACKED)) {
838 goto out;
839 } else if (unlikely(cr->state == CONN_RETRANS_LOWWINDOW)) {
840 BUG_ON(trgt_out_o->target.out.retrans_lowwindow == 0);
841 if (likely(trgt_out_o->target.out.retrans_lowwindow != 65535))
842 trgt_out_o->target.out.retrans_lowwindow--;
843 }
844
845 if (trgt_out_o->is_highlatency) {
846 first = unlikely(list_empty(
847 &(nb->retrans_conn_highlatency_list)));
848 list_add_tail(&(cr->timeout_list),
849 &(nb->retrans_conn_highlatency_list));
850 } else {
851 first = unlikely(list_empty(
852 &(nb->retrans_conn_lowlatency_list)));
853 list_add_tail(&(cr->timeout_list),
854 &(nb->retrans_conn_lowlatency_list));
855 }
856 kref_get(&(cr->ref));
857 cr->state = CONN_RETRANS_SCHEDULED;
858
859 if (unlikely(first)) {
860 cor_reschedule_conn_retrans_timer(nb);
861 } else {
862 cor_try_combine_conn_retrans_prev(nb, trgt_out_o, cr);
863 cor_try_combine_conn_retrans_next(nb, trgt_out_o, cr);
864 }
865
866 out:
867 if (nbretransconn_locked == 0)
868 spin_unlock_bh(&(nb->retrans_conn_lock));
869
870 kref_put(&(nb->ref), cor_neighbor_free);
871
872 if (connlocked == 0)
873 spin_unlock_bh(&(trgt_out_o->rcv_lock));
874 }
875
876 static int _cor_flush_out_skb(struct cor_conn *trgt_out_lx, __u32 len)
877 {
878 struct cor_neighbor *nb = trgt_out_lx->target.out.nb;
879
880 __u64 seqno;
881 struct cor_conn_retrans *cr;
882 struct sk_buff *skb;
883 char *dst;
884 __u8 flush;
885 int rc;
886
887 if (trgt_out_lx->flush != 0 &&
888 trgt_out_lx->data_buf.read_remaining == len)
889 flush = 1;
890
891 seqno = trgt_out_lx->target.out.seqno_nextsend;
892 skb = cor_create_packet_conndata(trgt_out_lx->target.out.nb, len,
893 GFP_ATOMIC, trgt_out_lx->target.out.conn_id, seqno,
894 trgt_out_lx->target.out.lastsend_windowused, flush);
895 if (unlikely(skb == 0))
896 return RC_FLUSH_CONN_OUT_OOM;
897
898 cr = cor_prepare_conn_retrans(trgt_out_lx, seqno, len,
899 trgt_out_lx->target.out.lastsend_windowused, 0, 0);
900 if (unlikely(cr == 0)) {
901 kfree_skb(skb);
902 return RC_FLUSH_CONN_OUT_OOM;
903 }
904
905 dst = skb_put(skb, len);
906
907 cor_databuf_pull(trgt_out_lx, dst, len);
908
909 rc = cor_dev_queue_xmit(skb, nb->queue, QOS_CALLER_NEIGHBOR);
910 if (rc == NET_XMIT_DROP) {
911 cor_databuf_unpull(trgt_out_lx, len);
912 spin_lock_bh(&(nb->retrans_conn_lock));
913 cor_cancel_conn_retrans(nb, trgt_out_lx, cr, 0);
914 spin_unlock_bh(&(nb->retrans_conn_lock));
915 kref_put(&(cr->ref), cor_free_connretrans); /* alloc */
916 return RC_FLUSH_CONN_OUT_CONG;
917 }
918
919 trgt_out_lx->target.out.seqno_nextsend += len;
920 cor_nbcongwin_data_sent(nb, len);
921 cor_schedule_retransmit_conn(cr, 1, 0);
922 if (trgt_out_lx->sourcetype == SOURCE_SOCK)
923 cor_update_src_sock_sndspeed(trgt_out_lx, len);
924
925 kref_put(&(cr->ref), cor_free_connretrans); /* alloc */
926
927 return (rc == NET_XMIT_SUCCESS) ?
928 RC_FLUSH_CONN_OUT_OK : RC_FLUSH_CONN_OUT_SENT_CONG;
929 }
930
931 static int _cor_flush_out_conndata(struct cor_conn *trgt_out_lx, __u32 len)
932 {
933 __u64 seqno;
934 struct cor_control_msg_out *cm;
935 struct cor_conn_retrans *cr;
936 char *buf;
937 __u8 flush = 0;
938
939 if (trgt_out_lx->flush != 0 &&
940 trgt_out_lx->data_buf.read_remaining == len)
941 flush = 1;
942
943 buf = kmalloc(len, GFP_ATOMIC);
944
945 if (unlikely(buf == 0))
946 return RC_FLUSH_CONN_OUT_OOM;
947
948 cm = cor_alloc_control_msg(trgt_out_lx->target.out.nb, ACM_PRIORITY_LOW);
949 if (unlikely(cm == 0)) {
950 kfree(buf);
951 return RC_FLUSH_CONN_OUT_OOM;
952 }
953
954 seqno = trgt_out_lx->target.out.seqno_nextsend;
955
956 cr = cor_prepare_conn_retrans(trgt_out_lx, seqno, len,
957 trgt_out_lx->target.out.lastsend_windowused, 0, 0);
958 if (unlikely(cr == 0)) {
959 kfree(buf);
960 cor_free_control_msg(cm);
961 return RC_FLUSH_CONN_OUT_OOM;
962 }
963
964 cor_databuf_pull(trgt_out_lx, buf, len);
965 trgt_out_lx->target.out.seqno_nextsend += len;
966 cor_nbcongwin_data_sent(trgt_out_lx->target.out.nb, len);
967 if (trgt_out_lx->sourcetype == SOURCE_SOCK)
968 cor_update_src_sock_sndspeed(trgt_out_lx, len);
969
970 cor_send_conndata(cm, trgt_out_lx->target.out.conn_id, seqno, buf, buf,
971 len, trgt_out_lx->target.out.lastsend_windowused, flush,
972 trgt_out_lx->is_highlatency, cr);
973
974 kref_put(&(cr->ref), cor_free_connretrans); /* alloc */
975
976 return RC_FLUSH_CONN_OUT_OK;
977 }
978
979 int cor_srcin_buflimit_reached(struct cor_conn *src_in_lx)
980 {
981 __u64 window_left;
982
983 if (unlikely(cor_seqno_before(src_in_lx->source.in.window_seqnolimit,
984 src_in_lx->source.in.next_seqno)))
985 return 1;
986
987 window_left = cor_seqno_clean(src_in_lx->source.in.window_seqnolimit -
988 src_in_lx->source.in.next_seqno);
989
990 if (window_left < WINDOW_ENCODE_MIN)
991 return 1;
992
993 if (window_left/2 < src_in_lx->data_buf.read_remaining)
994 return 1;
995
996 return 0;
997 }
998
999 static __u32 cor_maxsend_left_to_len(__u32 maxsend_left)
1000 {
1001 __u32 i;
1002 if (maxsend_left < 128)
1003 return maxsend_left;
1004
1005 for (i=128;i<4096;) {
1006 if (i*2 > maxsend_left)
1007 return i;
1008 i = i*2;
1009 }
1010
1011 return maxsend_left - maxsend_left%4096;
1012 }
1013
1014 static void cor_set_last_windowused(struct cor_conn *trgt_out_lx)
1015 {
1016 __u64 total_window;
1017 __u64 bytes_ackpending;
1018
1019 BUG_ON(cor_seqno_before(trgt_out_lx->target.out.seqno_windowlimit,
1020 trgt_out_lx->target.out.seqno_acked));
1021 BUG_ON(cor_seqno_before(trgt_out_lx->target.out.seqno_nextsend,
1022 trgt_out_lx->target.out.seqno_acked));
1023
1024 total_window = cor_seqno_clean(
1025 trgt_out_lx->target.out.seqno_windowlimit -
1026 trgt_out_lx->target.out.seqno_acked);
1027 bytes_ackpending = cor_seqno_clean(
1028 trgt_out_lx->target.out.seqno_nextsend -
1029 trgt_out_lx->target.out.seqno_acked);
1030
1031 BUG_ON(bytes_ackpending > total_window);
1032 BUG_ON(bytes_ackpending > (U64_MAX / 64));
1033
1034 trgt_out_lx->target.out.lastsend_windowused = div64_u64(
1035 bytes_ackpending * 31 + total_window - 1, total_window);
1036 }
1037
1038 static void _cor_flush_out_ignore_lowbuf(struct cor_conn *trgt_out_lx)
1039 {
1040 trgt_out_lx->bufsize.ignore_rcv_lowbuf = max(
1041 trgt_out_lx->bufsize.ignore_rcv_lowbuf,
1042 trgt_out_lx->bufsize.bufsize >> BUFSIZE_SHIFT);
1043 }
1044
1045 static __u64 cor_get_windowlimit(struct cor_conn *trgt_out_lx)
1046 {
1047 if (unlikely(cor_seqno_before(trgt_out_lx->target.out.seqno_windowlimit,
1048 trgt_out_lx->target.out.seqno_nextsend)))
1049 return 0;
1050
1051 return cor_seqno_clean(trgt_out_lx->target.out.seqno_windowlimit -
1052 trgt_out_lx->target.out.seqno_nextsend);
1053 }
1054
1055 int _cor_flush_out(struct cor_conn *trgt_out_lx, __u32 maxsend, __u32 *sent,
1056 int from_qos, int maxsend_forcedelay)
1057 {
1058 struct cor_neighbor *nb = trgt_out_lx->target.out.nb;
1059
1060 __u32 targetmss;
1061
1062 int nbstate;
1063
1064 __u32 maxsend_left = maxsend;
1065
1066 BUG_ON(trgt_out_lx->targettype != TARGET_OUT);
1067
1068 if (unlikely(trgt_out_lx->target.out.established == 0))
1069 return RC_FLUSH_CONN_OUT_OK;
1070
1071 if (unlikely(trgt_out_lx->isreset != 0))
1072 return RC_FLUSH_CONN_OUT_OK;
1073
1074 BUG_ON(trgt_out_lx->target.out.conn_id == 0);
1075
1076 if (unlikely(trgt_out_lx->data_buf.read_remaining == 0))
1077 return RC_FLUSH_CONN_OUT_OK;
1078
1079 if (from_qos == 0 && cor_qos_fastsend_allowed_conn(trgt_out_lx) == 0)
1080 return RC_FLUSH_CONN_OUT_CONG;
1081
1082 cor_get_conn_idletime(trgt_out_lx);
1083
1084 nbstate = cor_get_neigh_state(nb);
1085
1086 if (unlikely(nbstate != NEIGHBOR_STATE_ACTIVE))
1087 return RC_FLUSH_CONN_OUT_NBNOTACTIVE;
1088
1089 /* printk(KERN_ERR "flush %p %llu %u", trgt_out_l,
1090 cor_get_windowlimit(trgt_out_l),
1091 trgt_out_l->data_buf.read_remaining); */
1092
1093 targetmss = cor_mss_conndata(nb, trgt_out_lx->is_highlatency != 0);
1094
1095 while (trgt_out_lx->data_buf.read_remaining >= targetmss) {
1096 __u64 windowlimit = cor_get_windowlimit(trgt_out_lx);
1097 int rc;
1098
1099 if (maxsend_left < targetmss)
1100 break;
1101
1102 if (windowlimit < targetmss) {
1103 trgt_out_lx->target.out.lastsend_windowused = 31;
1104 _cor_flush_out_ignore_lowbuf(trgt_out_lx);
1105 break;
1106 }
1107
1108 if (cor_nbcongwin_send_allowed(nb) == 0)
1109 return RC_FLUSH_CONN_OUT_CONG;
1110
1111 if (likely(cor_send_conndata_as_skb(nb, targetmss)))
1112 rc = _cor_flush_out_skb(trgt_out_lx, targetmss);
1113 else
1114 rc = _cor_flush_out_conndata(trgt_out_lx, targetmss);
1115
1116 if (rc == RC_FLUSH_CONN_OUT_OK ||
1117 rc == RC_FLUSH_CONN_OUT_SENT_CONG) {
1118 maxsend_left -= targetmss;
1119 *sent += targetmss;
1120 cor_set_last_windowused(trgt_out_lx);
1121 }
1122
1123 if (rc == RC_FLUSH_CONN_OUT_SENT_CONG)
1124 return RC_FLUSH_CONN_OUT_CONG;
1125 if (rc != RC_FLUSH_CONN_OUT_OK)
1126 return rc;
1127 }
1128
1129 if (trgt_out_lx->data_buf.read_remaining > 0) {
1130 __u32 len = trgt_out_lx->data_buf.read_remaining;
1131 __u64 windowlimit = cor_get_windowlimit(trgt_out_lx);
1132 int rc;
1133
1134 if (maxsend_left < len) {
1135 if (maxsend_left >= 65536 || (
1136 maxsend_left == maxsend &&
1137 maxsend_left >= 128 &&
1138 trgt_out_lx->is_highlatency == 0 &&
1139 !maxsend_forcedelay)) {
1140 len = cor_maxsend_left_to_len(maxsend_left);
1141 } else {
1142 return RC_FLUSH_CONN_OUT_MAXSENT;
1143 }
1144 }
1145
1146 if (trgt_out_lx->flush == 0 &&
1147 trgt_out_lx->sourcetype == SOURCE_SOCK &&
1148 cor_sock_sndbufavailable(trgt_out_lx, 1) != 0)
1149 goto out;
1150
1151 if (trgt_out_lx->flush == 0 &&
1152 trgt_out_lx->sourcetype == SOURCE_IN &&
1153 cor_srcin_buflimit_reached(trgt_out_lx)
1154 == 0 && (
1155 cor_seqno_eq(
1156 trgt_out_lx->target.out.seqno_nextsend,
1157 trgt_out_lx->target.out.seqno_acked) == 0 ||
1158 trgt_out_lx->is_highlatency != 0 ||
1159 LOWLATENCY_SEND_UNFLUSHED_DATA != 0))
1160 goto out;
1161
1162 if (trgt_out_lx->flush == 0 &&
1163 trgt_out_lx->sourcetype == SOURCE_UNCONNECTED &&
1164 cor_conn_src_unconn_write_allowed(
1165 trgt_out_lx) != 0)
1166 goto out;
1167
1168 if (windowlimit == 0 || (windowlimit < len &&
1169 cor_seqno_eq(
1170 trgt_out_lx->target.out.seqno_nextsend,
1171 trgt_out_lx->target.out.seqno_acked) == 0)) {
1172 trgt_out_lx->target.out.lastsend_windowused = 31;
1173 _cor_flush_out_ignore_lowbuf(trgt_out_lx);
1174 goto out;
1175 }
1176
1177 if (cor_nbcongwin_send_allowed(nb) == 0)
1178 return RC_FLUSH_CONN_OUT_CONG;
1179
1180 if (len > windowlimit) {
1181 len = windowlimit;
1182 _cor_flush_out_ignore_lowbuf(trgt_out_lx);
1183 }
1184
1185 if (cor_send_conndata_as_skb(nb, len))
1186 rc = _cor_flush_out_skb(trgt_out_lx, len);
1187 else
1188 rc = _cor_flush_out_conndata(trgt_out_lx, len);
1189
1190
1191 if (rc == RC_FLUSH_CONN_OUT_OK ||
1192 rc == RC_FLUSH_CONN_OUT_SENT_CONG) {
1193 maxsend_left -= len;
1194 *sent += len;
1195 cor_set_last_windowused(trgt_out_lx);
1196 }
1197
1198 if (rc == RC_FLUSH_CONN_OUT_SENT_CONG)
1199 return RC_FLUSH_CONN_OUT_CONG;
1200 if (rc != RC_FLUSH_CONN_OUT_OK)
1201 return rc;
1202 }
1203
1204 out:
1205 return RC_FLUSH_CONN_OUT_OK;
1206 }
1207
1208 int __init cor_snd_init(void)
1209 {
1210 cor_connretrans_slab = kmem_cache_create("cor_connretrans",
1211 sizeof(struct cor_conn_retrans), 8, 0, 0);
1212 if (unlikely(cor_connretrans_slab == 0))
1213 return -ENOMEM;
1214
1215 return 0;
1216 }
1217
1218 void __exit cor_snd_exit2(void)
1219 {
1220 kmem_cache_destroy(cor_connretrans_slab);
1221 cor_connretrans_slab = 0;
1222 }
1223
1224 MODULE_LICENSE("GPL");
connection oriented routing