ia64/linux-2.6.18-xen.hg

view net/dccp/timer.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 /*
2 * net/dccp/timer.c
3 *
4 * An implementation of the DCCP protocol
5 * Arnaldo Carvalho de Melo <acme@conectiva.com.br>
6 *
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation; either version
10 * 2 of the License, or (at your option) any later version.
11 */
13 #include <linux/dccp.h>
14 #include <linux/skbuff.h>
16 #include "dccp.h"
18 static void dccp_write_timer(unsigned long data);
19 static void dccp_keepalive_timer(unsigned long data);
20 static void dccp_delack_timer(unsigned long data);
22 void dccp_init_xmit_timers(struct sock *sk)
23 {
24 inet_csk_init_xmit_timers(sk, &dccp_write_timer, &dccp_delack_timer,
25 &dccp_keepalive_timer);
26 }
28 static void dccp_write_err(struct sock *sk)
29 {
30 sk->sk_err = sk->sk_err_soft ? : ETIMEDOUT;
31 sk->sk_error_report(sk);
33 dccp_send_reset(sk, DCCP_RESET_CODE_ABORTED);
34 dccp_done(sk);
35 DCCP_INC_STATS_BH(DCCP_MIB_ABORTONTIMEOUT);
36 }
38 /* A write timeout has occurred. Process the after effects. */
39 static int dccp_write_timeout(struct sock *sk)
40 {
41 const struct inet_connection_sock *icsk = inet_csk(sk);
42 int retry_until;
44 if (sk->sk_state == DCCP_REQUESTING || sk->sk_state == DCCP_PARTOPEN) {
45 if (icsk->icsk_retransmits != 0)
46 dst_negative_advice(&sk->sk_dst_cache);
47 retry_until = icsk->icsk_syn_retries ? :
48 /* FIXME! */ 3 /* FIXME! sysctl_tcp_syn_retries */;
49 } else {
50 if (icsk->icsk_retransmits >=
51 /* FIXME! sysctl_tcp_retries1 */ 5 /* FIXME! */) {
52 /* NOTE. draft-ietf-tcpimpl-pmtud-01.txt requires pmtu
53 black hole detection. :-(
55 It is place to make it. It is not made. I do not want
56 to make it. It is disguisting. It does not work in any
57 case. Let me to cite the same draft, which requires for
58 us to implement this:
60 "The one security concern raised by this memo is that ICMP black holes
61 are often caused by over-zealous security administrators who block
62 all ICMP messages. It is vitally important that those who design and
63 deploy security systems understand the impact of strict filtering on
64 upper-layer protocols. The safest web site in the world is worthless
65 if most TCP implementations cannot transfer data from it. It would
66 be far nicer to have all of the black holes fixed rather than fixing
67 all of the TCP implementations."
69 Golden words :-).
70 */
72 dst_negative_advice(&sk->sk_dst_cache);
73 }
75 retry_until = /* FIXME! */ 15 /* FIXME! sysctl_tcp_retries2 */;
76 /*
77 * FIXME: see tcp_write_timout and tcp_out_of_resources
78 */
79 }
81 if (icsk->icsk_retransmits >= retry_until) {
82 /* Has it gone just too far? */
83 dccp_write_err(sk);
84 return 1;
85 }
86 return 0;
87 }
89 /* This is the same as tcp_delack_timer, sans prequeue & mem_reclaim stuff */
90 static void dccp_delack_timer(unsigned long data)
91 {
92 struct sock *sk = (struct sock *)data;
93 struct inet_connection_sock *icsk = inet_csk(sk);
95 bh_lock_sock(sk);
96 if (sock_owned_by_user(sk)) {
97 /* Try again later. */
98 icsk->icsk_ack.blocked = 1;
99 NET_INC_STATS_BH(LINUX_MIB_DELAYEDACKLOCKED);
100 sk_reset_timer(sk, &icsk->icsk_delack_timer,
101 jiffies + TCP_DELACK_MIN);
102 goto out;
103 }
105 if (sk->sk_state == DCCP_CLOSED ||
106 !(icsk->icsk_ack.pending & ICSK_ACK_TIMER))
107 goto out;
108 if (time_after(icsk->icsk_ack.timeout, jiffies)) {
109 sk_reset_timer(sk, &icsk->icsk_delack_timer,
110 icsk->icsk_ack.timeout);
111 goto out;
112 }
114 icsk->icsk_ack.pending &= ~ICSK_ACK_TIMER;
116 if (inet_csk_ack_scheduled(sk)) {
117 if (!icsk->icsk_ack.pingpong) {
118 /* Delayed ACK missed: inflate ATO. */
119 icsk->icsk_ack.ato = min(icsk->icsk_ack.ato << 1,
120 icsk->icsk_rto);
121 } else {
122 /* Delayed ACK missed: leave pingpong mode and
123 * deflate ATO.
124 */
125 icsk->icsk_ack.pingpong = 0;
126 icsk->icsk_ack.ato = TCP_ATO_MIN;
127 }
128 dccp_send_ack(sk);
129 NET_INC_STATS_BH(LINUX_MIB_DELAYEDACKS);
130 }
131 out:
132 bh_unlock_sock(sk);
133 sock_put(sk);
134 }
136 /*
137 * The DCCP retransmit timer.
138 */
139 static void dccp_retransmit_timer(struct sock *sk)
140 {
141 struct inet_connection_sock *icsk = inet_csk(sk);
143 /* retransmit timer is used for feature negotiation throughout
144 * connection. In this case, no packet is re-transmitted, but rather an
145 * ack is generated and pending changes are splaced into its options.
146 */
147 if (sk->sk_send_head == NULL) {
148 dccp_pr_debug("feat negotiation retransmit timeout %p\n", sk);
149 if (sk->sk_state == DCCP_OPEN)
150 dccp_send_ack(sk);
151 goto backoff;
152 }
154 /*
155 * sk->sk_send_head has to have one skb with
156 * DCCP_SKB_CB(skb)->dccpd_type set to one of the retransmittable DCCP
157 * packet types (REQUEST, RESPONSE, the ACK in the 3way handshake
158 * (PARTOPEN timer), etc).
159 */
160 BUG_TRAP(sk->sk_send_head != NULL);
162 /*
163 * More than than 4MSL (8 minutes) has passed, a RESET(aborted) was
164 * sent, no need to retransmit, this sock is dead.
165 */
166 if (dccp_write_timeout(sk))
167 goto out;
169 /*
170 * We want to know the number of packets retransmitted, not the
171 * total number of retransmissions of clones of original packets.
172 */
173 if (icsk->icsk_retransmits == 0)
174 DCCP_INC_STATS_BH(DCCP_MIB_TIMEOUTS);
176 if (dccp_retransmit_skb(sk, sk->sk_send_head) < 0) {
177 /*
178 * Retransmission failed because of local congestion,
179 * do not backoff.
180 */
181 if (icsk->icsk_retransmits == 0)
182 icsk->icsk_retransmits = 1;
183 inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS,
184 min(icsk->icsk_rto,
185 TCP_RESOURCE_PROBE_INTERVAL),
186 DCCP_RTO_MAX);
187 goto out;
188 }
190 backoff:
191 icsk->icsk_backoff++;
192 icsk->icsk_retransmits++;
194 icsk->icsk_rto = min(icsk->icsk_rto << 1, DCCP_RTO_MAX);
195 inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS, icsk->icsk_rto,
196 DCCP_RTO_MAX);
197 if (icsk->icsk_retransmits > 3 /* FIXME: sysctl_dccp_retries1 */)
198 __sk_dst_reset(sk);
199 out:;
200 }
202 static void dccp_write_timer(unsigned long data)
203 {
204 struct sock *sk = (struct sock *)data;
205 struct inet_connection_sock *icsk = inet_csk(sk);
206 int event = 0;
208 bh_lock_sock(sk);
209 if (sock_owned_by_user(sk)) {
210 /* Try again later */
211 sk_reset_timer(sk, &icsk->icsk_retransmit_timer,
212 jiffies + (HZ / 20));
213 goto out;
214 }
216 if (sk->sk_state == DCCP_CLOSED || !icsk->icsk_pending)
217 goto out;
219 if (time_after(icsk->icsk_timeout, jiffies)) {
220 sk_reset_timer(sk, &icsk->icsk_retransmit_timer,
221 icsk->icsk_timeout);
222 goto out;
223 }
225 event = icsk->icsk_pending;
226 icsk->icsk_pending = 0;
228 switch (event) {
229 case ICSK_TIME_RETRANS:
230 dccp_retransmit_timer(sk);
231 break;
232 }
233 out:
234 bh_unlock_sock(sk);
235 sock_put(sk);
236 }
238 /*
239 * Timer for listening sockets
240 */
241 static void dccp_response_timer(struct sock *sk)
242 {
243 inet_csk_reqsk_queue_prune(sk, TCP_SYNQ_INTERVAL, DCCP_TIMEOUT_INIT,
244 DCCP_RTO_MAX);
245 }
247 static void dccp_keepalive_timer(unsigned long data)
248 {
249 struct sock *sk = (struct sock *)data;
251 /* Only process if socket is not in use. */
252 bh_lock_sock(sk);
253 if (sock_owned_by_user(sk)) {
254 /* Try again later. */
255 inet_csk_reset_keepalive_timer(sk, HZ / 20);
256 goto out;
257 }
259 if (sk->sk_state == DCCP_LISTEN) {
260 dccp_response_timer(sk);
261 goto out;
262 }
263 out:
264 bh_unlock_sock(sk);
265 sock_put(sk);
266 }