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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
52
53#include <linux/slab.h>
54#include <linux/types.h>
55#include <linux/random.h>
56#include <net/sctp/sctp.h>
57#include <net/sctp/sm.h>
58
59
60
61
62static struct sctp_transport *sctp_transport_init(struct net *net,
63 struct sctp_transport *peer,
64 const union sctp_addr *addr,
65 gfp_t gfp)
66{
67
68 peer->ipaddr = *addr;
69 peer->af_specific = sctp_get_af_specific(addr->sa.sa_family);
70 memset(&peer->saddr, 0, sizeof(union sctp_addr));
71
72 peer->sack_generation = 0;
73
74
75
76
77
78
79
80 peer->rto = msecs_to_jiffies(net->sctp.rto_initial);
81
82 peer->last_time_heard = jiffies;
83 peer->last_time_ecne_reduced = jiffies;
84
85 peer->param_flags = SPP_HB_DISABLE |
86 SPP_PMTUD_ENABLE |
87 SPP_SACKDELAY_ENABLE;
88
89
90 peer->pathmaxrxt = net->sctp.max_retrans_path;
91 peer->pf_retrans = net->sctp.pf_retrans;
92
93 INIT_LIST_HEAD(&peer->transmitted);
94 INIT_LIST_HEAD(&peer->send_ready);
95 INIT_LIST_HEAD(&peer->transports);
96
97 setup_timer(&peer->T3_rtx_timer, sctp_generate_t3_rtx_event,
98 (unsigned long)peer);
99 setup_timer(&peer->hb_timer, sctp_generate_heartbeat_event,
100 (unsigned long)peer);
101 setup_timer(&peer->proto_unreach_timer,
102 sctp_generate_proto_unreach_event, (unsigned long)peer);
103
104
105 get_random_bytes(&peer->hb_nonce, sizeof(peer->hb_nonce));
106
107 atomic_set(&peer->refcnt, 1);
108
109 return peer;
110}
111
112
113struct sctp_transport *sctp_transport_new(struct net *net,
114 const union sctp_addr *addr,
115 gfp_t gfp)
116{
117 struct sctp_transport *transport;
118
119 transport = t_new(struct sctp_transport, gfp);
120 if (!transport)
121 goto fail;
122
123 if (!sctp_transport_init(net, transport, addr, gfp))
124 goto fail_init;
125
126 SCTP_DBG_OBJCNT_INC(transport);
127
128 return transport;
129
130fail_init:
131 kfree(transport);
132
133fail:
134 return NULL;
135}
136
137
138
139
140void sctp_transport_free(struct sctp_transport *transport)
141{
142 transport->dead = 1;
143
144
145 if (del_timer(&transport->hb_timer))
146 sctp_transport_put(transport);
147
148
149
150
151
152
153 if (del_timer(&transport->T3_rtx_timer))
154 sctp_transport_put(transport);
155
156
157 if (del_timer(&transport->proto_unreach_timer))
158 sctp_association_put(transport->asoc);
159
160 sctp_transport_put(transport);
161}
162
163static void sctp_transport_destroy_rcu(struct rcu_head *head)
164{
165 struct sctp_transport *transport;
166
167 transport = container_of(head, struct sctp_transport, rcu);
168
169 dst_release(transport->dst);
170 kfree(transport);
171 SCTP_DBG_OBJCNT_DEC(transport);
172}
173
174
175
176
177static void sctp_transport_destroy(struct sctp_transport *transport)
178{
179 SCTP_ASSERT(transport->dead, "Transport is not dead", return);
180
181 call_rcu(&transport->rcu, sctp_transport_destroy_rcu);
182
183 sctp_packet_free(&transport->packet);
184
185 if (transport->asoc)
186 sctp_association_put(transport->asoc);
187}
188
189
190
191
192void sctp_transport_reset_timers(struct sctp_transport *transport)
193{
194
195
196
197
198
199
200
201
202 if (!timer_pending(&transport->T3_rtx_timer))
203 if (!mod_timer(&transport->T3_rtx_timer,
204 jiffies + transport->rto))
205 sctp_transport_hold(transport);
206
207
208 if (!mod_timer(&transport->hb_timer,
209 sctp_transport_timeout(transport)))
210 sctp_transport_hold(transport);
211}
212
213
214
215
216
217void sctp_transport_set_owner(struct sctp_transport *transport,
218 struct sctp_association *asoc)
219{
220 transport->asoc = asoc;
221 sctp_association_hold(asoc);
222}
223
224
225void sctp_transport_pmtu(struct sctp_transport *transport, struct sock *sk)
226{
227
228 if (!transport->dst || transport->dst->obsolete) {
229 dst_release(transport->dst);
230 transport->af_specific->get_dst(transport, &transport->saddr,
231 &transport->fl, sk);
232 }
233
234 if (transport->dst) {
235 transport->pathmtu = dst_mtu(transport->dst);
236 } else
237 transport->pathmtu = SCTP_DEFAULT_MAXSEGMENT;
238}
239
240void sctp_transport_update_pmtu(struct sock *sk, struct sctp_transport *t, u32 pmtu)
241{
242 struct dst_entry *dst;
243
244 if (unlikely(pmtu < SCTP_DEFAULT_MINSEGMENT)) {
245 pr_warn("%s: Reported pmtu %d too low, using default minimum of %d\n",
246 __func__, pmtu,
247 SCTP_DEFAULT_MINSEGMENT);
248
249
250
251 t->pathmtu = SCTP_DEFAULT_MINSEGMENT;
252 } else {
253 t->pathmtu = pmtu;
254 }
255
256 dst = sctp_transport_dst_check(t);
257 if (!dst)
258 t->af_specific->get_dst(t, &t->saddr, &t->fl, sk);
259
260 if (dst) {
261 dst->ops->update_pmtu(dst, sk, NULL, pmtu);
262
263 dst = sctp_transport_dst_check(t);
264 if (!dst)
265 t->af_specific->get_dst(t, &t->saddr, &t->fl, sk);
266 }
267}
268
269
270
271
272void sctp_transport_route(struct sctp_transport *transport,
273 union sctp_addr *saddr, struct sctp_sock *opt)
274{
275 struct sctp_association *asoc = transport->asoc;
276 struct sctp_af *af = transport->af_specific;
277
278 af->get_dst(transport, saddr, &transport->fl, sctp_opt2sk(opt));
279
280 if (saddr)
281 memcpy(&transport->saddr, saddr, sizeof(union sctp_addr));
282 else
283 af->get_saddr(opt, transport, &transport->fl);
284
285 if ((transport->param_flags & SPP_PMTUD_DISABLE) && transport->pathmtu) {
286 return;
287 }
288 if (transport->dst) {
289 transport->pathmtu = dst_mtu(transport->dst);
290
291
292
293
294 if (asoc && (!asoc->peer.primary_path ||
295 (transport == asoc->peer.active_path)))
296 opt->pf->af->to_sk_saddr(&transport->saddr,
297 asoc->base.sk);
298 } else
299 transport->pathmtu = SCTP_DEFAULT_MAXSEGMENT;
300}
301
302
303void sctp_transport_hold(struct sctp_transport *transport)
304{
305 atomic_inc(&transport->refcnt);
306}
307
308
309
310
311void sctp_transport_put(struct sctp_transport *transport)
312{
313 if (atomic_dec_and_test(&transport->refcnt))
314 sctp_transport_destroy(transport);
315}
316
317
318void sctp_transport_update_rto(struct sctp_transport *tp, __u32 rtt)
319{
320
321 SCTP_ASSERT(tp, "NULL transport", return);
322
323
324 SCTP_ASSERT(tp->rto_pending, "rto_pending not set", return);
325
326 if (tp->rttvar || tp->srtt) {
327 struct net *net = sock_net(tp->asoc->base.sk);
328
329
330
331
332
333
334
335
336
337
338
339 tp->rttvar = tp->rttvar - (tp->rttvar >> net->sctp.rto_beta)
340 + (((__u32)abs64((__s64)tp->srtt - (__s64)rtt)) >> net->sctp.rto_beta);
341 tp->srtt = tp->srtt - (tp->srtt >> net->sctp.rto_alpha)
342 + (rtt >> net->sctp.rto_alpha);
343 } else {
344
345
346
347 tp->srtt = rtt;
348 tp->rttvar = rtt >> 1;
349 }
350
351
352
353
354 if (tp->rttvar == 0)
355 tp->rttvar = SCTP_CLOCK_GRANULARITY;
356
357
358 tp->rto = tp->srtt + (tp->rttvar << 2);
359
360
361
362
363 if (tp->rto < tp->asoc->rto_min)
364 tp->rto = tp->asoc->rto_min;
365
366
367
368
369 if (tp->rto > tp->asoc->rto_max)
370 tp->rto = tp->asoc->rto_max;
371
372 sctp_max_rto(tp->asoc, tp);
373 tp->rtt = rtt;
374
375
376
377
378 tp->rto_pending = 0;
379
380 SCTP_DEBUG_PRINTK("%s: transport: %p, rtt: %d, srtt: %d "
381 "rttvar: %d, rto: %ld\n", __func__,
382 tp, rtt, tp->srtt, tp->rttvar, tp->rto);
383}
384
385
386
387
388void sctp_transport_raise_cwnd(struct sctp_transport *transport,
389 __u32 sack_ctsn, __u32 bytes_acked)
390{
391 struct sctp_association *asoc = transport->asoc;
392 __u32 cwnd, ssthresh, flight_size, pba, pmtu;
393
394 cwnd = transport->cwnd;
395 flight_size = transport->flight_size;
396
397
398 if (asoc->fast_recovery &&
399 TSN_lte(asoc->fast_recovery_exit, sack_ctsn))
400 asoc->fast_recovery = 0;
401
402
403
404
405
406 if (TSN_lte(sack_ctsn, transport->asoc->ctsn_ack_point) ||
407 (flight_size < cwnd))
408 return;
409
410 ssthresh = transport->ssthresh;
411 pba = transport->partial_bytes_acked;
412 pmtu = transport->asoc->pathmtu;
413
414 if (cwnd <= ssthresh) {
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429 if (asoc->fast_recovery)
430 return;
431
432 if (bytes_acked > pmtu)
433 cwnd += pmtu;
434 else
435 cwnd += bytes_acked;
436 SCTP_DEBUG_PRINTK("%s: SLOW START: transport: %p, "
437 "bytes_acked: %d, cwnd: %d, ssthresh: %d, "
438 "flight_size: %d, pba: %d\n",
439 __func__,
440 transport, bytes_acked, cwnd,
441 ssthresh, flight_size, pba);
442 } else {
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457 pba += bytes_acked;
458 if (pba >= cwnd) {
459 cwnd += pmtu;
460 pba = ((cwnd < pba) ? (pba - cwnd) : 0);
461 }
462 SCTP_DEBUG_PRINTK("%s: CONGESTION AVOIDANCE: "
463 "transport: %p, bytes_acked: %d, cwnd: %d, "
464 "ssthresh: %d, flight_size: %d, pba: %d\n",
465 __func__,
466 transport, bytes_acked, cwnd,
467 ssthresh, flight_size, pba);
468 }
469
470 transport->cwnd = cwnd;
471 transport->partial_bytes_acked = pba;
472}
473
474
475
476
477void sctp_transport_lower_cwnd(struct sctp_transport *transport,
478 sctp_lower_cwnd_t reason)
479{
480 struct sctp_association *asoc = transport->asoc;
481
482 switch (reason) {
483 case SCTP_LOWER_CWND_T3_RTX:
484
485
486
487
488
489
490
491 transport->ssthresh = max(transport->cwnd/2,
492 4*asoc->pathmtu);
493 transport->cwnd = asoc->pathmtu;
494
495
496 asoc->fast_recovery = 0;
497 break;
498
499 case SCTP_LOWER_CWND_FAST_RTX:
500
501
502
503
504
505
506
507
508
509
510
511
512 if (asoc->fast_recovery)
513 return;
514
515
516 asoc->fast_recovery = 1;
517 asoc->fast_recovery_exit = asoc->next_tsn - 1;
518
519 transport->ssthresh = max(transport->cwnd/2,
520 4*asoc->pathmtu);
521 transport->cwnd = transport->ssthresh;
522 break;
523
524 case SCTP_LOWER_CWND_ECNE:
525
526
527
528
529
530
531
532
533
534
535
536
537 if (time_after(jiffies, transport->last_time_ecne_reduced +
538 transport->rtt)) {
539 transport->ssthresh = max(transport->cwnd/2,
540 4*asoc->pathmtu);
541 transport->cwnd = transport->ssthresh;
542 transport->last_time_ecne_reduced = jiffies;
543 }
544 break;
545
546 case SCTP_LOWER_CWND_INACTIVE:
547
548
549
550
551
552
553
554
555 transport->cwnd = max(transport->cwnd/2,
556 4*asoc->pathmtu);
557 break;
558 }
559
560 transport->partial_bytes_acked = 0;
561 SCTP_DEBUG_PRINTK("%s: transport: %p reason: %d cwnd: "
562 "%d ssthresh: %d\n", __func__,
563 transport, reason,
564 transport->cwnd, transport->ssthresh);
565}
566
567
568
569
570
571
572
573
574
575
576
577void sctp_transport_burst_limited(struct sctp_transport *t)
578{
579 struct sctp_association *asoc = t->asoc;
580 u32 old_cwnd = t->cwnd;
581 u32 max_burst_bytes;
582
583 if (t->burst_limited)
584 return;
585
586 max_burst_bytes = t->flight_size + (asoc->max_burst * asoc->pathmtu);
587 if (max_burst_bytes < old_cwnd) {
588 t->cwnd = max_burst_bytes;
589 t->burst_limited = old_cwnd;
590 }
591}
592
593
594
595
596void sctp_transport_burst_reset(struct sctp_transport *t)
597{
598 if (t->burst_limited) {
599 t->cwnd = t->burst_limited;
600 t->burst_limited = 0;
601 }
602}
603
604
605unsigned long sctp_transport_timeout(struct sctp_transport *t)
606{
607 unsigned long timeout;
608 timeout = t->rto + sctp_jitter(t->rto);
609 if ((t->state != SCTP_UNCONFIRMED) &&
610 (t->state != SCTP_PF))
611 timeout += t->hbinterval;
612 timeout += jiffies;
613 return timeout;
614}
615
616
617void sctp_transport_reset(struct sctp_transport *t)
618{
619 struct sctp_association *asoc = t->asoc;
620
621
622
623
624
625
626 t->cwnd = min(4*asoc->pathmtu, max_t(__u32, 2*asoc->pathmtu, 4380));
627 t->burst_limited = 0;
628 t->ssthresh = asoc->peer.i.a_rwnd;
629 t->rto = asoc->rto_initial;
630 sctp_max_rto(asoc, t);
631 t->rtt = 0;
632 t->srtt = 0;
633 t->rttvar = 0;
634
635
636
637
638 t->partial_bytes_acked = 0;
639 t->flight_size = 0;
640 t->error_count = 0;
641 t->rto_pending = 0;
642 t->hb_sent = 0;
643
644
645 t->cacc.changeover_active = 0;
646 t->cacc.cycling_changeover = 0;
647 t->cacc.next_tsn_at_change = 0;
648 t->cacc.cacc_saw_newack = 0;
649}
650
651
652void sctp_transport_immediate_rtx(struct sctp_transport *t)
653{
654
655 if (del_timer(&t->T3_rtx_timer))
656 sctp_transport_put(t);
657
658 sctp_retransmit(&t->asoc->outqueue, t, SCTP_RTXR_T3_RTX);
659 if (!timer_pending(&t->T3_rtx_timer)) {
660 if (!mod_timer(&t->T3_rtx_timer, jiffies + t->rto))
661 sctp_transport_hold(t);
662 }
663 return;
664}
665