]>
Commit | Line | Data |
---|---|---|
1 | /* Management of Tx window, Tx resend, ACKs and out-of-sequence reception | |
2 | * | |
3 | * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved. | |
4 | * Written by David Howells (dhowells@redhat.com) | |
5 | * | |
6 | * This program is free software; you can redistribute it and/or | |
7 | * modify it under the terms of the GNU General Public License | |
8 | * as published by the Free Software Foundation; either version | |
9 | * 2 of the License, or (at your option) any later version. | |
10 | */ | |
11 | ||
12 | #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt | |
13 | ||
14 | #include <linux/module.h> | |
15 | #include <linux/circ_buf.h> | |
16 | #include <linux/net.h> | |
17 | #include <linux/skbuff.h> | |
18 | #include <linux/slab.h> | |
19 | #include <linux/udp.h> | |
20 | #include <net/sock.h> | |
21 | #include <net/af_rxrpc.h> | |
22 | #include "ar-internal.h" | |
23 | ||
24 | /* | |
25 | * Propose a PING ACK be sent. | |
26 | */ | |
27 | static void rxrpc_propose_ping(struct rxrpc_call *call, | |
28 | bool immediate, bool background) | |
29 | { | |
30 | if (immediate) { | |
31 | if (background && | |
32 | !test_and_set_bit(RXRPC_CALL_EV_PING, &call->events)) | |
33 | rxrpc_queue_call(call); | |
34 | } else { | |
35 | unsigned long now = jiffies; | |
36 | unsigned long ping_at = now + rxrpc_idle_ack_delay; | |
37 | ||
38 | if (time_before(ping_at, call->ping_at)) { | |
39 | WRITE_ONCE(call->ping_at, ping_at); | |
40 | rxrpc_reduce_call_timer(call, ping_at, now, | |
41 | rxrpc_timer_set_for_ping); | |
42 | } | |
43 | } | |
44 | } | |
45 | ||
46 | /* | |
47 | * propose an ACK be sent | |
48 | */ | |
49 | static void __rxrpc_propose_ACK(struct rxrpc_call *call, u8 ack_reason, | |
50 | u16 skew, u32 serial, bool immediate, | |
51 | bool background, | |
52 | enum rxrpc_propose_ack_trace why) | |
53 | { | |
54 | enum rxrpc_propose_ack_outcome outcome = rxrpc_propose_ack_use; | |
55 | unsigned long expiry = rxrpc_soft_ack_delay; | |
56 | s8 prior = rxrpc_ack_priority[ack_reason]; | |
57 | ||
58 | /* Pings are handled specially because we don't want to accidentally | |
59 | * lose a ping response by subsuming it into a ping. | |
60 | */ | |
61 | if (ack_reason == RXRPC_ACK_PING) { | |
62 | rxrpc_propose_ping(call, immediate, background); | |
63 | goto trace; | |
64 | } | |
65 | ||
66 | /* Update DELAY, IDLE, REQUESTED and PING_RESPONSE ACK serial | |
67 | * numbers, but we don't alter the timeout. | |
68 | */ | |
69 | _debug("prior %u %u vs %u %u", | |
70 | ack_reason, prior, | |
71 | call->ackr_reason, rxrpc_ack_priority[call->ackr_reason]); | |
72 | if (ack_reason == call->ackr_reason) { | |
73 | if (RXRPC_ACK_UPDATEABLE & (1 << ack_reason)) { | |
74 | outcome = rxrpc_propose_ack_update; | |
75 | call->ackr_serial = serial; | |
76 | call->ackr_skew = skew; | |
77 | } | |
78 | if (!immediate) | |
79 | goto trace; | |
80 | } else if (prior > rxrpc_ack_priority[call->ackr_reason]) { | |
81 | call->ackr_reason = ack_reason; | |
82 | call->ackr_serial = serial; | |
83 | call->ackr_skew = skew; | |
84 | } else { | |
85 | outcome = rxrpc_propose_ack_subsume; | |
86 | } | |
87 | ||
88 | switch (ack_reason) { | |
89 | case RXRPC_ACK_REQUESTED: | |
90 | if (rxrpc_requested_ack_delay < expiry) | |
91 | expiry = rxrpc_requested_ack_delay; | |
92 | if (serial == 1) | |
93 | immediate = false; | |
94 | break; | |
95 | ||
96 | case RXRPC_ACK_DELAY: | |
97 | if (rxrpc_soft_ack_delay < expiry) | |
98 | expiry = rxrpc_soft_ack_delay; | |
99 | break; | |
100 | ||
101 | case RXRPC_ACK_IDLE: | |
102 | if (rxrpc_idle_ack_delay < expiry) | |
103 | expiry = rxrpc_idle_ack_delay; | |
104 | break; | |
105 | ||
106 | default: | |
107 | immediate = true; | |
108 | break; | |
109 | } | |
110 | ||
111 | if (test_bit(RXRPC_CALL_EV_ACK, &call->events)) { | |
112 | _debug("already scheduled"); | |
113 | } else if (immediate || expiry == 0) { | |
114 | _debug("immediate ACK %lx", call->events); | |
115 | if (!test_and_set_bit(RXRPC_CALL_EV_ACK, &call->events) && | |
116 | background) | |
117 | rxrpc_queue_call(call); | |
118 | } else { | |
119 | unsigned long now = jiffies, ack_at; | |
120 | ||
121 | if (call->peer->rtt_usage > 0) | |
122 | ack_at = nsecs_to_jiffies(call->peer->rtt); | |
123 | else | |
124 | ack_at = expiry; | |
125 | ||
126 | ack_at += READ_ONCE(call->tx_backoff); | |
127 | ack_at += now; | |
128 | if (time_before(ack_at, call->ack_at)) { | |
129 | WRITE_ONCE(call->ack_at, ack_at); | |
130 | rxrpc_reduce_call_timer(call, ack_at, now, | |
131 | rxrpc_timer_set_for_ack); | |
132 | } | |
133 | } | |
134 | ||
135 | trace: | |
136 | trace_rxrpc_propose_ack(call, why, ack_reason, serial, immediate, | |
137 | background, outcome); | |
138 | } | |
139 | ||
140 | /* | |
141 | * propose an ACK be sent, locking the call structure | |
142 | */ | |
143 | void rxrpc_propose_ACK(struct rxrpc_call *call, u8 ack_reason, | |
144 | u16 skew, u32 serial, bool immediate, bool background, | |
145 | enum rxrpc_propose_ack_trace why) | |
146 | { | |
147 | spin_lock_bh(&call->lock); | |
148 | __rxrpc_propose_ACK(call, ack_reason, skew, serial, | |
149 | immediate, background, why); | |
150 | spin_unlock_bh(&call->lock); | |
151 | } | |
152 | ||
153 | /* | |
154 | * Handle congestion being detected by the retransmit timeout. | |
155 | */ | |
156 | static void rxrpc_congestion_timeout(struct rxrpc_call *call) | |
157 | { | |
158 | set_bit(RXRPC_CALL_RETRANS_TIMEOUT, &call->flags); | |
159 | } | |
160 | ||
161 | /* | |
162 | * Perform retransmission of NAK'd and unack'd packets. | |
163 | */ | |
164 | static void rxrpc_resend(struct rxrpc_call *call, unsigned long now_j) | |
165 | { | |
166 | struct rxrpc_skb_priv *sp; | |
167 | struct sk_buff *skb; | |
168 | unsigned long resend_at; | |
169 | rxrpc_seq_t cursor, seq, top; | |
170 | ktime_t now, max_age, oldest, ack_ts, timeout, min_timeo; | |
171 | int ix; | |
172 | u8 annotation, anno_type, retrans = 0, unacked = 0; | |
173 | ||
174 | _enter("{%d,%d}", call->tx_hard_ack, call->tx_top); | |
175 | ||
176 | if (call->peer->rtt_usage > 1) | |
177 | timeout = ns_to_ktime(call->peer->rtt * 3 / 2); | |
178 | else | |
179 | timeout = ms_to_ktime(rxrpc_resend_timeout); | |
180 | min_timeo = ns_to_ktime((1000000000 / HZ) * 4); | |
181 | if (ktime_before(timeout, min_timeo)) | |
182 | timeout = min_timeo; | |
183 | ||
184 | now = ktime_get_real(); | |
185 | max_age = ktime_sub(now, timeout); | |
186 | ||
187 | spin_lock_bh(&call->lock); | |
188 | ||
189 | cursor = call->tx_hard_ack; | |
190 | top = call->tx_top; | |
191 | ASSERT(before_eq(cursor, top)); | |
192 | if (cursor == top) | |
193 | goto out_unlock; | |
194 | ||
195 | /* Scan the packet list without dropping the lock and decide which of | |
196 | * the packets in the Tx buffer we're going to resend and what the new | |
197 | * resend timeout will be. | |
198 | */ | |
199 | oldest = now; | |
200 | for (seq = cursor + 1; before_eq(seq, top); seq++) { | |
201 | ix = seq & RXRPC_RXTX_BUFF_MASK; | |
202 | annotation = call->rxtx_annotations[ix]; | |
203 | anno_type = annotation & RXRPC_TX_ANNO_MASK; | |
204 | annotation &= ~RXRPC_TX_ANNO_MASK; | |
205 | if (anno_type == RXRPC_TX_ANNO_ACK) | |
206 | continue; | |
207 | ||
208 | skb = call->rxtx_buffer[ix]; | |
209 | rxrpc_see_skb(skb, rxrpc_skb_tx_seen); | |
210 | sp = rxrpc_skb(skb); | |
211 | ||
212 | if (anno_type == RXRPC_TX_ANNO_UNACK) { | |
213 | if (ktime_after(skb->tstamp, max_age)) { | |
214 | if (ktime_before(skb->tstamp, oldest)) | |
215 | oldest = skb->tstamp; | |
216 | continue; | |
217 | } | |
218 | if (!(annotation & RXRPC_TX_ANNO_RESENT)) | |
219 | unacked++; | |
220 | } | |
221 | ||
222 | /* Okay, we need to retransmit a packet. */ | |
223 | call->rxtx_annotations[ix] = RXRPC_TX_ANNO_RETRANS | annotation; | |
224 | retrans++; | |
225 | trace_rxrpc_retransmit(call, seq, annotation | anno_type, | |
226 | ktime_to_ns(ktime_sub(skb->tstamp, max_age))); | |
227 | } | |
228 | ||
229 | resend_at = nsecs_to_jiffies(ktime_to_ns(ktime_sub(now, oldest))); | |
230 | resend_at += jiffies + rxrpc_resend_timeout; | |
231 | WRITE_ONCE(call->resend_at, resend_at); | |
232 | ||
233 | if (unacked) | |
234 | rxrpc_congestion_timeout(call); | |
235 | ||
236 | /* If there was nothing that needed retransmission then it's likely | |
237 | * that an ACK got lost somewhere. Send a ping to find out instead of | |
238 | * retransmitting data. | |
239 | */ | |
240 | if (!retrans) { | |
241 | rxrpc_reduce_call_timer(call, resend_at, now, | |
242 | rxrpc_timer_set_for_resend); | |
243 | spin_unlock_bh(&call->lock); | |
244 | ack_ts = ktime_sub(now, call->acks_latest_ts); | |
245 | if (ktime_to_ns(ack_ts) < call->peer->rtt) | |
246 | goto out; | |
247 | rxrpc_propose_ACK(call, RXRPC_ACK_PING, 0, 0, true, false, | |
248 | rxrpc_propose_ack_ping_for_lost_ack); | |
249 | rxrpc_send_ack_packet(call, true, NULL); | |
250 | goto out; | |
251 | } | |
252 | ||
253 | /* Now go through the Tx window and perform the retransmissions. We | |
254 | * have to drop the lock for each send. If an ACK comes in whilst the | |
255 | * lock is dropped, it may clear some of the retransmission markers for | |
256 | * packets that it soft-ACKs. | |
257 | */ | |
258 | for (seq = cursor + 1; before_eq(seq, top); seq++) { | |
259 | ix = seq & RXRPC_RXTX_BUFF_MASK; | |
260 | annotation = call->rxtx_annotations[ix]; | |
261 | anno_type = annotation & RXRPC_TX_ANNO_MASK; | |
262 | if (anno_type != RXRPC_TX_ANNO_RETRANS) | |
263 | continue; | |
264 | ||
265 | skb = call->rxtx_buffer[ix]; | |
266 | rxrpc_get_skb(skb, rxrpc_skb_tx_got); | |
267 | spin_unlock_bh(&call->lock); | |
268 | ||
269 | if (rxrpc_send_data_packet(call, skb, true) < 0) { | |
270 | rxrpc_free_skb(skb, rxrpc_skb_tx_freed); | |
271 | return; | |
272 | } | |
273 | ||
274 | if (rxrpc_is_client_call(call)) | |
275 | rxrpc_expose_client_call(call); | |
276 | ||
277 | rxrpc_free_skb(skb, rxrpc_skb_tx_freed); | |
278 | spin_lock_bh(&call->lock); | |
279 | ||
280 | /* We need to clear the retransmit state, but there are two | |
281 | * things we need to be aware of: A new ACK/NAK might have been | |
282 | * received and the packet might have been hard-ACK'd (in which | |
283 | * case it will no longer be in the buffer). | |
284 | */ | |
285 | if (after(seq, call->tx_hard_ack)) { | |
286 | annotation = call->rxtx_annotations[ix]; | |
287 | anno_type = annotation & RXRPC_TX_ANNO_MASK; | |
288 | if (anno_type == RXRPC_TX_ANNO_RETRANS || | |
289 | anno_type == RXRPC_TX_ANNO_NAK) { | |
290 | annotation &= ~RXRPC_TX_ANNO_MASK; | |
291 | annotation |= RXRPC_TX_ANNO_UNACK; | |
292 | } | |
293 | annotation |= RXRPC_TX_ANNO_RESENT; | |
294 | call->rxtx_annotations[ix] = annotation; | |
295 | } | |
296 | ||
297 | if (after(call->tx_hard_ack, seq)) | |
298 | seq = call->tx_hard_ack; | |
299 | } | |
300 | ||
301 | out_unlock: | |
302 | spin_unlock_bh(&call->lock); | |
303 | out: | |
304 | _leave(""); | |
305 | } | |
306 | ||
307 | /* | |
308 | * Handle retransmission and deferred ACK/abort generation. | |
309 | */ | |
310 | void rxrpc_process_call(struct work_struct *work) | |
311 | { | |
312 | struct rxrpc_call *call = | |
313 | container_of(work, struct rxrpc_call, processor); | |
314 | rxrpc_serial_t *send_ack; | |
315 | unsigned long now, next, t; | |
316 | unsigned int iterations = 0; | |
317 | ||
318 | rxrpc_see_call(call); | |
319 | ||
320 | //printk("\n--------------------\n"); | |
321 | _enter("{%d,%s,%lx}", | |
322 | call->debug_id, rxrpc_call_states[call->state], call->events); | |
323 | ||
324 | recheck_state: | |
325 | /* Limit the number of times we do this before returning to the manager */ | |
326 | iterations++; | |
327 | if (iterations > 5) | |
328 | goto requeue; | |
329 | ||
330 | if (test_and_clear_bit(RXRPC_CALL_EV_ABORT, &call->events)) { | |
331 | rxrpc_send_abort_packet(call); | |
332 | goto recheck_state; | |
333 | } | |
334 | ||
335 | if (call->state == RXRPC_CALL_COMPLETE) { | |
336 | del_timer_sync(&call->timer); | |
337 | rxrpc_notify_socket(call); | |
338 | goto out_put; | |
339 | } | |
340 | ||
341 | /* Work out if any timeouts tripped */ | |
342 | now = jiffies; | |
343 | t = READ_ONCE(call->expect_rx_by); | |
344 | if (time_after_eq(now, t)) { | |
345 | trace_rxrpc_timer(call, rxrpc_timer_exp_normal, now); | |
346 | set_bit(RXRPC_CALL_EV_EXPIRED, &call->events); | |
347 | } | |
348 | ||
349 | t = READ_ONCE(call->expect_req_by); | |
350 | if (call->state == RXRPC_CALL_SERVER_RECV_REQUEST && | |
351 | time_after_eq(now, t)) { | |
352 | trace_rxrpc_timer(call, rxrpc_timer_exp_idle, now); | |
353 | set_bit(RXRPC_CALL_EV_EXPIRED, &call->events); | |
354 | } | |
355 | ||
356 | t = READ_ONCE(call->expect_term_by); | |
357 | if (time_after_eq(now, t)) { | |
358 | trace_rxrpc_timer(call, rxrpc_timer_exp_hard, now); | |
359 | set_bit(RXRPC_CALL_EV_EXPIRED, &call->events); | |
360 | } | |
361 | ||
362 | t = READ_ONCE(call->ack_at); | |
363 | if (time_after_eq(now, t)) { | |
364 | trace_rxrpc_timer(call, rxrpc_timer_exp_ack, now); | |
365 | cmpxchg(&call->ack_at, t, now + MAX_JIFFY_OFFSET); | |
366 | set_bit(RXRPC_CALL_EV_ACK, &call->events); | |
367 | } | |
368 | ||
369 | t = READ_ONCE(call->ack_lost_at); | |
370 | if (time_after_eq(now, t)) { | |
371 | trace_rxrpc_timer(call, rxrpc_timer_exp_lost_ack, now); | |
372 | cmpxchg(&call->ack_lost_at, t, now + MAX_JIFFY_OFFSET); | |
373 | set_bit(RXRPC_CALL_EV_ACK_LOST, &call->events); | |
374 | } | |
375 | ||
376 | t = READ_ONCE(call->keepalive_at); | |
377 | if (time_after_eq(now, t)) { | |
378 | trace_rxrpc_timer(call, rxrpc_timer_exp_keepalive, now); | |
379 | cmpxchg(&call->keepalive_at, t, now + MAX_JIFFY_OFFSET); | |
380 | rxrpc_propose_ACK(call, RXRPC_ACK_PING, 0, 0, true, true, | |
381 | rxrpc_propose_ack_ping_for_keepalive); | |
382 | set_bit(RXRPC_CALL_EV_PING, &call->events); | |
383 | } | |
384 | ||
385 | t = READ_ONCE(call->ping_at); | |
386 | if (time_after_eq(now, t)) { | |
387 | trace_rxrpc_timer(call, rxrpc_timer_exp_ping, now); | |
388 | cmpxchg(&call->ping_at, t, now + MAX_JIFFY_OFFSET); | |
389 | set_bit(RXRPC_CALL_EV_PING, &call->events); | |
390 | } | |
391 | ||
392 | t = READ_ONCE(call->resend_at); | |
393 | if (time_after_eq(now, t)) { | |
394 | trace_rxrpc_timer(call, rxrpc_timer_exp_resend, now); | |
395 | cmpxchg(&call->resend_at, t, now + MAX_JIFFY_OFFSET); | |
396 | set_bit(RXRPC_CALL_EV_RESEND, &call->events); | |
397 | } | |
398 | ||
399 | /* Process events */ | |
400 | if (test_and_clear_bit(RXRPC_CALL_EV_EXPIRED, &call->events)) { | |
401 | rxrpc_abort_call("EXP", call, 0, RX_USER_ABORT, -ETIME); | |
402 | set_bit(RXRPC_CALL_EV_ABORT, &call->events); | |
403 | goto recheck_state; | |
404 | } | |
405 | ||
406 | send_ack = NULL; | |
407 | if (test_and_clear_bit(RXRPC_CALL_EV_ACK_LOST, &call->events)) { | |
408 | call->acks_lost_top = call->tx_top; | |
409 | rxrpc_propose_ACK(call, RXRPC_ACK_PING, 0, 0, true, false, | |
410 | rxrpc_propose_ack_ping_for_lost_ack); | |
411 | send_ack = &call->acks_lost_ping; | |
412 | } | |
413 | ||
414 | if (test_and_clear_bit(RXRPC_CALL_EV_ACK, &call->events) || | |
415 | send_ack) { | |
416 | if (call->ackr_reason) { | |
417 | rxrpc_send_ack_packet(call, false, send_ack); | |
418 | goto recheck_state; | |
419 | } | |
420 | } | |
421 | ||
422 | if (test_and_clear_bit(RXRPC_CALL_EV_PING, &call->events)) { | |
423 | rxrpc_send_ack_packet(call, true, NULL); | |
424 | goto recheck_state; | |
425 | } | |
426 | ||
427 | if (test_and_clear_bit(RXRPC_CALL_EV_RESEND, &call->events)) { | |
428 | rxrpc_resend(call, now); | |
429 | goto recheck_state; | |
430 | } | |
431 | ||
432 | /* Make sure the timer is restarted */ | |
433 | next = call->expect_rx_by; | |
434 | ||
435 | #define set(T) { t = READ_ONCE(T); if (time_before(t, next)) next = t; } | |
436 | ||
437 | set(call->expect_req_by); | |
438 | set(call->expect_term_by); | |
439 | set(call->ack_at); | |
440 | set(call->ack_lost_at); | |
441 | set(call->resend_at); | |
442 | set(call->keepalive_at); | |
443 | set(call->ping_at); | |
444 | ||
445 | now = jiffies; | |
446 | if (time_after_eq(now, next)) | |
447 | goto recheck_state; | |
448 | ||
449 | rxrpc_reduce_call_timer(call, next, now, rxrpc_timer_restart); | |
450 | ||
451 | /* other events may have been raised since we started checking */ | |
452 | if (call->events && call->state < RXRPC_CALL_COMPLETE) | |
453 | goto requeue; | |
454 | ||
455 | out_put: | |
456 | rxrpc_put_call(call, rxrpc_call_put); | |
457 | out: | |
458 | _leave(""); | |
459 | return; | |
460 | ||
461 | requeue: | |
462 | __rxrpc_queue_call(call); | |
463 | goto out; | |
464 | } |