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