1 | // SPDX-License-Identifier: GPL-2.0-or-later |
2 | /* |
3 | * Copyright (c) 2007 The University of Aberdeen, Scotland, UK |
4 | * Copyright (c) 2005-7 The University of Waikato, Hamilton, New Zealand. |
5 | * Copyright (c) 2005-7 Ian McDonald <ian.mcdonald@jandi.co.nz> |
6 | * |
7 | * An implementation of the DCCP protocol |
8 | * |
9 | * This code has been developed by the University of Waikato WAND |
10 | * research group. For further information please see https://www.wand.net.nz/ |
11 | * |
12 | * This code also uses code from Lulea University, rereleased as GPL by its |
13 | * authors: |
14 | * Copyright (c) 2003 Nils-Erik Mattsson, Joacim Haggmark, Magnus Erixzon |
15 | * |
16 | * Changes to meet Linux coding standards, to make it meet latest ccid3 draft |
17 | * and to make it work as a loadable module in the DCCP stack written by |
18 | * Arnaldo Carvalho de Melo <acme@conectiva.com.br>. |
19 | * |
20 | * Copyright (c) 2005 Arnaldo Carvalho de Melo <acme@conectiva.com.br> |
21 | */ |
22 | #include "../dccp.h" |
23 | #include "ccid3.h" |
24 | |
25 | #include <asm/unaligned.h> |
26 | |
27 | #ifdef CONFIG_IP_DCCP_CCID3_DEBUG |
28 | static bool ccid3_debug; |
29 | #define ccid3_pr_debug(format, a...) DCCP_PR_DEBUG(ccid3_debug, format, ##a) |
30 | #else |
31 | #define ccid3_pr_debug(format, a...) |
32 | #endif |
33 | |
34 | /* |
35 | * Transmitter Half-Connection Routines |
36 | */ |
37 | #ifdef CONFIG_IP_DCCP_CCID3_DEBUG |
38 | static const char *ccid3_tx_state_name(enum ccid3_hc_tx_states state) |
39 | { |
40 | static const char *const ccid3_state_names[] = { |
41 | [TFRC_SSTATE_NO_SENT] = "NO_SENT" , |
42 | [TFRC_SSTATE_NO_FBACK] = "NO_FBACK" , |
43 | [TFRC_SSTATE_FBACK] = "FBACK" , |
44 | }; |
45 | |
46 | return ccid3_state_names[state]; |
47 | } |
48 | #endif |
49 | |
50 | static void ccid3_hc_tx_set_state(struct sock *sk, |
51 | enum ccid3_hc_tx_states state) |
52 | { |
53 | struct ccid3_hc_tx_sock *hc = ccid3_hc_tx_sk(sk); |
54 | enum ccid3_hc_tx_states oldstate = hc->tx_state; |
55 | |
56 | ccid3_pr_debug("%s(%p) %-8.8s -> %s\n" , |
57 | dccp_role(sk), sk, ccid3_tx_state_name(oldstate), |
58 | ccid3_tx_state_name(state)); |
59 | WARN_ON(state == oldstate); |
60 | hc->tx_state = state; |
61 | } |
62 | |
63 | /* |
64 | * Compute the initial sending rate X_init in the manner of RFC 3390: |
65 | * |
66 | * X_init = min(4 * s, max(2 * s, 4380 bytes)) / RTT |
67 | * |
68 | * Note that RFC 3390 uses MSS, RFC 4342 refers to RFC 3390, and rfc3448bis |
69 | * (rev-02) clarifies the use of RFC 3390 with regard to the above formula. |
70 | * For consistency with other parts of the code, X_init is scaled by 2^6. |
71 | */ |
72 | static inline u64 rfc3390_initial_rate(struct sock *sk) |
73 | { |
74 | const struct ccid3_hc_tx_sock *hc = ccid3_hc_tx_sk(sk); |
75 | const __u32 w_init = clamp_t(__u32, 4380U, 2 * hc->tx_s, 4 * hc->tx_s); |
76 | |
77 | return scaled_div(a: w_init << 6, b: hc->tx_rtt); |
78 | } |
79 | |
80 | /** |
81 | * ccid3_update_send_interval - Calculate new t_ipi = s / X_inst |
82 | * @hc: socket to have the send interval updated |
83 | * |
84 | * This respects the granularity of X_inst (64 * bytes/second). |
85 | */ |
86 | static void ccid3_update_send_interval(struct ccid3_hc_tx_sock *hc) |
87 | { |
88 | hc->tx_t_ipi = scaled_div32(a: ((u64)hc->tx_s) << 6, b: hc->tx_x); |
89 | |
90 | DCCP_BUG_ON(hc->tx_t_ipi == 0); |
91 | ccid3_pr_debug("t_ipi=%u, s=%u, X=%u\n" , hc->tx_t_ipi, |
92 | hc->tx_s, (unsigned int)(hc->tx_x >> 6)); |
93 | } |
94 | |
95 | static u32 ccid3_hc_tx_idle_rtt(struct ccid3_hc_tx_sock *hc, ktime_t now) |
96 | { |
97 | u32 delta = ktime_us_delta(later: now, earlier: hc->tx_t_last_win_count); |
98 | |
99 | return delta / hc->tx_rtt; |
100 | } |
101 | |
102 | /** |
103 | * ccid3_hc_tx_update_x - Update allowed sending rate X |
104 | * @sk: socket to be updated |
105 | * @stamp: most recent time if available - can be left NULL. |
106 | * |
107 | * This function tracks draft rfc3448bis, check there for latest details. |
108 | * |
109 | * Note: X and X_recv are both stored in units of 64 * bytes/second, to support |
110 | * fine-grained resolution of sending rates. This requires scaling by 2^6 |
111 | * throughout the code. Only X_calc is unscaled (in bytes/second). |
112 | * |
113 | */ |
114 | static void ccid3_hc_tx_update_x(struct sock *sk, ktime_t *stamp) |
115 | { |
116 | struct ccid3_hc_tx_sock *hc = ccid3_hc_tx_sk(sk); |
117 | __u64 min_rate = 2 * hc->tx_x_recv; |
118 | const __u64 old_x = hc->tx_x; |
119 | ktime_t now = stamp ? *stamp : ktime_get_real(); |
120 | |
121 | /* |
122 | * Handle IDLE periods: do not reduce below RFC3390 initial sending rate |
123 | * when idling [RFC 4342, 5.1]. Definition of idling is from rfc3448bis: |
124 | * a sender is idle if it has not sent anything over a 2-RTT-period. |
125 | * For consistency with X and X_recv, min_rate is also scaled by 2^6. |
126 | */ |
127 | if (ccid3_hc_tx_idle_rtt(hc, now) >= 2) { |
128 | min_rate = rfc3390_initial_rate(sk); |
129 | min_rate = max(min_rate, 2 * hc->tx_x_recv); |
130 | } |
131 | |
132 | if (hc->tx_p > 0) { |
133 | |
134 | hc->tx_x = min(((__u64)hc->tx_x_calc) << 6, min_rate); |
135 | hc->tx_x = max(hc->tx_x, (((__u64)hc->tx_s) << 6) / TFRC_T_MBI); |
136 | |
137 | } else if (ktime_us_delta(later: now, earlier: hc->tx_t_ld) - (s64)hc->tx_rtt >= 0) { |
138 | |
139 | hc->tx_x = min(2 * hc->tx_x, min_rate); |
140 | hc->tx_x = max(hc->tx_x, |
141 | scaled_div(((__u64)hc->tx_s) << 6, hc->tx_rtt)); |
142 | hc->tx_t_ld = now; |
143 | } |
144 | |
145 | if (hc->tx_x != old_x) { |
146 | ccid3_pr_debug("X_prev=%u, X_now=%u, X_calc=%u, " |
147 | "X_recv=%u\n" , (unsigned int)(old_x >> 6), |
148 | (unsigned int)(hc->tx_x >> 6), hc->tx_x_calc, |
149 | (unsigned int)(hc->tx_x_recv >> 6)); |
150 | |
151 | ccid3_update_send_interval(hc); |
152 | } |
153 | } |
154 | |
155 | /** |
156 | * ccid3_hc_tx_update_s - Track the mean packet size `s' |
157 | * @hc: socket to be updated |
158 | * @len: DCCP packet payload size in bytes |
159 | * |
160 | * cf. RFC 4342, 5.3 and RFC 3448, 4.1 |
161 | */ |
162 | static inline void ccid3_hc_tx_update_s(struct ccid3_hc_tx_sock *hc, int len) |
163 | { |
164 | const u16 old_s = hc->tx_s; |
165 | |
166 | hc->tx_s = tfrc_ewma(avg: hc->tx_s, newval: len, weight: 9); |
167 | |
168 | if (hc->tx_s != old_s) |
169 | ccid3_update_send_interval(hc); |
170 | } |
171 | |
172 | /* |
173 | * Update Window Counter using the algorithm from [RFC 4342, 8.1]. |
174 | * As elsewhere, RTT > 0 is assumed by using dccp_sample_rtt(). |
175 | */ |
176 | static inline void ccid3_hc_tx_update_win_count(struct ccid3_hc_tx_sock *hc, |
177 | ktime_t now) |
178 | { |
179 | u32 delta = ktime_us_delta(later: now, earlier: hc->tx_t_last_win_count), |
180 | quarter_rtts = (4 * delta) / hc->tx_rtt; |
181 | |
182 | if (quarter_rtts > 0) { |
183 | hc->tx_t_last_win_count = now; |
184 | hc->tx_last_win_count += min(quarter_rtts, 5U); |
185 | hc->tx_last_win_count &= 0xF; /* mod 16 */ |
186 | } |
187 | } |
188 | |
189 | static void ccid3_hc_tx_no_feedback_timer(struct timer_list *t) |
190 | { |
191 | struct ccid3_hc_tx_sock *hc = from_timer(hc, t, tx_no_feedback_timer); |
192 | struct sock *sk = hc->sk; |
193 | unsigned long t_nfb = USEC_PER_SEC / 5; |
194 | |
195 | bh_lock_sock(sk); |
196 | if (sock_owned_by_user(sk)) { |
197 | /* Try again later. */ |
198 | /* XXX: set some sensible MIB */ |
199 | goto restart_timer; |
200 | } |
201 | |
202 | ccid3_pr_debug("%s(%p, state=%s) - entry\n" , dccp_role(sk), sk, |
203 | ccid3_tx_state_name(hc->tx_state)); |
204 | |
205 | /* Ignore and do not restart after leaving the established state */ |
206 | if ((1 << sk->sk_state) & ~(DCCPF_OPEN | DCCPF_PARTOPEN)) |
207 | goto out; |
208 | |
209 | /* Reset feedback state to "no feedback received" */ |
210 | if (hc->tx_state == TFRC_SSTATE_FBACK) |
211 | ccid3_hc_tx_set_state(sk, state: TFRC_SSTATE_NO_FBACK); |
212 | |
213 | /* |
214 | * Determine new allowed sending rate X as per draft rfc3448bis-00, 4.4 |
215 | * RTO is 0 if and only if no feedback has been received yet. |
216 | */ |
217 | if (hc->tx_t_rto == 0 || hc->tx_p == 0) { |
218 | |
219 | /* halve send rate directly */ |
220 | hc->tx_x = max(hc->tx_x / 2, |
221 | (((__u64)hc->tx_s) << 6) / TFRC_T_MBI); |
222 | ccid3_update_send_interval(hc); |
223 | } else { |
224 | /* |
225 | * Modify the cached value of X_recv |
226 | * |
227 | * If (X_calc > 2 * X_recv) |
228 | * X_recv = max(X_recv / 2, s / (2 * t_mbi)); |
229 | * Else |
230 | * X_recv = X_calc / 4; |
231 | * |
232 | * Note that X_recv is scaled by 2^6 while X_calc is not |
233 | */ |
234 | if (hc->tx_x_calc > (hc->tx_x_recv >> 5)) |
235 | hc->tx_x_recv = |
236 | max(hc->tx_x_recv / 2, |
237 | (((__u64)hc->tx_s) << 6) / (2*TFRC_T_MBI)); |
238 | else { |
239 | hc->tx_x_recv = hc->tx_x_calc; |
240 | hc->tx_x_recv <<= 4; |
241 | } |
242 | ccid3_hc_tx_update_x(sk, NULL); |
243 | } |
244 | ccid3_pr_debug("Reduced X to %llu/64 bytes/sec\n" , |
245 | (unsigned long long)hc->tx_x); |
246 | |
247 | /* |
248 | * Set new timeout for the nofeedback timer. |
249 | * See comments in packet_recv() regarding the value of t_RTO. |
250 | */ |
251 | if (unlikely(hc->tx_t_rto == 0)) /* no feedback received yet */ |
252 | t_nfb = TFRC_INITIAL_TIMEOUT; |
253 | else |
254 | t_nfb = max(hc->tx_t_rto, 2 * hc->tx_t_ipi); |
255 | |
256 | restart_timer: |
257 | sk_reset_timer(sk, timer: &hc->tx_no_feedback_timer, |
258 | expires: jiffies + usecs_to_jiffies(u: t_nfb)); |
259 | out: |
260 | bh_unlock_sock(sk); |
261 | sock_put(sk); |
262 | } |
263 | |
264 | /** |
265 | * ccid3_hc_tx_send_packet - Delay-based dequeueing of TX packets |
266 | * @sk: socket to send packet from |
267 | * @skb: next packet candidate to send on @sk |
268 | * |
269 | * This function uses the convention of ccid_packet_dequeue_eval() and |
270 | * returns a millisecond-delay value between 0 and t_mbi = 64000 msec. |
271 | */ |
272 | static int ccid3_hc_tx_send_packet(struct sock *sk, struct sk_buff *skb) |
273 | { |
274 | struct dccp_sock *dp = dccp_sk(sk); |
275 | struct ccid3_hc_tx_sock *hc = ccid3_hc_tx_sk(sk); |
276 | ktime_t now = ktime_get_real(); |
277 | s64 delay; |
278 | |
279 | /* |
280 | * This function is called only for Data and DataAck packets. Sending |
281 | * zero-sized Data(Ack)s is theoretically possible, but for congestion |
282 | * control this case is pathological - ignore it. |
283 | */ |
284 | if (unlikely(skb->len == 0)) |
285 | return -EBADMSG; |
286 | |
287 | if (hc->tx_state == TFRC_SSTATE_NO_SENT) { |
288 | sk_reset_timer(sk, timer: &hc->tx_no_feedback_timer, expires: (jiffies + |
289 | usecs_to_jiffies(TFRC_INITIAL_TIMEOUT))); |
290 | hc->tx_last_win_count = 0; |
291 | hc->tx_t_last_win_count = now; |
292 | |
293 | /* Set t_0 for initial packet */ |
294 | hc->tx_t_nom = now; |
295 | |
296 | hc->tx_s = skb->len; |
297 | |
298 | /* |
299 | * Use initial RTT sample when available: recommended by erratum |
300 | * to RFC 4342. This implements the initialisation procedure of |
301 | * draft rfc3448bis, section 4.2. Remember, X is scaled by 2^6. |
302 | */ |
303 | if (dp->dccps_syn_rtt) { |
304 | ccid3_pr_debug("SYN RTT = %uus\n" , dp->dccps_syn_rtt); |
305 | hc->tx_rtt = dp->dccps_syn_rtt; |
306 | hc->tx_x = rfc3390_initial_rate(sk); |
307 | hc->tx_t_ld = now; |
308 | } else { |
309 | /* |
310 | * Sender does not have RTT sample: |
311 | * - set fallback RTT (RFC 4340, 3.4) since a RTT value |
312 | * is needed in several parts (e.g. window counter); |
313 | * - set sending rate X_pps = 1pps as per RFC 3448, 4.2. |
314 | */ |
315 | hc->tx_rtt = DCCP_FALLBACK_RTT; |
316 | hc->tx_x = hc->tx_s; |
317 | hc->tx_x <<= 6; |
318 | } |
319 | ccid3_update_send_interval(hc); |
320 | |
321 | ccid3_hc_tx_set_state(sk, state: TFRC_SSTATE_NO_FBACK); |
322 | |
323 | } else { |
324 | delay = ktime_us_delta(later: hc->tx_t_nom, earlier: now); |
325 | ccid3_pr_debug("delay=%ld\n" , (long)delay); |
326 | /* |
327 | * Scheduling of packet transmissions (RFC 5348, 8.3) |
328 | * |
329 | * if (t_now > t_nom - delta) |
330 | * // send the packet now |
331 | * else |
332 | * // send the packet in (t_nom - t_now) milliseconds. |
333 | */ |
334 | if (delay >= TFRC_T_DELTA) |
335 | return (u32)delay / USEC_PER_MSEC; |
336 | |
337 | ccid3_hc_tx_update_win_count(hc, now); |
338 | } |
339 | |
340 | /* prepare to send now (add options etc.) */ |
341 | dp->dccps_hc_tx_insert_options = 1; |
342 | DCCP_SKB_CB(skb)->dccpd_ccval = hc->tx_last_win_count; |
343 | |
344 | /* set the nominal send time for the next following packet */ |
345 | hc->tx_t_nom = ktime_add_us(kt: hc->tx_t_nom, usec: hc->tx_t_ipi); |
346 | return CCID_PACKET_SEND_AT_ONCE; |
347 | } |
348 | |
349 | static void ccid3_hc_tx_packet_sent(struct sock *sk, unsigned int len) |
350 | { |
351 | struct ccid3_hc_tx_sock *hc = ccid3_hc_tx_sk(sk); |
352 | |
353 | ccid3_hc_tx_update_s(hc, len); |
354 | |
355 | if (tfrc_tx_hist_add(headp: &hc->tx_hist, dccp_sk(sk)->dccps_gss)) |
356 | DCCP_CRIT("packet history - out of memory!" ); |
357 | } |
358 | |
359 | static void ccid3_hc_tx_packet_recv(struct sock *sk, struct sk_buff *skb) |
360 | { |
361 | struct ccid3_hc_tx_sock *hc = ccid3_hc_tx_sk(sk); |
362 | struct tfrc_tx_hist_entry *acked; |
363 | ktime_t now; |
364 | unsigned long t_nfb; |
365 | u32 r_sample; |
366 | |
367 | /* we are only interested in ACKs */ |
368 | if (!(DCCP_SKB_CB(skb)->dccpd_type == DCCP_PKT_ACK || |
369 | DCCP_SKB_CB(skb)->dccpd_type == DCCP_PKT_DATAACK)) |
370 | return; |
371 | /* |
372 | * Locate the acknowledged packet in the TX history. |
373 | * |
374 | * Returning "entry not found" here can for instance happen when |
375 | * - the host has not sent out anything (e.g. a passive server), |
376 | * - the Ack is outdated (packet with higher Ack number was received), |
377 | * - it is a bogus Ack (for a packet not sent on this connection). |
378 | */ |
379 | acked = tfrc_tx_hist_find_entry(head: hc->tx_hist, seqno: dccp_hdr_ack_seq(skb)); |
380 | if (acked == NULL) |
381 | return; |
382 | /* For the sake of RTT sampling, ignore/remove all older entries */ |
383 | tfrc_tx_hist_purge(headp: &acked->next); |
384 | |
385 | /* Update the moving average for the RTT estimate (RFC 3448, 4.3) */ |
386 | now = ktime_get_real(); |
387 | r_sample = dccp_sample_rtt(sk, delta: ktime_us_delta(later: now, earlier: acked->stamp)); |
388 | hc->tx_rtt = tfrc_ewma(avg: hc->tx_rtt, newval: r_sample, weight: 9); |
389 | |
390 | /* |
391 | * Update allowed sending rate X as per draft rfc3448bis-00, 4.2/3 |
392 | */ |
393 | if (hc->tx_state == TFRC_SSTATE_NO_FBACK) { |
394 | ccid3_hc_tx_set_state(sk, state: TFRC_SSTATE_FBACK); |
395 | |
396 | if (hc->tx_t_rto == 0) { |
397 | /* |
398 | * Initial feedback packet: Larger Initial Windows (4.2) |
399 | */ |
400 | hc->tx_x = rfc3390_initial_rate(sk); |
401 | hc->tx_t_ld = now; |
402 | |
403 | ccid3_update_send_interval(hc); |
404 | |
405 | goto done_computing_x; |
406 | } else if (hc->tx_p == 0) { |
407 | /* |
408 | * First feedback after nofeedback timer expiry (4.3) |
409 | */ |
410 | goto done_computing_x; |
411 | } |
412 | } |
413 | |
414 | /* Update sending rate (step 4 of [RFC 3448, 4.3]) */ |
415 | if (hc->tx_p > 0) |
416 | hc->tx_x_calc = tfrc_calc_x(s: hc->tx_s, R: hc->tx_rtt, p: hc->tx_p); |
417 | ccid3_hc_tx_update_x(sk, stamp: &now); |
418 | |
419 | done_computing_x: |
420 | ccid3_pr_debug("%s(%p), RTT=%uus (sample=%uus), s=%u, " |
421 | "p=%u, X_calc=%u, X_recv=%u, X=%u\n" , |
422 | dccp_role(sk), sk, hc->tx_rtt, r_sample, |
423 | hc->tx_s, hc->tx_p, hc->tx_x_calc, |
424 | (unsigned int)(hc->tx_x_recv >> 6), |
425 | (unsigned int)(hc->tx_x >> 6)); |
426 | |
427 | /* unschedule no feedback timer */ |
428 | sk_stop_timer(sk, timer: &hc->tx_no_feedback_timer); |
429 | |
430 | /* |
431 | * As we have calculated new ipi, delta, t_nom it is possible |
432 | * that we now can send a packet, so wake up dccp_wait_for_ccid |
433 | */ |
434 | sk->sk_write_space(sk); |
435 | |
436 | /* |
437 | * Update timeout interval for the nofeedback timer. In order to control |
438 | * rate halving on networks with very low RTTs (<= 1 ms), use per-route |
439 | * tunable RTAX_RTO_MIN value as the lower bound. |
440 | */ |
441 | hc->tx_t_rto = max_t(u32, 4 * hc->tx_rtt, |
442 | USEC_PER_SEC/HZ * tcp_rto_min(sk)); |
443 | /* |
444 | * Schedule no feedback timer to expire in |
445 | * max(t_RTO, 2 * s/X) = max(t_RTO, 2 * t_ipi) |
446 | */ |
447 | t_nfb = max(hc->tx_t_rto, 2 * hc->tx_t_ipi); |
448 | |
449 | ccid3_pr_debug("%s(%p), Scheduled no feedback timer to " |
450 | "expire in %lu jiffies (%luus)\n" , |
451 | dccp_role(sk), sk, usecs_to_jiffies(t_nfb), t_nfb); |
452 | |
453 | sk_reset_timer(sk, timer: &hc->tx_no_feedback_timer, |
454 | expires: jiffies + usecs_to_jiffies(u: t_nfb)); |
455 | } |
456 | |
457 | static int ccid3_hc_tx_parse_options(struct sock *sk, u8 packet_type, |
458 | u8 option, u8 *optval, u8 optlen) |
459 | { |
460 | struct ccid3_hc_tx_sock *hc = ccid3_hc_tx_sk(sk); |
461 | __be32 opt_val; |
462 | |
463 | switch (option) { |
464 | case TFRC_OPT_RECEIVE_RATE: |
465 | case TFRC_OPT_LOSS_EVENT_RATE: |
466 | /* Must be ignored on Data packets, cf. RFC 4342 8.3 and 8.5 */ |
467 | if (packet_type == DCCP_PKT_DATA) |
468 | break; |
469 | if (unlikely(optlen != 4)) { |
470 | DCCP_WARN("%s(%p), invalid len %d for %u\n" , |
471 | dccp_role(sk), sk, optlen, option); |
472 | return -EINVAL; |
473 | } |
474 | opt_val = ntohl(get_unaligned((__be32 *)optval)); |
475 | |
476 | if (option == TFRC_OPT_RECEIVE_RATE) { |
477 | /* Receive Rate is kept in units of 64 bytes/second */ |
478 | hc->tx_x_recv = opt_val; |
479 | hc->tx_x_recv <<= 6; |
480 | |
481 | ccid3_pr_debug("%s(%p), RECEIVE_RATE=%u\n" , |
482 | dccp_role(sk), sk, opt_val); |
483 | } else { |
484 | /* Update the fixpoint Loss Event Rate fraction */ |
485 | hc->tx_p = tfrc_invert_loss_event_rate(loss_event_rate: opt_val); |
486 | |
487 | ccid3_pr_debug("%s(%p), LOSS_EVENT_RATE=%u\n" , |
488 | dccp_role(sk), sk, opt_val); |
489 | } |
490 | } |
491 | return 0; |
492 | } |
493 | |
494 | static int ccid3_hc_tx_init(struct ccid *ccid, struct sock *sk) |
495 | { |
496 | struct ccid3_hc_tx_sock *hc = ccid_priv(ccid); |
497 | |
498 | hc->tx_state = TFRC_SSTATE_NO_SENT; |
499 | hc->tx_hist = NULL; |
500 | hc->sk = sk; |
501 | timer_setup(&hc->tx_no_feedback_timer, |
502 | ccid3_hc_tx_no_feedback_timer, 0); |
503 | return 0; |
504 | } |
505 | |
506 | static void ccid3_hc_tx_exit(struct sock *sk) |
507 | { |
508 | struct ccid3_hc_tx_sock *hc = ccid3_hc_tx_sk(sk); |
509 | |
510 | sk_stop_timer(sk, timer: &hc->tx_no_feedback_timer); |
511 | tfrc_tx_hist_purge(headp: &hc->tx_hist); |
512 | } |
513 | |
514 | static void ccid3_hc_tx_get_info(struct sock *sk, struct tcp_info *info) |
515 | { |
516 | info->tcpi_rto = ccid3_hc_tx_sk(sk)->tx_t_rto; |
517 | info->tcpi_rtt = ccid3_hc_tx_sk(sk)->tx_rtt; |
518 | } |
519 | |
520 | static int ccid3_hc_tx_getsockopt(struct sock *sk, const int optname, int len, |
521 | u32 __user *optval, int __user *optlen) |
522 | { |
523 | const struct ccid3_hc_tx_sock *hc = ccid3_hc_tx_sk(sk); |
524 | struct tfrc_tx_info tfrc; |
525 | const void *val; |
526 | |
527 | switch (optname) { |
528 | case DCCP_SOCKOPT_CCID_TX_INFO: |
529 | if (len < sizeof(tfrc)) |
530 | return -EINVAL; |
531 | memset(&tfrc, 0, sizeof(tfrc)); |
532 | tfrc.tfrctx_x = hc->tx_x; |
533 | tfrc.tfrctx_x_recv = hc->tx_x_recv; |
534 | tfrc.tfrctx_x_calc = hc->tx_x_calc; |
535 | tfrc.tfrctx_rtt = hc->tx_rtt; |
536 | tfrc.tfrctx_p = hc->tx_p; |
537 | tfrc.tfrctx_rto = hc->tx_t_rto; |
538 | tfrc.tfrctx_ipi = hc->tx_t_ipi; |
539 | len = sizeof(tfrc); |
540 | val = &tfrc; |
541 | break; |
542 | default: |
543 | return -ENOPROTOOPT; |
544 | } |
545 | |
546 | if (put_user(len, optlen) || copy_to_user(to: optval, from: val, n: len)) |
547 | return -EFAULT; |
548 | |
549 | return 0; |
550 | } |
551 | |
552 | /* |
553 | * Receiver Half-Connection Routines |
554 | */ |
555 | |
556 | /* CCID3 feedback types */ |
557 | enum ccid3_fback_type { |
558 | CCID3_FBACK_NONE = 0, |
559 | CCID3_FBACK_INITIAL, |
560 | CCID3_FBACK_PERIODIC, |
561 | CCID3_FBACK_PARAM_CHANGE |
562 | }; |
563 | |
564 | #ifdef CONFIG_IP_DCCP_CCID3_DEBUG |
565 | static const char *ccid3_rx_state_name(enum ccid3_hc_rx_states state) |
566 | { |
567 | static const char *const ccid3_rx_state_names[] = { |
568 | [TFRC_RSTATE_NO_DATA] = "NO_DATA" , |
569 | [TFRC_RSTATE_DATA] = "DATA" , |
570 | }; |
571 | |
572 | return ccid3_rx_state_names[state]; |
573 | } |
574 | #endif |
575 | |
576 | static void ccid3_hc_rx_set_state(struct sock *sk, |
577 | enum ccid3_hc_rx_states state) |
578 | { |
579 | struct ccid3_hc_rx_sock *hc = ccid3_hc_rx_sk(sk); |
580 | enum ccid3_hc_rx_states oldstate = hc->rx_state; |
581 | |
582 | ccid3_pr_debug("%s(%p) %-8.8s -> %s\n" , |
583 | dccp_role(sk), sk, ccid3_rx_state_name(oldstate), |
584 | ccid3_rx_state_name(state)); |
585 | WARN_ON(state == oldstate); |
586 | hc->rx_state = state; |
587 | } |
588 | |
589 | static void ccid3_hc_rx_send_feedback(struct sock *sk, |
590 | const struct sk_buff *skb, |
591 | enum ccid3_fback_type fbtype) |
592 | { |
593 | struct ccid3_hc_rx_sock *hc = ccid3_hc_rx_sk(sk); |
594 | struct dccp_sock *dp = dccp_sk(sk); |
595 | ktime_t now = ktime_get(); |
596 | s64 delta = 0; |
597 | |
598 | switch (fbtype) { |
599 | case CCID3_FBACK_INITIAL: |
600 | hc->rx_x_recv = 0; |
601 | hc->rx_pinv = ~0U; /* see RFC 4342, 8.5 */ |
602 | break; |
603 | case CCID3_FBACK_PARAM_CHANGE: |
604 | /* |
605 | * When parameters change (new loss or p > p_prev), we do not |
606 | * have a reliable estimate for R_m of [RFC 3448, 6.2] and so |
607 | * need to reuse the previous value of X_recv. However, when |
608 | * X_recv was 0 (due to early loss), this would kill X down to |
609 | * s/t_mbi (i.e. one packet in 64 seconds). |
610 | * To avoid such drastic reduction, we approximate X_recv as |
611 | * the number of bytes since last feedback. |
612 | * This is a safe fallback, since X is bounded above by X_calc. |
613 | */ |
614 | if (hc->rx_x_recv > 0) |
615 | break; |
616 | fallthrough; |
617 | case CCID3_FBACK_PERIODIC: |
618 | delta = ktime_us_delta(later: now, earlier: hc->rx_tstamp_last_feedback); |
619 | if (delta <= 0) |
620 | delta = 1; |
621 | hc->rx_x_recv = scaled_div32(a: hc->rx_bytes_recv, b: delta); |
622 | break; |
623 | default: |
624 | return; |
625 | } |
626 | |
627 | ccid3_pr_debug("Interval %lldusec, X_recv=%u, 1/p=%u\n" , delta, |
628 | hc->rx_x_recv, hc->rx_pinv); |
629 | |
630 | hc->rx_tstamp_last_feedback = now; |
631 | hc->rx_last_counter = dccp_hdr(skb)->dccph_ccval; |
632 | hc->rx_bytes_recv = 0; |
633 | |
634 | dp->dccps_hc_rx_insert_options = 1; |
635 | dccp_send_ack(sk); |
636 | } |
637 | |
638 | static int ccid3_hc_rx_insert_options(struct sock *sk, struct sk_buff *skb) |
639 | { |
640 | const struct ccid3_hc_rx_sock *hc = ccid3_hc_rx_sk(sk); |
641 | __be32 x_recv, pinv; |
642 | |
643 | if (!(sk->sk_state == DCCP_OPEN || sk->sk_state == DCCP_PARTOPEN)) |
644 | return 0; |
645 | |
646 | if (dccp_packet_without_ack(skb)) |
647 | return 0; |
648 | |
649 | x_recv = htonl(hc->rx_x_recv); |
650 | pinv = htonl(hc->rx_pinv); |
651 | |
652 | if (dccp_insert_option(skb, option: TFRC_OPT_LOSS_EVENT_RATE, |
653 | value: &pinv, len: sizeof(pinv)) || |
654 | dccp_insert_option(skb, option: TFRC_OPT_RECEIVE_RATE, |
655 | value: &x_recv, len: sizeof(x_recv))) |
656 | return -1; |
657 | |
658 | return 0; |
659 | } |
660 | |
661 | /** |
662 | * ccid3_first_li - Implements [RFC 5348, 6.3.1] |
663 | * @sk: socket to calculate loss interval for |
664 | * |
665 | * Determine the length of the first loss interval via inverse lookup. |
666 | * Assume that X_recv can be computed by the throughput equation |
667 | * s |
668 | * X_recv = -------- |
669 | * R * fval |
670 | * Find some p such that f(p) = fval; return 1/p (scaled). |
671 | */ |
672 | static u32 ccid3_first_li(struct sock *sk) |
673 | { |
674 | struct ccid3_hc_rx_sock *hc = ccid3_hc_rx_sk(sk); |
675 | u32 x_recv, p; |
676 | s64 delta; |
677 | u64 fval; |
678 | |
679 | if (hc->rx_rtt == 0) { |
680 | DCCP_WARN("No RTT estimate available, using fallback RTT\n" ); |
681 | hc->rx_rtt = DCCP_FALLBACK_RTT; |
682 | } |
683 | |
684 | delta = ktime_us_delta(later: ktime_get(), earlier: hc->rx_tstamp_last_feedback); |
685 | if (delta <= 0) |
686 | delta = 1; |
687 | x_recv = scaled_div32(a: hc->rx_bytes_recv, b: delta); |
688 | if (x_recv == 0) { /* would also trigger divide-by-zero */ |
689 | DCCP_WARN("X_recv==0\n" ); |
690 | if (hc->rx_x_recv == 0) { |
691 | DCCP_BUG("stored value of X_recv is zero" ); |
692 | return ~0U; |
693 | } |
694 | x_recv = hc->rx_x_recv; |
695 | } |
696 | |
697 | fval = scaled_div(a: hc->rx_s, b: hc->rx_rtt); |
698 | fval = scaled_div32(a: fval, b: x_recv); |
699 | p = tfrc_calc_x_reverse_lookup(fvalue: fval); |
700 | |
701 | ccid3_pr_debug("%s(%p), receive rate=%u bytes/s, implied " |
702 | "loss rate=%u\n" , dccp_role(sk), sk, x_recv, p); |
703 | |
704 | return p == 0 ? ~0U : scaled_div(a: 1, b: p); |
705 | } |
706 | |
707 | static void ccid3_hc_rx_packet_recv(struct sock *sk, struct sk_buff *skb) |
708 | { |
709 | struct ccid3_hc_rx_sock *hc = ccid3_hc_rx_sk(sk); |
710 | enum ccid3_fback_type do_feedback = CCID3_FBACK_NONE; |
711 | const u64 ndp = dccp_sk(sk)->dccps_options_received.dccpor_ndp; |
712 | const bool is_data_packet = dccp_data_packet(skb); |
713 | |
714 | if (unlikely(hc->rx_state == TFRC_RSTATE_NO_DATA)) { |
715 | if (is_data_packet) { |
716 | const u32 payload = skb->len - dccp_hdr(skb)->dccph_doff * 4; |
717 | do_feedback = CCID3_FBACK_INITIAL; |
718 | ccid3_hc_rx_set_state(sk, state: TFRC_RSTATE_DATA); |
719 | hc->rx_s = payload; |
720 | /* |
721 | * Not necessary to update rx_bytes_recv here, |
722 | * since X_recv = 0 for the first feedback packet (cf. |
723 | * RFC 3448, 6.3) -- gerrit |
724 | */ |
725 | } |
726 | goto update_records; |
727 | } |
728 | |
729 | if (tfrc_rx_hist_duplicate(h: &hc->rx_hist, skb)) |
730 | return; /* done receiving */ |
731 | |
732 | if (is_data_packet) { |
733 | const u32 payload = skb->len - dccp_hdr(skb)->dccph_doff * 4; |
734 | /* |
735 | * Update moving-average of s and the sum of received payload bytes |
736 | */ |
737 | hc->rx_s = tfrc_ewma(avg: hc->rx_s, newval: payload, weight: 9); |
738 | hc->rx_bytes_recv += payload; |
739 | } |
740 | |
741 | /* |
742 | * Perform loss detection and handle pending losses |
743 | */ |
744 | if (tfrc_rx_handle_loss(h: &hc->rx_hist, lh: &hc->rx_li_hist, |
745 | skb, ndp, first_li: ccid3_first_li, sk)) { |
746 | do_feedback = CCID3_FBACK_PARAM_CHANGE; |
747 | goto done_receiving; |
748 | } |
749 | |
750 | if (tfrc_rx_hist_loss_pending(h: &hc->rx_hist)) |
751 | return; /* done receiving */ |
752 | |
753 | /* |
754 | * Handle data packets: RTT sampling and monitoring p |
755 | */ |
756 | if (unlikely(!is_data_packet)) |
757 | goto update_records; |
758 | |
759 | if (!tfrc_lh_is_initialised(lh: &hc->rx_li_hist)) { |
760 | const u32 sample = tfrc_rx_hist_sample_rtt(h: &hc->rx_hist, skb); |
761 | /* |
762 | * Empty loss history: no loss so far, hence p stays 0. |
763 | * Sample RTT values, since an RTT estimate is required for the |
764 | * computation of p when the first loss occurs; RFC 3448, 6.3.1. |
765 | */ |
766 | if (sample != 0) |
767 | hc->rx_rtt = tfrc_ewma(avg: hc->rx_rtt, newval: sample, weight: 9); |
768 | |
769 | } else if (tfrc_lh_update_i_mean(lh: &hc->rx_li_hist, skb)) { |
770 | /* |
771 | * Step (3) of [RFC 3448, 6.1]: Recompute I_mean and, if I_mean |
772 | * has decreased (resp. p has increased), send feedback now. |
773 | */ |
774 | do_feedback = CCID3_FBACK_PARAM_CHANGE; |
775 | } |
776 | |
777 | /* |
778 | * Check if the periodic once-per-RTT feedback is due; RFC 4342, 10.3 |
779 | */ |
780 | if (SUB16(dccp_hdr(skb)->dccph_ccval, hc->rx_last_counter) > 3) |
781 | do_feedback = CCID3_FBACK_PERIODIC; |
782 | |
783 | update_records: |
784 | tfrc_rx_hist_add_packet(h: &hc->rx_hist, skb, ndp); |
785 | |
786 | done_receiving: |
787 | if (do_feedback) |
788 | ccid3_hc_rx_send_feedback(sk, skb, fbtype: do_feedback); |
789 | } |
790 | |
791 | static int ccid3_hc_rx_init(struct ccid *ccid, struct sock *sk) |
792 | { |
793 | struct ccid3_hc_rx_sock *hc = ccid_priv(ccid); |
794 | |
795 | hc->rx_state = TFRC_RSTATE_NO_DATA; |
796 | tfrc_lh_init(lh: &hc->rx_li_hist); |
797 | return tfrc_rx_hist_alloc(h: &hc->rx_hist); |
798 | } |
799 | |
800 | static void ccid3_hc_rx_exit(struct sock *sk) |
801 | { |
802 | struct ccid3_hc_rx_sock *hc = ccid3_hc_rx_sk(sk); |
803 | |
804 | tfrc_rx_hist_purge(h: &hc->rx_hist); |
805 | tfrc_lh_cleanup(lh: &hc->rx_li_hist); |
806 | } |
807 | |
808 | static void ccid3_hc_rx_get_info(struct sock *sk, struct tcp_info *info) |
809 | { |
810 | info->tcpi_ca_state = ccid3_hc_rx_sk(sk)->rx_state; |
811 | info->tcpi_options |= TCPI_OPT_TIMESTAMPS; |
812 | info->tcpi_rcv_rtt = ccid3_hc_rx_sk(sk)->rx_rtt; |
813 | } |
814 | |
815 | static int ccid3_hc_rx_getsockopt(struct sock *sk, const int optname, int len, |
816 | u32 __user *optval, int __user *optlen) |
817 | { |
818 | const struct ccid3_hc_rx_sock *hc = ccid3_hc_rx_sk(sk); |
819 | struct tfrc_rx_info rx_info; |
820 | const void *val; |
821 | |
822 | switch (optname) { |
823 | case DCCP_SOCKOPT_CCID_RX_INFO: |
824 | if (len < sizeof(rx_info)) |
825 | return -EINVAL; |
826 | rx_info.tfrcrx_x_recv = hc->rx_x_recv; |
827 | rx_info.tfrcrx_rtt = hc->rx_rtt; |
828 | rx_info.tfrcrx_p = tfrc_invert_loss_event_rate(loss_event_rate: hc->rx_pinv); |
829 | len = sizeof(rx_info); |
830 | val = &rx_info; |
831 | break; |
832 | default: |
833 | return -ENOPROTOOPT; |
834 | } |
835 | |
836 | if (put_user(len, optlen) || copy_to_user(to: optval, from: val, n: len)) |
837 | return -EFAULT; |
838 | |
839 | return 0; |
840 | } |
841 | |
842 | struct ccid_operations ccid3_ops = { |
843 | .ccid_id = DCCPC_CCID3, |
844 | .ccid_name = "TCP-Friendly Rate Control" , |
845 | .ccid_hc_tx_obj_size = sizeof(struct ccid3_hc_tx_sock), |
846 | .ccid_hc_tx_init = ccid3_hc_tx_init, |
847 | .ccid_hc_tx_exit = ccid3_hc_tx_exit, |
848 | .ccid_hc_tx_send_packet = ccid3_hc_tx_send_packet, |
849 | .ccid_hc_tx_packet_sent = ccid3_hc_tx_packet_sent, |
850 | .ccid_hc_tx_packet_recv = ccid3_hc_tx_packet_recv, |
851 | .ccid_hc_tx_parse_options = ccid3_hc_tx_parse_options, |
852 | .ccid_hc_rx_obj_size = sizeof(struct ccid3_hc_rx_sock), |
853 | .ccid_hc_rx_init = ccid3_hc_rx_init, |
854 | .ccid_hc_rx_exit = ccid3_hc_rx_exit, |
855 | .ccid_hc_rx_insert_options = ccid3_hc_rx_insert_options, |
856 | .ccid_hc_rx_packet_recv = ccid3_hc_rx_packet_recv, |
857 | .ccid_hc_rx_get_info = ccid3_hc_rx_get_info, |
858 | .ccid_hc_tx_get_info = ccid3_hc_tx_get_info, |
859 | .ccid_hc_rx_getsockopt = ccid3_hc_rx_getsockopt, |
860 | .ccid_hc_tx_getsockopt = ccid3_hc_tx_getsockopt, |
861 | }; |
862 | |
863 | #ifdef CONFIG_IP_DCCP_CCID3_DEBUG |
864 | module_param(ccid3_debug, bool, 0644); |
865 | MODULE_PARM_DESC(ccid3_debug, "Enable CCID-3 debug messages" ); |
866 | #endif |
867 | |