?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[DCCP] ccid3: Simplify control flow in the calculation of t_ipi
[linux-2.6/x86.git] / net / dccp / ccids / ccid3.c
blobdf88c54b2ec5d0bd81274abc6b8c3f7f3522292f
1 /*
2 * net/dccp/ccids/ccid3.c
3 *
4 * Copyright (c) 2005 The University of Waikato, Hamilton, New Zealand.
5 * Copyright (c) 2005-6 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 http://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 * This program is free software; you can redistribute it and/or modify
23 * it under the terms of the GNU General Public License as published by
24 * the Free Software Foundation; either version 2 of the License, or
25 * (at your option) any later version.
26 *
27 * This program is distributed in the hope that it will be useful,
28 * but WITHOUT ANY WARRANTY; without even the implied warranty of
29 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
30 * GNU General Public License for more details.
31 *
32 * You should have received a copy of the GNU General Public License
33 * along with this program; if not, write to the Free Software
34 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
35 */
36
37 #include "../ccid.h"
38 #include "../dccp.h"
39 #include "lib/packet_history.h"
40 #include "lib/loss_interval.h"
41 #include "lib/tfrc.h"
42 #include "ccid3.h"
43
44 /*
45 * Reason for maths here is to avoid 32 bit overflow when a is big.
46 * With this we get close to the limit.
47 */
48 static u32 usecs_div(const u32 a, const u32 b)
49 {
50 const u32 div = a < (UINT_MAX / (USEC_PER_SEC / 10)) ? 10 :
51 a < (UINT_MAX / (USEC_PER_SEC / 50)) ? 50 :
52 a < (UINT_MAX / (USEC_PER_SEC / 100)) ? 100 :
53 a < (UINT_MAX / (USEC_PER_SEC / 500)) ? 500 :
54 a < (UINT_MAX / (USEC_PER_SEC / 1000)) ? 1000 :
55 a < (UINT_MAX / (USEC_PER_SEC / 5000)) ? 5000 :
56 a < (UINT_MAX / (USEC_PER_SEC / 10000)) ? 10000 :
57 a < (UINT_MAX / (USEC_PER_SEC / 50000)) ? 50000 :
58 100000;
59 const u32 tmp = a * (USEC_PER_SEC / div);
60 return (b >= 2 * div) ? tmp / (b / div) : tmp;
61 }
62
63
64
65 #ifdef CONFIG_IP_DCCP_CCID3_DEBUG
66 static int ccid3_debug;
67 #define ccid3_pr_debug(format, a...) DCCP_PR_DEBUG(ccid3_debug, format, ##a)
68 #else
69 #define ccid3_pr_debug(format, a...)
70 #endif
71
72 static struct dccp_tx_hist *ccid3_tx_hist;
73 static struct dccp_rx_hist *ccid3_rx_hist;
74 static struct dccp_li_hist *ccid3_li_hist;
75
76 #ifdef CONFIG_IP_DCCP_CCID3_DEBUG
77 static const char *ccid3_tx_state_name(enum ccid3_hc_tx_states state)
78 {
79 static char *ccid3_state_names[] = {
80 [TFRC_SSTATE_NO_SENT] = "NO_SENT",
81 [TFRC_SSTATE_NO_FBACK] = "NO_FBACK",
82 [TFRC_SSTATE_FBACK] = "FBACK",
83 [TFRC_SSTATE_TERM] = "TERM",
84 };
85
86 return ccid3_state_names[state];
87 }
88 #endif
89
90 static void ccid3_hc_tx_set_state(struct sock *sk,
91 enum ccid3_hc_tx_states state)
92 {
93 struct ccid3_hc_tx_sock *hctx = ccid3_hc_tx_sk(sk);
94 enum ccid3_hc_tx_states oldstate = hctx->ccid3hctx_state;
95
96 ccid3_pr_debug("%s(%p) %-8.8s -> %s\n",
97 dccp_role(sk), sk, ccid3_tx_state_name(oldstate),
98 ccid3_tx_state_name(state));
99 WARN_ON(state == oldstate);
100 hctx->ccid3hctx_state = state;
101 }
102
103 /* Calculate new t_ipi (inter packet interval) by t_ipi = s / X_inst */
104 static inline void ccid3_calc_new_t_ipi(struct ccid3_hc_tx_sock *hctx)
105 {
106 hctx->ccid3hctx_t_ipi = usecs_div(hctx->ccid3hctx_s, hctx->ccid3hctx_x);
107 }
108
109 /* Calculate new delta by delta = min(t_ipi / 2, t_gran / 2) */
110 static inline void ccid3_calc_new_delta(struct ccid3_hc_tx_sock *hctx)
111 {
112 hctx->ccid3hctx_delta = min_t(u32, hctx->ccid3hctx_t_ipi / 2,
113 TFRC_OPSYS_HALF_TIME_GRAN);
114 }
115
116 /*
117 * Update X by
118 * If (p > 0)
119 * x_calc = calcX(s, R, p);
120 * X = max(min(X_calc, 2 * X_recv), s / t_mbi);
121 * Else
122 * If (now - tld >= R)
123 * X = max(min(2 * X, 2 * X_recv), s / R);
124 * tld = now;
125 */
126 static void ccid3_hc_tx_update_x(struct sock *sk)
127 {
128 struct ccid3_hc_tx_sock *hctx = ccid3_hc_tx_sk(sk);
129
130 /* To avoid large error in calcX */
131 if (hctx->ccid3hctx_p >= TFRC_SMALLEST_P) {
132 hctx->ccid3hctx_x_calc = tfrc_calc_x(hctx->ccid3hctx_s,
133 hctx->ccid3hctx_rtt,
134 hctx->ccid3hctx_p);
135 hctx->ccid3hctx_x = max_t(u32, min_t(u32, hctx->ccid3hctx_x_calc,
136 2 * hctx->ccid3hctx_x_recv),
137 (hctx->ccid3hctx_s /
138 TFRC_MAX_BACK_OFF_TIME));
139 } else {
140 struct timeval now;
141
142 dccp_timestamp(sk, &now);
143 if (timeval_delta(&now, &hctx->ccid3hctx_t_ld) >=
144 hctx->ccid3hctx_rtt) {
145 hctx->ccid3hctx_x = max_t(u32, min_t(u32, hctx->ccid3hctx_x_recv,
146 hctx->ccid3hctx_x) * 2,
147 usecs_div(hctx->ccid3hctx_s,
148 hctx->ccid3hctx_rtt));
149 hctx->ccid3hctx_t_ld = now;
150 }
151 }
152 }
153
154 static void ccid3_hc_tx_no_feedback_timer(unsigned long data)
155 {
156 struct sock *sk = (struct sock *)data;
157 unsigned long next_tmout = 0;
158 struct ccid3_hc_tx_sock *hctx = ccid3_hc_tx_sk(sk);
159
160 bh_lock_sock(sk);
161 if (sock_owned_by_user(sk)) {
162 /* Try again later. */
163 /* XXX: set some sensible MIB */
164 sk_reset_timer(sk, &hctx->ccid3hctx_no_feedback_timer,
165 jiffies + HZ / 5);
166 goto out;
167 }
168
169 ccid3_pr_debug("%s, sk=%p, state=%s\n", dccp_role(sk), sk,
170 ccid3_tx_state_name(hctx->ccid3hctx_state));
171
172 switch (hctx->ccid3hctx_state) {
173 case TFRC_SSTATE_NO_FBACK:
174 /* Halve send rate */
175 hctx->ccid3hctx_x /= 2;
176 if (hctx->ccid3hctx_x < (hctx->ccid3hctx_s /
177 TFRC_MAX_BACK_OFF_TIME))
178 hctx->ccid3hctx_x = (hctx->ccid3hctx_s /
179 TFRC_MAX_BACK_OFF_TIME);
180
181 ccid3_pr_debug("%s, sk=%p, state=%s, updated tx rate to %d "
182 "bytes/s\n",
183 dccp_role(sk), sk,
184 ccid3_tx_state_name(hctx->ccid3hctx_state),
185 hctx->ccid3hctx_x);
186 next_tmout = max_t(u32, 2 * usecs_div(hctx->ccid3hctx_s,
187 hctx->ccid3hctx_x),
188 TFRC_INITIAL_TIMEOUT);
189 /*
190 * FIXME - not sure above calculation is correct. See section
191 * 5 of CCID3 11 should adjust tx_t_ipi and double that to
192 * achieve it really
193 */
194 break;
195 case TFRC_SSTATE_FBACK:
196 /*
197 * Check if IDLE since last timeout and recv rate is less than
198 * 4 packets per RTT
199 */
200 if (!hctx->ccid3hctx_idle ||
201 (hctx->ccid3hctx_x_recv >=
202 4 * usecs_div(hctx->ccid3hctx_s, hctx->ccid3hctx_rtt))) {
203 ccid3_pr_debug("%s, sk=%p, state=%s, not idle\n",
204 dccp_role(sk), sk,
205 ccid3_tx_state_name(hctx->ccid3hctx_state));
206 /* Halve sending rate */
207
208 /* If (X_calc > 2 * X_recv)
209 * X_recv = max(X_recv / 2, s / (2 * t_mbi));
210 * Else
211 * X_recv = X_calc / 4;
212 */
213 BUG_ON(hctx->ccid3hctx_p >= TFRC_SMALLEST_P &&
214 hctx->ccid3hctx_x_calc == 0);
215
216 /* check also if p is zero -> x_calc is infinity? */
217 if (hctx->ccid3hctx_p < TFRC_SMALLEST_P ||
218 hctx->ccid3hctx_x_calc > 2 * hctx->ccid3hctx_x_recv)
219 hctx->ccid3hctx_x_recv = max_t(u32, hctx->ccid3hctx_x_recv / 2,
220 hctx->ccid3hctx_s / (2 * TFRC_MAX_BACK_OFF_TIME));
221 else
222 hctx->ccid3hctx_x_recv = hctx->ccid3hctx_x_calc / 4;
223
224 /* Update sending rate */
225 ccid3_hc_tx_update_x(sk);
226 }
227 /*
228 * Schedule no feedback timer to expire in
229 * max(4 * R, 2 * s / X)
230 */
231 next_tmout = max_t(u32, hctx->ccid3hctx_t_rto,
232 2 * usecs_div(hctx->ccid3hctx_s,
233 hctx->ccid3hctx_x));
234 break;
235 case TFRC_SSTATE_NO_SENT:
236 DCCP_BUG("Illegal %s state NO_SENT, sk=%p", dccp_role(sk), sk);
237 /* fall through */
238 case TFRC_SSTATE_TERM:
239 goto out;
240 }
241
242 sk_reset_timer(sk, &hctx->ccid3hctx_no_feedback_timer,
243 jiffies + max_t(u32, 1, usecs_to_jiffies(next_tmout)));
244 hctx->ccid3hctx_idle = 1;
245 out:
246 bh_unlock_sock(sk);
247 sock_put(sk);
248 }
249
250 static int ccid3_hc_tx_send_packet(struct sock *sk,
251 struct sk_buff *skb, int len)
252 {
253 struct dccp_sock *dp = dccp_sk(sk);
254 struct ccid3_hc_tx_sock *hctx = ccid3_hc_tx_sk(sk);
255 struct dccp_tx_hist_entry *new_packet;
256 struct timeval now;
257 long delay;
258 int rc = -ENOTCONN;
259
260 BUG_ON(hctx == NULL);
261
262 /* Check if pure ACK or Terminating*/
263 /*
264 * XXX: We only call this function for DATA and DATAACK, on, these
265 * packets can have zero length, but why the comment about "pure ACK"?
266 */
267 if (unlikely(len == 0))
268 goto out;
269
270 /* See if last packet allocated was not sent */
271 new_packet = dccp_tx_hist_head(&hctx->ccid3hctx_hist);
272 if (new_packet == NULL || new_packet->dccphtx_sent) {
273 new_packet = dccp_tx_hist_entry_new(ccid3_tx_hist,
274 SLAB_ATOMIC);
275
276 rc = -ENOBUFS;
277 if (unlikely(new_packet == NULL)) {
278 DCCP_WARN("%s, sk=%p, not enough mem to add to history,"
279 "send refused\n", dccp_role(sk), sk);
280 goto out;
281 }
282
283 dccp_tx_hist_add_entry(&hctx->ccid3hctx_hist, new_packet);
284 }
285
286 dccp_timestamp(sk, &now);
287
288 switch (hctx->ccid3hctx_state) {
289 case TFRC_SSTATE_NO_SENT:
290 sk_reset_timer(sk, &hctx->ccid3hctx_no_feedback_timer,
291 jiffies + usecs_to_jiffies(TFRC_INITIAL_TIMEOUT));
292 hctx->ccid3hctx_last_win_count = 0;
293 hctx->ccid3hctx_t_last_win_count = now;
294 ccid3_hc_tx_set_state(sk, TFRC_SSTATE_NO_FBACK);
295
296 /* First timeout, according to [RFC 3448, 4.2], is 1 second */
297 hctx->ccid3hctx_t_ipi = USEC_PER_SEC;
298 /* Initial delta: minimum of 0.5 sec and t_gran/2 */
299 hctx->ccid3hctx_delta = TFRC_OPSYS_HALF_TIME_GRAN;
300
301 /* Set t_0 for initial packet */
302 hctx->ccid3hctx_t_nom = now;
303 rc = 0;
304 break;
305 case TFRC_SSTATE_NO_FBACK:
306 case TFRC_SSTATE_FBACK:
307 delay = (timeval_delta(&now, &hctx->ccid3hctx_t_nom) -
308 hctx->ccid3hctx_delta);
309 delay /= -1000;
310 /* divide by -1000 is to convert to ms and get sign right */
311 rc = delay > 0 ? delay : 0;
312 break;
313 case TFRC_SSTATE_TERM:
314 DCCP_BUG("Illegal %s state TERM, sk=%p", dccp_role(sk), sk);
315 rc = -EINVAL;
316 break;
317 }
318
319 /* Can we send? if so add options and add to packet history */
320 if (rc == 0) {
321 dp->dccps_hc_tx_insert_options = 1;
322 new_packet->dccphtx_ccval =
323 DCCP_SKB_CB(skb)->dccpd_ccval =
324 hctx->ccid3hctx_last_win_count;
325 timeval_add_usecs(&hctx->ccid3hctx_t_nom,
326 hctx->ccid3hctx_t_ipi);
327 }
328 out:
329 return rc;
330 }
331
332 static void ccid3_hc_tx_packet_sent(struct sock *sk, int more, int len)
333 {
334 const struct dccp_sock *dp = dccp_sk(sk);
335 struct ccid3_hc_tx_sock *hctx = ccid3_hc_tx_sk(sk);
336 struct timeval now;
337
338 BUG_ON(hctx == NULL);
339
340 dccp_timestamp(sk, &now);
341
342 /* check if we have sent a data packet */
343 if (len > 0) {
344 unsigned long quarter_rtt;
345 struct dccp_tx_hist_entry *packet;
346
347 packet = dccp_tx_hist_head(&hctx->ccid3hctx_hist);
348 if (unlikely(packet == NULL)) {
349 DCCP_WARN("packet doesn't exist in history!\n");
350 return;
351 }
352 if (unlikely(packet->dccphtx_sent)) {
353 DCCP_WARN("no unsent packet in history!\n");
354 return;
355 }
356 packet->dccphtx_tstamp = now;
357 packet->dccphtx_seqno = dp->dccps_gss;
358 /*
359 * Check if win_count have changed
360 * Algorithm in "8.1. Window Counter Value" in RFC 4342.
361 */
362 quarter_rtt = timeval_delta(&now, &hctx->ccid3hctx_t_last_win_count);
363 if (likely(hctx->ccid3hctx_rtt > 8))
364 quarter_rtt /= hctx->ccid3hctx_rtt / 4;
365
366 if (quarter_rtt > 0) {
367 hctx->ccid3hctx_t_last_win_count = now;
368 hctx->ccid3hctx_last_win_count = (hctx->ccid3hctx_last_win_count +
369 min_t(unsigned long, quarter_rtt, 5)) % 16;
370 ccid3_pr_debug("%s, sk=%p, window changed from "
371 "%u to %u!\n",
372 dccp_role(sk), sk,
373 packet->dccphtx_ccval,
374 hctx->ccid3hctx_last_win_count);
375 }
376
377 hctx->ccid3hctx_idle = 0;
378 packet->dccphtx_rtt = hctx->ccid3hctx_rtt;
379 packet->dccphtx_sent = 1;
380 } else
381 ccid3_pr_debug("%s, sk=%p, seqno=%llu NOT inserted!\n",
382 dccp_role(sk), sk, dp->dccps_gss);
383
384 switch (hctx->ccid3hctx_state) {
385 case TFRC_SSTATE_NO_SENT:
386 /* if first wasn't pure ack */
387 if (len != 0)
388 DCCP_CRIT("%s, First packet sent is noted "
389 "as a data packet", dccp_role(sk));
390 return;
391 case TFRC_SSTATE_NO_FBACK:
392 /* t_nom, t_ipi, delta do not change until feedback arrives */
393 return;
394 case TFRC_SSTATE_FBACK:
395 if (len > 0) {
396 timeval_sub_usecs(&hctx->ccid3hctx_t_nom,
397 hctx->ccid3hctx_t_ipi);
398 ccid3_calc_new_t_ipi(hctx);
399 ccid3_calc_new_delta(hctx);
400 timeval_add_usecs(&hctx->ccid3hctx_t_nom,
401 hctx->ccid3hctx_t_ipi);
402 }
403 break;
404 case TFRC_SSTATE_TERM:
405 DCCP_BUG("Illegal %s state TERM, sk=%p", dccp_role(sk), sk);
406 break;
407 }
408 }
409
410 static void ccid3_hc_tx_packet_recv(struct sock *sk, struct sk_buff *skb)
411 {
412 const struct dccp_sock *dp = dccp_sk(sk);
413 struct ccid3_hc_tx_sock *hctx = ccid3_hc_tx_sk(sk);
414 struct ccid3_options_received *opt_recv;
415 struct dccp_tx_hist_entry *packet;
416 struct timeval now;
417 unsigned long next_tmout;
418 u32 t_elapsed;
419 u32 pinv;
420 u32 x_recv;
421 u32 r_sample;
422
423 BUG_ON(hctx == NULL);
424
425 /* we are only interested in ACKs */
426 if (!(DCCP_SKB_CB(skb)->dccpd_type == DCCP_PKT_ACK ||
427 DCCP_SKB_CB(skb)->dccpd_type == DCCP_PKT_DATAACK))
428 return;
429
430 opt_recv = &hctx->ccid3hctx_options_received;
431
432 t_elapsed = dp->dccps_options_received.dccpor_elapsed_time * 10;
433 x_recv = opt_recv->ccid3or_receive_rate;
434 pinv = opt_recv->ccid3or_loss_event_rate;
435
436 switch (hctx->ccid3hctx_state) {
437 case TFRC_SSTATE_NO_SENT:
438 /* FIXME: what to do here? */
439 return;
440 case TFRC_SSTATE_NO_FBACK:
441 case TFRC_SSTATE_FBACK:
442 /* Calculate new round trip sample by
443 * R_sample = (now - t_recvdata) - t_delay */
444 /* get t_recvdata from history */
445 packet = dccp_tx_hist_find_entry(&hctx->ccid3hctx_hist,
446 DCCP_SKB_CB(skb)->dccpd_ack_seq);
447 if (unlikely(packet == NULL)) {
448 DCCP_WARN("%s, sk=%p, seqno %llu(%s) does't exist "
449 "in history!\n", dccp_role(sk), sk,
450 (unsigned long long)DCCP_SKB_CB(skb)->dccpd_ack_seq,
451 dccp_packet_name(DCCP_SKB_CB(skb)->dccpd_type));
452 return;
453 }
454
455 /* Update RTT */
456 dccp_timestamp(sk, &now);
457 r_sample = timeval_delta(&now, &packet->dccphtx_tstamp);
458 if (unlikely(r_sample <= t_elapsed))
459 DCCP_WARN("r_sample=%uus,t_elapsed=%uus\n",
460 r_sample, t_elapsed);
461 else
462 r_sample -= t_elapsed;
463
464 /* Update RTT estimate by
465 * If (No feedback recv)
466 * R = R_sample;
467 * Else
468 * R = q * R + (1 - q) * R_sample;
469 *
470 * q is a constant, RFC 3448 recomments 0.9
471 */
472 if (hctx->ccid3hctx_state == TFRC_SSTATE_NO_FBACK) {
473 ccid3_hc_tx_set_state(sk, TFRC_SSTATE_FBACK);
474 hctx->ccid3hctx_rtt = r_sample;
475 } else
476 hctx->ccid3hctx_rtt = (hctx->ccid3hctx_rtt * 9) / 10 +
477 r_sample / 10;
478
479 ccid3_pr_debug("%s, sk=%p, New RTT estimate=%uus, "
480 "r_sample=%us\n", dccp_role(sk), sk,
481 hctx->ccid3hctx_rtt, r_sample);
482
483 /* Update timeout interval */
484 hctx->ccid3hctx_t_rto = max_t(u32, 4 * hctx->ccid3hctx_rtt,
485 USEC_PER_SEC);
486
487 /* Update receive rate */
488 hctx->ccid3hctx_x_recv = x_recv;/* X_recv in bytes per sec */
489
490 /* Update loss event rate */
491 if (pinv == ~0 || pinv == 0)
492 hctx->ccid3hctx_p = 0;
493 else {
494 hctx->ccid3hctx_p = 1000000 / pinv;
495
496 if (hctx->ccid3hctx_p < TFRC_SMALLEST_P) {
497 hctx->ccid3hctx_p = TFRC_SMALLEST_P;
498 ccid3_pr_debug("%s, sk=%p, Smallest p used!\n",
499 dccp_role(sk), sk);
500 }
501 }
502
503 /* unschedule no feedback timer */
504 sk_stop_timer(sk, &hctx->ccid3hctx_no_feedback_timer);
505
506 /* Update sending rate */
507 ccid3_hc_tx_update_x(sk);
508
509 /* Update next send time */
510 timeval_sub_usecs(&hctx->ccid3hctx_t_nom,
511 hctx->ccid3hctx_t_ipi);
512 ccid3_calc_new_t_ipi(hctx);
513 timeval_add_usecs(&hctx->ccid3hctx_t_nom,
514 hctx->ccid3hctx_t_ipi);
515 ccid3_calc_new_delta(hctx);
516
517 /* remove all packets older than the one acked from history */
518 dccp_tx_hist_purge_older(ccid3_tx_hist,
519 &hctx->ccid3hctx_hist, packet);
520 /*
521 * As we have calculated new ipi, delta, t_nom it is possible that
522 * we now can send a packet, so wake up dccp_wait_for_ccids.
523 */
524 sk->sk_write_space(sk);
525
526 /*
527 * Schedule no feedback timer to expire in
528 * max(4 * R, 2 * s / X)
529 */
530 next_tmout = max(hctx->ccid3hctx_t_rto,
531 2 * usecs_div(hctx->ccid3hctx_s,
532 hctx->ccid3hctx_x));
533
534 ccid3_pr_debug("%s, sk=%p, Scheduled no feedback timer to "
535 "expire in %lu jiffies (%luus)\n",
536 dccp_role(sk), sk,
537 usecs_to_jiffies(next_tmout), next_tmout);
538
539 sk_reset_timer(sk, &hctx->ccid3hctx_no_feedback_timer,
540 jiffies + max_t(u32, 1, usecs_to_jiffies(next_tmout)));
541
542 /* set idle flag */
543 hctx->ccid3hctx_idle = 1;
544 break;
545 case TFRC_SSTATE_TERM:
546 DCCP_BUG("Illegal %s state TERM, sk=%p", dccp_role(sk), sk);
547 break;
548 }
549 }
550
551 static int ccid3_hc_tx_insert_options(struct sock *sk, struct sk_buff *skb)
552 {
553 const struct ccid3_hc_tx_sock *hctx = ccid3_hc_tx_sk(sk);
554
555 BUG_ON(hctx == NULL);
556
557 if (sk->sk_state == DCCP_OPEN || sk->sk_state == DCCP_PARTOPEN)
558 DCCP_SKB_CB(skb)->dccpd_ccval = hctx->ccid3hctx_last_win_count;
559 return 0;
560 }
561
562 static int ccid3_hc_tx_parse_options(struct sock *sk, unsigned char option,
563 unsigned char len, u16 idx,
564 unsigned char *value)
565 {
566 int rc = 0;
567 const struct dccp_sock *dp = dccp_sk(sk);
568 struct ccid3_hc_tx_sock *hctx = ccid3_hc_tx_sk(sk);
569 struct ccid3_options_received *opt_recv;
570
571 BUG_ON(hctx == NULL);
572
573 opt_recv = &hctx->ccid3hctx_options_received;
574
575 if (opt_recv->ccid3or_seqno != dp->dccps_gsr) {
576 opt_recv->ccid3or_seqno = dp->dccps_gsr;
577 opt_recv->ccid3or_loss_event_rate = ~0;
578 opt_recv->ccid3or_loss_intervals_idx = 0;
579 opt_recv->ccid3or_loss_intervals_len = 0;
580 opt_recv->ccid3or_receive_rate = 0;
581 }
582
583 switch (option) {
584 case TFRC_OPT_LOSS_EVENT_RATE:
585 if (unlikely(len != 4)) {
586 DCCP_WARN("%s, sk=%p, invalid len %d "
587 "for TFRC_OPT_LOSS_EVENT_RATE\n",
588 dccp_role(sk), sk, len);
589 rc = -EINVAL;
590 } else {
591 opt_recv->ccid3or_loss_event_rate = ntohl(*(__be32 *)value);
592 ccid3_pr_debug("%s, sk=%p, LOSS_EVENT_RATE=%u\n",
593 dccp_role(sk), sk,
594 opt_recv->ccid3or_loss_event_rate);
595 }
596 break;
597 case TFRC_OPT_LOSS_INTERVALS:
598 opt_recv->ccid3or_loss_intervals_idx = idx;
599 opt_recv->ccid3or_loss_intervals_len = len;
600 ccid3_pr_debug("%s, sk=%p, LOSS_INTERVALS=(%u, %u)\n",
601 dccp_role(sk), sk,
602 opt_recv->ccid3or_loss_intervals_idx,
603 opt_recv->ccid3or_loss_intervals_len);
604 break;
605 case TFRC_OPT_RECEIVE_RATE:
606 if (unlikely(len != 4)) {
607 DCCP_WARN("%s, sk=%p, invalid len %d "
608 "for TFRC_OPT_RECEIVE_RATE\n",
609 dccp_role(sk), sk, len);
610 rc = -EINVAL;
611 } else {
612 opt_recv->ccid3or_receive_rate = ntohl(*(__be32 *)value);
613 ccid3_pr_debug("%s, sk=%p, RECEIVE_RATE=%u\n",
614 dccp_role(sk), sk,
615 opt_recv->ccid3or_receive_rate);
616 }
617 break;
618 }
619
620 return rc;
621 }
622
623 static int ccid3_hc_tx_init(struct ccid *ccid, struct sock *sk)
624 {
625 struct dccp_sock *dp = dccp_sk(sk);
626 struct ccid3_hc_tx_sock *hctx = ccid_priv(ccid);
627
628 if (dp->dccps_packet_size >= TFRC_MIN_PACKET_SIZE &&
629 dp->dccps_packet_size <= TFRC_MAX_PACKET_SIZE)
630 hctx->ccid3hctx_s = dp->dccps_packet_size;
631 else
632 hctx->ccid3hctx_s = TFRC_STD_PACKET_SIZE;
633
634 /* Set transmission rate to 1 packet per second */
635 hctx->ccid3hctx_x = hctx->ccid3hctx_s;
636 hctx->ccid3hctx_t_rto = USEC_PER_SEC;
637 hctx->ccid3hctx_state = TFRC_SSTATE_NO_SENT;
638 INIT_LIST_HEAD(&hctx->ccid3hctx_hist);
639
640 hctx->ccid3hctx_no_feedback_timer.function = ccid3_hc_tx_no_feedback_timer;
641 hctx->ccid3hctx_no_feedback_timer.data = (unsigned long)sk;
642 init_timer(&hctx->ccid3hctx_no_feedback_timer);
643
644 return 0;
645 }
646
647 static void ccid3_hc_tx_exit(struct sock *sk)
648 {
649 struct ccid3_hc_tx_sock *hctx = ccid3_hc_tx_sk(sk);
650
651 BUG_ON(hctx == NULL);
652
653 ccid3_hc_tx_set_state(sk, TFRC_SSTATE_TERM);
654 sk_stop_timer(sk, &hctx->ccid3hctx_no_feedback_timer);
655
656 /* Empty packet history */
657 dccp_tx_hist_purge(ccid3_tx_hist, &hctx->ccid3hctx_hist);
658 }
659
660 /*
661 * RX Half Connection methods
662 */
663
664 #ifdef CONFIG_IP_DCCP_CCID3_DEBUG
665 static const char *ccid3_rx_state_name(enum ccid3_hc_rx_states state)
666 {
667 static char *ccid3_rx_state_names[] = {
668 [TFRC_RSTATE_NO_DATA] = "NO_DATA",
669 [TFRC_RSTATE_DATA] = "DATA",
670 [TFRC_RSTATE_TERM] = "TERM",
671 };
672
673 return ccid3_rx_state_names[state];
674 }
675 #endif
676
677 static void ccid3_hc_rx_set_state(struct sock *sk,
678 enum ccid3_hc_rx_states state)
679 {
680 struct ccid3_hc_rx_sock *hcrx = ccid3_hc_rx_sk(sk);
681 enum ccid3_hc_rx_states oldstate = hcrx->ccid3hcrx_state;
682
683 ccid3_pr_debug("%s(%p) %-8.8s -> %s\n",
684 dccp_role(sk), sk, ccid3_rx_state_name(oldstate),
685 ccid3_rx_state_name(state));
686 WARN_ON(state == oldstate);
687 hcrx->ccid3hcrx_state = state;
688 }
689
690 static void ccid3_hc_rx_send_feedback(struct sock *sk)
691 {
692 struct ccid3_hc_rx_sock *hcrx = ccid3_hc_rx_sk(sk);
693 struct dccp_sock *dp = dccp_sk(sk);
694 struct dccp_rx_hist_entry *packet;
695 struct timeval now;
696
697 ccid3_pr_debug("%s, sk=%p\n", dccp_role(sk), sk);
698
699 dccp_timestamp(sk, &now);
700
701 switch (hcrx->ccid3hcrx_state) {
702 case TFRC_RSTATE_NO_DATA:
703 hcrx->ccid3hcrx_x_recv = 0;
704 break;
705 case TFRC_RSTATE_DATA: {
706 const u32 delta = timeval_delta(&now,
707 &hcrx->ccid3hcrx_tstamp_last_feedback);
708 hcrx->ccid3hcrx_x_recv = usecs_div(hcrx->ccid3hcrx_bytes_recv,
709 delta);
710 }
711 break;
712 case TFRC_RSTATE_TERM:
713 DCCP_BUG("Illegal %s state TERM, sk=%p", dccp_role(sk), sk);
714 return;
715 }
716
717 packet = dccp_rx_hist_find_data_packet(&hcrx->ccid3hcrx_hist);
718 if (unlikely(packet == NULL)) {
719 DCCP_WARN("%s, sk=%p, no data packet in history!\n",
720 dccp_role(sk), sk);
721 return;
722 }
723
724 hcrx->ccid3hcrx_tstamp_last_feedback = now;
725 hcrx->ccid3hcrx_ccval_last_counter = packet->dccphrx_ccval;
726 hcrx->ccid3hcrx_bytes_recv = 0;
727
728 /* Convert to multiples of 10us */
729 hcrx->ccid3hcrx_elapsed_time =
730 timeval_delta(&now, &packet->dccphrx_tstamp) / 10;
731 if (hcrx->ccid3hcrx_p == 0)
732 hcrx->ccid3hcrx_pinv = ~0;
733 else
734 hcrx->ccid3hcrx_pinv = 1000000 / hcrx->ccid3hcrx_p;
735 dp->dccps_hc_rx_insert_options = 1;
736 dccp_send_ack(sk);
737 }
738
739 static int ccid3_hc_rx_insert_options(struct sock *sk, struct sk_buff *skb)
740 {
741 const struct ccid3_hc_rx_sock *hcrx = ccid3_hc_rx_sk(sk);
742 __be32 x_recv, pinv;
743
744 BUG_ON(hcrx == NULL);
745
746 if (!(sk->sk_state == DCCP_OPEN || sk->sk_state == DCCP_PARTOPEN))
747 return 0;
748
749 DCCP_SKB_CB(skb)->dccpd_ccval = hcrx->ccid3hcrx_ccval_last_counter;
750
751 if (dccp_packet_without_ack(skb))
752 return 0;
753
754 x_recv = htonl(hcrx->ccid3hcrx_x_recv);
755 pinv = htonl(hcrx->ccid3hcrx_pinv);
756
757 if ((hcrx->ccid3hcrx_elapsed_time != 0 &&
758 dccp_insert_option_elapsed_time(sk, skb,
759 hcrx->ccid3hcrx_elapsed_time)) ||
760 dccp_insert_option_timestamp(sk, skb) ||
761 dccp_insert_option(sk, skb, TFRC_OPT_LOSS_EVENT_RATE,
762 &pinv, sizeof(pinv)) ||
763 dccp_insert_option(sk, skb, TFRC_OPT_RECEIVE_RATE,
764 &x_recv, sizeof(x_recv)))
765 return -1;
766
767 return 0;
768 }
769
770 /* calculate first loss interval
771 *
772 * returns estimated loss interval in usecs */
773
774 static u32 ccid3_hc_rx_calc_first_li(struct sock *sk)
775 {
776 struct ccid3_hc_rx_sock *hcrx = ccid3_hc_rx_sk(sk);
777 struct dccp_rx_hist_entry *entry, *next, *tail = NULL;
778 u32 rtt, delta, x_recv, fval, p, tmp2;
779 struct timeval tstamp = { 0, };
780 int interval = 0;
781 int win_count = 0;
782 int step = 0;
783 u64 tmp1;
784
785 list_for_each_entry_safe(entry, next, &hcrx->ccid3hcrx_hist,
786 dccphrx_node) {
787 if (dccp_rx_hist_entry_data_packet(entry)) {
788 tail = entry;
789
790 switch (step) {
791 case 0:
792 tstamp = entry->dccphrx_tstamp;
793 win_count = entry->dccphrx_ccval;
794 step = 1;
795 break;
796 case 1:
797 interval = win_count - entry->dccphrx_ccval;
798 if (interval < 0)
799 interval += TFRC_WIN_COUNT_LIMIT;
800 if (interval > 4)
801 goto found;
802 break;
803 }
804 }
805 }
806
807 if (unlikely(step == 0)) {
808 DCCP_WARN("%s, sk=%p, packet history has no data packets!\n",
809 dccp_role(sk), sk);
810 return ~0;
811 }
812
813 if (unlikely(interval == 0)) {
814 DCCP_WARN("%s, sk=%p, Could not find a win_count interval > 0."
815 "Defaulting to 1\n", dccp_role(sk), sk);
816 interval = 1;
817 }
818 found:
819 if (!tail) {
820 DCCP_CRIT("tail is null\n");
821 return ~0;
822 }
823 rtt = timeval_delta(&tstamp, &tail->dccphrx_tstamp) * 4 / interval;
824 ccid3_pr_debug("%s, sk=%p, approximated RTT to %uus\n",
825 dccp_role(sk), sk, rtt);
826
827 if (rtt == 0) {
828 DCCP_WARN("RTT==0, setting to 1\n");
829 rtt = 1;
830 }
831
832 dccp_timestamp(sk, &tstamp);
833 delta = timeval_delta(&tstamp, &hcrx->ccid3hcrx_tstamp_last_feedback);
834 x_recv = usecs_div(hcrx->ccid3hcrx_bytes_recv, delta);
835
836 if (x_recv == 0)
837 x_recv = hcrx->ccid3hcrx_x_recv;
838
839 tmp1 = (u64)x_recv * (u64)rtt;
840 do_div(tmp1,10000000);
841 tmp2 = (u32)tmp1;
842
843 if (!tmp2) {
844 DCCP_CRIT("tmp2 = 0, x_recv = %u, rtt =%u\n", x_recv, rtt);
845 return ~0;
846 }
847
848 fval = (hcrx->ccid3hcrx_s * 100000) / tmp2;
849 /* do not alter order above or you will get overflow on 32 bit */
850 p = tfrc_calc_x_reverse_lookup(fval);
851 ccid3_pr_debug("%s, sk=%p, receive rate=%u bytes/s, implied "
852 "loss rate=%u\n", dccp_role(sk), sk, x_recv, p);
853
854 if (p == 0)
855 return ~0;
856 else
857 return 1000000 / p;
858 }
859
860 static void ccid3_hc_rx_update_li(struct sock *sk, u64 seq_loss, u8 win_loss)
861 {
862 struct ccid3_hc_rx_sock *hcrx = ccid3_hc_rx_sk(sk);
863 struct dccp_li_hist_entry *head;
864 u64 seq_temp;
865
866 if (list_empty(&hcrx->ccid3hcrx_li_hist)) {
867 if (!dccp_li_hist_interval_new(ccid3_li_hist,
868 &hcrx->ccid3hcrx_li_hist, seq_loss, win_loss))
869 return;
870
871 head = list_entry(hcrx->ccid3hcrx_li_hist.next,
872 struct dccp_li_hist_entry, dccplih_node);
873 head->dccplih_interval = ccid3_hc_rx_calc_first_li(sk);
874 } else {
875 struct dccp_li_hist_entry *entry;
876 struct list_head *tail;
877
878 head = list_entry(hcrx->ccid3hcrx_li_hist.next,
879 struct dccp_li_hist_entry, dccplih_node);
880 /* FIXME win count check removed as was wrong */
881 /* should make this check with receive history */
882 /* and compare there as per section 10.2 of RFC4342 */
883
884 /* new loss event detected */
885 /* calculate last interval length */
886 seq_temp = dccp_delta_seqno(head->dccplih_seqno, seq_loss);
887 entry = dccp_li_hist_entry_new(ccid3_li_hist, SLAB_ATOMIC);
888
889 if (entry == NULL) {
890 DCCP_BUG("out of memory - can not allocate entry");
891 return;
892 }
893
894 list_add(&entry->dccplih_node, &hcrx->ccid3hcrx_li_hist);
895
896 tail = hcrx->ccid3hcrx_li_hist.prev;
897 list_del(tail);
898 kmem_cache_free(ccid3_li_hist->dccplih_slab, tail);
899
900 /* Create the newest interval */
901 entry->dccplih_seqno = seq_loss;
902 entry->dccplih_interval = seq_temp;
903 entry->dccplih_win_count = win_loss;
904 }
905 }
906
907 static int ccid3_hc_rx_detect_loss(struct sock *sk,
908 struct dccp_rx_hist_entry *packet)
909 {
910 struct ccid3_hc_rx_sock *hcrx = ccid3_hc_rx_sk(sk);
911 struct dccp_rx_hist_entry *rx_hist = dccp_rx_hist_head(&hcrx->ccid3hcrx_hist);
912 u64 seqno = packet->dccphrx_seqno;
913 u64 tmp_seqno;
914 int loss = 0;
915 u8 ccval;
916
917
918 tmp_seqno = hcrx->ccid3hcrx_seqno_nonloss;
919
920 if (!rx_hist ||
921 follows48(packet->dccphrx_seqno, hcrx->ccid3hcrx_seqno_nonloss)) {
922 hcrx->ccid3hcrx_seqno_nonloss = seqno;
923 hcrx->ccid3hcrx_ccval_nonloss = packet->dccphrx_ccval;
924 goto detect_out;
925 }
926
927
928 while (dccp_delta_seqno(hcrx->ccid3hcrx_seqno_nonloss, seqno)
929 > TFRC_RECV_NUM_LATE_LOSS) {
930 loss = 1;
931 ccid3_hc_rx_update_li(sk, hcrx->ccid3hcrx_seqno_nonloss,
932 hcrx->ccid3hcrx_ccval_nonloss);
933 tmp_seqno = hcrx->ccid3hcrx_seqno_nonloss;
934 dccp_inc_seqno(&tmp_seqno);
935 hcrx->ccid3hcrx_seqno_nonloss = tmp_seqno;
936 dccp_inc_seqno(&tmp_seqno);
937 while (dccp_rx_hist_find_entry(&hcrx->ccid3hcrx_hist,
938 tmp_seqno, &ccval)) {
939 hcrx->ccid3hcrx_seqno_nonloss = tmp_seqno;
940 hcrx->ccid3hcrx_ccval_nonloss = ccval;
941 dccp_inc_seqno(&tmp_seqno);
942 }
943 }
944
945 /* FIXME - this code could be simplified with above while */
946 /* but works at moment */
947 if (follows48(packet->dccphrx_seqno, hcrx->ccid3hcrx_seqno_nonloss)) {
948 hcrx->ccid3hcrx_seqno_nonloss = seqno;
949 hcrx->ccid3hcrx_ccval_nonloss = packet->dccphrx_ccval;
950 }
951
952 detect_out:
953 dccp_rx_hist_add_packet(ccid3_rx_hist, &hcrx->ccid3hcrx_hist,
954 &hcrx->ccid3hcrx_li_hist, packet,
955 hcrx->ccid3hcrx_seqno_nonloss);
956 return loss;
957 }
958
959 static void ccid3_hc_rx_packet_recv(struct sock *sk, struct sk_buff *skb)
960 {
961 struct ccid3_hc_rx_sock *hcrx = ccid3_hc_rx_sk(sk);
962 const struct dccp_options_received *opt_recv;
963 struct dccp_rx_hist_entry *packet;
964 struct timeval now;
965 u32 p_prev, rtt_prev, r_sample, t_elapsed;
966 int loss;
967
968 BUG_ON(hcrx == NULL);
969
970 opt_recv = &dccp_sk(sk)->dccps_options_received;
971
972 switch (DCCP_SKB_CB(skb)->dccpd_type) {
973 case DCCP_PKT_ACK:
974 if (hcrx->ccid3hcrx_state == TFRC_RSTATE_NO_DATA)
975 return;
976 case DCCP_PKT_DATAACK:
977 if (opt_recv->dccpor_timestamp_echo == 0)
978 break;
979 rtt_prev = hcrx->ccid3hcrx_rtt;
980 dccp_timestamp(sk, &now);
981 timeval_sub_usecs(&now, opt_recv->dccpor_timestamp_echo * 10);
982 r_sample = timeval_usecs(&now);
983 t_elapsed = opt_recv->dccpor_elapsed_time * 10;
984
985 if (unlikely(r_sample <= t_elapsed))
986 DCCP_WARN("r_sample=%uus, t_elapsed=%uus\n",
987 r_sample, t_elapsed);
988 else
989 r_sample -= t_elapsed;
990
991 if (hcrx->ccid3hcrx_state == TFRC_RSTATE_NO_DATA)
992 hcrx->ccid3hcrx_rtt = r_sample;
993 else
994 hcrx->ccid3hcrx_rtt = (hcrx->ccid3hcrx_rtt * 9) / 10 +
995 r_sample / 10;
996
997 if (rtt_prev != hcrx->ccid3hcrx_rtt)
998 ccid3_pr_debug("%s, New RTT=%uus, elapsed time=%u\n",
999 dccp_role(sk), hcrx->ccid3hcrx_rtt,
1000 opt_recv->dccpor_elapsed_time);
1001 break;
1002 case DCCP_PKT_DATA:
1003 break;
1004 default: /* We're not interested in other packet types, move along */
1005 return;
1006 }
1007
1008 packet = dccp_rx_hist_entry_new(ccid3_rx_hist, sk, opt_recv->dccpor_ndp,
1009 skb, SLAB_ATOMIC);
1010 if (unlikely(packet == NULL)) {
1011 DCCP_WARN("%s, sk=%p, Not enough mem to add rx packet "
1012 "to history, consider it lost!\n", dccp_role(sk), sk);
1013 return;
1014 }
1015
1016 loss = ccid3_hc_rx_detect_loss(sk, packet);
1017
1018 if (DCCP_SKB_CB(skb)->dccpd_type == DCCP_PKT_ACK)
1019 return;
1020
1021 switch (hcrx->ccid3hcrx_state) {
1022 case TFRC_RSTATE_NO_DATA:
1023 ccid3_pr_debug("%s, sk=%p(%s), skb=%p, sending initial "
1024 "feedback\n",
1025 dccp_role(sk), sk,
1026 dccp_state_name(sk->sk_state), skb);
1027 ccid3_hc_rx_send_feedback(sk);
1028 ccid3_hc_rx_set_state(sk, TFRC_RSTATE_DATA);
1029 return;
1030 case TFRC_RSTATE_DATA:
1031 hcrx->ccid3hcrx_bytes_recv += skb->len -
1032 dccp_hdr(skb)->dccph_doff * 4;
1033 if (loss)
1034 break;
1035
1036 dccp_timestamp(sk, &now);
1037 if (timeval_delta(&now, &hcrx->ccid3hcrx_tstamp_last_ack) >=
1038 hcrx->ccid3hcrx_rtt) {
1039 hcrx->ccid3hcrx_tstamp_last_ack = now;
1040 ccid3_hc_rx_send_feedback(sk);
1041 }
1042 return;
1043 case TFRC_RSTATE_TERM:
1044 DCCP_BUG("Illegal %s state TERM, sk=%p", dccp_role(sk), sk);
1045 return;
1046 }
1047
1048 /* Dealing with packet loss */
1049 ccid3_pr_debug("%s, sk=%p(%s), data loss! Reacting...\n",
1050 dccp_role(sk), sk, dccp_state_name(sk->sk_state));
1051
1052 p_prev = hcrx->ccid3hcrx_p;
1053
1054 /* Calculate loss event rate */
1055 if (!list_empty(&hcrx->ccid3hcrx_li_hist)) {
1056 u32 i_mean = dccp_li_hist_calc_i_mean(&hcrx->ccid3hcrx_li_hist);
1057
1058 /* Scaling up by 1000000 as fixed decimal */
1059 if (i_mean != 0)
1060 hcrx->ccid3hcrx_p = 1000000 / i_mean;
1061 } else
1062 DCCP_BUG("empty loss history");
1063
1064 if (hcrx->ccid3hcrx_p > p_prev) {
1065 ccid3_hc_rx_send_feedback(sk);
1066 return;
1067 }
1068 }
1069
1070 static int ccid3_hc_rx_init(struct ccid *ccid, struct sock *sk)
1071 {
1072 struct dccp_sock *dp = dccp_sk(sk);
1073 struct ccid3_hc_rx_sock *hcrx = ccid_priv(ccid);
1074
1075 ccid3_pr_debug("%s, sk=%p\n", dccp_role(sk), sk);
1076
1077 if (dp->dccps_packet_size >= TFRC_MIN_PACKET_SIZE &&
1078 dp->dccps_packet_size <= TFRC_MAX_PACKET_SIZE)
1079 hcrx->ccid3hcrx_s = dp->dccps_packet_size;
1080 else
1081 hcrx->ccid3hcrx_s = TFRC_STD_PACKET_SIZE;
1082
1083 hcrx->ccid3hcrx_state = TFRC_RSTATE_NO_DATA;
1084 INIT_LIST_HEAD(&hcrx->ccid3hcrx_hist);
1085 INIT_LIST_HEAD(&hcrx->ccid3hcrx_li_hist);
1086 dccp_timestamp(sk, &hcrx->ccid3hcrx_tstamp_last_ack);
1087 hcrx->ccid3hcrx_tstamp_last_feedback = hcrx->ccid3hcrx_tstamp_last_ack;
1088 hcrx->ccid3hcrx_rtt = 5000; /* XXX 5ms for now... */
1089 return 0;
1090 }
1091
1092 static void ccid3_hc_rx_exit(struct sock *sk)
1093 {
1094 struct ccid3_hc_rx_sock *hcrx = ccid3_hc_rx_sk(sk);
1095
1096 BUG_ON(hcrx == NULL);
1097
1098 ccid3_hc_rx_set_state(sk, TFRC_RSTATE_TERM);
1099
1100 /* Empty packet history */
1101 dccp_rx_hist_purge(ccid3_rx_hist, &hcrx->ccid3hcrx_hist);
1102
1103 /* Empty loss interval history */
1104 dccp_li_hist_purge(ccid3_li_hist, &hcrx->ccid3hcrx_li_hist);
1105 }
1106
1107 static void ccid3_hc_rx_get_info(struct sock *sk, struct tcp_info *info)
1108 {
1109 const struct ccid3_hc_rx_sock *hcrx = ccid3_hc_rx_sk(sk);
1110
1111 /* Listen socks doesn't have a private CCID block */
1112 if (sk->sk_state == DCCP_LISTEN)
1113 return;
1114
1115 BUG_ON(hcrx == NULL);
1116
1117 info->tcpi_ca_state = hcrx->ccid3hcrx_state;
1118 info->tcpi_options |= TCPI_OPT_TIMESTAMPS;
1119 info->tcpi_rcv_rtt = hcrx->ccid3hcrx_rtt;
1120 }
1121
1122 static void ccid3_hc_tx_get_info(struct sock *sk, struct tcp_info *info)
1123 {
1124 const struct ccid3_hc_tx_sock *hctx = ccid3_hc_tx_sk(sk);
1125
1126 /* Listen socks doesn't have a private CCID block */
1127 if (sk->sk_state == DCCP_LISTEN)
1128 return;
1129
1130 BUG_ON(hctx == NULL);
1131
1132 info->tcpi_rto = hctx->ccid3hctx_t_rto;
1133 info->tcpi_rtt = hctx->ccid3hctx_rtt;
1134 }
1135
1136 static int ccid3_hc_rx_getsockopt(struct sock *sk, const int optname, int len,
1137 u32 __user *optval, int __user *optlen)
1138 {
1139 const struct ccid3_hc_rx_sock *hcrx = ccid3_hc_rx_sk(sk);
1140 const void *val;
1141
1142 /* Listen socks doesn't have a private CCID block */
1143 if (sk->sk_state == DCCP_LISTEN)
1144 return -EINVAL;
1145
1146 switch (optname) {
1147 case DCCP_SOCKOPT_CCID_RX_INFO:
1148 if (len < sizeof(hcrx->ccid3hcrx_tfrc))
1149 return -EINVAL;
1150 len = sizeof(hcrx->ccid3hcrx_tfrc);
1151 val = &hcrx->ccid3hcrx_tfrc;
1152 break;
1153 default:
1154 return -ENOPROTOOPT;
1155 }
1156
1157 if (put_user(len, optlen) || copy_to_user(optval, val, len))
1158 return -EFAULT;
1159
1160 return 0;
1161 }
1162
1163 static int ccid3_hc_tx_getsockopt(struct sock *sk, const int optname, int len,
1164 u32 __user *optval, int __user *optlen)
1165 {
1166 const struct ccid3_hc_tx_sock *hctx = ccid3_hc_tx_sk(sk);
1167 const void *val;
1168
1169 /* Listen socks doesn't have a private CCID block */
1170 if (sk->sk_state == DCCP_LISTEN)
1171 return -EINVAL;
1172
1173 switch (optname) {
1174 case DCCP_SOCKOPT_CCID_TX_INFO:
1175 if (len < sizeof(hctx->ccid3hctx_tfrc))
1176 return -EINVAL;
1177 len = sizeof(hctx->ccid3hctx_tfrc);
1178 val = &hctx->ccid3hctx_tfrc;
1179 break;
1180 default:
1181 return -ENOPROTOOPT;
1182 }
1183
1184 if (put_user(len, optlen) || copy_to_user(optval, val, len))
1185 return -EFAULT;
1186
1187 return 0;
1188 }
1189
1190 static struct ccid_operations ccid3 = {
1191 .ccid_id = DCCPC_CCID3,
1192 .ccid_name = "ccid3",
1193 .ccid_owner = THIS_MODULE,
1194 .ccid_hc_tx_obj_size = sizeof(struct ccid3_hc_tx_sock),
1195 .ccid_hc_tx_init = ccid3_hc_tx_init,
1196 .ccid_hc_tx_exit = ccid3_hc_tx_exit,
1197 .ccid_hc_tx_send_packet = ccid3_hc_tx_send_packet,
1198 .ccid_hc_tx_packet_sent = ccid3_hc_tx_packet_sent,
1199 .ccid_hc_tx_packet_recv = ccid3_hc_tx_packet_recv,
1200 .ccid_hc_tx_insert_options = ccid3_hc_tx_insert_options,
1201 .ccid_hc_tx_parse_options = ccid3_hc_tx_parse_options,
1202 .ccid_hc_rx_obj_size = sizeof(struct ccid3_hc_rx_sock),
1203 .ccid_hc_rx_init = ccid3_hc_rx_init,
1204 .ccid_hc_rx_exit = ccid3_hc_rx_exit,
1205 .ccid_hc_rx_insert_options = ccid3_hc_rx_insert_options,
1206 .ccid_hc_rx_packet_recv = ccid3_hc_rx_packet_recv,
1207 .ccid_hc_rx_get_info = ccid3_hc_rx_get_info,
1208 .ccid_hc_tx_get_info = ccid3_hc_tx_get_info,
1209 .ccid_hc_rx_getsockopt = ccid3_hc_rx_getsockopt,
1210 .ccid_hc_tx_getsockopt = ccid3_hc_tx_getsockopt,
1211 };
1212
1213 #ifdef CONFIG_IP_DCCP_CCID3_DEBUG
1214 module_param(ccid3_debug, int, 0444);
1215 MODULE_PARM_DESC(ccid3_debug, "Enable debug messages");
1216 #endif
1217
1218 static __init int ccid3_module_init(void)
1219 {
1220 int rc = -ENOBUFS;
1221
1222 ccid3_rx_hist = dccp_rx_hist_new("ccid3");
1223 if (ccid3_rx_hist == NULL)
1224 goto out;
1225
1226 ccid3_tx_hist = dccp_tx_hist_new("ccid3");
1227 if (ccid3_tx_hist == NULL)
1228 goto out_free_rx;
1229
1230 ccid3_li_hist = dccp_li_hist_new("ccid3");
1231 if (ccid3_li_hist == NULL)
1232 goto out_free_tx;
1233
1234 rc = ccid_register(&ccid3);
1235 if (rc != 0)
1236 goto out_free_loss_interval_history;
1237 out:
1238 return rc;
1239
1240 out_free_loss_interval_history:
1241 dccp_li_hist_delete(ccid3_li_hist);
1242 ccid3_li_hist = NULL;
1243 out_free_tx:
1244 dccp_tx_hist_delete(ccid3_tx_hist);
1245 ccid3_tx_hist = NULL;
1246 out_free_rx:
1247 dccp_rx_hist_delete(ccid3_rx_hist);
1248 ccid3_rx_hist = NULL;
1249 goto out;
1250 }
1251 module_init(ccid3_module_init);
1252
1253 static __exit void ccid3_module_exit(void)
1254 {
1255 ccid_unregister(&ccid3);
1256
1257 if (ccid3_tx_hist != NULL) {
1258 dccp_tx_hist_delete(ccid3_tx_hist);
1259 ccid3_tx_hist = NULL;
1260 }
1261 if (ccid3_rx_hist != NULL) {
1262 dccp_rx_hist_delete(ccid3_rx_hist);
1263 ccid3_rx_hist = NULL;
1264 }
1265 if (ccid3_li_hist != NULL) {
1266 dccp_li_hist_delete(ccid3_li_hist);
1267 ccid3_li_hist = NULL;
1268 }
1269 }
1270 module_exit(ccid3_module_exit);
1271
1272 MODULE_AUTHOR("Ian McDonald <ian.mcdonald@jandi.co.nz>, "
1273 "Arnaldo Carvalho de Melo <acme@ghostprotocols.net>");
1274 MODULE_DESCRIPTION("DCCP TFRC CCID3 CCID");
1275 MODULE_LICENSE("GPL");
1276 MODULE_ALIAS("net-dccp-ccid-3");
x86 "subsystem" repository