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#include "../dccp.h"
36#include "ccid3.h"
37
38#include <asm/unaligned.h>
39
40#ifdef CONFIG_IP_DCCP_CCID3_DEBUG
41static int ccid3_debug;
42#define ccid3_pr_debug(format, a...) DCCP_PR_DEBUG(ccid3_debug, format, ##a)
43#else
44#define ccid3_pr_debug(format, a...)
45#endif
46
47
48
49
50#ifdef CONFIG_IP_DCCP_CCID3_DEBUG
51static const char *ccid3_tx_state_name(enum ccid3_hc_tx_states state)
52{
53 static const char *const ccid3_state_names[] = {
54 [TFRC_SSTATE_NO_SENT] = "NO_SENT",
55 [TFRC_SSTATE_NO_FBACK] = "NO_FBACK",
56 [TFRC_SSTATE_FBACK] = "FBACK",
57 [TFRC_SSTATE_TERM] = "TERM",
58 };
59
60 return ccid3_state_names[state];
61}
62#endif
63
64static void ccid3_hc_tx_set_state(struct sock *sk,
65 enum ccid3_hc_tx_states state)
66{
67 struct ccid3_hc_tx_sock *hctx = ccid3_hc_tx_sk(sk);
68 enum ccid3_hc_tx_states oldstate = hctx->ccid3hctx_state;
69
70 ccid3_pr_debug("%s(%p) %-8.8s -> %s\n",
71 dccp_role(sk), sk, ccid3_tx_state_name(oldstate),
72 ccid3_tx_state_name(state));
73 WARN_ON(state == oldstate);
74 hctx->ccid3hctx_state = state;
75}
76
77
78
79
80
81
82
83
84
85
86static inline u64 rfc3390_initial_rate(struct sock *sk)
87{
88 const struct ccid3_hc_tx_sock *hctx = ccid3_hc_tx_sk(sk);
89 const __u32 w_init = clamp_t(__u32, 4380U,
90 2 * hctx->ccid3hctx_s, 4 * hctx->ccid3hctx_s);
91
92 return scaled_div(w_init << 6, hctx->ccid3hctx_rtt);
93}
94
95
96
97
98static void ccid3_update_send_interval(struct ccid3_hc_tx_sock *hctx)
99{
100
101 hctx->ccid3hctx_t_ipi = scaled_div32(((u64)hctx->ccid3hctx_s) << 6,
102 hctx->ccid3hctx_x);
103
104
105 hctx->ccid3hctx_delta = min_t(u32, hctx->ccid3hctx_t_ipi / 2,
106 TFRC_OPSYS_HALF_TIME_GRAN);
107
108 ccid3_pr_debug("t_ipi=%u, delta=%u, s=%u, X=%u\n",
109 hctx->ccid3hctx_t_ipi, hctx->ccid3hctx_delta,
110 hctx->ccid3hctx_s, (unsigned)(hctx->ccid3hctx_x >> 6));
111
112}
113
114static u32 ccid3_hc_tx_idle_rtt(struct ccid3_hc_tx_sock *hctx, ktime_t now)
115{
116 u32 delta = ktime_us_delta(now, hctx->ccid3hctx_t_last_win_count);
117
118 return delta / hctx->ccid3hctx_rtt;
119}
120
121
122
123
124
125
126
127
128
129
130
131static void ccid3_hc_tx_update_x(struct sock *sk, ktime_t *stamp)
132{
133 struct ccid3_hc_tx_sock *hctx = ccid3_hc_tx_sk(sk);
134 __u64 min_rate = 2 * hctx->ccid3hctx_x_recv;
135 const __u64 old_x = hctx->ccid3hctx_x;
136 ktime_t now = stamp ? *stamp : ktime_get_real();
137
138
139
140
141
142
143
144 if (ccid3_hc_tx_idle_rtt(hctx, now) >= 2) {
145 min_rate = rfc3390_initial_rate(sk);
146 min_rate = max(min_rate, 2 * hctx->ccid3hctx_x_recv);
147 }
148
149 if (hctx->ccid3hctx_p > 0) {
150
151 hctx->ccid3hctx_x = min(((__u64)hctx->ccid3hctx_x_calc) << 6,
152 min_rate);
153 hctx->ccid3hctx_x = max(hctx->ccid3hctx_x,
154 (((__u64)hctx->ccid3hctx_s) << 6) /
155 TFRC_T_MBI);
156
157 } else if (ktime_us_delta(now, hctx->ccid3hctx_t_ld)
158 - (s64)hctx->ccid3hctx_rtt >= 0) {
159
160 hctx->ccid3hctx_x = min(2 * hctx->ccid3hctx_x, min_rate);
161 hctx->ccid3hctx_x = max(hctx->ccid3hctx_x,
162 scaled_div(((__u64)hctx->ccid3hctx_s) << 6,
163 hctx->ccid3hctx_rtt));
164 hctx->ccid3hctx_t_ld = now;
165 }
166
167 if (hctx->ccid3hctx_x != old_x) {
168 ccid3_pr_debug("X_prev=%u, X_now=%u, X_calc=%u, "
169 "X_recv=%u\n", (unsigned)(old_x >> 6),
170 (unsigned)(hctx->ccid3hctx_x >> 6),
171 hctx->ccid3hctx_x_calc,
172 (unsigned)(hctx->ccid3hctx_x_recv >> 6));
173
174 ccid3_update_send_interval(hctx);
175 }
176}
177
178
179
180
181
182static inline void ccid3_hc_tx_update_s(struct ccid3_hc_tx_sock *hctx, int len)
183{
184 const u16 old_s = hctx->ccid3hctx_s;
185
186 hctx->ccid3hctx_s = tfrc_ewma(hctx->ccid3hctx_s, len, 9);
187
188 if (hctx->ccid3hctx_s != old_s)
189 ccid3_update_send_interval(hctx);
190}
191
192
193
194
195
196static inline void ccid3_hc_tx_update_win_count(struct ccid3_hc_tx_sock *hctx,
197 ktime_t now)
198{
199 u32 delta = ktime_us_delta(now, hctx->ccid3hctx_t_last_win_count),
200 quarter_rtts = (4 * delta) / hctx->ccid3hctx_rtt;
201
202 if (quarter_rtts > 0) {
203 hctx->ccid3hctx_t_last_win_count = now;
204 hctx->ccid3hctx_last_win_count += min(quarter_rtts, 5U);
205 hctx->ccid3hctx_last_win_count &= 0xF;
206 }
207}
208
209static void ccid3_hc_tx_no_feedback_timer(unsigned long data)
210{
211 struct sock *sk = (struct sock *)data;
212 struct ccid3_hc_tx_sock *hctx = ccid3_hc_tx_sk(sk);
213 unsigned long t_nfb = USEC_PER_SEC / 5;
214
215 bh_lock_sock(sk);
216 if (sock_owned_by_user(sk)) {
217
218
219 goto restart_timer;
220 }
221
222 ccid3_pr_debug("%s(%p, state=%s) - entry \n", dccp_role(sk), sk,
223 ccid3_tx_state_name(hctx->ccid3hctx_state));
224
225 if (hctx->ccid3hctx_state == TFRC_SSTATE_FBACK)
226 ccid3_hc_tx_set_state(sk, TFRC_SSTATE_NO_FBACK);
227 else if (hctx->ccid3hctx_state != TFRC_SSTATE_NO_FBACK)
228 goto out;
229
230
231
232
233 if (hctx->ccid3hctx_t_rto == 0 ||
234 hctx->ccid3hctx_p == 0) {
235
236
237 hctx->ccid3hctx_x = max(hctx->ccid3hctx_x / 2,
238 (((__u64)hctx->ccid3hctx_s) << 6) /
239 TFRC_T_MBI);
240 ccid3_update_send_interval(hctx);
241 } else {
242
243
244
245
246
247
248
249
250
251
252 BUG_ON(hctx->ccid3hctx_p && !hctx->ccid3hctx_x_calc);
253
254 if (hctx->ccid3hctx_x_calc > (hctx->ccid3hctx_x_recv >> 5))
255 hctx->ccid3hctx_x_recv =
256 max(hctx->ccid3hctx_x_recv / 2,
257 (((__u64)hctx->ccid3hctx_s) << 6) /
258 (2 * TFRC_T_MBI));
259 else {
260 hctx->ccid3hctx_x_recv = hctx->ccid3hctx_x_calc;
261 hctx->ccid3hctx_x_recv <<= 4;
262 }
263 ccid3_hc_tx_update_x(sk, NULL);
264 }
265 ccid3_pr_debug("Reduced X to %llu/64 bytes/sec\n",
266 (unsigned long long)hctx->ccid3hctx_x);
267
268
269
270
271
272 if (unlikely(hctx->ccid3hctx_t_rto == 0))
273 t_nfb = TFRC_INITIAL_TIMEOUT;
274 else
275 t_nfb = max(hctx->ccid3hctx_t_rto, 2 * hctx->ccid3hctx_t_ipi);
276
277restart_timer:
278 sk_reset_timer(sk, &hctx->ccid3hctx_no_feedback_timer,
279 jiffies + usecs_to_jiffies(t_nfb));
280out:
281 bh_unlock_sock(sk);
282 sock_put(sk);
283}
284
285
286
287
288
289
290
291static int ccid3_hc_tx_send_packet(struct sock *sk, struct sk_buff *skb)
292{
293 struct dccp_sock *dp = dccp_sk(sk);
294 struct ccid3_hc_tx_sock *hctx = ccid3_hc_tx_sk(sk);
295 ktime_t now = ktime_get_real();
296 s64 delay;
297
298
299
300
301
302
303 if (unlikely(skb->len == 0))
304 return -EBADMSG;
305
306 switch (hctx->ccid3hctx_state) {
307 case TFRC_SSTATE_NO_SENT:
308 sk_reset_timer(sk, &hctx->ccid3hctx_no_feedback_timer,
309 (jiffies +
310 usecs_to_jiffies(TFRC_INITIAL_TIMEOUT)));
311 hctx->ccid3hctx_last_win_count = 0;
312 hctx->ccid3hctx_t_last_win_count = now;
313
314
315 hctx->ccid3hctx_t_nom = now;
316
317 hctx->ccid3hctx_s = skb->len;
318
319
320
321
322
323
324 if (dp->dccps_syn_rtt) {
325 ccid3_pr_debug("SYN RTT = %uus\n", dp->dccps_syn_rtt);
326 hctx->ccid3hctx_rtt = dp->dccps_syn_rtt;
327 hctx->ccid3hctx_x = rfc3390_initial_rate(sk);
328 hctx->ccid3hctx_t_ld = now;
329 } else {
330
331
332
333
334
335
336 hctx->ccid3hctx_rtt = DCCP_FALLBACK_RTT;
337 hctx->ccid3hctx_x = hctx->ccid3hctx_s;
338 hctx->ccid3hctx_x <<= 6;
339 }
340 ccid3_update_send_interval(hctx);
341
342 ccid3_hc_tx_set_state(sk, TFRC_SSTATE_NO_FBACK);
343 break;
344 case TFRC_SSTATE_NO_FBACK:
345 case TFRC_SSTATE_FBACK:
346 delay = ktime_us_delta(hctx->ccid3hctx_t_nom, now);
347 ccid3_pr_debug("delay=%ld\n", (long)delay);
348
349
350
351
352
353
354
355
356 if (delay - (s64)hctx->ccid3hctx_delta >= 1000)
357 return (u32)delay / 1000L;
358
359 ccid3_hc_tx_update_win_count(hctx, now);
360 break;
361 case TFRC_SSTATE_TERM:
362 DCCP_BUG("%s(%p) - Illegal state TERM", dccp_role(sk), sk);
363 return -EINVAL;
364 }
365
366
367 dp->dccps_hc_tx_insert_options = 1;
368 DCCP_SKB_CB(skb)->dccpd_ccval = hctx->ccid3hctx_last_win_count;
369
370
371 hctx->ccid3hctx_t_nom = ktime_add_us(hctx->ccid3hctx_t_nom,
372 hctx->ccid3hctx_t_ipi);
373 return 0;
374}
375
376static void ccid3_hc_tx_packet_sent(struct sock *sk, int more,
377 unsigned int len)
378{
379 struct ccid3_hc_tx_sock *hctx = ccid3_hc_tx_sk(sk);
380
381 ccid3_hc_tx_update_s(hctx, len);
382
383 if (tfrc_tx_hist_add(&hctx->ccid3hctx_hist, dccp_sk(sk)->dccps_gss))
384 DCCP_CRIT("packet history - out of memory!");
385}
386
387static void ccid3_hc_tx_packet_recv(struct sock *sk, struct sk_buff *skb)
388{
389 struct ccid3_hc_tx_sock *hctx = ccid3_hc_tx_sk(sk);
390 struct ccid3_options_received *opt_recv;
391 ktime_t now;
392 unsigned long t_nfb;
393 u32 pinv, r_sample;
394
395
396 if (!(DCCP_SKB_CB(skb)->dccpd_type == DCCP_PKT_ACK ||
397 DCCP_SKB_CB(skb)->dccpd_type == DCCP_PKT_DATAACK))
398 return;
399
400 if (hctx->ccid3hctx_state != TFRC_SSTATE_FBACK &&
401 hctx->ccid3hctx_state != TFRC_SSTATE_NO_FBACK)
402 return;
403
404 opt_recv = &hctx->ccid3hctx_options_received;
405 now = ktime_get_real();
406
407
408 r_sample = tfrc_tx_hist_rtt(hctx->ccid3hctx_hist,
409 DCCP_SKB_CB(skb)->dccpd_ack_seq, now);
410 if (r_sample == 0) {
411 DCCP_WARN("%s(%p): %s with bogus ACK-%llu\n", dccp_role(sk), sk,
412 dccp_packet_name(DCCP_SKB_CB(skb)->dccpd_type),
413 (unsigned long long)DCCP_SKB_CB(skb)->dccpd_ack_seq);
414 return;
415 }
416
417
418 hctx->ccid3hctx_x_recv = opt_recv->ccid3or_receive_rate;
419 hctx->ccid3hctx_x_recv <<= 6;
420
421
422 pinv = opt_recv->ccid3or_loss_event_rate;
423 if (pinv == ~0U || pinv == 0)
424 hctx->ccid3hctx_p = 0;
425 else
426 hctx->ccid3hctx_p = scaled_div(1, pinv);
427
428
429
430 r_sample = dccp_sample_rtt(sk, r_sample);
431 hctx->ccid3hctx_rtt = tfrc_ewma(hctx->ccid3hctx_rtt, r_sample, 9);
432
433
434
435 if (hctx->ccid3hctx_state == TFRC_SSTATE_NO_FBACK) {
436 ccid3_hc_tx_set_state(sk, TFRC_SSTATE_FBACK);
437
438 if (hctx->ccid3hctx_t_rto == 0) {
439
440
441
442 hctx->ccid3hctx_x = rfc3390_initial_rate(sk);
443 hctx->ccid3hctx_t_ld = now;
444
445 ccid3_update_send_interval(hctx);
446
447 goto done_computing_x;
448 } else if (hctx->ccid3hctx_p == 0) {
449
450
451
452 goto done_computing_x;
453 }
454 }
455
456
457 if (hctx->ccid3hctx_p > 0)
458 hctx->ccid3hctx_x_calc =
459 tfrc_calc_x(hctx->ccid3hctx_s,
460 hctx->ccid3hctx_rtt,
461 hctx->ccid3hctx_p);
462 ccid3_hc_tx_update_x(sk, &now);
463
464done_computing_x:
465 ccid3_pr_debug("%s(%p), RTT=%uus (sample=%uus), s=%u, "
466 "p=%u, X_calc=%u, X_recv=%u, X=%u\n",
467 dccp_role(sk),
468 sk, hctx->ccid3hctx_rtt, r_sample,
469 hctx->ccid3hctx_s, hctx->ccid3hctx_p,
470 hctx->ccid3hctx_x_calc,
471 (unsigned)(hctx->ccid3hctx_x_recv >> 6),
472 (unsigned)(hctx->ccid3hctx_x >> 6));
473
474
475 sk_stop_timer(sk, &hctx->ccid3hctx_no_feedback_timer);
476
477
478
479
480
481 sk->sk_write_space(sk);
482
483
484
485
486
487
488
489 hctx->ccid3hctx_t_rto = max_t(u32, 4 * hctx->ccid3hctx_rtt,
490 (CONFIG_IP_DCCP_CCID3_RTO *
491 (USEC_PER_SEC / 1000)));
492
493
494
495
496 t_nfb = max(hctx->ccid3hctx_t_rto, 2 * hctx->ccid3hctx_t_ipi);
497
498 ccid3_pr_debug("%s(%p), Scheduled no feedback timer to "
499 "expire in %lu jiffies (%luus)\n",
500 dccp_role(sk),
501 sk, usecs_to_jiffies(t_nfb), t_nfb);
502
503 sk_reset_timer(sk, &hctx->ccid3hctx_no_feedback_timer,
504 jiffies + usecs_to_jiffies(t_nfb));
505}
506
507static int ccid3_hc_tx_parse_options(struct sock *sk, unsigned char option,
508 unsigned char len, u16 idx,
509 unsigned char *value)
510{
511 int rc = 0;
512 const struct dccp_sock *dp = dccp_sk(sk);
513 struct ccid3_hc_tx_sock *hctx = ccid3_hc_tx_sk(sk);
514 struct ccid3_options_received *opt_recv;
515 __be32 opt_val;
516
517 opt_recv = &hctx->ccid3hctx_options_received;
518
519 if (opt_recv->ccid3or_seqno != dp->dccps_gsr) {
520 opt_recv->ccid3or_seqno = dp->dccps_gsr;
521 opt_recv->ccid3or_loss_event_rate = ~0;
522 opt_recv->ccid3or_loss_intervals_idx = 0;
523 opt_recv->ccid3or_loss_intervals_len = 0;
524 opt_recv->ccid3or_receive_rate = 0;
525 }
526
527 switch (option) {
528 case TFRC_OPT_LOSS_EVENT_RATE:
529 if (unlikely(len != 4)) {
530 DCCP_WARN("%s(%p), invalid len %d "
531 "for TFRC_OPT_LOSS_EVENT_RATE\n",
532 dccp_role(sk), sk, len);
533 rc = -EINVAL;
534 } else {
535 opt_val = get_unaligned((__be32 *)value);
536 opt_recv->ccid3or_loss_event_rate = ntohl(opt_val);
537 ccid3_pr_debug("%s(%p), LOSS_EVENT_RATE=%u\n",
538 dccp_role(sk), sk,
539 opt_recv->ccid3or_loss_event_rate);
540 }
541 break;
542 case TFRC_OPT_LOSS_INTERVALS:
543 opt_recv->ccid3or_loss_intervals_idx = idx;
544 opt_recv->ccid3or_loss_intervals_len = len;
545 ccid3_pr_debug("%s(%p), LOSS_INTERVALS=(%u, %u)\n",
546 dccp_role(sk), sk,
547 opt_recv->ccid3or_loss_intervals_idx,
548 opt_recv->ccid3or_loss_intervals_len);
549 break;
550 case TFRC_OPT_RECEIVE_RATE:
551 if (unlikely(len != 4)) {
552 DCCP_WARN("%s(%p), invalid len %d "
553 "for TFRC_OPT_RECEIVE_RATE\n",
554 dccp_role(sk), sk, len);
555 rc = -EINVAL;
556 } else {
557 opt_val = get_unaligned((__be32 *)value);
558 opt_recv->ccid3or_receive_rate = ntohl(opt_val);
559 ccid3_pr_debug("%s(%p), RECEIVE_RATE=%u\n",
560 dccp_role(sk), sk,
561 opt_recv->ccid3or_receive_rate);
562 }
563 break;
564 }
565
566 return rc;
567}
568
569static int ccid3_hc_tx_init(struct ccid *ccid, struct sock *sk)
570{
571 struct ccid3_hc_tx_sock *hctx = ccid_priv(ccid);
572
573 hctx->ccid3hctx_state = TFRC_SSTATE_NO_SENT;
574 hctx->ccid3hctx_hist = NULL;
575 setup_timer(&hctx->ccid3hctx_no_feedback_timer,
576 ccid3_hc_tx_no_feedback_timer, (unsigned long)sk);
577
578 return 0;
579}
580
581static void ccid3_hc_tx_exit(struct sock *sk)
582{
583 struct ccid3_hc_tx_sock *hctx = ccid3_hc_tx_sk(sk);
584
585 ccid3_hc_tx_set_state(sk, TFRC_SSTATE_TERM);
586 sk_stop_timer(sk, &hctx->ccid3hctx_no_feedback_timer);
587
588 tfrc_tx_hist_purge(&hctx->ccid3hctx_hist);
589}
590
591static void ccid3_hc_tx_get_info(struct sock *sk, struct tcp_info *info)
592{
593 struct ccid3_hc_tx_sock *hctx;
594
595
596 if (sk->sk_state == DCCP_LISTEN)
597 return;
598
599 hctx = ccid3_hc_tx_sk(sk);
600 info->tcpi_rto = hctx->ccid3hctx_t_rto;
601 info->tcpi_rtt = hctx->ccid3hctx_rtt;
602}
603
604static int ccid3_hc_tx_getsockopt(struct sock *sk, const int optname, int len,
605 u32 __user *optval, int __user *optlen)
606{
607 const struct ccid3_hc_tx_sock *hctx;
608 const void *val;
609
610
611 if (sk->sk_state == DCCP_LISTEN)
612 return -EINVAL;
613
614 hctx = ccid3_hc_tx_sk(sk);
615 switch (optname) {
616 case DCCP_SOCKOPT_CCID_TX_INFO:
617 if (len < sizeof(hctx->ccid3hctx_tfrc))
618 return -EINVAL;
619 len = sizeof(hctx->ccid3hctx_tfrc);
620 val = &hctx->ccid3hctx_tfrc;
621 break;
622 default:
623 return -ENOPROTOOPT;
624 }
625
626 if (put_user(len, optlen) || copy_to_user(optval, val, len))
627 return -EFAULT;
628
629 return 0;
630}
631
632
633
634
635
636
637enum ccid3_fback_type {
638 CCID3_FBACK_NONE = 0,
639 CCID3_FBACK_INITIAL,
640 CCID3_FBACK_PERIODIC,
641 CCID3_FBACK_PARAM_CHANGE
642};
643
644#ifdef CONFIG_IP_DCCP_CCID3_DEBUG
645static const char *ccid3_rx_state_name(enum ccid3_hc_rx_states state)
646{
647 static const char *const ccid3_rx_state_names[] = {
648 [TFRC_RSTATE_NO_DATA] = "NO_DATA",
649 [TFRC_RSTATE_DATA] = "DATA",
650 [TFRC_RSTATE_TERM] = "TERM",
651 };
652
653 return ccid3_rx_state_names[state];
654}
655#endif
656
657static void ccid3_hc_rx_set_state(struct sock *sk,
658 enum ccid3_hc_rx_states state)
659{
660 struct ccid3_hc_rx_sock *hcrx = ccid3_hc_rx_sk(sk);
661 enum ccid3_hc_rx_states oldstate = hcrx->ccid3hcrx_state;
662
663 ccid3_pr_debug("%s(%p) %-8.8s -> %s\n",
664 dccp_role(sk), sk, ccid3_rx_state_name(oldstate),
665 ccid3_rx_state_name(state));
666 WARN_ON(state == oldstate);
667 hcrx->ccid3hcrx_state = state;
668}
669
670static void ccid3_hc_rx_send_feedback(struct sock *sk,
671 const struct sk_buff *skb,
672 enum ccid3_fback_type fbtype)
673{
674 struct ccid3_hc_rx_sock *hcrx = ccid3_hc_rx_sk(sk);
675 struct dccp_sock *dp = dccp_sk(sk);
676 ktime_t now;
677 s64 delta = 0;
678
679 if (unlikely(hcrx->ccid3hcrx_state == TFRC_RSTATE_TERM))
680 return;
681
682 now = ktime_get_real();
683
684 switch (fbtype) {
685 case CCID3_FBACK_INITIAL:
686 hcrx->ccid3hcrx_x_recv = 0;
687 hcrx->ccid3hcrx_pinv = ~0U;
688 break;
689 case CCID3_FBACK_PARAM_CHANGE:
690
691
692
693
694
695
696
697
698
699
700 if (hcrx->ccid3hcrx_x_recv > 0)
701 break;
702
703 case CCID3_FBACK_PERIODIC:
704 delta = ktime_us_delta(now, hcrx->ccid3hcrx_tstamp_last_feedback);
705 if (delta <= 0)
706 DCCP_BUG("delta (%ld) <= 0", (long)delta);
707 else
708 hcrx->ccid3hcrx_x_recv =
709 scaled_div32(hcrx->ccid3hcrx_bytes_recv, delta);
710 break;
711 default:
712 return;
713 }
714
715 ccid3_pr_debug("Interval %ldusec, X_recv=%u, 1/p=%u\n", (long)delta,
716 hcrx->ccid3hcrx_x_recv, hcrx->ccid3hcrx_pinv);
717
718 hcrx->ccid3hcrx_tstamp_last_feedback = now;
719 hcrx->ccid3hcrx_last_counter = dccp_hdr(skb)->dccph_ccval;
720 hcrx->ccid3hcrx_bytes_recv = 0;
721
722 dp->dccps_hc_rx_insert_options = 1;
723 dccp_send_ack(sk);
724}
725
726static int ccid3_hc_rx_insert_options(struct sock *sk, struct sk_buff *skb)
727{
728 const struct ccid3_hc_rx_sock *hcrx;
729 __be32 x_recv, pinv;
730
731 if (!(sk->sk_state == DCCP_OPEN || sk->sk_state == DCCP_PARTOPEN))
732 return 0;
733
734 hcrx = ccid3_hc_rx_sk(sk);
735
736 if (dccp_packet_without_ack(skb))
737 return 0;
738
739 x_recv = htonl(hcrx->ccid3hcrx_x_recv);
740 pinv = htonl(hcrx->ccid3hcrx_pinv);
741
742 if (dccp_insert_option(sk, skb, TFRC_OPT_LOSS_EVENT_RATE,
743 &pinv, sizeof(pinv)) ||
744 dccp_insert_option(sk, skb, TFRC_OPT_RECEIVE_RATE,
745 &x_recv, sizeof(x_recv)))
746 return -1;
747
748 return 0;
749}
750
751
752
753
754
755
756
757
758
759
760
761static u32 ccid3_first_li(struct sock *sk)
762{
763 struct ccid3_hc_rx_sock *hcrx = ccid3_hc_rx_sk(sk);
764 u32 x_recv, p, delta;
765 u64 fval;
766
767 if (hcrx->ccid3hcrx_rtt == 0) {
768 DCCP_WARN("No RTT estimate available, using fallback RTT\n");
769 hcrx->ccid3hcrx_rtt = DCCP_FALLBACK_RTT;
770 }
771
772 delta = ktime_to_us(net_timedelta(hcrx->ccid3hcrx_tstamp_last_feedback));
773 x_recv = scaled_div32(hcrx->ccid3hcrx_bytes_recv, delta);
774 if (x_recv == 0) {
775 DCCP_WARN("X_recv==0\n");
776 if ((x_recv = hcrx->ccid3hcrx_x_recv) == 0) {
777 DCCP_BUG("stored value of X_recv is zero");
778 return ~0U;
779 }
780 }
781
782 fval = scaled_div(hcrx->ccid3hcrx_s, hcrx->ccid3hcrx_rtt);
783 fval = scaled_div32(fval, x_recv);
784 p = tfrc_calc_x_reverse_lookup(fval);
785
786 ccid3_pr_debug("%s(%p), receive rate=%u bytes/s, implied "
787 "loss rate=%u\n", dccp_role(sk), sk, x_recv, p);
788
789 return p == 0 ? ~0U : scaled_div(1, p);
790}
791
792static void ccid3_hc_rx_packet_recv(struct sock *sk, struct sk_buff *skb)
793{
794 struct ccid3_hc_rx_sock *hcrx = ccid3_hc_rx_sk(sk);
795 enum ccid3_fback_type do_feedback = CCID3_FBACK_NONE;
796 const u64 ndp = dccp_sk(sk)->dccps_options_received.dccpor_ndp;
797 const bool is_data_packet = dccp_data_packet(skb);
798
799 if (unlikely(hcrx->ccid3hcrx_state == TFRC_RSTATE_NO_DATA)) {
800 if (is_data_packet) {
801 const u32 payload = skb->len - dccp_hdr(skb)->dccph_doff * 4;
802 do_feedback = CCID3_FBACK_INITIAL;
803 ccid3_hc_rx_set_state(sk, TFRC_RSTATE_DATA);
804 hcrx->ccid3hcrx_s = payload;
805
806
807
808
809
810 }
811 goto update_records;
812 }
813
814 if (tfrc_rx_hist_duplicate(&hcrx->ccid3hcrx_hist, skb))
815 return;
816
817 if (is_data_packet) {
818 const u32 payload = skb->len - dccp_hdr(skb)->dccph_doff * 4;
819
820
821
822 hcrx->ccid3hcrx_s = tfrc_ewma(hcrx->ccid3hcrx_s, payload, 9);
823 hcrx->ccid3hcrx_bytes_recv += payload;
824 }
825
826
827
828
829 if (tfrc_rx_handle_loss(&hcrx->ccid3hcrx_hist, &hcrx->ccid3hcrx_li_hist,
830 skb, ndp, ccid3_first_li, sk)) {
831 do_feedback = CCID3_FBACK_PARAM_CHANGE;
832 goto done_receiving;
833 }
834
835 if (tfrc_rx_hist_loss_pending(&hcrx->ccid3hcrx_hist))
836 return;
837
838
839
840
841 if (unlikely(!is_data_packet))
842 goto update_records;
843
844 if (!tfrc_lh_is_initialised(&hcrx->ccid3hcrx_li_hist)) {
845 const u32 sample = tfrc_rx_hist_sample_rtt(&hcrx->ccid3hcrx_hist, skb);
846
847
848
849
850
851 if (sample != 0)
852 hcrx->ccid3hcrx_rtt = tfrc_ewma(hcrx->ccid3hcrx_rtt, sample, 9);
853
854 } else if (tfrc_lh_update_i_mean(&hcrx->ccid3hcrx_li_hist, skb)) {
855
856
857
858
859 do_feedback = CCID3_FBACK_PARAM_CHANGE;
860 }
861
862
863
864
865 if (SUB16(dccp_hdr(skb)->dccph_ccval, hcrx->ccid3hcrx_last_counter) > 3)
866 do_feedback = CCID3_FBACK_PERIODIC;
867
868update_records:
869 tfrc_rx_hist_add_packet(&hcrx->ccid3hcrx_hist, skb, ndp);
870
871done_receiving:
872 if (do_feedback)
873 ccid3_hc_rx_send_feedback(sk, skb, do_feedback);
874}
875
876static int ccid3_hc_rx_init(struct ccid *ccid, struct sock *sk)
877{
878 struct ccid3_hc_rx_sock *hcrx = ccid_priv(ccid);
879
880 hcrx->ccid3hcrx_state = TFRC_RSTATE_NO_DATA;
881 tfrc_lh_init(&hcrx->ccid3hcrx_li_hist);
882 return tfrc_rx_hist_alloc(&hcrx->ccid3hcrx_hist);
883}
884
885static void ccid3_hc_rx_exit(struct sock *sk)
886{
887 struct ccid3_hc_rx_sock *hcrx = ccid3_hc_rx_sk(sk);
888
889 ccid3_hc_rx_set_state(sk, TFRC_RSTATE_TERM);
890
891 tfrc_rx_hist_purge(&hcrx->ccid3hcrx_hist);
892 tfrc_lh_cleanup(&hcrx->ccid3hcrx_li_hist);
893}
894
895static void ccid3_hc_rx_get_info(struct sock *sk, struct tcp_info *info)
896{
897 const struct ccid3_hc_rx_sock *hcrx;
898
899
900 if (sk->sk_state == DCCP_LISTEN)
901 return;
902
903 hcrx = ccid3_hc_rx_sk(sk);
904 info->tcpi_ca_state = hcrx->ccid3hcrx_state;
905 info->tcpi_options |= TCPI_OPT_TIMESTAMPS;
906 info->tcpi_rcv_rtt = hcrx->ccid3hcrx_rtt;
907}
908
909static int ccid3_hc_rx_getsockopt(struct sock *sk, const int optname, int len,
910 u32 __user *optval, int __user *optlen)
911{
912 const struct ccid3_hc_rx_sock *hcrx;
913 struct tfrc_rx_info rx_info;
914 const void *val;
915
916
917 if (sk->sk_state == DCCP_LISTEN)
918 return -EINVAL;
919
920 hcrx = ccid3_hc_rx_sk(sk);
921 switch (optname) {
922 case DCCP_SOCKOPT_CCID_RX_INFO:
923 if (len < sizeof(rx_info))
924 return -EINVAL;
925 rx_info.tfrcrx_x_recv = hcrx->ccid3hcrx_x_recv;
926 rx_info.tfrcrx_rtt = hcrx->ccid3hcrx_rtt;
927 rx_info.tfrcrx_p = hcrx->ccid3hcrx_pinv == 0 ? ~0U :
928 scaled_div(1, hcrx->ccid3hcrx_pinv);
929 len = sizeof(rx_info);
930 val = &rx_info;
931 break;
932 default:
933 return -ENOPROTOOPT;
934 }
935
936 if (put_user(len, optlen) || copy_to_user(optval, val, len))
937 return -EFAULT;
938
939 return 0;
940}
941
942struct ccid_operations ccid3_ops = {
943 .ccid_id = DCCPC_CCID3,
944 .ccid_name = "TCP-Friendly Rate Control",
945 .ccid_hc_tx_obj_size = sizeof(struct ccid3_hc_tx_sock),
946 .ccid_hc_tx_init = ccid3_hc_tx_init,
947 .ccid_hc_tx_exit = ccid3_hc_tx_exit,
948 .ccid_hc_tx_send_packet = ccid3_hc_tx_send_packet,
949 .ccid_hc_tx_packet_sent = ccid3_hc_tx_packet_sent,
950 .ccid_hc_tx_packet_recv = ccid3_hc_tx_packet_recv,
951 .ccid_hc_tx_parse_options = ccid3_hc_tx_parse_options,
952 .ccid_hc_rx_obj_size = sizeof(struct ccid3_hc_rx_sock),
953 .ccid_hc_rx_init = ccid3_hc_rx_init,
954 .ccid_hc_rx_exit = ccid3_hc_rx_exit,
955 .ccid_hc_rx_insert_options = ccid3_hc_rx_insert_options,
956 .ccid_hc_rx_packet_recv = ccid3_hc_rx_packet_recv,
957 .ccid_hc_rx_get_info = ccid3_hc_rx_get_info,
958 .ccid_hc_tx_get_info = ccid3_hc_tx_get_info,
959 .ccid_hc_rx_getsockopt = ccid3_hc_rx_getsockopt,
960 .ccid_hc_tx_getsockopt = ccid3_hc_tx_getsockopt,
961};
962
963#ifdef CONFIG_IP_DCCP_CCID3_DEBUG
964module_param(ccid3_debug, bool, 0644);
965MODULE_PARM_DESC(ccid3_debug, "Enable CCID-3 debug messages");
966#endif
967