1 /* 2 * net/dccp/ccids/ccid3.c 3 * 4 * Copyright (c) 2005-7 The University of Waikato, Hamilton, New Zealand. 5 * Copyright (c) 2005-7 Ian McDonald <ian.mcdonald@jandi.co.nz> 6 * 7 * An implementation of the DCCP protocol 8 * 9 * This code has been developed by the University of Waikato WAND 10 * research group. For further information please see 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 #include "../ccid.h" 37 #include "../dccp.h" 38 #include "lib/packet_history.h" 39 #include "lib/loss_interval.h" 40 #include "lib/tfrc.h" 41 #include "ccid3.h" 42 43 #include <asm/unaligned.h> 44 45 #ifdef CONFIG_IP_DCCP_CCID3_DEBUG 46 static int ccid3_debug; 47 #define ccid3_pr_debug(format, a...) DCCP_PR_DEBUG(ccid3_debug, format, ##a) 48 #else 49 #define ccid3_pr_debug(format, a...) 50 #endif 51 52 static struct dccp_tx_hist *ccid3_tx_hist; 53 static struct dccp_rx_hist *ccid3_rx_hist; 54 55 /* 56 * Transmitter Half-Connection Routines 57 */ 58 #ifdef CONFIG_IP_DCCP_CCID3_DEBUG 59 static const char *ccid3_tx_state_name(enum ccid3_hc_tx_states state) 60 { 61 static char *ccid3_state_names[] = { 62 [TFRC_SSTATE_NO_SENT] = "NO_SENT", 63 [TFRC_SSTATE_NO_FBACK] = "NO_FBACK", 64 [TFRC_SSTATE_FBACK] = "FBACK", 65 [TFRC_SSTATE_TERM] = "TERM", 66 }; 67 68 return ccid3_state_names[state]; 69 } 70 #endif 71 72 static void ccid3_hc_tx_set_state(struct sock *sk, 73 enum ccid3_hc_tx_states state) 74 { 75 struct ccid3_hc_tx_sock *hctx = ccid3_hc_tx_sk(sk); 76 enum ccid3_hc_tx_states oldstate = hctx->ccid3hctx_state; 77 78 ccid3_pr_debug("%s(%p) %-8.8s -> %s\n", 79 dccp_role(sk), sk, ccid3_tx_state_name(oldstate), 80 ccid3_tx_state_name(state)); 81 WARN_ON(state == oldstate); 82 hctx->ccid3hctx_state = state; 83 } 84 85 /* 86 * Compute the initial sending rate X_init according to RFC 3390: 87 * w_init = min(4 * MSS, max(2 * MSS, 4380 bytes)) 88 * X_init = w_init / RTT 89 * For consistency with other parts of the code, X_init is scaled by 2^6. 90 */ 91 static inline u64 rfc3390_initial_rate(struct sock *sk) 92 { 93 const struct dccp_sock *dp = dccp_sk(sk); 94 const __u32 w_init = min(4 * dp->dccps_mss_cache, 95 max(2 * dp->dccps_mss_cache, 4380U)); 96 97 return scaled_div(w_init << 6, ccid3_hc_tx_sk(sk)->ccid3hctx_rtt); 98 } 99 100 /* 101 * Recalculate t_ipi and delta (should be called whenever X changes) 102 */ 103 static inline void ccid3_update_send_interval(struct ccid3_hc_tx_sock *hctx) 104 { 105 /* Calculate new t_ipi = s / X_inst (X_inst is in 64 * bytes/second) */ 106 hctx->ccid3hctx_t_ipi = scaled_div32(((u64)hctx->ccid3hctx_s) << 6, 107 hctx->ccid3hctx_x); 108 109 /* Calculate new delta by delta = min(t_ipi / 2, t_gran / 2) */ 110 hctx->ccid3hctx_delta = min_t(u32, hctx->ccid3hctx_t_ipi / 2, 111 TFRC_OPSYS_HALF_TIME_GRAN); 112 113 ccid3_pr_debug("t_ipi=%u, delta=%u, s=%u, X=%u\n", 114 hctx->ccid3hctx_t_ipi, hctx->ccid3hctx_delta, 115 hctx->ccid3hctx_s, (unsigned)(hctx->ccid3hctx_x >> 6)); 116 117 } 118 119 /** 120 * ccid3_hc_tx_update_x - Update allowed sending rate X 121 * @stamp: most recent time if available - can be left NULL. 122 * This function tracks draft rfc3448bis, check there for latest details. 123 * 124 * Note: X and X_recv are both stored in units of 64 * bytes/second, to support 125 * fine-grained resolution of sending rates. This requires scaling by 2^6 126 * throughout the code. Only X_calc is unscaled (in bytes/second). 127 * 128 */ 129 static void ccid3_hc_tx_update_x(struct sock *sk, ktime_t *stamp) 130 131 { 132 struct ccid3_hc_tx_sock *hctx = ccid3_hc_tx_sk(sk); 133 __u64 min_rate = 2 * hctx->ccid3hctx_x_recv; 134 const __u64 old_x = hctx->ccid3hctx_x; 135 ktime_t now = stamp? *stamp : ktime_get_real(); 136 137 /* 138 * Handle IDLE periods: do not reduce below RFC3390 initial sending rate 139 * when idling [RFC 4342, 5.1]. See also draft-ietf-dccp-rfc3448bis. 140 * For consistency with X and X_recv, min_rate is also scaled by 2^6. 141 */ 142 if (unlikely(hctx->ccid3hctx_idle)) { 143 min_rate = rfc3390_initial_rate(sk); 144 min_rate = max(min_rate, 2 * hctx->ccid3hctx_x_recv); 145 } 146 147 if (hctx->ccid3hctx_p > 0) { 148 149 hctx->ccid3hctx_x = min(((__u64)hctx->ccid3hctx_x_calc) << 6, 150 min_rate); 151 hctx->ccid3hctx_x = max(hctx->ccid3hctx_x, 152 (((__u64)hctx->ccid3hctx_s) << 6) / 153 TFRC_T_MBI); 154 155 } else if (ktime_us_delta(now, hctx->ccid3hctx_t_ld) 156 - (s64)hctx->ccid3hctx_rtt >= 0) { 157 158 hctx->ccid3hctx_x = 159 max(min(2 * hctx->ccid3hctx_x, min_rate), 160 scaled_div(((__u64)hctx->ccid3hctx_s) << 6, 161 hctx->ccid3hctx_rtt)); 162 hctx->ccid3hctx_t_ld = now; 163 } 164 165 if (hctx->ccid3hctx_x != old_x) { 166 ccid3_pr_debug("X_prev=%u, X_now=%u, X_calc=%u, " 167 "X_recv=%u\n", (unsigned)(old_x >> 6), 168 (unsigned)(hctx->ccid3hctx_x >> 6), 169 hctx->ccid3hctx_x_calc, 170 (unsigned)(hctx->ccid3hctx_x_recv >> 6)); 171 172 ccid3_update_send_interval(hctx); 173 } 174 } 175 176 /* 177 * Track the mean packet size `s' (cf. RFC 4342, 5.3 and RFC 3448, 4.1) 178 * @len: DCCP packet payload size in bytes 179 */ 180 static inline void ccid3_hc_tx_update_s(struct ccid3_hc_tx_sock *hctx, int len) 181 { 182 const u16 old_s = hctx->ccid3hctx_s; 183 184 hctx->ccid3hctx_s = old_s == 0 ? len : (9 * old_s + len) / 10; 185 186 if (hctx->ccid3hctx_s != old_s) 187 ccid3_update_send_interval(hctx); 188 } 189 190 /* 191 * Update Window Counter using the algorithm from [RFC 4342, 8.1]. 192 * The algorithm is not applicable if RTT < 4 microseconds. 193 */ 194 static inline void ccid3_hc_tx_update_win_count(struct ccid3_hc_tx_sock *hctx, 195 ktime_t now) 196 { 197 u32 quarter_rtts; 198 199 if (unlikely(hctx->ccid3hctx_rtt < 4)) /* avoid divide-by-zero */ 200 return; 201 202 quarter_rtts = ktime_us_delta(now, hctx->ccid3hctx_t_last_win_count); 203 quarter_rtts /= hctx->ccid3hctx_rtt / 4; 204 205 if (quarter_rtts > 0) { 206 hctx->ccid3hctx_t_last_win_count = now; 207 hctx->ccid3hctx_last_win_count += min_t(u32, quarter_rtts, 5); 208 hctx->ccid3hctx_last_win_count &= 0xF; /* mod 16 */ 209 } 210 } 211 212 static void ccid3_hc_tx_no_feedback_timer(unsigned long data) 213 { 214 struct sock *sk = (struct sock *)data; 215 struct ccid3_hc_tx_sock *hctx = ccid3_hc_tx_sk(sk); 216 unsigned long t_nfb = USEC_PER_SEC / 5; 217 218 bh_lock_sock(sk); 219 if (sock_owned_by_user(sk)) { 220 /* Try again later. */ 221 /* XXX: set some sensible MIB */ 222 goto restart_timer; 223 } 224 225 ccid3_pr_debug("%s(%p, state=%s) - entry \n", dccp_role(sk), sk, 226 ccid3_tx_state_name(hctx->ccid3hctx_state)); 227 228 hctx->ccid3hctx_idle = 1; 229 230 switch (hctx->ccid3hctx_state) { 231 case TFRC_SSTATE_NO_FBACK: 232 /* RFC 3448, 4.4: Halve send rate directly */ 233 hctx->ccid3hctx_x = max(hctx->ccid3hctx_x / 2, 234 (((__u64)hctx->ccid3hctx_s) << 6) / 235 TFRC_T_MBI); 236 237 ccid3_pr_debug("%s(%p, state=%s), updated tx rate to %u " 238 "bytes/s\n", dccp_role(sk), sk, 239 ccid3_tx_state_name(hctx->ccid3hctx_state), 240 (unsigned)(hctx->ccid3hctx_x >> 6)); 241 /* The value of R is still undefined and so we can not recompute 242 * the timeout value. Keep initial value as per [RFC 4342, 5]. */ 243 t_nfb = TFRC_INITIAL_TIMEOUT; 244 ccid3_update_send_interval(hctx); 245 break; 246 case TFRC_SSTATE_FBACK: 247 /* 248 * Modify the cached value of X_recv [RFC 3448, 4.4] 249 * 250 * If (p == 0 || X_calc > 2 * X_recv) 251 * X_recv = max(X_recv / 2, s / (2 * t_mbi)); 252 * Else 253 * X_recv = X_calc / 4; 254 * 255 * Note that X_recv is scaled by 2^6 while X_calc is not 256 */ 257 BUG_ON(hctx->ccid3hctx_p && !hctx->ccid3hctx_x_calc); 258 259 if (hctx->ccid3hctx_p == 0 || 260 (hctx->ccid3hctx_x_calc > (hctx->ccid3hctx_x_recv >> 5))) { 261 262 hctx->ccid3hctx_x_recv = 263 max(hctx->ccid3hctx_x_recv / 2, 264 (((__u64)hctx->ccid3hctx_s) << 6) / 265 (2 * TFRC_T_MBI)); 266 } else { 267 hctx->ccid3hctx_x_recv = hctx->ccid3hctx_x_calc; 268 hctx->ccid3hctx_x_recv <<= 4; 269 } 270 /* Now recalculate X [RFC 3448, 4.3, step (4)] */ 271 ccid3_hc_tx_update_x(sk, NULL); 272 /* 273 * Schedule no feedback timer to expire in 274 * max(t_RTO, 2 * s/X) = max(t_RTO, 2 * t_ipi) 275 * See comments in packet_recv() regarding the value of t_RTO. 276 */ 277 t_nfb = max(hctx->ccid3hctx_t_rto, 2 * hctx->ccid3hctx_t_ipi); 278 break; 279 case TFRC_SSTATE_NO_SENT: 280 DCCP_BUG("%s(%p) - Illegal state NO_SENT", dccp_role(sk), sk); 281 /* fall through */ 282 case TFRC_SSTATE_TERM: 283 goto out; 284 } 285 286 restart_timer: 287 sk_reset_timer(sk, &hctx->ccid3hctx_no_feedback_timer, 288 jiffies + usecs_to_jiffies(t_nfb)); 289 out: 290 bh_unlock_sock(sk); 291 sock_put(sk); 292 } 293 294 /* 295 * returns 296 * > 0: delay (in msecs) that should pass before actually sending 297 * = 0: can send immediately 298 * < 0: error condition; do not send packet 299 */ 300 static int ccid3_hc_tx_send_packet(struct sock *sk, struct sk_buff *skb) 301 { 302 struct dccp_sock *dp = dccp_sk(sk); 303 struct ccid3_hc_tx_sock *hctx = ccid3_hc_tx_sk(sk); 304 ktime_t now = ktime_get_real(); 305 s64 delay; 306 307 /* 308 * This function is called only for Data and DataAck packets. Sending 309 * zero-sized Data(Ack)s is theoretically possible, but for congestion 310 * control this case is pathological - ignore it. 311 */ 312 if (unlikely(skb->len == 0)) 313 return -EBADMSG; 314 315 switch (hctx->ccid3hctx_state) { 316 case TFRC_SSTATE_NO_SENT: 317 sk_reset_timer(sk, &hctx->ccid3hctx_no_feedback_timer, 318 (jiffies + 319 usecs_to_jiffies(TFRC_INITIAL_TIMEOUT))); 320 hctx->ccid3hctx_last_win_count = 0; 321 hctx->ccid3hctx_t_last_win_count = now; 322 323 /* Set t_0 for initial packet */ 324 hctx->ccid3hctx_t_nom = now; 325 326 hctx->ccid3hctx_s = skb->len; 327 328 /* 329 * Use initial RTT sample when available: recommended by erratum 330 * to RFC 4342. This implements the initialisation procedure of 331 * draft rfc3448bis, section 4.2. Remember, X is scaled by 2^6. 332 */ 333 if (dp->dccps_syn_rtt) { 334 ccid3_pr_debug("SYN RTT = %uus\n", dp->dccps_syn_rtt); 335 hctx->ccid3hctx_rtt = dp->dccps_syn_rtt; 336 hctx->ccid3hctx_x = rfc3390_initial_rate(sk); 337 hctx->ccid3hctx_t_ld = now; 338 } else { 339 /* Sender does not have RTT sample: X = MSS/second */ 340 hctx->ccid3hctx_x = dp->dccps_mss_cache; 341 hctx->ccid3hctx_x <<= 6; 342 } 343 ccid3_update_send_interval(hctx); 344 345 ccid3_hc_tx_set_state(sk, TFRC_SSTATE_NO_FBACK); 346 break; 347 case TFRC_SSTATE_NO_FBACK: 348 case TFRC_SSTATE_FBACK: 349 delay = ktime_us_delta(hctx->ccid3hctx_t_nom, now); 350 ccid3_pr_debug("delay=%ld\n", (long)delay); 351 /* 352 * Scheduling of packet transmissions [RFC 3448, 4.6] 353 * 354 * if (t_now > t_nom - delta) 355 * // send the packet now 356 * else 357 * // send the packet in (t_nom - t_now) milliseconds. 358 */ 359 if (delay - (s64)hctx->ccid3hctx_delta >= 1000) 360 return (u32)delay / 1000L; 361 362 ccid3_hc_tx_update_win_count(hctx, now); 363 break; 364 case TFRC_SSTATE_TERM: 365 DCCP_BUG("%s(%p) - Illegal state TERM", dccp_role(sk), sk); 366 return -EINVAL; 367 } 368 369 /* prepare to send now (add options etc.) */ 370 dp->dccps_hc_tx_insert_options = 1; 371 DCCP_SKB_CB(skb)->dccpd_ccval = hctx->ccid3hctx_last_win_count; 372 hctx->ccid3hctx_idle = 0; 373 374 /* set the nominal send time for the next following packet */ 375 hctx->ccid3hctx_t_nom = ktime_add_us(hctx->ccid3hctx_t_nom, 376 hctx->ccid3hctx_t_ipi); 377 return 0; 378 } 379 380 static void ccid3_hc_tx_packet_sent(struct sock *sk, int more, 381 unsigned int len) 382 { 383 struct ccid3_hc_tx_sock *hctx = ccid3_hc_tx_sk(sk); 384 struct dccp_tx_hist_entry *packet; 385 386 ccid3_hc_tx_update_s(hctx, len); 387 388 packet = dccp_tx_hist_entry_new(ccid3_tx_hist, GFP_ATOMIC); 389 if (unlikely(packet == NULL)) { 390 DCCP_CRIT("packet history - out of memory!"); 391 return; 392 } 393 dccp_tx_hist_add_entry(&hctx->ccid3hctx_hist, packet); 394 395 packet->dccphtx_tstamp = ktime_get_real(); 396 packet->dccphtx_seqno = dccp_sk(sk)->dccps_gss; 397 packet->dccphtx_rtt = hctx->ccid3hctx_rtt; 398 packet->dccphtx_sent = 1; 399 } 400 401 static void ccid3_hc_tx_packet_recv(struct sock *sk, struct sk_buff *skb) 402 { 403 struct ccid3_hc_tx_sock *hctx = ccid3_hc_tx_sk(sk); 404 struct ccid3_options_received *opt_recv; 405 struct dccp_tx_hist_entry *packet; 406 ktime_t now; 407 unsigned long t_nfb; 408 u32 pinv, r_sample; 409 410 /* we are only interested in ACKs */ 411 if (!(DCCP_SKB_CB(skb)->dccpd_type == DCCP_PKT_ACK || 412 DCCP_SKB_CB(skb)->dccpd_type == DCCP_PKT_DATAACK)) 413 return; 414 415 opt_recv = &hctx->ccid3hctx_options_received; 416 417 switch (hctx->ccid3hctx_state) { 418 case TFRC_SSTATE_NO_FBACK: 419 case TFRC_SSTATE_FBACK: 420 /* get packet from history to look up t_recvdata */ 421 packet = dccp_tx_hist_find_entry(&hctx->ccid3hctx_hist, 422 DCCP_SKB_CB(skb)->dccpd_ack_seq); 423 if (unlikely(packet == NULL)) { 424 DCCP_WARN("%s(%p), seqno %llu(%s) doesn't exist " 425 "in history!\n", dccp_role(sk), sk, 426 (unsigned long long)DCCP_SKB_CB(skb)->dccpd_ack_seq, 427 dccp_packet_name(DCCP_SKB_CB(skb)->dccpd_type)); 428 return; 429 } 430 431 /* Update receive rate in units of 64 * bytes/second */ 432 hctx->ccid3hctx_x_recv = opt_recv->ccid3or_receive_rate; 433 hctx->ccid3hctx_x_recv <<= 6; 434 435 /* Update loss event rate */ 436 pinv = opt_recv->ccid3or_loss_event_rate; 437 if (pinv == ~0U || pinv == 0) /* see RFC 4342, 8.5 */ 438 hctx->ccid3hctx_p = 0; 439 else /* can not exceed 100% */ 440 hctx->ccid3hctx_p = 1000000 / pinv; 441 442 now = ktime_get_real(); 443 /* 444 * Calculate new round trip sample as per [RFC 3448, 4.3] by 445 * R_sample = (now - t_recvdata) - t_elapsed 446 */ 447 r_sample = dccp_sample_rtt(sk, ktime_us_delta(now, packet->dccphtx_tstamp)); 448 449 /* 450 * Update RTT estimate by 451 * If (No feedback recv) 452 * R = R_sample; 453 * Else 454 * R = q * R + (1 - q) * R_sample; 455 * 456 * q is a constant, RFC 3448 recomments 0.9 457 */ 458 if (hctx->ccid3hctx_state == TFRC_SSTATE_NO_FBACK) { 459 /* 460 * Larger Initial Windows [RFC 4342, sec. 5] 461 */ 462 hctx->ccid3hctx_rtt = r_sample; 463 hctx->ccid3hctx_x = rfc3390_initial_rate(sk); 464 hctx->ccid3hctx_t_ld = now; 465 466 ccid3_update_send_interval(hctx); 467 468 ccid3_pr_debug("%s(%p), s=%u, MSS=%u, " 469 "R_sample=%uus, X=%u\n", dccp_role(sk), 470 sk, hctx->ccid3hctx_s, 471 dccp_sk(sk)->dccps_mss_cache, r_sample, 472 (unsigned)(hctx->ccid3hctx_x >> 6)); 473 474 ccid3_hc_tx_set_state(sk, TFRC_SSTATE_FBACK); 475 } else { 476 hctx->ccid3hctx_rtt = (9 * hctx->ccid3hctx_rtt + 477 r_sample) / 10; 478 479 /* Update sending rate (step 4 of [RFC 3448, 4.3]) */ 480 if (hctx->ccid3hctx_p > 0) 481 hctx->ccid3hctx_x_calc = 482 tfrc_calc_x(hctx->ccid3hctx_s, 483 hctx->ccid3hctx_rtt, 484 hctx->ccid3hctx_p); 485 ccid3_hc_tx_update_x(sk, &now); 486 487 ccid3_pr_debug("%s(%p), RTT=%uus (sample=%uus), s=%u, " 488 "p=%u, X_calc=%u, X_recv=%u, X=%u\n", 489 dccp_role(sk), 490 sk, hctx->ccid3hctx_rtt, r_sample, 491 hctx->ccid3hctx_s, hctx->ccid3hctx_p, 492 hctx->ccid3hctx_x_calc, 493 (unsigned)(hctx->ccid3hctx_x_recv >> 6), 494 (unsigned)(hctx->ccid3hctx_x >> 6)); 495 } 496 497 /* unschedule no feedback timer */ 498 sk_stop_timer(sk, &hctx->ccid3hctx_no_feedback_timer); 499 500 /* remove all packets older than the one acked from history */ 501 dccp_tx_hist_purge_older(ccid3_tx_hist, 502 &hctx->ccid3hctx_hist, packet); 503 /* 504 * As we have calculated new ipi, delta, t_nom it is possible 505 * that we now can send a packet, so wake up dccp_wait_for_ccid 506 */ 507 sk->sk_write_space(sk); 508 509 /* 510 * Update timeout interval for the nofeedback timer. 511 * We use a configuration option to increase the lower bound. 512 * This can help avoid triggering the nofeedback timer too 513 * often ('spinning') on LANs with small RTTs. 514 */ 515 hctx->ccid3hctx_t_rto = max_t(u32, 4 * hctx->ccid3hctx_rtt, 516 CONFIG_IP_DCCP_CCID3_RTO * 517 (USEC_PER_SEC/1000)); 518 /* 519 * Schedule no feedback timer to expire in 520 * max(t_RTO, 2 * s/X) = max(t_RTO, 2 * t_ipi) 521 */ 522 t_nfb = max(hctx->ccid3hctx_t_rto, 2 * hctx->ccid3hctx_t_ipi); 523 524 ccid3_pr_debug("%s(%p), Scheduled no feedback timer to " 525 "expire in %lu jiffies (%luus)\n", 526 dccp_role(sk), 527 sk, usecs_to_jiffies(t_nfb), t_nfb); 528 529 sk_reset_timer(sk, &hctx->ccid3hctx_no_feedback_timer, 530 jiffies + usecs_to_jiffies(t_nfb)); 531 532 /* set idle flag */ 533 hctx->ccid3hctx_idle = 1; 534 break; 535 case TFRC_SSTATE_NO_SENT: /* fall through */ 536 case TFRC_SSTATE_TERM: /* ignore feedback when closing */ 537 break; 538 } 539 } 540 541 static int ccid3_hc_tx_parse_options(struct sock *sk, unsigned char option, 542 unsigned char len, u16 idx, 543 unsigned char *value) 544 { 545 int rc = 0; 546 const struct dccp_sock *dp = dccp_sk(sk); 547 struct ccid3_hc_tx_sock *hctx = ccid3_hc_tx_sk(sk); 548 struct ccid3_options_received *opt_recv; 549 __be32 opt_val; 550 551 opt_recv = &hctx->ccid3hctx_options_received; 552 553 if (opt_recv->ccid3or_seqno != dp->dccps_gsr) { 554 opt_recv->ccid3or_seqno = dp->dccps_gsr; 555 opt_recv->ccid3or_loss_event_rate = ~0; 556 opt_recv->ccid3or_loss_intervals_idx = 0; 557 opt_recv->ccid3or_loss_intervals_len = 0; 558 opt_recv->ccid3or_receive_rate = 0; 559 } 560 561 switch (option) { 562 case TFRC_OPT_LOSS_EVENT_RATE: 563 if (unlikely(len != 4)) { 564 DCCP_WARN("%s(%p), invalid len %d " 565 "for TFRC_OPT_LOSS_EVENT_RATE\n", 566 dccp_role(sk), sk, len); 567 rc = -EINVAL; 568 } else { 569 opt_val = get_unaligned((__be32 *)value); 570 opt_recv->ccid3or_loss_event_rate = ntohl(opt_val); 571 ccid3_pr_debug("%s(%p), LOSS_EVENT_RATE=%u\n", 572 dccp_role(sk), sk, 573 opt_recv->ccid3or_loss_event_rate); 574 } 575 break; 576 case TFRC_OPT_LOSS_INTERVALS: 577 opt_recv->ccid3or_loss_intervals_idx = idx; 578 opt_recv->ccid3or_loss_intervals_len = len; 579 ccid3_pr_debug("%s(%p), LOSS_INTERVALS=(%u, %u)\n", 580 dccp_role(sk), sk, 581 opt_recv->ccid3or_loss_intervals_idx, 582 opt_recv->ccid3or_loss_intervals_len); 583 break; 584 case TFRC_OPT_RECEIVE_RATE: 585 if (unlikely(len != 4)) { 586 DCCP_WARN("%s(%p), invalid len %d " 587 "for TFRC_OPT_RECEIVE_RATE\n", 588 dccp_role(sk), sk, len); 589 rc = -EINVAL; 590 } else { 591 opt_val = get_unaligned((__be32 *)value); 592 opt_recv->ccid3or_receive_rate = ntohl(opt_val); 593 ccid3_pr_debug("%s(%p), RECEIVE_RATE=%u\n", 594 dccp_role(sk), sk, 595 opt_recv->ccid3or_receive_rate); 596 } 597 break; 598 } 599 600 return rc; 601 } 602 603 static int ccid3_hc_tx_init(struct ccid *ccid, struct sock *sk) 604 { 605 struct ccid3_hc_tx_sock *hctx = ccid_priv(ccid); 606 607 hctx->ccid3hctx_state = TFRC_SSTATE_NO_SENT; 608 INIT_LIST_HEAD(&hctx->ccid3hctx_hist); 609 setup_timer(&hctx->ccid3hctx_no_feedback_timer, 610 ccid3_hc_tx_no_feedback_timer, (unsigned long)sk); 611 612 return 0; 613 } 614 615 static void ccid3_hc_tx_exit(struct sock *sk) 616 { 617 struct ccid3_hc_tx_sock *hctx = ccid3_hc_tx_sk(sk); 618 619 ccid3_hc_tx_set_state(sk, TFRC_SSTATE_TERM); 620 sk_stop_timer(sk, &hctx->ccid3hctx_no_feedback_timer); 621 622 /* Empty packet history */ 623 dccp_tx_hist_purge(ccid3_tx_hist, &hctx->ccid3hctx_hist); 624 } 625 626 static void ccid3_hc_tx_get_info(struct sock *sk, struct tcp_info *info) 627 { 628 struct ccid3_hc_tx_sock *hctx; 629 630 /* Listen socks doesn't have a private CCID block */ 631 if (sk->sk_state == DCCP_LISTEN) 632 return; 633 634 hctx = ccid3_hc_tx_sk(sk); 635 info->tcpi_rto = hctx->ccid3hctx_t_rto; 636 info->tcpi_rtt = hctx->ccid3hctx_rtt; 637 } 638 639 static int ccid3_hc_tx_getsockopt(struct sock *sk, const int optname, int len, 640 u32 __user *optval, int __user *optlen) 641 { 642 const struct ccid3_hc_tx_sock *hctx; 643 const void *val; 644 645 /* Listen socks doesn't have a private CCID block */ 646 if (sk->sk_state == DCCP_LISTEN) 647 return -EINVAL; 648 649 hctx = ccid3_hc_tx_sk(sk); 650 switch (optname) { 651 case DCCP_SOCKOPT_CCID_TX_INFO: 652 if (len < sizeof(hctx->ccid3hctx_tfrc)) 653 return -EINVAL; 654 len = sizeof(hctx->ccid3hctx_tfrc); 655 val = &hctx->ccid3hctx_tfrc; 656 break; 657 default: 658 return -ENOPROTOOPT; 659 } 660 661 if (put_user(len, optlen) || copy_to_user(optval, val, len)) 662 return -EFAULT; 663 664 return 0; 665 } 666 667 /* 668 * Receiver Half-Connection Routines 669 */ 670 #ifdef CONFIG_IP_DCCP_CCID3_DEBUG 671 static const char *ccid3_rx_state_name(enum ccid3_hc_rx_states state) 672 { 673 static char *ccid3_rx_state_names[] = { 674 [TFRC_RSTATE_NO_DATA] = "NO_DATA", 675 [TFRC_RSTATE_DATA] = "DATA", 676 [TFRC_RSTATE_TERM] = "TERM", 677 }; 678 679 return ccid3_rx_state_names[state]; 680 } 681 #endif 682 683 static void ccid3_hc_rx_set_state(struct sock *sk, 684 enum ccid3_hc_rx_states state) 685 { 686 struct ccid3_hc_rx_sock *hcrx = ccid3_hc_rx_sk(sk); 687 enum ccid3_hc_rx_states oldstate = hcrx->ccid3hcrx_state; 688 689 ccid3_pr_debug("%s(%p) %-8.8s -> %s\n", 690 dccp_role(sk), sk, ccid3_rx_state_name(oldstate), 691 ccid3_rx_state_name(state)); 692 WARN_ON(state == oldstate); 693 hcrx->ccid3hcrx_state = state; 694 } 695 696 static inline void ccid3_hc_rx_update_s(struct ccid3_hc_rx_sock *hcrx, int len) 697 { 698 if (unlikely(len == 0)) /* don't update on empty packets (e.g. ACKs) */ 699 ccid3_pr_debug("Packet payload length is 0 - not updating\n"); 700 else 701 hcrx->ccid3hcrx_s = hcrx->ccid3hcrx_s == 0 ? len : 702 (9 * hcrx->ccid3hcrx_s + len) / 10; 703 } 704 705 static void ccid3_hc_rx_send_feedback(struct sock *sk) 706 { 707 struct ccid3_hc_rx_sock *hcrx = ccid3_hc_rx_sk(sk); 708 struct dccp_sock *dp = dccp_sk(sk); 709 struct dccp_rx_hist_entry *packet; 710 ktime_t now; 711 suseconds_t delta; 712 713 ccid3_pr_debug("%s(%p) - entry \n", dccp_role(sk), sk); 714 715 now = ktime_get_real(); 716 717 switch (hcrx->ccid3hcrx_state) { 718 case TFRC_RSTATE_NO_DATA: 719 hcrx->ccid3hcrx_x_recv = 0; 720 break; 721 case TFRC_RSTATE_DATA: 722 delta = ktime_us_delta(now, 723 hcrx->ccid3hcrx_tstamp_last_feedback); 724 DCCP_BUG_ON(delta < 0); 725 hcrx->ccid3hcrx_x_recv = 726 scaled_div32(hcrx->ccid3hcrx_bytes_recv, delta); 727 break; 728 case TFRC_RSTATE_TERM: 729 DCCP_BUG("%s(%p) - Illegal state TERM", dccp_role(sk), sk); 730 return; 731 } 732 733 packet = dccp_rx_hist_find_data_packet(&hcrx->ccid3hcrx_hist); 734 if (unlikely(packet == NULL)) { 735 DCCP_WARN("%s(%p), no data packet in history!\n", 736 dccp_role(sk), sk); 737 return; 738 } 739 740 hcrx->ccid3hcrx_tstamp_last_feedback = now; 741 hcrx->ccid3hcrx_ccval_last_counter = packet->dccphrx_ccval; 742 hcrx->ccid3hcrx_bytes_recv = 0; 743 744 /* Elapsed time information [RFC 4340, 13.2] in units of 10 * usecs */ 745 delta = ktime_us_delta(now, packet->dccphrx_tstamp); 746 DCCP_BUG_ON(delta < 0); 747 hcrx->ccid3hcrx_elapsed_time = delta / 10; 748 749 if (hcrx->ccid3hcrx_p == 0) 750 hcrx->ccid3hcrx_pinv = ~0U; /* see RFC 4342, 8.5 */ 751 else if (hcrx->ccid3hcrx_p > 1000000) { 752 DCCP_WARN("p (%u) > 100%%\n", hcrx->ccid3hcrx_p); 753 hcrx->ccid3hcrx_pinv = 1; /* use 100% in this case */ 754 } else 755 hcrx->ccid3hcrx_pinv = 1000000 / hcrx->ccid3hcrx_p; 756 757 dp->dccps_hc_rx_insert_options = 1; 758 dccp_send_ack(sk); 759 } 760 761 static int ccid3_hc_rx_insert_options(struct sock *sk, struct sk_buff *skb) 762 { 763 const struct ccid3_hc_rx_sock *hcrx; 764 __be32 x_recv, pinv; 765 766 if (!(sk->sk_state == DCCP_OPEN || sk->sk_state == DCCP_PARTOPEN)) 767 return 0; 768 769 hcrx = ccid3_hc_rx_sk(sk); 770 DCCP_SKB_CB(skb)->dccpd_ccval = hcrx->ccid3hcrx_ccval_last_counter; 771 772 if (dccp_packet_without_ack(skb)) 773 return 0; 774 775 x_recv = htonl(hcrx->ccid3hcrx_x_recv); 776 pinv = htonl(hcrx->ccid3hcrx_pinv); 777 778 if ((hcrx->ccid3hcrx_elapsed_time != 0 && 779 dccp_insert_option_elapsed_time(sk, skb, 780 hcrx->ccid3hcrx_elapsed_time)) || 781 dccp_insert_option_timestamp(sk, skb) || 782 dccp_insert_option(sk, skb, TFRC_OPT_LOSS_EVENT_RATE, 783 &pinv, sizeof(pinv)) || 784 dccp_insert_option(sk, skb, TFRC_OPT_RECEIVE_RATE, 785 &x_recv, sizeof(x_recv))) 786 return -1; 787 788 return 0; 789 } 790 791 static int ccid3_hc_rx_detect_loss(struct sock *sk, 792 struct dccp_rx_hist_entry *packet) 793 { 794 struct ccid3_hc_rx_sock *hcrx = ccid3_hc_rx_sk(sk); 795 struct dccp_rx_hist_entry *rx_hist = 796 dccp_rx_hist_head(&hcrx->ccid3hcrx_hist); 797 u64 seqno = packet->dccphrx_seqno; 798 u64 tmp_seqno; 799 int loss = 0; 800 u8 ccval; 801 802 803 tmp_seqno = hcrx->ccid3hcrx_seqno_nonloss; 804 805 if (!rx_hist || 806 follows48(packet->dccphrx_seqno, hcrx->ccid3hcrx_seqno_nonloss)) { 807 hcrx->ccid3hcrx_seqno_nonloss = seqno; 808 hcrx->ccid3hcrx_ccval_nonloss = packet->dccphrx_ccval; 809 goto detect_out; 810 } 811 812 813 while (dccp_delta_seqno(hcrx->ccid3hcrx_seqno_nonloss, seqno) 814 > TFRC_RECV_NUM_LATE_LOSS) { 815 loss = 1; 816 dccp_li_update_li(sk, 817 &hcrx->ccid3hcrx_li_hist, 818 &hcrx->ccid3hcrx_hist, 819 hcrx->ccid3hcrx_tstamp_last_feedback, 820 hcrx->ccid3hcrx_s, 821 hcrx->ccid3hcrx_bytes_recv, 822 hcrx->ccid3hcrx_x_recv, 823 hcrx->ccid3hcrx_seqno_nonloss, 824 hcrx->ccid3hcrx_ccval_nonloss); 825 tmp_seqno = hcrx->ccid3hcrx_seqno_nonloss; 826 dccp_inc_seqno(&tmp_seqno); 827 hcrx->ccid3hcrx_seqno_nonloss = tmp_seqno; 828 dccp_inc_seqno(&tmp_seqno); 829 while (dccp_rx_hist_find_entry(&hcrx->ccid3hcrx_hist, 830 tmp_seqno, &ccval)) { 831 hcrx->ccid3hcrx_seqno_nonloss = tmp_seqno; 832 hcrx->ccid3hcrx_ccval_nonloss = ccval; 833 dccp_inc_seqno(&tmp_seqno); 834 } 835 } 836 837 /* FIXME - this code could be simplified with above while */ 838 /* but works at moment */ 839 if (follows48(packet->dccphrx_seqno, hcrx->ccid3hcrx_seqno_nonloss)) { 840 hcrx->ccid3hcrx_seqno_nonloss = seqno; 841 hcrx->ccid3hcrx_ccval_nonloss = packet->dccphrx_ccval; 842 } 843 844 detect_out: 845 dccp_rx_hist_add_packet(ccid3_rx_hist, &hcrx->ccid3hcrx_hist, 846 &hcrx->ccid3hcrx_li_hist, packet, 847 hcrx->ccid3hcrx_seqno_nonloss); 848 return loss; 849 } 850 851 static void ccid3_hc_rx_packet_recv(struct sock *sk, struct sk_buff *skb) 852 { 853 struct ccid3_hc_rx_sock *hcrx = ccid3_hc_rx_sk(sk); 854 const struct dccp_options_received *opt_recv; 855 struct dccp_rx_hist_entry *packet; 856 u32 p_prev, r_sample, rtt_prev; 857 int loss, payload_size; 858 ktime_t now; 859 860 opt_recv = &dccp_sk(sk)->dccps_options_received; 861 862 switch (DCCP_SKB_CB(skb)->dccpd_type) { 863 case DCCP_PKT_ACK: 864 if (hcrx->ccid3hcrx_state == TFRC_RSTATE_NO_DATA) 865 return; 866 case DCCP_PKT_DATAACK: 867 if (opt_recv->dccpor_timestamp_echo == 0) 868 break; 869 r_sample = dccp_timestamp() - opt_recv->dccpor_timestamp_echo; 870 rtt_prev = hcrx->ccid3hcrx_rtt; 871 r_sample = dccp_sample_rtt(sk, 10 * r_sample); 872 873 if (hcrx->ccid3hcrx_state == TFRC_RSTATE_NO_DATA) 874 hcrx->ccid3hcrx_rtt = r_sample; 875 else 876 hcrx->ccid3hcrx_rtt = (hcrx->ccid3hcrx_rtt * 9) / 10 + 877 r_sample / 10; 878 879 if (rtt_prev != hcrx->ccid3hcrx_rtt) 880 ccid3_pr_debug("%s(%p), New RTT=%uus, elapsed time=%u\n", 881 dccp_role(sk), sk, hcrx->ccid3hcrx_rtt, 882 opt_recv->dccpor_elapsed_time); 883 break; 884 case DCCP_PKT_DATA: 885 break; 886 default: /* We're not interested in other packet types, move along */ 887 return; 888 } 889 890 packet = dccp_rx_hist_entry_new(ccid3_rx_hist, opt_recv->dccpor_ndp, 891 skb, GFP_ATOMIC); 892 if (unlikely(packet == NULL)) { 893 DCCP_WARN("%s(%p), Not enough mem to add rx packet " 894 "to history, consider it lost!\n", dccp_role(sk), sk); 895 return; 896 } 897 898 loss = ccid3_hc_rx_detect_loss(sk, packet); 899 900 if (DCCP_SKB_CB(skb)->dccpd_type == DCCP_PKT_ACK) 901 return; 902 903 payload_size = skb->len - dccp_hdr(skb)->dccph_doff * 4; 904 ccid3_hc_rx_update_s(hcrx, payload_size); 905 906 switch (hcrx->ccid3hcrx_state) { 907 case TFRC_RSTATE_NO_DATA: 908 ccid3_pr_debug("%s(%p, state=%s), skb=%p, sending initial " 909 "feedback\n", dccp_role(sk), sk, 910 dccp_state_name(sk->sk_state), skb); 911 ccid3_hc_rx_send_feedback(sk); 912 ccid3_hc_rx_set_state(sk, TFRC_RSTATE_DATA); 913 return; 914 case TFRC_RSTATE_DATA: 915 hcrx->ccid3hcrx_bytes_recv += payload_size; 916 if (loss) 917 break; 918 919 now = ktime_get_real(); 920 if ((ktime_us_delta(now, hcrx->ccid3hcrx_tstamp_last_ack) - 921 (s64)hcrx->ccid3hcrx_rtt) >= 0) { 922 hcrx->ccid3hcrx_tstamp_last_ack = now; 923 ccid3_hc_rx_send_feedback(sk); 924 } 925 return; 926 case TFRC_RSTATE_TERM: 927 DCCP_BUG("%s(%p) - Illegal state TERM", dccp_role(sk), sk); 928 return; 929 } 930 931 /* Dealing with packet loss */ 932 ccid3_pr_debug("%s(%p, state=%s), data loss! Reacting...\n", 933 dccp_role(sk), sk, dccp_state_name(sk->sk_state)); 934 935 p_prev = hcrx->ccid3hcrx_p; 936 937 /* Calculate loss event rate */ 938 if (!list_empty(&hcrx->ccid3hcrx_li_hist)) { 939 u32 i_mean = dccp_li_hist_calc_i_mean(&hcrx->ccid3hcrx_li_hist); 940 941 /* Scaling up by 1000000 as fixed decimal */ 942 if (i_mean != 0) 943 hcrx->ccid3hcrx_p = 1000000 / i_mean; 944 } else 945 DCCP_BUG("empty loss history"); 946 947 if (hcrx->ccid3hcrx_p > p_prev) { 948 ccid3_hc_rx_send_feedback(sk); 949 return; 950 } 951 } 952 953 static int ccid3_hc_rx_init(struct ccid *ccid, struct sock *sk) 954 { 955 struct ccid3_hc_rx_sock *hcrx = ccid_priv(ccid); 956 957 ccid3_pr_debug("entry\n"); 958 959 hcrx->ccid3hcrx_state = TFRC_RSTATE_NO_DATA; 960 INIT_LIST_HEAD(&hcrx->ccid3hcrx_hist); 961 INIT_LIST_HEAD(&hcrx->ccid3hcrx_li_hist); 962 hcrx->ccid3hcrx_tstamp_last_feedback = 963 hcrx->ccid3hcrx_tstamp_last_ack = ktime_get_real(); 964 return 0; 965 } 966 967 static void ccid3_hc_rx_exit(struct sock *sk) 968 { 969 struct ccid3_hc_rx_sock *hcrx = ccid3_hc_rx_sk(sk); 970 971 ccid3_hc_rx_set_state(sk, TFRC_RSTATE_TERM); 972 973 /* Empty packet history */ 974 dccp_rx_hist_purge(ccid3_rx_hist, &hcrx->ccid3hcrx_hist); 975 976 /* Empty loss interval history */ 977 dccp_li_hist_purge(&hcrx->ccid3hcrx_li_hist); 978 } 979 980 static void ccid3_hc_rx_get_info(struct sock *sk, struct tcp_info *info) 981 { 982 const struct ccid3_hc_rx_sock *hcrx; 983 984 /* Listen socks doesn't have a private CCID block */ 985 if (sk->sk_state == DCCP_LISTEN) 986 return; 987 988 hcrx = ccid3_hc_rx_sk(sk); 989 info->tcpi_ca_state = hcrx->ccid3hcrx_state; 990 info->tcpi_options |= TCPI_OPT_TIMESTAMPS; 991 info->tcpi_rcv_rtt = hcrx->ccid3hcrx_rtt; 992 } 993 994 static int ccid3_hc_rx_getsockopt(struct sock *sk, const int optname, int len, 995 u32 __user *optval, int __user *optlen) 996 { 997 const struct ccid3_hc_rx_sock *hcrx; 998 const void *val; 999 1000 /* Listen socks doesn't have a private CCID block */ 1001 if (sk->sk_state == DCCP_LISTEN) 1002 return -EINVAL; 1003 1004 hcrx = ccid3_hc_rx_sk(sk); 1005 switch (optname) { 1006 case DCCP_SOCKOPT_CCID_RX_INFO: 1007 if (len < sizeof(hcrx->ccid3hcrx_tfrc)) 1008 return -EINVAL; 1009 len = sizeof(hcrx->ccid3hcrx_tfrc); 1010 val = &hcrx->ccid3hcrx_tfrc; 1011 break; 1012 default: 1013 return -ENOPROTOOPT; 1014 } 1015 1016 if (put_user(len, optlen) || copy_to_user(optval, val, len)) 1017 return -EFAULT; 1018 1019 return 0; 1020 } 1021 1022 static struct ccid_operations ccid3 = { 1023 .ccid_id = DCCPC_CCID3, 1024 .ccid_name = "ccid3", 1025 .ccid_owner = THIS_MODULE, 1026 .ccid_hc_tx_obj_size = sizeof(struct ccid3_hc_tx_sock), 1027 .ccid_hc_tx_init = ccid3_hc_tx_init, 1028 .ccid_hc_tx_exit = ccid3_hc_tx_exit, 1029 .ccid_hc_tx_send_packet = ccid3_hc_tx_send_packet, 1030 .ccid_hc_tx_packet_sent = ccid3_hc_tx_packet_sent, 1031 .ccid_hc_tx_packet_recv = ccid3_hc_tx_packet_recv, 1032 .ccid_hc_tx_parse_options = ccid3_hc_tx_parse_options, 1033 .ccid_hc_rx_obj_size = sizeof(struct ccid3_hc_rx_sock), 1034 .ccid_hc_rx_init = ccid3_hc_rx_init, 1035 .ccid_hc_rx_exit = ccid3_hc_rx_exit, 1036 .ccid_hc_rx_insert_options = ccid3_hc_rx_insert_options, 1037 .ccid_hc_rx_packet_recv = ccid3_hc_rx_packet_recv, 1038 .ccid_hc_rx_get_info = ccid3_hc_rx_get_info, 1039 .ccid_hc_tx_get_info = ccid3_hc_tx_get_info, 1040 .ccid_hc_rx_getsockopt = ccid3_hc_rx_getsockopt, 1041 .ccid_hc_tx_getsockopt = ccid3_hc_tx_getsockopt, 1042 }; 1043 1044 #ifdef CONFIG_IP_DCCP_CCID3_DEBUG 1045 module_param(ccid3_debug, bool, 0444); 1046 MODULE_PARM_DESC(ccid3_debug, "Enable debug messages"); 1047 #endif 1048 1049 static __init int ccid3_module_init(void) 1050 { 1051 int rc = -ENOBUFS; 1052 1053 ccid3_rx_hist = dccp_rx_hist_new("ccid3"); 1054 if (ccid3_rx_hist == NULL) 1055 goto out; 1056 1057 ccid3_tx_hist = dccp_tx_hist_new("ccid3"); 1058 if (ccid3_tx_hist == NULL) 1059 goto out_free_rx; 1060 1061 rc = ccid_register(&ccid3); 1062 if (rc != 0) 1063 goto out_free_tx; 1064 out: 1065 return rc; 1066 1067 out_free_tx: 1068 dccp_tx_hist_delete(ccid3_tx_hist); 1069 ccid3_tx_hist = NULL; 1070 out_free_rx: 1071 dccp_rx_hist_delete(ccid3_rx_hist); 1072 ccid3_rx_hist = NULL; 1073 goto out; 1074 } 1075 module_init(ccid3_module_init); 1076 1077 static __exit void ccid3_module_exit(void) 1078 { 1079 ccid_unregister(&ccid3); 1080 1081 if (ccid3_tx_hist != NULL) { 1082 dccp_tx_hist_delete(ccid3_tx_hist); 1083 ccid3_tx_hist = NULL; 1084 } 1085 if (ccid3_rx_hist != NULL) { 1086 dccp_rx_hist_delete(ccid3_rx_hist); 1087 ccid3_rx_hist = NULL; 1088 } 1089 } 1090 module_exit(ccid3_module_exit); 1091 1092 MODULE_AUTHOR("Ian McDonald <ian.mcdonald@jandi.co.nz>, " 1093 "Arnaldo Carvalho de Melo <acme@ghostprotocols.net>"); 1094 MODULE_DESCRIPTION("DCCP TFRC CCID3 CCID"); 1095 MODULE_LICENSE("GPL"); 1096 MODULE_ALIAS("net-dccp-ccid-3"); 1097