?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
set credits on new connections
[cor_2_6_31.git] / net / cor / snd.c
blob629d78d9cc57423a4a7c3c0d544c758609c09587
1 /*
2 * Connection oriented routing
3 * Copyright (C) 2007-2010 Michael Blizek
4 *
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License
7 * as published by the Free Software Foundation; either version 2
8 * of the License, or (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
18 * 02110-1301, USA.
19 */
20
21 #include <linux/gfp.h>
22 #include <linux/jiffies.h>
23 #include <linux/slab.h>
24
25 #include "cor.h"
26
27 struct kmem_cache *connretrans_slab;
28
29 struct conn_retrans {
30 /* timeout_list and conn_list share a single ref */
31 struct kref ref;
32 struct list_head timeout_list;
33 struct list_head conn_list;
34 struct htab_entry htab_entry;
35 struct conn *rconn;
36 __u32 seqno;
37 __u32 length;
38 __u8 ackrcvd;
39 unsigned long timeout;
40 };
41
42 static void free_connretrans(struct kref *ref)
43 {
44 struct conn_retrans *cr = container_of(ref, struct conn_retrans, ref);
45 kmem_cache_free(connretrans_slab, cr);
46 kref_put(&(cr->rconn->ref), free_conn);
47 }
48
49 DEFINE_MUTEX(queues_lock);
50 LIST_HEAD(queues);
51 struct delayed_work qos_resume_work;
52 int qos_resume_scheduled;
53
54 struct qos_queue {
55 struct list_head queue_list;
56
57 struct net_device *dev;
58
59 struct list_head kpackets_waiting;
60 struct list_head conn_retrans_waiting;
61 struct list_head announce_waiting;
62 struct list_head conns_waiting;
63 };
64
65 /* Higherst bidder "pays" the credits the second has bid */
66 static int _resume_conns(struct qos_queue *q)
67 {
68 struct conn *best = 0;
69 __u64 bestcredit = 0;
70 __u64 secondcredit = 0;
71
72 int rc;
73
74 struct list_head *lh = q->conns_waiting.next;
75
76 while (lh != &(q->conns_waiting)) {
77 struct conn *rconn = container_of(lh, struct conn,
78 target.out.rb.lh);
79 __u64 credits;
80
81 lh = lh->next;
82
83 refresh_conn_credits(rconn, 0, 0);
84
85 mutex_lock(&(rconn->rcv_lock));
86
87 BUG_ON(rconn->targettype != TARGET_OUT);
88
89 if (atomic_read(&(rconn->isreset)) != 0) {
90 rconn->target.out.rb.in_queue = 0;
91 list_del(&(rconn->target.out.rb.lh));
92 mutex_unlock(&(rconn->rcv_lock));
93 kref_put(&(rconn->ref), free_conn);
94
95 continue;
96 }
97
98 BUG_ON(rconn->data_buf.read_remaining == 0);
99
100 if (may_alloc_control_msg(rconn->target.out.nb,
101 ACM_PRIORITY_MED) == 0)
102 continue;
103
104 if (rconn->credits <= 0)
105 credits = 0;
106 else
107 credits = multiply_div(rconn->credits, 1LL << 24,
108 rconn->data_buf.read_remaining);
109 mutex_unlock(&(rconn->rcv_lock));
110
111 if (best == 0 || bestcredit < credits) {
112 secondcredit = bestcredit;
113 best = rconn;
114 bestcredit = credits;
115 } else if (secondcredit < credits) {
116 secondcredit = credits;
117 }
118 }
119
120 if (best == 0)
121 return RC_FLUSH_CONN_OUT_OK;
122
123 mutex_lock(&(best->rcv_lock));
124 rc = flush_out(best, 1, (__u32) (secondcredit >> 32));
125
126 if (rc == RC_FLUSH_CONN_OUT_OK || rc == RC_FLUSH_CONN_OUT_OK_SENT) {
127 best->target.out.rb.in_queue = 0;
128 list_del(&(best->target.out.rb.lh));
129 }
130 mutex_unlock(&(best->rcv_lock));
131
132 refresh_conn_credits(best, 0, 0);
133 unreserve_sock_buffer(best);
134
135 if (rc == RC_FLUSH_CONN_OUT_OK_SENT)
136 wake_sender(best);
137
138 if (rc == RC_FLUSH_CONN_OUT_OK || rc == RC_FLUSH_CONN_OUT_OK_SENT)
139 kref_put(&(best->ref), free_conn);
140
141 return rc;
142 }
143
144 static int resume_conns(struct qos_queue *q)
145 {
146 while (list_empty(&(q->conns_waiting)) == 0) {
147 int rc = _resume_conns(q);
148 if (rc != RC_FLUSH_CONN_OUT_OK &&
149 rc != RC_FLUSH_CONN_OUT_OK_SENT)
150 return 1;
151 }
152 return 0;
153 }
154
155 static int send_retrans(struct neighbor *nb, int fromqos);
156
157 static int _qos_resume(struct qos_queue *q, int caller)
158 {
159 int rc = 0;
160
161 struct list_head *lh;
162
163 if (caller == QOS_CALLER_KPACKET)
164 lh = &(q->conn_retrans_waiting);
165 else if (caller == QOS_CALLER_CONN_RETRANS)
166 lh = &(q->kpackets_waiting);
167 else if (caller == QOS_CALLER_ANNOUNCE)
168 lh = &(q->announce_waiting);
169 else
170 BUG();
171
172 while (list_empty(lh) == 0) {
173 struct list_head *curr = lh->next;
174 struct resume_block *rb = container_of(curr,
175 struct resume_block, lh);
176 rb->in_queue = 0;
177 list_del(curr);
178
179 if (caller == QOS_CALLER_KPACKET) {
180 struct neighbor *nb = container_of(rb, struct neighbor,
181 rb_kp);
182 rc = send_messages(nb, 0, 1);
183 } else if (caller == QOS_CALLER_CONN_RETRANS) {
184 struct neighbor *nb = container_of(rb, struct neighbor,
185 rb_cr);
186 #warning todo do not send if neighbor is stalled
187 rc = send_retrans(nb, 1);
188 } else if (caller == QOS_CALLER_ANNOUNCE) {
189 struct announce_data *ann = container_of(rb,
190 struct announce_data, rb);
191 rc = send_announce_qos(ann);
192 } else {
193 BUG();
194 }
195
196 if (rc != 0 && rb->in_queue == 0) {
197 rb->in_queue = 1;
198 list_add(curr , lh);
199 } else {
200 if (caller == QOS_CALLER_KPACKET) {
201 kref_put(&(container_of(rb, struct neighbor,
202 rb_kp)->ref), neighbor_free);
203 } else if (caller == QOS_CALLER_CONN_RETRANS) {
204 kref_put(&(container_of(rb, struct neighbor,
205 rb_cr)->ref), neighbor_free);
206 } else if (caller == QOS_CALLER_ANNOUNCE) {
207 kref_put(&(container_of(rb,
208 struct announce_data, rb)->ref),
209 announce_data_free);
210 } else {
211 BUG();
212 }
213
214 }
215
216 if (rc != 0)
217 break;
218 }
219 return rc;
220 }
221
222 static void qos_resume(struct work_struct *work)
223 {
224 struct list_head *curr;
225
226 mutex_lock(&(queues_lock));
227
228 curr = queues.next;
229 while (curr != (&queues)) {
230 struct qos_queue *q = container_of(curr,
231 struct qos_queue, queue_list);
232 int i;
233
234 for (i=0;i<4;i++) {
235 int rc;
236 if (i == 3)
237 rc = resume_conns(q);
238 else
239 rc = _qos_resume(q, i);
240
241 if (rc != 0)
242 goto congested;
243 }
244
245 curr = curr->next;
246
247 if (i == 4 && unlikely(q->dev == 0)) {
248 list_del(&(q->queue_list));
249 kfree(q);
250 }
251 }
252
253 qos_resume_scheduled = 0;
254
255 if (0) {
256 congested:
257 schedule_delayed_work(&(qos_resume_work), 1);
258 }
259
260 mutex_unlock(&(queues_lock));
261 }
262
263 static struct qos_queue *get_queue(struct net_device *dev)
264 {
265 struct list_head *curr = queues.next;
266 while (curr != (&queues)) {
267 struct qos_queue *q = container_of(curr,
268 struct qos_queue, queue_list);
269 if (q->dev == dev)
270 return q;
271 }
272 return 0;
273 }
274
275 int destroy_queue(struct net_device *dev)
276 {
277 struct qos_queue *q;
278
279 mutex_lock(&(queues_lock));
280
281 q = get_queue(dev);
282
283 if (q == 0) {
284 mutex_unlock(&(queues_lock));
285 return 1;
286 }
287
288 q->dev = 0;
289
290 dev_put(dev);
291
292 mutex_unlock(&(queues_lock));
293
294 return 0;
295 }
296
297 int create_queue(struct net_device *dev)
298 {
299 struct qos_queue *q = kmalloc(sizeof(struct qos_queue), GFP_KERNEL);
300
301 if (q == 0) {
302 printk(KERN_ERR "cor: unable to allocate memory for device "
303 "queue, not enabling device");
304 return 1;
305 }
306
307 q->dev = dev;
308 dev_hold(dev);
309
310 INIT_LIST_HEAD(&(q->kpackets_waiting));
311 INIT_LIST_HEAD(&(q->conn_retrans_waiting));
312 INIT_LIST_HEAD(&(q->announce_waiting));
313 INIT_LIST_HEAD(&(q->conns_waiting));
314
315 mutex_lock(&(queues_lock));
316 list_add(&(q->queue_list), &queues);
317 mutex_unlock(&(queues_lock));
318
319 return 0;
320 }
321
322 void qos_enqueue(struct net_device *dev, struct resume_block *rb, int caller)
323 {
324 struct qos_queue *q;
325
326 mutex_lock(&(queues_lock));
327
328 if (rb->in_queue)
329 goto out;
330
331 q = get_queue(dev);
332 if (unlikely(q == 0))
333 goto out;
334
335 rb->in_queue = 1;
336
337 if (caller == QOS_CALLER_KPACKET) {
338 list_add(&(rb->lh) , &(q->conn_retrans_waiting));
339 kref_get(&(container_of(rb, struct neighbor, rb_kp)->ref));
340 } else if (caller == QOS_CALLER_CONN_RETRANS) {
341 list_add(&(rb->lh), &(q->kpackets_waiting));
342 kref_get(&(container_of(rb, struct neighbor, rb_cr)->ref));
343 } else if (caller == QOS_CALLER_ANNOUNCE) {
344 list_add(&(rb->lh), &(q->announce_waiting));
345 kref_get(&(container_of(rb, struct announce_data, rb)->ref));
346 } else if (caller == QOS_CALLER_CONN) {
347 struct conn *rconn = container_of(rb, struct conn,
348 target.out.rb);
349 mutex_lock(&(rconn->rcv_lock));
350 BUG_ON(rconn->targettype != TARGET_OUT);
351 list_add(&(rb->lh), &(q->conns_waiting));
352 kref_get(&(rconn->ref));
353 mutex_lock(&(rconn->rcv_lock));
354 } else {
355 BUG();
356 }
357
358 if (qos_resume_scheduled == 0) {
359 schedule_delayed_work(&(qos_resume_work), 1);
360 qos_resume_scheduled = 1;
361 }
362
363 out:
364 mutex_unlock(&(queues_lock));
365 }
366
367 void qos_remove_conn(struct conn *rconn)
368 {
369 int kref = 0;
370 mutex_lock(&(queues_lock));
371 if (rconn->targettype != TARGET_OUT)
372 goto out;
373
374 if (rconn->target.out.rb.in_queue == 0)
375 goto out;
376
377 rconn->target.out.rb.in_queue = 0;
378 list_del(&(rconn->target.out.rb.lh));
379 kref = 1;
380
381 out:
382 mutex_unlock(&(queues_lock));
383
384 if (kref)
385 kref_put(&(rconn->ref), free_conn);
386 }
387
388 static int may_send_conn_retrans(struct neighbor *nb)
389 {
390 struct qos_queue *q;
391 int rc = 0;
392
393 mutex_lock(&(queues_lock));
394
395 q = get_queue(nb->dev);
396 if (unlikely(q == 0))
397 goto out;
398
399 rc = (list_empty(&(q->kpackets_waiting)));
400
401 out:
402 mutex_unlock(&(queues_lock));
403
404 return rc;
405 }
406
407 static int may_send_conn(struct conn *rconn)
408 {
409 struct qos_queue *q;
410 int rc = 0;
411
412 mutex_lock(&(queues_lock));
413
414 q = get_queue(rconn->target.out.nb->dev);
415 if (unlikely(q == 0))
416 goto out;
417
418 rc = (list_empty(&(q->kpackets_waiting)) &&
419 list_empty(&(q->conn_retrans_waiting)) &&
420 list_empty(&(q->announce_waiting)) &&
421 list_empty(&(q->conns_waiting)));
422
423 out:
424 mutex_unlock(&(queues_lock));
425
426 return rc;
427 }
428
429
430 struct sk_buff *create_packet(struct neighbor *nb, int size,
431 gfp_t alloc_flags, __u32 conn_id, __u32 seqno)
432 {
433 struct sk_buff *ret;
434 char *dest;
435
436 ret = alloc_skb(size + 9 + LL_ALLOCATED_SPACE(nb->dev), alloc_flags);
437 if (unlikely(0 == ret))
438 return 0;
439
440 ret->protocol = htons(ETH_P_COR);
441 ret->dev = nb->dev;
442
443 skb_reserve(ret, LL_RESERVED_SPACE(nb->dev));
444 if(unlikely(dev_hard_header(ret, nb->dev, ETH_P_COR, nb->mac,
445 nb->dev->dev_addr, ret->len) < 0))
446 return 0;
447 skb_reset_network_header(ret);
448
449 dest = skb_put(ret, 9);
450 BUG_ON(0 == dest);
451
452 dest[0] = PACKET_TYPE_DATA;
453 dest += 1;
454
455 put_u32(dest, conn_id, 1);
456 dest += 4;
457 put_u32(dest, seqno, 1);
458 dest += 4;
459
460 return ret;
461 }
462
463 static void set_conn_retrans_timeout(struct conn_retrans *cr)
464 {
465 struct neighbor *nb = cr->rconn->target.out.nb;
466 cr->timeout = jiffies + usecs_to_jiffies(100000 +
467 ((__u32) atomic_read(&(nb->latency))) +
468 ((__u32) atomic_read(&(nb->max_remote_cmsg_delay))));
469 }
470
471 static struct conn_retrans *readd_conn_retrans(struct conn_retrans *cr,
472 struct neighbor *nb, __u32 length, int *dontsend)
473 {
474 unsigned long iflags;
475
476 struct conn_retrans *ret = 0;
477
478 spin_lock_irqsave( &(nb->retrans_lock), iflags );
479
480 if (unlikely(cr->ackrcvd)) {
481 *dontsend = 1;
482 goto out;
483 } else
484 *dontsend = 0;
485
486 if (unlikely(cr->length > length)) {
487 ret = kmem_cache_alloc(connretrans_slab, GFP_ATOMIC);
488 if (unlikely(ret == 0)) {
489 cr->timeout = jiffies + 1;
490 goto out;
491 }
492
493 memset(ret, 0, sizeof (struct conn_retrans));
494 ret->rconn = cr->rconn;
495 kref_get(&(cr->rconn->ref));
496 ret->seqno = cr->seqno + length;
497 ret->length = cr->length - length;
498 kref_init(&(ret->ref));
499
500 list_add(&(ret->timeout_list), &(nb->retrans_list_conn));
501 list_add(&(ret->conn_list), &(cr->conn_list));
502
503 cr->length = length;
504 } else {
505 list_del(&(cr->timeout_list));
506 list_add_tail(&(cr->timeout_list), &(nb->retrans_list_conn));
507 set_conn_retrans_timeout(cr);
508
509 BUG_ON(cr->length != length);
510 }
511
512 out:
513 spin_unlock_irqrestore( &(nb->retrans_lock), iflags );
514
515 return ret;
516 }
517
518 /* rcvlock *must* be held while calling this */
519 void cancel_retrans(struct conn *rconn)
520 {
521 unsigned long iflags;
522 struct neighbor *nb = rconn->target.out.nb;
523
524 spin_lock_irqsave( &(nb->retrans_lock), iflags );
525
526 while (list_empty(&(rconn->target.out.retrans_list)) == 0) {
527 struct conn_retrans *cr = container_of(
528 rconn->target.out.retrans_list.next,
529 struct conn_retrans, conn_list);
530 BUG_ON(cr->rconn != rconn);
531
532 list_del(&(cr->timeout_list));
533 list_del(&(cr->conn_list));
534 cr->ackrcvd = 1;
535 kref_put(&(cr->ref), free_connretrans);
536 }
537
538 spin_unlock_irqrestore( &(nb->retrans_lock), iflags );
539 }
540
541 static int _send_retrans(struct neighbor *nb, struct conn_retrans *cr)
542 {
543 int targetmss = mss(nb);
544 int dontsend;
545 int queuefull = 0;
546
547 mutex_lock(&(cr->rconn->rcv_lock));
548
549 BUG_ON(cr->rconn->targettype != TARGET_OUT);
550 BUG_ON(cr->rconn->target.out.nb != nb);
551
552 kref_get(&(cr->rconn->ref));
553
554 if (unlikely(atomic_read(&(cr->rconn->isreset)) != 0)) {
555 cancel_retrans(cr->rconn);
556 goto out;
557 }
558
559 while (cr->length >= targetmss) {
560 struct sk_buff *skb;
561 char *dst;
562 struct conn_retrans *cr2;
563 int rc;
564
565 if (may_send_conn_retrans(nb) == 0)
566 goto qos_enqueue;
567
568 skb = create_packet(nb, targetmss, GFP_KERNEL,
569 cr->rconn->target.out.conn_id, cr->seqno);
570 if (unlikely(skb == 0)) {
571 cr->timeout = jiffies + 1;
572 goto out;
573 }
574
575 cr2 = readd_conn_retrans(cr, nb, targetmss, &dontsend);
576 if (unlikely(unlikely(dontsend) || unlikely(cr2 == 0 &&
577 unlikely(cr->length > targetmss)))) {
578 kfree_skb(skb);
579 goto out;
580 }
581
582 dst = skb_put(skb, targetmss);
583
584 databuf_pullold(cr->rconn, cr->seqno, dst, targetmss);
585 rc = dev_queue_xmit(skb);
586
587 if (rc != 0) {
588 unsigned long iflags;
589
590 spin_lock_irqsave( &(nb->retrans_lock), iflags );
591 if (unlikely(cr->ackrcvd)) {
592 dontsend = 1;
593 } else {
594 list_del(&(cr->timeout_list));
595 list_add(&(cr->timeout_list),
596 &(nb->retrans_list_conn));
597 }
598 spin_unlock_irqrestore( &(nb->retrans_lock), iflags );
599 if (dontsend == 0)
600 goto qos_enqueue;
601 }
602
603 cr = cr2;
604
605 if (likely(cr == 0))
606 goto out;
607 }
608
609 if (unlikely(cr->length <= 0)) {
610 BUG();
611 } else {
612 struct control_msg_out *cm;
613 char *buf = kmalloc(cr->length, GFP_KERNEL);
614
615 if (unlikely(buf == 0)) {
616 cr->timeout = jiffies + 1;
617 goto out;
618 }
619
620 cm = alloc_control_msg(nb, ACM_PRIORITY_MED);
621 if (unlikely(cm == 0)) {
622 cr->timeout = jiffies + 1;
623 kfree(buf);
624 goto out;
625 }
626
627 databuf_pullold(cr->rconn, cr->seqno, buf, cr->length);
628
629 if (unlikely(readd_conn_retrans(cr, nb, cr->length, &dontsend)
630 != 0))
631 BUG();
632
633 if (likely(dontsend == 0)) {
634 send_conndata(cm, cr->rconn->target.out.conn_id,
635 cr->seqno, buf, buf, cr->length);
636 }
637 }
638
639 if (0) {
640 qos_enqueue:
641 queuefull = 1;
642 }
643 out:
644 mutex_unlock(&(cr->rconn->rcv_lock));
645
646 kref_put(&(cr->rconn->ref), free_conn);
647
648 return queuefull;
649 }
650
651 static int send_retrans(struct neighbor *nb, int fromqos)
652 {
653 unsigned long iflags;
654
655 struct conn_retrans *cr = 0;
656
657 int nbstate;
658 int rescheduled = 0;
659 int queuefull = 0;
660
661 spin_lock_irqsave( &(nb->state_lock), iflags );
662 nbstate = nb->state;
663 spin_unlock_irqrestore( &(nb->state_lock), iflags );
664
665 while (1) {
666 spin_lock_irqsave( &(nb->retrans_lock), iflags );
667
668 if (list_empty(&(nb->retrans_list_conn))) {
669 nb->retrans_timer_conn_running = 0;
670 spin_unlock_irqrestore( &(nb->retrans_lock), iflags );
671 break;
672 }
673
674 cr = container_of(nb->retrans_list_conn.next,
675 struct conn_retrans, timeout_list);
676
677 BUG_ON(cr->rconn->targettype != TARGET_OUT);
678
679 if (unlikely(unlikely(nbstate == NEIGHBOR_STATE_KILLED) ||
680 unlikely(atomic_read(
681 &(cr->rconn->isreset)) != 0))) {
682 list_del(&(cr->timeout_list));
683 list_del(&(cr->conn_list));
684 spin_unlock_irqrestore( &(nb->retrans_lock), iflags );
685
686 kref_put(&(cr->ref), free_connretrans);
687 continue;
688 }
689
690 BUG_ON(nb != cr->rconn->target.out.nb);
691
692 #warning todo check window limit
693
694 if (time_after(cr->timeout, jiffies)) {
695 schedule_delayed_work(&(nb->retrans_timer_conn),
696 cr->timeout - jiffies);
697 rescheduled = 1;
698 spin_unlock_irqrestore( &(nb->retrans_lock), iflags );
699 break;
700 }
701
702 kref_get(&(cr->ref));
703 spin_unlock_irqrestore( &(nb->retrans_lock), iflags );
704 queuefull = _send_retrans(nb, cr);
705 kref_put(&(cr->ref), free_connretrans);
706 if (queuefull) {
707 rescheduled = 1;
708 if (fromqos == 0)
709 qos_enqueue(nb->dev, &(nb->rb_cr),
710 QOS_CALLER_CONN_RETRANS);
711 break;
712 }
713 }
714
715 if (rescheduled == 0)
716 kref_put(&(nb->ref), neighbor_free);
717
718 return queuefull;
719 }
720
721 void retransmit_conn_timerfunc(struct work_struct *work)
722 {
723 struct neighbor *nb = container_of(to_delayed_work(work),
724 struct neighbor, retrans_timer_conn);
725
726 send_retrans(nb, 0);
727 }
728
729 void conn_ack_ooo_rcvd(struct conn *rconn, __u32 seqno_ooo, __u32 length)
730 {
731 unsigned long iflags;
732 struct neighbor *nb;
733 struct list_head *curr;
734
735 if (unlikely(length == 0))
736 return;
737
738 mutex_lock(&(rconn->rcv_lock));
739
740 BUG_ON(rconn->targettype != TARGET_OUT);
741
742 nb = rconn->target.out.nb;
743
744 spin_lock_irqsave( &(nb->retrans_lock), iflags );
745
746 curr = rconn->target.out.retrans_list.next;
747
748 while (curr != &(rconn->target.out.retrans_list)) {
749 struct conn_retrans *cr = container_of(curr,
750 struct conn_retrans, conn_list);
751
752 if (((__s32)(cr->seqno + cr->length - seqno_ooo)) > 0)
753 goto cont;
754
755 if (((__s32)(cr->seqno + cr->length - seqno_ooo - length)) >0) {
756 if (((__s32)(cr->seqno - seqno_ooo - length)) < 0) {
757 __u32 newseqno = seqno_ooo + length;
758 cr->length -= (newseqno - cr->seqno);
759 cr->seqno = newseqno;
760 }
761
762 break;
763 }
764
765 if (((__s32)(cr->seqno - seqno_ooo)) < 0 &&
766 ((__s32)(cr->seqno + cr->length - seqno_ooo -
767 length)) <= 0) {
768 __u32 diff = seqno_ooo + length - cr->seqno -
769 cr->length;
770 cr->seqno += diff;
771 cr->length -= diff;
772 } else {
773 list_del(&(cr->timeout_list));
774 list_del(&(cr->conn_list));
775 cr->ackrcvd = 1;
776 kref_put(&(cr->ref), free_connretrans);
777 }
778
779 cont:
780 curr = curr->next;
781 }
782
783 if (unlikely(list_empty(&(rconn->target.out.retrans_list))) == 0) {
784 struct conn_retrans *cr = container_of(
785 rconn->target.out.retrans_list.next,
786 struct conn_retrans, conn_list);
787 if (unlikely(((__s32) (cr->seqno -
788 rconn->target.out.seqno_acked)) > 0))
789 rconn->target.out.seqno_acked = cr->seqno;
790 }
791
792 spin_unlock_irqrestore( &(nb->retrans_lock), iflags );
793
794 mutex_unlock(&(rconn->rcv_lock));
795 }
796
797 void conn_ack_rcvd(struct conn *rconn, __u32 seqno, int setwindow, __u8 window)
798 {
799 unsigned long iflags;
800 struct neighbor *nb;
801
802 mutex_lock(&(rconn->rcv_lock));
803
804 BUG_ON(rconn->targettype != TARGET_OUT);
805
806 if (unlikely(((__s32)(seqno - rconn->target.out.seqno_nextsend)) > 0) ||
807 ((__s32)(seqno - rconn->target.out.seqno_acked)) < 0)
808 goto out;
809
810 if (setwindow) {
811 __u32 windowdec = dec_log_64_11(window);
812 if (unlikely(seqno == rconn->target.out.seqno_acked &&
813 ((__s32) (seqno + windowdec -
814 rconn->target.out.seqno_windowlimit )) < 0))
815 goto skipwindow;
816
817 rconn->target.out.seqno_windowlimit = seqno + windowdec;
818 }
819
820 skipwindow:
821 if (seqno == rconn->target.out.seqno_acked)
822 goto out;
823
824 nb = rconn->target.out.nb;
825
826 spin_lock_irqsave( &(nb->retrans_lock), iflags );
827
828 rconn->target.out.seqno_acked = seqno;
829
830 while (list_empty(&(rconn->target.out.retrans_list)) == 0) {
831 struct conn_retrans *cr = container_of(
832 rconn->target.out.retrans_list.next,
833 struct conn_retrans, conn_list);
834
835 if (((__s32)(cr->seqno + cr->length - seqno)) > 0) {
836 if (((__s32)(cr->seqno - seqno)) < 0) {
837 cr->length -= (seqno - cr->seqno);
838 cr->seqno = seqno;
839 }
840 break;
841 }
842
843 list_del(&(cr->timeout_list));
844 list_del(&(cr->conn_list));
845 cr->ackrcvd = 1;
846 kref_put(&(cr->ref), free_connretrans);
847 }
848
849 spin_unlock_irqrestore( &(nb->retrans_lock), iflags );
850 databuf_ack(rconn, rconn->target.out.seqno_acked);
851
852 out:
853 mutex_unlock(&(rconn->rcv_lock));
854
855 flush_buf(rconn);
856 }
857
858 static void schedule_retransmit_conn(struct conn_retrans *cr,
859 struct conn *rconn, __u32 seqno, __u32 len)
860 {
861 unsigned long iflags;
862
863 struct neighbor *nb = rconn->target.out.nb;
864
865 int first;
866
867 BUG_ON(rconn->targettype != TARGET_OUT);
868
869 memset(cr, 0, sizeof (struct conn_retrans));
870 cr->rconn = rconn;
871 kref_get(&(rconn->ref));
872 cr->seqno = seqno;
873 cr->length = len;
874 kref_init(&(cr->ref));
875 set_conn_retrans_timeout(cr);
876
877 spin_lock_irqsave( &(nb->retrans_lock), iflags );
878
879 first = unlikely(list_empty(&(nb->retrans_list_conn)));
880 list_add_tail(&(cr->timeout_list), &(nb->retrans_list_conn));
881
882 list_add_tail(&(cr->conn_list), &(rconn->target.out.retrans_list));
883
884 if (unlikely(unlikely(first) &&
885 unlikely(nb->retrans_timer_conn_running == 0))) {
886 schedule_delayed_work(&(nb->retrans_timer_conn),
887 cr->timeout - jiffies);
888 nb->retrans_timer_conn_running = 1;
889 kref_get(&(nb->ref));
890 }
891
892 spin_unlock_irqrestore( &(nb->retrans_lock), iflags );
893 }
894
895 static __u32 get_windowlimit(struct conn *rconn)
896 {
897 __s32 windowlimit = (__s32)(rconn->target.out.seqno_windowlimit -
898 rconn->target.out.seqno_nextsend);
899 if (unlikely(windowlimit < 0))
900 return 0;
901 return windowlimit;
902 }
903
904 #warning todo reset connections which are SOURCE_NONE and are stuck for too long
905 int flush_out(struct conn *rconn, int fromqos, __u32 creditsperbyte)
906 {
907 int targetmss = mss(rconn->target.out.nb);
908 __u32 seqno;
909 int sent = 0;
910
911 BUG_ON(rconn->targettype != TARGET_OUT);
912
913 if (unlikely(rconn->target.out.conn_id == 0))
914 return RC_FLUSH_CONN_OUT_OK;
915
916 if (unlikely(atomic_read(&(rconn->isreset)) != 0))
917 return RC_FLUSH_CONN_OUT_OK;
918
919 if (unlikely(rconn->sourcetype == SOURCE_SOCK &&
920 rconn->source.sock.delay_flush != 0))
921 return RC_FLUSH_CONN_OUT_OK;
922
923 if (fromqos == 0 && may_send_conn(rconn) == 0)
924 return RC_FLUSH_CONN_OUT_CONG;
925
926 while (rconn->data_buf.read_remaining >= targetmss &&
927 get_windowlimit(rconn) >= targetmss) {
928 struct conn_retrans *cr;
929 struct sk_buff *skb;
930 char *dst;
931 int rc;
932
933 if (unlikely(creditsperbyte * targetmss >
934 rconn->credits))
935 return RC_FLUSH_CONN_OUT_CREDITS;
936
937 seqno = rconn->target.out.seqno_nextsend;
938 skb = create_packet(rconn->target.out.nb, targetmss, GFP_ATOMIC,
939 rconn->target.out.conn_id, seqno);
940 if (unlikely(skb == 0))
941 return RC_FLUSH_CONN_OUT_OOM;
942
943 cr = kmem_cache_alloc(connretrans_slab, GFP_KERNEL);
944 if (unlikely(cr == 0)) {
945 kfree_skb(skb);
946 return RC_FLUSH_CONN_OUT_OOM;
947 }
948
949 dst = skb_put(skb, targetmss);
950
951 databuf_pull(rconn, dst, targetmss);
952
953 rc = dev_queue_xmit(skb);
954 if (rc != 0) {
955 databuf_unpull(rconn, targetmss);
956 kmem_cache_free(connretrans_slab, cr);
957 return RC_FLUSH_CONN_OUT_CONG;
958 }
959
960 rconn->credits -= creditsperbyte * targetmss;
961 rconn->target.out.seqno_nextsend += targetmss;
962 schedule_retransmit_conn(cr, rconn, seqno, targetmss);
963 sent = 1;
964 }
965
966 if (rconn->data_buf.read_remaining > 0 && (rconn->tos == TOS_LATENCY ||
967 rconn->target.out.seqno_nextsend ==
968 rconn->target.out.seqno_acked)) {
969 struct control_msg_out *cm;
970 struct conn_retrans *cr;
971 __u32 len = rconn->data_buf.read_remaining;
972 __s32 windowlimit = get_windowlimit(rconn);
973 char *buf;
974
975 if (windowlimit == 0)
976 goto out;
977
978 if (windowlimit < len/2 && rconn->target.out.seqno_nextsend !=
979 rconn->target.out.seqno_acked)
980 goto out;
981
982 if (len > windowlimit)
983 len = windowlimit;
984
985 buf = kmalloc(len, GFP_KERNEL);
986
987 if (unlikely(creditsperbyte * len > rconn->credits))
988 return RC_FLUSH_CONN_OUT_CREDITS;
989
990 if (unlikely(buf == 0))
991 return RC_FLUSH_CONN_OUT_OOM;
992
993 cm = alloc_control_msg(rconn->target.out.nb, ACM_PRIORITY_MED);
994 if (unlikely(cm == 0)) {
995 kfree(buf);
996 return RC_FLUSH_CONN_OUT_OOM;
997 }
998
999 cr = kmem_cache_alloc(connretrans_slab, GFP_KERNEL);
1000 if (unlikely(cr == 0)) {
1001 kfree(buf);
1002 free_control_msg(cm);
1003 return RC_FLUSH_CONN_OUT_CONG;
1004 }
1005
1006 databuf_pull(rconn, buf, len);
1007
1008 seqno = rconn->target.out.seqno_nextsend;
1009 rconn->credits -= creditsperbyte * len;
1010 rconn->target.out.seqno_nextsend += len;
1011
1012 schedule_retransmit_conn(cr, rconn, seqno, len);
1013
1014 send_conndata(cm, rconn->target.out.conn_id, seqno, buf, buf,
1015 len);
1016 sent = 1;
1017 }
1018
1019 out:
1020 if (sent)
1021 return RC_FLUSH_CONN_OUT_OK_SENT;
1022
1023 return RC_FLUSH_CONN_OUT_OK;
1024 }
1025
1026 int __init cor_snd_init(void)
1027 {
1028 connretrans_slab = kmem_cache_create("cor_connretrans",
1029 sizeof(struct conn_retrans), 8, 0, 0);
1030
1031 if (unlikely(connretrans_slab == 0))
1032 return 1;
1033
1034 INIT_DELAYED_WORK(&(qos_resume_work), qos_resume);
1035 qos_resume_scheduled = 0;
1036
1037 return 0;
1038 }
1039
1040 MODULE_LICENSE("GPL");
connection oriented routing - ARCHIVE NO UPDATES HERE