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