1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
28
29#include <linux/types.h>
30#include <linux/list.h>
31#include <linux/socket.h>
32#include <linux/ip.h>
33#include <linux/slab.h>
34#include <net/sock.h>
35
36#include <net/sctp/sctp.h>
37#include <net/sctp/sm.h>
38#include <net/sctp/stream_sched.h>
39#include <trace/events/sctp.h>
40
41
42static int sctp_acked(struct sctp_sackhdr *sack, __u32 tsn);
43static void sctp_check_transmitted(struct sctp_outq *q,
44 struct list_head *transmitted_queue,
45 struct sctp_transport *transport,
46 union sctp_addr *saddr,
47 struct sctp_sackhdr *sack,
48 __u32 *highest_new_tsn);
49
50static void sctp_mark_missing(struct sctp_outq *q,
51 struct list_head *transmitted_queue,
52 struct sctp_transport *transport,
53 __u32 highest_new_tsn,
54 int count_of_newacks);
55
56static void sctp_outq_flush(struct sctp_outq *q, int rtx_timeout, gfp_t gfp);
57
58
59static inline void sctp_outq_head_data(struct sctp_outq *q,
60 struct sctp_chunk *ch)
61{
62 struct sctp_stream_out_ext *oute;
63 __u16 stream;
64
65 list_add(&ch->list, &q->out_chunk_list);
66 q->out_qlen += ch->skb->len;
67
68 stream = sctp_chunk_stream_no(ch);
69 oute = SCTP_SO(&q->asoc->stream, stream)->ext;
70 list_add(&ch->stream_list, &oute->outq);
71}
72
73
74static inline struct sctp_chunk *sctp_outq_dequeue_data(struct sctp_outq *q)
75{
76 return q->sched->dequeue(q);
77}
78
79
80static inline void sctp_outq_tail_data(struct sctp_outq *q,
81 struct sctp_chunk *ch)
82{
83 struct sctp_stream_out_ext *oute;
84 __u16 stream;
85
86 list_add_tail(&ch->list, &q->out_chunk_list);
87 q->out_qlen += ch->skb->len;
88
89 stream = sctp_chunk_stream_no(ch);
90 oute = SCTP_SO(&q->asoc->stream, stream)->ext;
91 list_add_tail(&ch->stream_list, &oute->outq);
92}
93
94
95
96
97
98
99
100static inline int sctp_cacc_skip_3_1_d(struct sctp_transport *primary,
101 struct sctp_transport *transport,
102 int count_of_newacks)
103{
104 if (count_of_newacks >= 2 && transport != primary)
105 return 1;
106 return 0;
107}
108
109
110
111
112
113
114
115
116static inline int sctp_cacc_skip_3_1_f(struct sctp_transport *transport,
117 int count_of_newacks)
118{
119 if (count_of_newacks < 2 &&
120 (transport && !transport->cacc.cacc_saw_newack))
121 return 1;
122 return 0;
123}
124
125
126
127
128
129
130
131
132static inline int sctp_cacc_skip_3_1(struct sctp_transport *primary,
133 struct sctp_transport *transport,
134 int count_of_newacks)
135{
136 if (!primary->cacc.cycling_changeover) {
137 if (sctp_cacc_skip_3_1_d(primary, transport, count_of_newacks))
138 return 1;
139 if (sctp_cacc_skip_3_1_f(transport, count_of_newacks))
140 return 1;
141 return 0;
142 }
143 return 0;
144}
145
146
147
148
149
150
151
152
153static inline int sctp_cacc_skip_3_2(struct sctp_transport *primary, __u32 tsn)
154{
155 if (primary->cacc.cycling_changeover &&
156 TSN_lt(tsn, primary->cacc.next_tsn_at_change))
157 return 1;
158 return 0;
159}
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175static inline int sctp_cacc_skip(struct sctp_transport *primary,
176 struct sctp_transport *transport,
177 int count_of_newacks,
178 __u32 tsn)
179{
180 if (primary->cacc.changeover_active &&
181 (sctp_cacc_skip_3_1(primary, transport, count_of_newacks) ||
182 sctp_cacc_skip_3_2(primary, tsn)))
183 return 1;
184 return 0;
185}
186
187
188
189
190
191void sctp_outq_init(struct sctp_association *asoc, struct sctp_outq *q)
192{
193 memset(q, 0, sizeof(struct sctp_outq));
194
195 q->asoc = asoc;
196 INIT_LIST_HEAD(&q->out_chunk_list);
197 INIT_LIST_HEAD(&q->control_chunk_list);
198 INIT_LIST_HEAD(&q->retransmit);
199 INIT_LIST_HEAD(&q->sacked);
200 INIT_LIST_HEAD(&q->abandoned);
201 sctp_sched_set_sched(asoc, sctp_sk(asoc->base.sk)->default_ss);
202}
203
204
205
206static void __sctp_outq_teardown(struct sctp_outq *q)
207{
208 struct sctp_transport *transport;
209 struct list_head *lchunk, *temp;
210 struct sctp_chunk *chunk, *tmp;
211
212
213 list_for_each_entry(transport, &q->asoc->peer.transport_addr_list,
214 transports) {
215 while ((lchunk = sctp_list_dequeue(&transport->transmitted)) != NULL) {
216 chunk = list_entry(lchunk, struct sctp_chunk,
217 transmitted_list);
218
219 sctp_chunk_fail(chunk, q->error);
220 sctp_chunk_free(chunk);
221 }
222 }
223
224
225 list_for_each_safe(lchunk, temp, &q->sacked) {
226 list_del_init(lchunk);
227 chunk = list_entry(lchunk, struct sctp_chunk,
228 transmitted_list);
229 sctp_chunk_fail(chunk, q->error);
230 sctp_chunk_free(chunk);
231 }
232
233
234 list_for_each_safe(lchunk, temp, &q->retransmit) {
235 list_del_init(lchunk);
236 chunk = list_entry(lchunk, struct sctp_chunk,
237 transmitted_list);
238 sctp_chunk_fail(chunk, q->error);
239 sctp_chunk_free(chunk);
240 }
241
242
243 list_for_each_safe(lchunk, temp, &q->abandoned) {
244 list_del_init(lchunk);
245 chunk = list_entry(lchunk, struct sctp_chunk,
246 transmitted_list);
247 sctp_chunk_fail(chunk, q->error);
248 sctp_chunk_free(chunk);
249 }
250
251
252 while ((chunk = sctp_outq_dequeue_data(q)) != NULL) {
253 sctp_sched_dequeue_done(q, chunk);
254
255
256 sctp_chunk_fail(chunk, q->error);
257 sctp_chunk_free(chunk);
258 }
259
260
261 list_for_each_entry_safe(chunk, tmp, &q->control_chunk_list, list) {
262 list_del_init(&chunk->list);
263 sctp_chunk_free(chunk);
264 }
265}
266
267void sctp_outq_teardown(struct sctp_outq *q)
268{
269 __sctp_outq_teardown(q);
270 sctp_outq_init(q->asoc, q);
271}
272
273
274void sctp_outq_free(struct sctp_outq *q)
275{
276
277 __sctp_outq_teardown(q);
278}
279
280
281void sctp_outq_tail(struct sctp_outq *q, struct sctp_chunk *chunk, gfp_t gfp)
282{
283 struct net *net = q->asoc->base.net;
284
285 pr_debug("%s: outq:%p, chunk:%p[%s]\n", __func__, q, chunk,
286 chunk && chunk->chunk_hdr ?
287 sctp_cname(SCTP_ST_CHUNK(chunk->chunk_hdr->type)) :
288 "illegal chunk");
289
290
291
292
293 if (sctp_chunk_is_data(chunk)) {
294 pr_debug("%s: outqueueing: outq:%p, chunk:%p[%s])\n",
295 __func__, q, chunk, chunk && chunk->chunk_hdr ?
296 sctp_cname(SCTP_ST_CHUNK(chunk->chunk_hdr->type)) :
297 "illegal chunk");
298
299 sctp_outq_tail_data(q, chunk);
300 if (chunk->asoc->peer.prsctp_capable &&
301 SCTP_PR_PRIO_ENABLED(chunk->sinfo.sinfo_flags))
302 chunk->asoc->sent_cnt_removable++;
303 if (chunk->chunk_hdr->flags & SCTP_DATA_UNORDERED)
304 SCTP_INC_STATS(net, SCTP_MIB_OUTUNORDERCHUNKS);
305 else
306 SCTP_INC_STATS(net, SCTP_MIB_OUTORDERCHUNKS);
307 } else {
308 list_add_tail(&chunk->list, &q->control_chunk_list);
309 SCTP_INC_STATS(net, SCTP_MIB_OUTCTRLCHUNKS);
310 }
311
312 if (!q->cork)
313 sctp_outq_flush(q, 0, gfp);
314}
315
316
317
318
319static void sctp_insert_list(struct list_head *head, struct list_head *new)
320{
321 struct list_head *pos;
322 struct sctp_chunk *nchunk, *lchunk;
323 __u32 ntsn, ltsn;
324 int done = 0;
325
326 nchunk = list_entry(new, struct sctp_chunk, transmitted_list);
327 ntsn = ntohl(nchunk->subh.data_hdr->tsn);
328
329 list_for_each(pos, head) {
330 lchunk = list_entry(pos, struct sctp_chunk, transmitted_list);
331 ltsn = ntohl(lchunk->subh.data_hdr->tsn);
332 if (TSN_lt(ntsn, ltsn)) {
333 list_add(new, pos->prev);
334 done = 1;
335 break;
336 }
337 }
338 if (!done)
339 list_add_tail(new, head);
340}
341
342static int sctp_prsctp_prune_sent(struct sctp_association *asoc,
343 struct sctp_sndrcvinfo *sinfo,
344 struct list_head *queue, int msg_len)
345{
346 struct sctp_chunk *chk, *temp;
347
348 list_for_each_entry_safe(chk, temp, queue, transmitted_list) {
349 struct sctp_stream_out *streamout;
350
351 if (!chk->msg->abandoned &&
352 (!SCTP_PR_PRIO_ENABLED(chk->sinfo.sinfo_flags) ||
353 chk->sinfo.sinfo_timetolive <= sinfo->sinfo_timetolive))
354 continue;
355
356 chk->msg->abandoned = 1;
357 list_del_init(&chk->transmitted_list);
358 sctp_insert_list(&asoc->outqueue.abandoned,
359 &chk->transmitted_list);
360
361 streamout = SCTP_SO(&asoc->stream, chk->sinfo.sinfo_stream);
362 asoc->sent_cnt_removable--;
363 asoc->abandoned_sent[SCTP_PR_INDEX(PRIO)]++;
364 streamout->ext->abandoned_sent[SCTP_PR_INDEX(PRIO)]++;
365
366 if (queue != &asoc->outqueue.retransmit &&
367 !chk->tsn_gap_acked) {
368 if (chk->transport)
369 chk->transport->flight_size -=
370 sctp_data_size(chk);
371 asoc->outqueue.outstanding_bytes -= sctp_data_size(chk);
372 }
373
374 msg_len -= chk->skb->truesize + sizeof(struct sctp_chunk);
375 if (msg_len <= 0)
376 break;
377 }
378
379 return msg_len;
380}
381
382static int sctp_prsctp_prune_unsent(struct sctp_association *asoc,
383 struct sctp_sndrcvinfo *sinfo, int msg_len)
384{
385 struct sctp_outq *q = &asoc->outqueue;
386 struct sctp_chunk *chk, *temp;
387
388 q->sched->unsched_all(&asoc->stream);
389
390 list_for_each_entry_safe(chk, temp, &q->out_chunk_list, list) {
391 if (!chk->msg->abandoned &&
392 (!(chk->chunk_hdr->flags & SCTP_DATA_FIRST_FRAG) ||
393 !SCTP_PR_PRIO_ENABLED(chk->sinfo.sinfo_flags) ||
394 chk->sinfo.sinfo_timetolive <= sinfo->sinfo_timetolive))
395 continue;
396
397 chk->msg->abandoned = 1;
398 sctp_sched_dequeue_common(q, chk);
399 asoc->sent_cnt_removable--;
400 asoc->abandoned_unsent[SCTP_PR_INDEX(PRIO)]++;
401 if (chk->sinfo.sinfo_stream < asoc->stream.outcnt) {
402 struct sctp_stream_out *streamout =
403 SCTP_SO(&asoc->stream, chk->sinfo.sinfo_stream);
404
405 streamout->ext->abandoned_unsent[SCTP_PR_INDEX(PRIO)]++;
406 }
407
408 msg_len -= chk->skb->truesize + sizeof(struct sctp_chunk);
409 sctp_chunk_free(chk);
410 if (msg_len <= 0)
411 break;
412 }
413
414 q->sched->sched_all(&asoc->stream);
415
416 return msg_len;
417}
418
419
420void sctp_prsctp_prune(struct sctp_association *asoc,
421 struct sctp_sndrcvinfo *sinfo, int msg_len)
422{
423 struct sctp_transport *transport;
424
425 if (!asoc->peer.prsctp_capable || !asoc->sent_cnt_removable)
426 return;
427
428 msg_len = sctp_prsctp_prune_sent(asoc, sinfo,
429 &asoc->outqueue.retransmit,
430 msg_len);
431 if (msg_len <= 0)
432 return;
433
434 list_for_each_entry(transport, &asoc->peer.transport_addr_list,
435 transports) {
436 msg_len = sctp_prsctp_prune_sent(asoc, sinfo,
437 &transport->transmitted,
438 msg_len);
439 if (msg_len <= 0)
440 return;
441 }
442
443 sctp_prsctp_prune_unsent(asoc, sinfo, msg_len);
444}
445
446
447void sctp_retransmit_mark(struct sctp_outq *q,
448 struct sctp_transport *transport,
449 __u8 reason)
450{
451 struct list_head *lchunk, *ltemp;
452 struct sctp_chunk *chunk;
453
454
455 list_for_each_safe(lchunk, ltemp, &transport->transmitted) {
456 chunk = list_entry(lchunk, struct sctp_chunk,
457 transmitted_list);
458
459
460 if (sctp_chunk_abandoned(chunk)) {
461 list_del_init(lchunk);
462 sctp_insert_list(&q->abandoned, lchunk);
463
464
465
466
467
468
469 if (!chunk->tsn_gap_acked) {
470 if (chunk->transport)
471 chunk->transport->flight_size -=
472 sctp_data_size(chunk);
473 q->outstanding_bytes -= sctp_data_size(chunk);
474 q->asoc->peer.rwnd += sctp_data_size(chunk);
475 }
476 continue;
477 }
478
479
480
481
482
483 if ((reason == SCTP_RTXR_FAST_RTX &&
484 (chunk->fast_retransmit == SCTP_NEED_FRTX)) ||
485 (reason != SCTP_RTXR_FAST_RTX && !chunk->tsn_gap_acked)) {
486
487
488
489
490
491
492
493
494 q->asoc->peer.rwnd += sctp_data_size(chunk);
495 q->outstanding_bytes -= sctp_data_size(chunk);
496 if (chunk->transport)
497 transport->flight_size -= sctp_data_size(chunk);
498
499
500
501
502
503
504 chunk->tsn_missing_report = 0;
505
506
507
508
509
510
511
512 if (chunk->rtt_in_progress) {
513 chunk->rtt_in_progress = 0;
514 transport->rto_pending = 0;
515 }
516
517
518
519
520 list_del_init(lchunk);
521 sctp_insert_list(&q->retransmit, lchunk);
522 }
523 }
524
525 pr_debug("%s: transport:%p, reason:%d, cwnd:%d, ssthresh:%d, "
526 "flight_size:%d, pba:%d\n", __func__, transport, reason,
527 transport->cwnd, transport->ssthresh, transport->flight_size,
528 transport->partial_bytes_acked);
529}
530
531
532
533
534void sctp_retransmit(struct sctp_outq *q, struct sctp_transport *transport,
535 enum sctp_retransmit_reason reason)
536{
537 struct net *net = q->asoc->base.net;
538
539 switch (reason) {
540 case SCTP_RTXR_T3_RTX:
541 SCTP_INC_STATS(net, SCTP_MIB_T3_RETRANSMITS);
542 sctp_transport_lower_cwnd(transport, SCTP_LOWER_CWND_T3_RTX);
543
544
545
546 if (transport == transport->asoc->peer.retran_path)
547 sctp_assoc_update_retran_path(transport->asoc);
548 transport->asoc->rtx_data_chunks +=
549 transport->asoc->unack_data;
550 break;
551 case SCTP_RTXR_FAST_RTX:
552 SCTP_INC_STATS(net, SCTP_MIB_FAST_RETRANSMITS);
553 sctp_transport_lower_cwnd(transport, SCTP_LOWER_CWND_FAST_RTX);
554 q->fast_rtx = 1;
555 break;
556 case SCTP_RTXR_PMTUD:
557 SCTP_INC_STATS(net, SCTP_MIB_PMTUD_RETRANSMITS);
558 break;
559 case SCTP_RTXR_T1_RTX:
560 SCTP_INC_STATS(net, SCTP_MIB_T1_RETRANSMITS);
561 transport->asoc->init_retries++;
562 break;
563 default:
564 BUG();
565 }
566
567 sctp_retransmit_mark(q, transport, reason);
568
569
570
571
572
573 if (reason == SCTP_RTXR_T3_RTX)
574 q->asoc->stream.si->generate_ftsn(q, q->asoc->ctsn_ack_point);
575
576
577
578
579
580 if (reason != SCTP_RTXR_FAST_RTX)
581 sctp_outq_flush(q, 1, GFP_ATOMIC);
582}
583
584
585
586
587
588
589
590
591
592static int __sctp_outq_flush_rtx(struct sctp_outq *q, struct sctp_packet *pkt,
593 int rtx_timeout, int *start_timer, gfp_t gfp)
594{
595 struct sctp_transport *transport = pkt->transport;
596 struct sctp_chunk *chunk, *chunk1;
597 struct list_head *lqueue;
598 enum sctp_xmit status;
599 int error = 0;
600 int timer = 0;
601 int done = 0;
602 int fast_rtx;
603
604 lqueue = &q->retransmit;
605 fast_rtx = q->fast_rtx;
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630 list_for_each_entry_safe(chunk, chunk1, lqueue, transmitted_list) {
631
632 if (sctp_chunk_abandoned(chunk)) {
633 list_del_init(&chunk->transmitted_list);
634 sctp_insert_list(&q->abandoned,
635 &chunk->transmitted_list);
636 continue;
637 }
638
639
640
641
642
643
644 if (chunk->tsn_gap_acked) {
645 list_move_tail(&chunk->transmitted_list,
646 &transport->transmitted);
647 continue;
648 }
649
650
651
652
653 if (fast_rtx && !chunk->fast_retransmit)
654 continue;
655
656redo:
657
658 status = sctp_packet_append_chunk(pkt, chunk);
659
660 switch (status) {
661 case SCTP_XMIT_PMTU_FULL:
662 if (!pkt->has_data && !pkt->has_cookie_echo) {
663
664
665
666
667
668
669 sctp_packet_transmit(pkt, gfp);
670 goto redo;
671 }
672
673
674 error = sctp_packet_transmit(pkt, gfp);
675
676
677
678
679
680 if (rtx_timeout || fast_rtx)
681 done = 1;
682 else
683 goto redo;
684
685
686 break;
687
688 case SCTP_XMIT_RWND_FULL:
689
690 error = sctp_packet_transmit(pkt, gfp);
691
692
693
694
695 done = 1;
696 break;
697
698 case SCTP_XMIT_DELAY:
699
700 error = sctp_packet_transmit(pkt, gfp);
701
702
703 done = 1;
704 break;
705
706 default:
707
708
709
710 list_move_tail(&chunk->transmitted_list,
711 &transport->transmitted);
712
713
714
715
716 if (chunk->fast_retransmit == SCTP_NEED_FRTX)
717 chunk->fast_retransmit = SCTP_DONT_FRTX;
718
719 q->asoc->stats.rtxchunks++;
720 break;
721 }
722
723
724 if (!error && !timer)
725 timer = 1;
726
727 if (done)
728 break;
729 }
730
731
732
733
734
735
736 if (rtx_timeout || fast_rtx) {
737 list_for_each_entry(chunk1, lqueue, transmitted_list) {
738 if (chunk1->fast_retransmit == SCTP_NEED_FRTX)
739 chunk1->fast_retransmit = SCTP_DONT_FRTX;
740 }
741 }
742
743 *start_timer = timer;
744
745
746 if (fast_rtx)
747 q->fast_rtx = 0;
748
749 return error;
750}
751
752
753void sctp_outq_uncork(struct sctp_outq *q, gfp_t gfp)
754{
755 if (q->cork)
756 q->cork = 0;
757
758 sctp_outq_flush(q, 0, gfp);
759}
760
761static int sctp_packet_singleton(struct sctp_transport *transport,
762 struct sctp_chunk *chunk, gfp_t gfp)
763{
764 const struct sctp_association *asoc = transport->asoc;
765 const __u16 sport = asoc->base.bind_addr.port;
766 const __u16 dport = asoc->peer.port;
767 const __u32 vtag = asoc->peer.i.init_tag;
768 struct sctp_packet singleton;
769
770 sctp_packet_init(&singleton, transport, sport, dport);
771 sctp_packet_config(&singleton, vtag, 0);
772 if (sctp_packet_append_chunk(&singleton, chunk) != SCTP_XMIT_OK) {
773 list_del_init(&chunk->list);
774 sctp_chunk_free(chunk);
775 return -ENOMEM;
776 }
777 return sctp_packet_transmit(&singleton, gfp);
778}
779
780
781struct sctp_flush_ctx {
782 struct sctp_outq *q;
783
784 struct sctp_transport *transport;
785
786 struct list_head transport_list;
787 struct sctp_association *asoc;
788
789 struct sctp_packet *packet;
790 gfp_t gfp;
791};
792
793
794static void sctp_outq_select_transport(struct sctp_flush_ctx *ctx,
795 struct sctp_chunk *chunk)
796{
797 struct sctp_transport *new_transport = chunk->transport;
798
799 if (!new_transport) {
800 if (!sctp_chunk_is_data(chunk)) {
801
802
803
804
805
806
807
808
809
810 if (ctx->transport && sctp_cmp_addr_exact(&chunk->dest,
811 &ctx->transport->ipaddr))
812 new_transport = ctx->transport;
813 else
814 new_transport = sctp_assoc_lookup_paddr(ctx->asoc,
815 &chunk->dest);
816 }
817
818
819
820
821 if (!new_transport)
822 new_transport = ctx->asoc->peer.active_path;
823 } else {
824 __u8 type;
825
826 switch (new_transport->state) {
827 case SCTP_INACTIVE:
828 case SCTP_UNCONFIRMED:
829 case SCTP_PF:
830
831
832
833
834
835
836
837
838
839
840
841
842
843 type = chunk->chunk_hdr->type;
844 if (type != SCTP_CID_HEARTBEAT &&
845 type != SCTP_CID_HEARTBEAT_ACK &&
846 type != SCTP_CID_ASCONF_ACK)
847 new_transport = ctx->asoc->peer.active_path;
848 break;
849 default:
850 break;
851 }
852 }
853
854
855 if (new_transport != ctx->transport) {
856 ctx->transport = new_transport;
857 ctx->packet = &ctx->transport->packet;
858
859 if (list_empty(&ctx->transport->send_ready))
860 list_add_tail(&ctx->transport->send_ready,
861 &ctx->transport_list);
862
863 sctp_packet_config(ctx->packet,
864 ctx->asoc->peer.i.init_tag,
865 ctx->asoc->peer.ecn_capable);
866
867
868
869 sctp_transport_burst_limited(ctx->transport);
870 }
871}
872
873static void sctp_outq_flush_ctrl(struct sctp_flush_ctx *ctx)
874{
875 struct sctp_chunk *chunk, *tmp;
876 enum sctp_xmit status;
877 int one_packet, error;
878
879 list_for_each_entry_safe(chunk, tmp, &ctx->q->control_chunk_list, list) {
880 one_packet = 0;
881
882
883
884
885
886
887
888 if (ctx->asoc->src_out_of_asoc_ok &&
889 chunk->chunk_hdr->type != SCTP_CID_ASCONF)
890 continue;
891
892 list_del_init(&chunk->list);
893
894
895
896
897 sctp_outq_select_transport(ctx, chunk);
898
899 switch (chunk->chunk_hdr->type) {
900
901
902
903
904
905 case SCTP_CID_INIT:
906 case SCTP_CID_INIT_ACK:
907 case SCTP_CID_SHUTDOWN_COMPLETE:
908 error = sctp_packet_singleton(ctx->transport, chunk,
909 ctx->gfp);
910 if (error < 0) {
911 ctx->asoc->base.sk->sk_err = -error;
912 return;
913 }
914 break;
915
916 case SCTP_CID_ABORT:
917 if (sctp_test_T_bit(chunk))
918 ctx->packet->vtag = ctx->asoc->c.my_vtag;
919 fallthrough;
920
921
922
923
924
925
926 case SCTP_CID_HEARTBEAT_ACK:
927 case SCTP_CID_SHUTDOWN_ACK:
928 case SCTP_CID_COOKIE_ACK:
929 case SCTP_CID_COOKIE_ECHO:
930 case SCTP_CID_ERROR:
931 case SCTP_CID_ECN_CWR:
932 case SCTP_CID_ASCONF_ACK:
933 one_packet = 1;
934 fallthrough;
935
936 case SCTP_CID_HEARTBEAT:
937 if (chunk->pmtu_probe) {
938 sctp_packet_singleton(ctx->transport, chunk, ctx->gfp);
939 break;
940 }
941 fallthrough;
942 case SCTP_CID_SACK:
943 case SCTP_CID_SHUTDOWN:
944 case SCTP_CID_ECN_ECNE:
945 case SCTP_CID_ASCONF:
946 case SCTP_CID_FWD_TSN:
947 case SCTP_CID_I_FWD_TSN:
948 case SCTP_CID_RECONF:
949 status = sctp_packet_transmit_chunk(ctx->packet, chunk,
950 one_packet, ctx->gfp);
951 if (status != SCTP_XMIT_OK) {
952
953 list_add(&chunk->list, &ctx->q->control_chunk_list);
954 break;
955 }
956
957 ctx->asoc->stats.octrlchunks++;
958
959
960
961
962 if (chunk->chunk_hdr->type == SCTP_CID_FWD_TSN ||
963 chunk->chunk_hdr->type == SCTP_CID_I_FWD_TSN) {
964 sctp_transport_reset_t3_rtx(ctx->transport);
965 ctx->transport->last_time_sent = jiffies;
966 }
967
968 if (chunk == ctx->asoc->strreset_chunk)
969 sctp_transport_reset_reconf_timer(ctx->transport);
970
971 break;
972
973 default:
974
975 BUG();
976 }
977 }
978}
979
980
981static bool sctp_outq_flush_rtx(struct sctp_flush_ctx *ctx,
982 int rtx_timeout)
983{
984 int error, start_timer = 0;
985
986 if (ctx->asoc->peer.retran_path->state == SCTP_UNCONFIRMED)
987 return false;
988
989 if (ctx->transport != ctx->asoc->peer.retran_path) {
990
991 ctx->transport = ctx->asoc->peer.retran_path;
992 ctx->packet = &ctx->transport->packet;
993
994 if (list_empty(&ctx->transport->send_ready))
995 list_add_tail(&ctx->transport->send_ready,
996 &ctx->transport_list);
997
998 sctp_packet_config(ctx->packet, ctx->asoc->peer.i.init_tag,
999 ctx->asoc->peer.ecn_capable);
1000 }
1001
1002 error = __sctp_outq_flush_rtx(ctx->q, ctx->packet, rtx_timeout,
1003 &start_timer, ctx->gfp);
1004 if (error < 0)
1005 ctx->asoc->base.sk->sk_err = -error;
1006
1007 if (start_timer) {
1008 sctp_transport_reset_t3_rtx(ctx->transport);
1009 ctx->transport->last_time_sent = jiffies;
1010 }
1011
1012
1013
1014
1015 if (ctx->packet->has_cookie_echo)
1016 return false;
1017
1018
1019
1020
1021 if (!list_empty(&ctx->q->retransmit))
1022 return false;
1023
1024 return true;
1025}
1026
1027static void sctp_outq_flush_data(struct sctp_flush_ctx *ctx,
1028 int rtx_timeout)
1029{
1030 struct sctp_chunk *chunk;
1031 enum sctp_xmit status;
1032
1033
1034 switch (ctx->asoc->state) {
1035 case SCTP_STATE_COOKIE_ECHOED:
1036
1037
1038
1039 if (!ctx->packet || !ctx->packet->has_cookie_echo)
1040 return;
1041
1042 fallthrough;
1043 case SCTP_STATE_ESTABLISHED:
1044 case SCTP_STATE_SHUTDOWN_PENDING:
1045 case SCTP_STATE_SHUTDOWN_RECEIVED:
1046 break;
1047
1048 default:
1049
1050 return;
1051 }
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061 if (!list_empty(&ctx->q->retransmit) &&
1062 !sctp_outq_flush_rtx(ctx, rtx_timeout))
1063 return;
1064
1065
1066
1067
1068
1069
1070 if (ctx->transport)
1071 sctp_transport_burst_limited(ctx->transport);
1072
1073
1074 while ((chunk = sctp_outq_dequeue_data(ctx->q)) != NULL) {
1075 __u32 sid = ntohs(chunk->subh.data_hdr->stream);
1076 __u8 stream_state = SCTP_SO(&ctx->asoc->stream, sid)->state;
1077
1078
1079 if (sctp_chunk_abandoned(chunk)) {
1080 sctp_sched_dequeue_done(ctx->q, chunk);
1081 sctp_chunk_fail(chunk, 0);
1082 sctp_chunk_free(chunk);
1083 continue;
1084 }
1085
1086 if (stream_state == SCTP_STREAM_CLOSED) {
1087 sctp_outq_head_data(ctx->q, chunk);
1088 break;
1089 }
1090
1091 sctp_outq_select_transport(ctx, chunk);
1092
1093 pr_debug("%s: outq:%p, chunk:%p[%s], tx-tsn:0x%x skb->head:%p skb->users:%d\n",
1094 __func__, ctx->q, chunk, chunk && chunk->chunk_hdr ?
1095 sctp_cname(SCTP_ST_CHUNK(chunk->chunk_hdr->type)) :
1096 "illegal chunk", ntohl(chunk->subh.data_hdr->tsn),
1097 chunk->skb ? chunk->skb->head : NULL, chunk->skb ?
1098 refcount_read(&chunk->skb->users) : -1);
1099
1100
1101 status = sctp_packet_transmit_chunk(ctx->packet, chunk, 0,
1102 ctx->gfp);
1103 if (status != SCTP_XMIT_OK) {
1104
1105
1106
1107 pr_debug("%s: could not transmit tsn:0x%x, status:%d\n",
1108 __func__, ntohl(chunk->subh.data_hdr->tsn),
1109 status);
1110
1111 sctp_outq_head_data(ctx->q, chunk);
1112 break;
1113 }
1114
1115
1116
1117
1118
1119 if (ctx->asoc->state == SCTP_STATE_SHUTDOWN_PENDING)
1120 chunk->chunk_hdr->flags |= SCTP_DATA_SACK_IMM;
1121 if (chunk->chunk_hdr->flags & SCTP_DATA_UNORDERED)
1122 ctx->asoc->stats.ouodchunks++;
1123 else
1124 ctx->asoc->stats.oodchunks++;
1125
1126
1127
1128
1129 sctp_sched_dequeue_done(ctx->q, chunk);
1130
1131 list_add_tail(&chunk->transmitted_list,
1132 &ctx->transport->transmitted);
1133
1134 sctp_transport_reset_t3_rtx(ctx->transport);
1135 ctx->transport->last_time_sent = jiffies;
1136
1137
1138
1139
1140 if (ctx->packet->has_cookie_echo)
1141 break;
1142 }
1143}
1144
1145static void sctp_outq_flush_transports(struct sctp_flush_ctx *ctx)
1146{
1147 struct sock *sk = ctx->asoc->base.sk;
1148 struct list_head *ltransport;
1149 struct sctp_packet *packet;
1150 struct sctp_transport *t;
1151 int error = 0;
1152
1153 while ((ltransport = sctp_list_dequeue(&ctx->transport_list)) != NULL) {
1154 t = list_entry(ltransport, struct sctp_transport, send_ready);
1155 packet = &t->packet;
1156 if (!sctp_packet_empty(packet)) {
1157 rcu_read_lock();
1158 if (t->dst && __sk_dst_get(sk) != t->dst) {
1159 dst_hold(t->dst);
1160 sk_setup_caps(sk, t->dst);
1161 }
1162 rcu_read_unlock();
1163 error = sctp_packet_transmit(packet, ctx->gfp);
1164 if (error < 0)
1165 ctx->q->asoc->base.sk->sk_err = -error;
1166 }
1167
1168
1169 sctp_transport_burst_reset(t);
1170 }
1171}
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182static void sctp_outq_flush(struct sctp_outq *q, int rtx_timeout, gfp_t gfp)
1183{
1184 struct sctp_flush_ctx ctx = {
1185 .q = q,
1186 .transport = NULL,
1187 .transport_list = LIST_HEAD_INIT(ctx.transport_list),
1188 .asoc = q->asoc,
1189 .packet = NULL,
1190 .gfp = gfp,
1191 };
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202 sctp_outq_flush_ctrl(&ctx);
1203
1204 if (q->asoc->src_out_of_asoc_ok)
1205 goto sctp_flush_out;
1206
1207 sctp_outq_flush_data(&ctx, rtx_timeout);
1208
1209sctp_flush_out:
1210
1211 sctp_outq_flush_transports(&ctx);
1212}
1213
1214
1215static void sctp_sack_update_unack_data(struct sctp_association *assoc,
1216 struct sctp_sackhdr *sack)
1217{
1218 union sctp_sack_variable *frags;
1219 __u16 unack_data;
1220 int i;
1221
1222 unack_data = assoc->next_tsn - assoc->ctsn_ack_point - 1;
1223
1224 frags = sack->variable;
1225 for (i = 0; i < ntohs(sack->num_gap_ack_blocks); i++) {
1226 unack_data -= ((ntohs(frags[i].gab.end) -
1227 ntohs(frags[i].gab.start) + 1));
1228 }
1229
1230 assoc->unack_data = unack_data;
1231}
1232
1233
1234
1235
1236
1237
1238int sctp_outq_sack(struct sctp_outq *q, struct sctp_chunk *chunk)
1239{
1240 struct sctp_association *asoc = q->asoc;
1241 struct sctp_sackhdr *sack = chunk->subh.sack_hdr;
1242 struct sctp_transport *transport;
1243 struct sctp_chunk *tchunk = NULL;
1244 struct list_head *lchunk, *transport_list, *temp;
1245 union sctp_sack_variable *frags = sack->variable;
1246 __u32 sack_ctsn, ctsn, tsn;
1247 __u32 highest_tsn, highest_new_tsn;
1248 __u32 sack_a_rwnd;
1249 unsigned int outstanding;
1250 struct sctp_transport *primary = asoc->peer.primary_path;
1251 int count_of_newacks = 0;
1252 int gap_ack_blocks;
1253 u8 accum_moved = 0;
1254
1255
1256 transport_list = &asoc->peer.transport_addr_list;
1257
1258
1259 if (trace_sctp_probe_path_enabled()) {
1260 list_for_each_entry(transport, transport_list, transports)
1261 trace_sctp_probe_path(transport, asoc);
1262 }
1263
1264 sack_ctsn = ntohl(sack->cum_tsn_ack);
1265 gap_ack_blocks = ntohs(sack->num_gap_ack_blocks);
1266 asoc->stats.gapcnt += gap_ack_blocks;
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285 if (primary->cacc.changeover_active) {
1286 u8 clear_cycling = 0;
1287
1288 if (TSN_lte(primary->cacc.next_tsn_at_change, sack_ctsn)) {
1289 primary->cacc.changeover_active = 0;
1290 clear_cycling = 1;
1291 }
1292
1293 if (clear_cycling || gap_ack_blocks) {
1294 list_for_each_entry(transport, transport_list,
1295 transports) {
1296 if (clear_cycling)
1297 transport->cacc.cycling_changeover = 0;
1298 if (gap_ack_blocks)
1299 transport->cacc.cacc_saw_newack = 0;
1300 }
1301 }
1302 }
1303
1304
1305 highest_tsn = sack_ctsn;
1306 if (gap_ack_blocks)
1307 highest_tsn += ntohs(frags[gap_ack_blocks - 1].gab.end);
1308
1309 if (TSN_lt(asoc->highest_sacked, highest_tsn))
1310 asoc->highest_sacked = highest_tsn;
1311
1312 highest_new_tsn = sack_ctsn;
1313
1314
1315
1316
1317 sctp_check_transmitted(q, &q->retransmit, NULL, NULL, sack, &highest_new_tsn);
1318
1319
1320
1321
1322
1323
1324 list_for_each_entry(transport, transport_list, transports) {
1325 sctp_check_transmitted(q, &transport->transmitted,
1326 transport, &chunk->source, sack,
1327 &highest_new_tsn);
1328
1329
1330
1331
1332
1333 if (transport->cacc.cacc_saw_newack)
1334 count_of_newacks++;
1335 }
1336
1337
1338 if (TSN_lt(asoc->ctsn_ack_point, sack_ctsn)) {
1339 asoc->ctsn_ack_point = sack_ctsn;
1340 accum_moved = 1;
1341 }
1342
1343 if (gap_ack_blocks) {
1344
1345 if (asoc->fast_recovery && accum_moved)
1346 highest_new_tsn = highest_tsn;
1347
1348 list_for_each_entry(transport, transport_list, transports)
1349 sctp_mark_missing(q, &transport->transmitted, transport,
1350 highest_new_tsn, count_of_newacks);
1351 }
1352
1353
1354 sctp_sack_update_unack_data(asoc, sack);
1355
1356 ctsn = asoc->ctsn_ack_point;
1357
1358
1359 list_for_each_safe(lchunk, temp, &q->sacked) {
1360 tchunk = list_entry(lchunk, struct sctp_chunk,
1361 transmitted_list);
1362 tsn = ntohl(tchunk->subh.data_hdr->tsn);
1363 if (TSN_lte(tsn, ctsn)) {
1364 list_del_init(&tchunk->transmitted_list);
1365 if (asoc->peer.prsctp_capable &&
1366 SCTP_PR_PRIO_ENABLED(chunk->sinfo.sinfo_flags))
1367 asoc->sent_cnt_removable--;
1368 sctp_chunk_free(tchunk);
1369 }
1370 }
1371
1372
1373
1374
1375
1376
1377 sack_a_rwnd = ntohl(sack->a_rwnd);
1378 asoc->peer.zero_window_announced = !sack_a_rwnd;
1379 outstanding = q->outstanding_bytes;
1380
1381 if (outstanding < sack_a_rwnd)
1382 sack_a_rwnd -= outstanding;
1383 else
1384 sack_a_rwnd = 0;
1385
1386 asoc->peer.rwnd = sack_a_rwnd;
1387
1388 asoc->stream.si->generate_ftsn(q, sack_ctsn);
1389
1390 pr_debug("%s: sack cumulative tsn ack:0x%x\n", __func__, sack_ctsn);
1391 pr_debug("%s: cumulative tsn ack of assoc:%p is 0x%x, "
1392 "advertised peer ack point:0x%x\n", __func__, asoc, ctsn,
1393 asoc->adv_peer_ack_point);
1394
1395 return sctp_outq_is_empty(q);
1396}
1397
1398
1399
1400
1401
1402int sctp_outq_is_empty(const struct sctp_outq *q)
1403{
1404 return q->out_qlen == 0 && q->outstanding_bytes == 0 &&
1405 list_empty(&q->retransmit);
1406}
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422static void sctp_check_transmitted(struct sctp_outq *q,
1423 struct list_head *transmitted_queue,
1424 struct sctp_transport *transport,
1425 union sctp_addr *saddr,
1426 struct sctp_sackhdr *sack,
1427 __u32 *highest_new_tsn_in_sack)
1428{
1429 struct list_head *lchunk;
1430 struct sctp_chunk *tchunk;
1431 struct list_head tlist;
1432 __u32 tsn;
1433 __u32 sack_ctsn;
1434 __u32 rtt;
1435 __u8 restart_timer = 0;
1436 int bytes_acked = 0;
1437 int migrate_bytes = 0;
1438 bool forward_progress = false;
1439
1440 sack_ctsn = ntohl(sack->cum_tsn_ack);
1441
1442 INIT_LIST_HEAD(&tlist);
1443
1444
1445 while (NULL != (lchunk = sctp_list_dequeue(transmitted_queue))) {
1446 tchunk = list_entry(lchunk, struct sctp_chunk,
1447 transmitted_list);
1448
1449 if (sctp_chunk_abandoned(tchunk)) {
1450
1451 sctp_insert_list(&q->abandoned, lchunk);
1452
1453
1454
1455
1456 if (transmitted_queue != &q->retransmit &&
1457 !tchunk->tsn_gap_acked) {
1458 if (tchunk->transport)
1459 tchunk->transport->flight_size -=
1460 sctp_data_size(tchunk);
1461 q->outstanding_bytes -= sctp_data_size(tchunk);
1462 }
1463 continue;
1464 }
1465
1466 tsn = ntohl(tchunk->subh.data_hdr->tsn);
1467 if (sctp_acked(sack, tsn)) {
1468
1469
1470
1471
1472
1473 if (transport && !tchunk->tsn_gap_acked) {
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485 if (!sctp_chunk_retransmitted(tchunk) &&
1486 tchunk->rtt_in_progress) {
1487 tchunk->rtt_in_progress = 0;
1488 rtt = jiffies - tchunk->sent_at;
1489 sctp_transport_update_rto(transport,
1490 rtt);
1491 }
1492
1493 if (TSN_lte(tsn, sack_ctsn)) {
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507 if (sack->num_gap_ack_blocks &&
1508 q->asoc->peer.primary_path->cacc.
1509 changeover_active)
1510 transport->cacc.cacc_saw_newack
1511 = 1;
1512 }
1513 }
1514
1515
1516
1517
1518
1519
1520
1521 if (!tchunk->tsn_gap_acked) {
1522 tchunk->tsn_gap_acked = 1;
1523 if (TSN_lt(*highest_new_tsn_in_sack, tsn))
1524 *highest_new_tsn_in_sack = tsn;
1525 bytes_acked += sctp_data_size(tchunk);
1526 if (!tchunk->transport)
1527 migrate_bytes += sctp_data_size(tchunk);
1528 forward_progress = true;
1529 }
1530
1531 if (TSN_lte(tsn, sack_ctsn)) {
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541 restart_timer = 1;
1542 forward_progress = true;
1543
1544 list_add_tail(&tchunk->transmitted_list,
1545 &q->sacked);
1546 } else {
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562 list_add_tail(lchunk, &tlist);
1563 }
1564 } else {
1565 if (tchunk->tsn_gap_acked) {
1566 pr_debug("%s: receiver reneged on data TSN:0x%x\n",
1567 __func__, tsn);
1568
1569 tchunk->tsn_gap_acked = 0;
1570
1571 if (tchunk->transport)
1572 bytes_acked -= sctp_data_size(tchunk);
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583 restart_timer = 1;
1584 }
1585
1586 list_add_tail(lchunk, &tlist);
1587 }
1588 }
1589
1590 if (transport) {
1591 if (bytes_acked) {
1592 struct sctp_association *asoc = transport->asoc;
1593
1594
1595
1596
1597
1598
1599
1600 bytes_acked -= migrate_bytes;
1601
1602
1603
1604
1605
1606
1607
1608
1609 transport->error_count = 0;
1610 transport->asoc->overall_error_count = 0;
1611 forward_progress = true;
1612
1613
1614
1615
1616
1617
1618
1619 if (asoc->state == SCTP_STATE_SHUTDOWN_PENDING &&
1620 del_timer(&asoc->timers
1621 [SCTP_EVENT_TIMEOUT_T5_SHUTDOWN_GUARD]))
1622 sctp_association_put(asoc);
1623
1624
1625
1626
1627 if ((transport->state == SCTP_INACTIVE ||
1628 transport->state == SCTP_UNCONFIRMED) &&
1629 sctp_cmp_addr_exact(&transport->ipaddr, saddr)) {
1630 sctp_assoc_control_transport(
1631 transport->asoc,
1632 transport,
1633 SCTP_TRANSPORT_UP,
1634 SCTP_RECEIVED_SACK);
1635 }
1636
1637 sctp_transport_raise_cwnd(transport, sack_ctsn,
1638 bytes_acked);
1639
1640 transport->flight_size -= bytes_acked;
1641 if (transport->flight_size == 0)
1642 transport->partial_bytes_acked = 0;
1643 q->outstanding_bytes -= bytes_acked + migrate_bytes;
1644 } else {
1645
1646
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659 if (!q->asoc->peer.rwnd &&
1660 !list_empty(&tlist) &&
1661 (sack_ctsn+2 == q->asoc->next_tsn) &&
1662 q->asoc->state < SCTP_STATE_SHUTDOWN_PENDING) {
1663 pr_debug("%s: sack received for zero window "
1664 "probe:%u\n", __func__, sack_ctsn);
1665
1666 q->asoc->overall_error_count = 0;
1667 transport->error_count = 0;
1668 }
1669 }
1670
1671
1672
1673
1674
1675
1676
1677 if (!transport->flight_size) {
1678 if (del_timer(&transport->T3_rtx_timer))
1679 sctp_transport_put(transport);
1680 } else if (restart_timer) {
1681 if (!mod_timer(&transport->T3_rtx_timer,
1682 jiffies + transport->rto))
1683 sctp_transport_hold(transport);
1684 }
1685
1686 if (forward_progress) {
1687 if (transport->dst)
1688 sctp_transport_dst_confirm(transport);
1689 }
1690 }
1691
1692 list_splice(&tlist, transmitted_queue);
1693}
1694
1695
1696static void sctp_mark_missing(struct sctp_outq *q,
1697 struct list_head *transmitted_queue,
1698 struct sctp_transport *transport,
1699 __u32 highest_new_tsn_in_sack,
1700 int count_of_newacks)
1701{
1702 struct sctp_chunk *chunk;
1703 __u32 tsn;
1704 char do_fast_retransmit = 0;
1705 struct sctp_association *asoc = q->asoc;
1706 struct sctp_transport *primary = asoc->peer.primary_path;
1707
1708 list_for_each_entry(chunk, transmitted_queue, transmitted_list) {
1709
1710 tsn = ntohl(chunk->subh.data_hdr->tsn);
1711
1712
1713
1714
1715
1716
1717
1718
1719 if (chunk->fast_retransmit == SCTP_CAN_FRTX &&
1720 !chunk->tsn_gap_acked &&
1721 TSN_lt(tsn, highest_new_tsn_in_sack)) {
1722
1723
1724
1725
1726 if (!transport || !sctp_cacc_skip(primary,
1727 chunk->transport,
1728 count_of_newacks, tsn)) {
1729 chunk->tsn_missing_report++;
1730
1731 pr_debug("%s: tsn:0x%x missing counter:%d\n",
1732 __func__, tsn, chunk->tsn_missing_report);
1733 }
1734 }
1735
1736
1737
1738
1739
1740
1741
1742 if (chunk->tsn_missing_report >= 3) {
1743 chunk->fast_retransmit = SCTP_NEED_FRTX;
1744 do_fast_retransmit = 1;
1745 }
1746 }
1747
1748 if (transport) {
1749 if (do_fast_retransmit)
1750 sctp_retransmit(q, transport, SCTP_RTXR_FAST_RTX);
1751
1752 pr_debug("%s: transport:%p, cwnd:%d, ssthresh:%d, "
1753 "flight_size:%d, pba:%d\n", __func__, transport,
1754 transport->cwnd, transport->ssthresh,
1755 transport->flight_size, transport->partial_bytes_acked);
1756 }
1757}
1758
1759
1760static int sctp_acked(struct sctp_sackhdr *sack, __u32 tsn)
1761{
1762 __u32 ctsn = ntohl(sack->cum_tsn_ack);
1763 union sctp_sack_variable *frags;
1764 __u16 tsn_offset, blocks;
1765 int i;
1766
1767 if (TSN_lte(tsn, ctsn))
1768 goto pass;
1769
1770
1771
1772
1773
1774
1775
1776
1777
1778
1779
1780
1781
1782 frags = sack->variable;
1783 blocks = ntohs(sack->num_gap_ack_blocks);
1784 tsn_offset = tsn - ctsn;
1785 for (i = 0; i < blocks; ++i) {
1786 if (tsn_offset >= ntohs(frags[i].gab.start) &&
1787 tsn_offset <= ntohs(frags[i].gab.end))
1788 goto pass;
1789 }
1790
1791 return 0;
1792pass:
1793 return 1;
1794}
1795
1796static inline int sctp_get_skip_pos(struct sctp_fwdtsn_skip *skiplist,
1797 int nskips, __be16 stream)
1798{
1799 int i;
1800
1801 for (i = 0; i < nskips; i++) {
1802 if (skiplist[i].stream == stream)
1803 return i;
1804 }
1805 return i;
1806}
1807
1808
1809void sctp_generate_fwdtsn(struct sctp_outq *q, __u32 ctsn)
1810{
1811 struct sctp_association *asoc = q->asoc;
1812 struct sctp_chunk *ftsn_chunk = NULL;
1813 struct sctp_fwdtsn_skip ftsn_skip_arr[10];
1814 int nskips = 0;
1815 int skip_pos = 0;
1816 __u32 tsn;
1817 struct sctp_chunk *chunk;
1818 struct list_head *lchunk, *temp;
1819
1820 if (!asoc->peer.prsctp_capable)
1821 return;
1822
1823
1824
1825
1826
1827
1828
1829 if (TSN_lt(asoc->adv_peer_ack_point, ctsn))
1830 asoc->adv_peer_ack_point = ctsn;
1831
1832
1833
1834
1835
1836
1837
1838
1839
1840
1841
1842
1843
1844
1845
1846
1847
1848
1849
1850
1851
1852
1853 list_for_each_safe(lchunk, temp, &q->abandoned) {
1854 chunk = list_entry(lchunk, struct sctp_chunk,
1855 transmitted_list);
1856 tsn = ntohl(chunk->subh.data_hdr->tsn);
1857
1858
1859
1860
1861 if (TSN_lte(tsn, ctsn)) {
1862 list_del_init(lchunk);
1863 sctp_chunk_free(chunk);
1864 } else {
1865 if (TSN_lte(tsn, asoc->adv_peer_ack_point+1)) {
1866 asoc->adv_peer_ack_point = tsn;
1867 if (chunk->chunk_hdr->flags &
1868 SCTP_DATA_UNORDERED)
1869 continue;
1870 skip_pos = sctp_get_skip_pos(&ftsn_skip_arr[0],
1871 nskips,
1872 chunk->subh.data_hdr->stream);
1873 ftsn_skip_arr[skip_pos].stream =
1874 chunk->subh.data_hdr->stream;
1875 ftsn_skip_arr[skip_pos].ssn =
1876 chunk->subh.data_hdr->ssn;
1877 if (skip_pos == nskips)
1878 nskips++;
1879 if (nskips == 10)
1880 break;
1881 } else
1882 break;
1883 }
1884 }
1885
1886
1887
1888
1889
1890
1891
1892
1893
1894
1895
1896
1897
1898
1899
1900
1901
1902
1903
1904 if (asoc->adv_peer_ack_point > ctsn)
1905 ftsn_chunk = sctp_make_fwdtsn(asoc, asoc->adv_peer_ack_point,
1906 nskips, &ftsn_skip_arr[0]);
1907
1908 if (ftsn_chunk) {
1909 list_add_tail(&ftsn_chunk->list, &q->control_chunk_list);
1910 SCTP_INC_STATS(asoc->base.net, SCTP_MIB_OUTCTRLCHUNKS);
1911 }
1912}
1913