ia64/linux-2.6.18-xen.hg

view net/sctp/transport.c @ 871:9cbcc9008446

xen/x86: don't initialize cpu_data[]'s apicid field on generic code

Afaict, this is not only redundant with the intialization done in
drivers/xen/core/smpboot.c, but actually results - at least for
secondary CPUs - in the Xen-specific value written to be later
overwritten with whatever the generic code determines (with no
guarantee that the two values are identical).

Signed-off-by: Jan Beulich <jbeulich@novell.com>
author Keir Fraser <keir.fraser@citrix.com>
date Thu May 14 10:09:15 2009 +0100 (2009-05-14)
parents 831230e53067
children
line source
1 /* SCTP kernel reference Implementation
2 * Copyright (c) 1999-2000 Cisco, Inc.
3 * Copyright (c) 1999-2001 Motorola, Inc.
4 * Copyright (c) 2001-2003 International Business Machines Corp.
5 * Copyright (c) 2001 Intel Corp.
6 * Copyright (c) 2001 La Monte H.P. Yarroll
7 *
8 * This file is part of the SCTP kernel reference Implementation
9 *
10 * This module provides the abstraction for an SCTP tranport representing
11 * a remote transport address. For local transport addresses, we just use
12 * union sctp_addr.
13 *
14 * The SCTP reference implementation is free software;
15 * you can redistribute it and/or modify it under the terms of
16 * the GNU General Public License as published by
17 * the Free Software Foundation; either version 2, or (at your option)
18 * any later version.
19 *
20 * The SCTP reference implementation is distributed in the hope that it
21 * will be useful, but WITHOUT ANY WARRANTY; without even the implied
22 * ************************
23 * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
24 * See the GNU General Public License for more details.
25 *
26 * You should have received a copy of the GNU General Public License
27 * along with GNU CC; see the file COPYING. If not, write to
28 * the Free Software Foundation, 59 Temple Place - Suite 330,
29 * Boston, MA 02111-1307, USA.
30 *
31 * Please send any bug reports or fixes you make to the
32 * email address(es):
33 * lksctp developers <lksctp-developers@lists.sourceforge.net>
34 *
35 * Or submit a bug report through the following website:
36 * http://www.sf.net/projects/lksctp
37 *
38 * Written or modified by:
39 * La Monte H.P. Yarroll <piggy@acm.org>
40 * Karl Knutson <karl@athena.chicago.il.us>
41 * Jon Grimm <jgrimm@us.ibm.com>
42 * Xingang Guo <xingang.guo@intel.com>
43 * Hui Huang <hui.huang@nokia.com>
44 * Sridhar Samudrala <sri@us.ibm.com>
45 * Ardelle Fan <ardelle.fan@intel.com>
46 *
47 * Any bugs reported given to us we will try to fix... any fixes shared will
48 * be incorporated into the next SCTP release.
49 */
51 #include <linux/types.h>
52 #include <linux/random.h>
53 #include <net/sctp/sctp.h>
54 #include <net/sctp/sm.h>
56 /* 1st Level Abstractions. */
58 /* Initialize a new transport from provided memory. */
59 static struct sctp_transport *sctp_transport_init(struct sctp_transport *peer,
60 const union sctp_addr *addr,
61 gfp_t gfp)
62 {
63 /* Copy in the address. */
64 peer->ipaddr = *addr;
65 peer->af_specific = sctp_get_af_specific(addr->sa.sa_family);
66 peer->asoc = NULL;
68 peer->dst = NULL;
69 memset(&peer->saddr, 0, sizeof(union sctp_addr));
71 /* From 6.3.1 RTO Calculation:
72 *
73 * C1) Until an RTT measurement has been made for a packet sent to the
74 * given destination transport address, set RTO to the protocol
75 * parameter 'RTO.Initial'.
76 */
77 peer->rtt = 0;
78 peer->rto = sctp_rto_initial;
79 peer->rttvar = 0;
80 peer->srtt = 0;
81 peer->rto_pending = 0;
83 peer->last_time_heard = jiffies;
84 peer->last_time_used = jiffies;
85 peer->last_time_ecne_reduced = jiffies;
87 peer->init_sent_count = 0;
89 peer->param_flags = SPP_HB_DISABLE |
90 SPP_PMTUD_ENABLE |
91 SPP_SACKDELAY_ENABLE;
92 peer->hbinterval = 0;
94 /* Initialize the default path max_retrans. */
95 peer->pathmaxrxt = sctp_max_retrans_path;
96 peer->error_count = 0;
98 INIT_LIST_HEAD(&peer->transmitted);
99 INIT_LIST_HEAD(&peer->send_ready);
100 INIT_LIST_HEAD(&peer->transports);
102 /* Set up the retransmission timer. */
103 init_timer(&peer->T3_rtx_timer);
104 peer->T3_rtx_timer.function = sctp_generate_t3_rtx_event;
105 peer->T3_rtx_timer.data = (unsigned long)peer;
107 /* Set up the heartbeat timer. */
108 init_timer(&peer->hb_timer);
109 peer->hb_timer.function = sctp_generate_heartbeat_event;
110 peer->hb_timer.data = (unsigned long)peer;
112 /* Initialize the 64-bit random nonce sent with heartbeat. */
113 get_random_bytes(&peer->hb_nonce, sizeof(peer->hb_nonce));
115 atomic_set(&peer->refcnt, 1);
116 peer->dead = 0;
118 peer->malloced = 0;
120 /* Initialize the state information for SFR-CACC */
121 peer->cacc.changeover_active = 0;
122 peer->cacc.cycling_changeover = 0;
123 peer->cacc.next_tsn_at_change = 0;
124 peer->cacc.cacc_saw_newack = 0;
126 return peer;
127 }
129 /* Allocate and initialize a new transport. */
130 struct sctp_transport *sctp_transport_new(const union sctp_addr *addr,
131 gfp_t gfp)
132 {
133 struct sctp_transport *transport;
135 transport = t_new(struct sctp_transport, gfp);
136 if (!transport)
137 goto fail;
139 if (!sctp_transport_init(transport, addr, gfp))
140 goto fail_init;
142 transport->malloced = 1;
143 SCTP_DBG_OBJCNT_INC(transport);
145 return transport;
147 fail_init:
148 kfree(transport);
150 fail:
151 return NULL;
152 }
154 /* This transport is no longer needed. Free up if possible, or
155 * delay until it last reference count.
156 */
157 void sctp_transport_free(struct sctp_transport *transport)
158 {
159 transport->dead = 1;
161 /* Try to delete the heartbeat timer. */
162 if (del_timer(&transport->hb_timer))
163 sctp_transport_put(transport);
165 /* Delete the T3_rtx timer if it's active.
166 * There is no point in not doing this now and letting
167 * structure hang around in memory since we know
168 * the tranport is going away.
169 */
170 if (timer_pending(&transport->T3_rtx_timer) &&
171 del_timer(&transport->T3_rtx_timer))
172 sctp_transport_put(transport);
175 sctp_transport_put(transport);
176 }
178 /* Destroy the transport data structure.
179 * Assumes there are no more users of this structure.
180 */
181 static void sctp_transport_destroy(struct sctp_transport *transport)
182 {
183 SCTP_ASSERT(transport->dead, "Transport is not dead", return);
185 if (transport->asoc)
186 sctp_association_put(transport->asoc);
188 sctp_packet_free(&transport->packet);
190 dst_release(transport->dst);
191 kfree(transport);
192 SCTP_DBG_OBJCNT_DEC(transport);
193 }
195 /* Start T3_rtx timer if it is not already running and update the heartbeat
196 * timer. This routine is called every time a DATA chunk is sent.
197 */
198 void sctp_transport_reset_timers(struct sctp_transport *transport)
199 {
200 /* RFC 2960 6.3.2 Retransmission Timer Rules
201 *
202 * R1) Every time a DATA chunk is sent to any address(including a
203 * retransmission), if the T3-rtx timer of that address is not running
204 * start it running so that it will expire after the RTO of that
205 * address.
206 */
208 if (!timer_pending(&transport->T3_rtx_timer))
209 if (!mod_timer(&transport->T3_rtx_timer,
210 jiffies + transport->rto))
211 sctp_transport_hold(transport);
213 /* When a data chunk is sent, reset the heartbeat interval. */
214 if (!mod_timer(&transport->hb_timer,
215 sctp_transport_timeout(transport)))
216 sctp_transport_hold(transport);
217 }
219 /* This transport has been assigned to an association.
220 * Initialize fields from the association or from the sock itself.
221 * Register the reference count in the association.
222 */
223 void sctp_transport_set_owner(struct sctp_transport *transport,
224 struct sctp_association *asoc)
225 {
226 transport->asoc = asoc;
227 sctp_association_hold(asoc);
228 }
230 /* Initialize the pmtu of a transport. */
231 void sctp_transport_pmtu(struct sctp_transport *transport)
232 {
233 struct dst_entry *dst;
235 dst = transport->af_specific->get_dst(NULL, &transport->ipaddr, NULL);
237 if (dst) {
238 transport->pathmtu = dst_mtu(dst);
239 dst_release(dst);
240 } else
241 transport->pathmtu = SCTP_DEFAULT_MAXSEGMENT;
242 }
244 /* Caches the dst entry and source address for a transport's destination
245 * address.
246 */
247 void sctp_transport_route(struct sctp_transport *transport,
248 union sctp_addr *saddr, struct sctp_sock *opt)
249 {
250 struct sctp_association *asoc = transport->asoc;
251 struct sctp_af *af = transport->af_specific;
252 union sctp_addr *daddr = &transport->ipaddr;
253 struct dst_entry *dst;
255 dst = af->get_dst(asoc, daddr, saddr);
257 if (saddr)
258 memcpy(&transport->saddr, saddr, sizeof(union sctp_addr));
259 else
260 af->get_saddr(asoc, dst, daddr, &transport->saddr);
262 transport->dst = dst;
263 if ((transport->param_flags & SPP_PMTUD_DISABLE) && transport->pathmtu) {
264 return;
265 }
266 if (dst) {
267 transport->pathmtu = dst_mtu(dst);
269 /* Initialize sk->sk_rcv_saddr, if the transport is the
270 * association's active path for getsockname().
271 */
272 if (asoc && (transport == asoc->peer.active_path))
273 opt->pf->af->to_sk_saddr(&transport->saddr,
274 asoc->base.sk);
275 } else
276 transport->pathmtu = SCTP_DEFAULT_MAXSEGMENT;
277 }
279 /* Hold a reference to a transport. */
280 void sctp_transport_hold(struct sctp_transport *transport)
281 {
282 atomic_inc(&transport->refcnt);
283 }
285 /* Release a reference to a transport and clean up
286 * if there are no more references.
287 */
288 void sctp_transport_put(struct sctp_transport *transport)
289 {
290 if (atomic_dec_and_test(&transport->refcnt))
291 sctp_transport_destroy(transport);
292 }
294 /* Update transport's RTO based on the newly calculated RTT. */
295 void sctp_transport_update_rto(struct sctp_transport *tp, __u32 rtt)
296 {
297 /* Check for valid transport. */
298 SCTP_ASSERT(tp, "NULL transport", return);
300 /* We should not be doing any RTO updates unless rto_pending is set. */
301 SCTP_ASSERT(tp->rto_pending, "rto_pending not set", return);
303 if (tp->rttvar || tp->srtt) {
304 /* 6.3.1 C3) When a new RTT measurement R' is made, set
305 * RTTVAR <- (1 - RTO.Beta) * RTTVAR + RTO.Beta * |SRTT - R'|
306 * SRTT <- (1 - RTO.Alpha) * SRTT + RTO.Alpha * R'
307 */
309 /* Note: The above algorithm has been rewritten to
310 * express rto_beta and rto_alpha as inverse powers
311 * of two.
312 * For example, assuming the default value of RTO.Alpha of
313 * 1/8, rto_alpha would be expressed as 3.
314 */
315 tp->rttvar = tp->rttvar - (tp->rttvar >> sctp_rto_beta)
316 + ((abs(tp->srtt - rtt)) >> sctp_rto_beta);
317 tp->srtt = tp->srtt - (tp->srtt >> sctp_rto_alpha)
318 + (rtt >> sctp_rto_alpha);
319 } else {
320 /* 6.3.1 C2) When the first RTT measurement R is made, set
321 * SRTT <- R, RTTVAR <- R/2.
322 */
323 tp->srtt = rtt;
324 tp->rttvar = rtt >> 1;
325 }
327 /* 6.3.1 G1) Whenever RTTVAR is computed, if RTTVAR = 0, then
328 * adjust RTTVAR <- G, where G is the CLOCK GRANULARITY.
329 */
330 if (tp->rttvar == 0)
331 tp->rttvar = SCTP_CLOCK_GRANULARITY;
333 /* 6.3.1 C3) After the computation, update RTO <- SRTT + 4 * RTTVAR. */
334 tp->rto = tp->srtt + (tp->rttvar << 2);
336 /* 6.3.1 C6) Whenever RTO is computed, if it is less than RTO.Min
337 * seconds then it is rounded up to RTO.Min seconds.
338 */
339 if (tp->rto < tp->asoc->rto_min)
340 tp->rto = tp->asoc->rto_min;
342 /* 6.3.1 C7) A maximum value may be placed on RTO provided it is
343 * at least RTO.max seconds.
344 */
345 if (tp->rto > tp->asoc->rto_max)
346 tp->rto = tp->asoc->rto_max;
348 tp->rtt = rtt;
350 /* Reset rto_pending so that a new RTT measurement is started when a
351 * new data chunk is sent.
352 */
353 tp->rto_pending = 0;
355 SCTP_DEBUG_PRINTK("%s: transport: %p, rtt: %d, srtt: %d "
356 "rttvar: %d, rto: %ld\n", __FUNCTION__,
357 tp, rtt, tp->srtt, tp->rttvar, tp->rto);
358 }
360 /* This routine updates the transport's cwnd and partial_bytes_acked
361 * parameters based on the bytes acked in the received SACK.
362 */
363 void sctp_transport_raise_cwnd(struct sctp_transport *transport,
364 __u32 sack_ctsn, __u32 bytes_acked)
365 {
366 __u32 cwnd, ssthresh, flight_size, pba, pmtu;
368 cwnd = transport->cwnd;
369 flight_size = transport->flight_size;
371 /* The appropriate cwnd increase algorithm is performed if, and only
372 * if the cumulative TSN has advanced and the congestion window is
373 * being fully utilized.
374 */
375 if ((transport->asoc->ctsn_ack_point >= sack_ctsn) ||
376 (flight_size < cwnd))
377 return;
379 ssthresh = transport->ssthresh;
380 pba = transport->partial_bytes_acked;
381 pmtu = transport->asoc->pathmtu;
383 if (cwnd <= ssthresh) {
384 /* RFC 2960 7.2.1, sctpimpguide-05 2.14.2 When cwnd is less
385 * than or equal to ssthresh an SCTP endpoint MUST use the
386 * slow start algorithm to increase cwnd only if the current
387 * congestion window is being fully utilized and an incoming
388 * SACK advances the Cumulative TSN Ack Point. Only when these
389 * two conditions are met can the cwnd be increased otherwise
390 * the cwnd MUST not be increased. If these conditions are met
391 * then cwnd MUST be increased by at most the lesser of
392 * 1) the total size of the previously outstanding DATA
393 * chunk(s) acknowledged, and 2) the destination's path MTU.
394 */
395 if (bytes_acked > pmtu)
396 cwnd += pmtu;
397 else
398 cwnd += bytes_acked;
399 SCTP_DEBUG_PRINTK("%s: SLOW START: transport: %p, "
400 "bytes_acked: %d, cwnd: %d, ssthresh: %d, "
401 "flight_size: %d, pba: %d\n",
402 __FUNCTION__,
403 transport, bytes_acked, cwnd,
404 ssthresh, flight_size, pba);
405 } else {
406 /* RFC 2960 7.2.2 Whenever cwnd is greater than ssthresh,
407 * upon each SACK arrival that advances the Cumulative TSN Ack
408 * Point, increase partial_bytes_acked by the total number of
409 * bytes of all new chunks acknowledged in that SACK including
410 * chunks acknowledged by the new Cumulative TSN Ack and by
411 * Gap Ack Blocks.
412 *
413 * When partial_bytes_acked is equal to or greater than cwnd
414 * and before the arrival of the SACK the sender had cwnd or
415 * more bytes of data outstanding (i.e., before arrival of the
416 * SACK, flightsize was greater than or equal to cwnd),
417 * increase cwnd by MTU, and reset partial_bytes_acked to
418 * (partial_bytes_acked - cwnd).
419 */
420 pba += bytes_acked;
421 if (pba >= cwnd) {
422 cwnd += pmtu;
423 pba = ((cwnd < pba) ? (pba - cwnd) : 0);
424 }
425 SCTP_DEBUG_PRINTK("%s: CONGESTION AVOIDANCE: "
426 "transport: %p, bytes_acked: %d, cwnd: %d, "
427 "ssthresh: %d, flight_size: %d, pba: %d\n",
428 __FUNCTION__,
429 transport, bytes_acked, cwnd,
430 ssthresh, flight_size, pba);
431 }
433 transport->cwnd = cwnd;
434 transport->partial_bytes_acked = pba;
435 }
437 /* This routine is used to lower the transport's cwnd when congestion is
438 * detected.
439 */
440 void sctp_transport_lower_cwnd(struct sctp_transport *transport,
441 sctp_lower_cwnd_t reason)
442 {
443 switch (reason) {
444 case SCTP_LOWER_CWND_T3_RTX:
445 /* RFC 2960 Section 7.2.3, sctpimpguide
446 * When the T3-rtx timer expires on an address, SCTP should
447 * perform slow start by:
448 * ssthresh = max(cwnd/2, 4*MTU)
449 * cwnd = 1*MTU
450 * partial_bytes_acked = 0
451 */
452 transport->ssthresh = max(transport->cwnd/2,
453 4*transport->asoc->pathmtu);
454 transport->cwnd = transport->asoc->pathmtu;
455 break;
457 case SCTP_LOWER_CWND_FAST_RTX:
458 /* RFC 2960 7.2.4 Adjust the ssthresh and cwnd of the
459 * destination address(es) to which the missing DATA chunks
460 * were last sent, according to the formula described in
461 * Section 7.2.3.
462 *
463 * RFC 2960 7.2.3, sctpimpguide Upon detection of packet
464 * losses from SACK (see Section 7.2.4), An endpoint
465 * should do the following:
466 * ssthresh = max(cwnd/2, 4*MTU)
467 * cwnd = ssthresh
468 * partial_bytes_acked = 0
469 */
470 transport->ssthresh = max(transport->cwnd/2,
471 4*transport->asoc->pathmtu);
472 transport->cwnd = transport->ssthresh;
473 break;
475 case SCTP_LOWER_CWND_ECNE:
476 /* RFC 2481 Section 6.1.2.
477 * If the sender receives an ECN-Echo ACK packet
478 * then the sender knows that congestion was encountered in the
479 * network on the path from the sender to the receiver. The
480 * indication of congestion should be treated just as a
481 * congestion loss in non-ECN Capable TCP. That is, the TCP
482 * source halves the congestion window "cwnd" and reduces the
483 * slow start threshold "ssthresh".
484 * A critical condition is that TCP does not react to
485 * congestion indications more than once every window of
486 * data (or more loosely more than once every round-trip time).
487 */
488 if ((jiffies - transport->last_time_ecne_reduced) >
489 transport->rtt) {
490 transport->ssthresh = max(transport->cwnd/2,
491 4*transport->asoc->pathmtu);
492 transport->cwnd = transport->ssthresh;
493 transport->last_time_ecne_reduced = jiffies;
494 }
495 break;
497 case SCTP_LOWER_CWND_INACTIVE:
498 /* RFC 2960 Section 7.2.1, sctpimpguide
499 * When the endpoint does not transmit data on a given
500 * transport address, the cwnd of the transport address
501 * should be adjusted to max(cwnd/2, 4*MTU) per RTO.
502 * NOTE: Although the draft recommends that this check needs
503 * to be done every RTO interval, we do it every hearbeat
504 * interval.
505 */
506 if ((jiffies - transport->last_time_used) > transport->rto)
507 transport->cwnd = max(transport->cwnd/2,
508 4*transport->asoc->pathmtu);
509 break;
510 };
512 transport->partial_bytes_acked = 0;
513 SCTP_DEBUG_PRINTK("%s: transport: %p reason: %d cwnd: "
514 "%d ssthresh: %d\n", __FUNCTION__,
515 transport, reason,
516 transport->cwnd, transport->ssthresh);
517 }
519 /* What is the next timeout value for this transport? */
520 unsigned long sctp_transport_timeout(struct sctp_transport *t)
521 {
522 unsigned long timeout;
523 timeout = t->rto + sctp_jitter(t->rto);
524 if (t->state != SCTP_UNCONFIRMED)
525 timeout += t->hbinterval;
526 timeout += jiffies;
527 return timeout;
528 }