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