1 /* Management of Tx window, Tx resend, ACKs and out-of-sequence reception
3 * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
4 * Written by David Howells (dhowells@redhat.com)
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.
12 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
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>
21 #include <net/af_rxrpc.h>
22 #include "ar-internal.h"
27 static void rxrpc_set_timer(struct rxrpc_call
*call
)
29 unsigned long t
, now
= jiffies
;
31 _enter("{%ld,%ld,%ld:%ld}",
32 call
->ack_at
- now
, call
->resend_at
- now
, call
->expire_at
- now
,
33 call
->timer
.expires
- now
);
35 read_lock_bh(&call
->state_lock
);
37 if (call
->state
< RXRPC_CALL_COMPLETE
) {
39 if (time_before(call
->resend_at
, t
))
41 if (time_before(call
->expire_at
, t
))
43 if (!timer_pending(&call
->timer
) ||
44 time_before(t
, call
->timer
.expires
)) {
45 _debug("set timer %ld", t
- now
);
46 mod_timer(&call
->timer
, t
);
49 read_unlock_bh(&call
->state_lock
);
53 * propose an ACK be sent
55 static void __rxrpc_propose_ACK(struct rxrpc_call
*call
, u8 ack_reason
,
56 u16 skew
, u32 serial
, bool immediate
,
59 unsigned long now
, ack_at
, expiry
= rxrpc_soft_ack_delay
;
60 s8 prior
= rxrpc_ack_priority
[ack_reason
];
62 _enter("{%d},%s,%%%x,%u",
63 call
->debug_id
, rxrpc_acks(ack_reason
), serial
, immediate
);
65 /* Update DELAY, IDLE, REQUESTED and PING_RESPONSE ACK serial
66 * numbers, but we don't alter the timeout.
68 _debug("prior %u %u vs %u %u",
70 call
->ackr_reason
, rxrpc_ack_priority
[call
->ackr_reason
]);
71 if (ack_reason
== call
->ackr_reason
) {
72 if (RXRPC_ACK_UPDATEABLE
& (1 << ack_reason
)) {
73 call
->ackr_serial
= serial
;
74 call
->ackr_skew
= skew
;
78 } else if (prior
> rxrpc_ack_priority
[call
->ackr_reason
]) {
79 call
->ackr_reason
= ack_reason
;
80 call
->ackr_serial
= serial
;
81 call
->ackr_skew
= skew
;
85 case RXRPC_ACK_REQUESTED
:
86 if (rxrpc_requested_ack_delay
< expiry
)
87 expiry
= rxrpc_requested_ack_delay
;
93 if (rxrpc_soft_ack_delay
< expiry
)
94 expiry
= rxrpc_soft_ack_delay
;
98 if (rxrpc_idle_ack_delay
< expiry
)
99 expiry
= rxrpc_idle_ack_delay
;
108 if (test_bit(RXRPC_CALL_EV_ACK
, &call
->events
)) {
109 _debug("already scheduled");
110 } else if (immediate
|| expiry
== 0) {
111 _debug("immediate ACK %lx", call
->events
);
112 if (!test_and_set_bit(RXRPC_CALL_EV_ACK
, &call
->events
) &&
114 rxrpc_queue_call(call
);
116 ack_at
= now
+ expiry
;
117 _debug("deferred ACK %ld < %ld", expiry
, call
->ack_at
- now
);
118 if (time_before(ack_at
, call
->ack_at
)) {
119 call
->ack_at
= ack_at
;
120 rxrpc_set_timer(call
);
126 * propose an ACK be sent, locking the call structure
128 void rxrpc_propose_ACK(struct rxrpc_call
*call
, u8 ack_reason
,
129 u16 skew
, u32 serial
, bool immediate
, bool background
)
131 spin_lock_bh(&call
->lock
);
132 __rxrpc_propose_ACK(call
, ack_reason
, skew
, serial
,
133 immediate
, background
);
134 spin_unlock_bh(&call
->lock
);
138 * Perform retransmission of NAK'd and unack'd packets.
140 static void rxrpc_resend(struct rxrpc_call
*call
)
142 struct rxrpc_wire_header
*whdr
;
143 struct rxrpc_skb_priv
*sp
;
145 rxrpc_seq_t cursor
, seq
, top
;
146 unsigned long resend_at
, now
;
150 _enter("{%d,%d}", call
->tx_hard_ack
, call
->tx_top
);
152 spin_lock_bh(&call
->lock
);
154 cursor
= call
->tx_hard_ack
;
156 ASSERT(before_eq(cursor
, top
));
160 /* Scan the packet list without dropping the lock and decide which of
161 * the packets in the Tx buffer we're going to resend and what the new
162 * resend timeout will be.
165 resend_at
= now
+ rxrpc_resend_timeout
;
168 ix
= seq
& RXRPC_RXTX_BUFF_MASK
;
169 annotation
= call
->rxtx_annotations
[ix
];
170 if (annotation
== RXRPC_TX_ANNO_ACK
)
173 skb
= call
->rxtx_buffer
[ix
];
177 if (annotation
== RXRPC_TX_ANNO_UNACK
) {
178 if (time_after(sp
->resend_at
, now
)) {
179 if (time_before(sp
->resend_at
, resend_at
))
180 resend_at
= sp
->resend_at
;
185 /* Okay, we need to retransmit a packet. */
186 call
->rxtx_annotations
[ix
] = RXRPC_TX_ANNO_RETRANS
;
188 } while (before_eq(seq
, top
));
190 call
->resend_at
= resend_at
;
192 /* Now go through the Tx window and perform the retransmissions. We
193 * have to drop the lock for each send. If an ACK comes in whilst the
194 * lock is dropped, it may clear some of the retransmission markers for
195 * packets that it soft-ACKs.
199 ix
= seq
& RXRPC_RXTX_BUFF_MASK
;
200 annotation
= call
->rxtx_annotations
[ix
];
201 if (annotation
!= RXRPC_TX_ANNO_RETRANS
)
204 skb
= call
->rxtx_buffer
[ix
];
206 spin_unlock_bh(&call
->lock
);
209 /* Each Tx packet needs a new serial number */
210 sp
->hdr
.serial
= atomic_inc_return(&call
->conn
->serial
);
212 whdr
= (struct rxrpc_wire_header
*)skb
->head
;
213 whdr
->serial
= htonl(sp
->hdr
.serial
);
215 if (rxrpc_send_data_packet(call
->conn
, skb
) < 0) {
216 call
->resend_at
= now
+ 2;
221 if (rxrpc_is_client_call(call
))
222 rxrpc_expose_client_call(call
);
223 sp
->resend_at
= now
+ rxrpc_resend_timeout
;
226 spin_lock_bh(&call
->lock
);
228 /* We need to clear the retransmit state, but there are two
229 * things we need to be aware of: A new ACK/NAK might have been
230 * received and the packet might have been hard-ACK'd (in which
231 * case it will no longer be in the buffer).
233 if (after(seq
, call
->tx_hard_ack
) &&
234 (call
->rxtx_annotations
[ix
] == RXRPC_TX_ANNO_RETRANS
||
235 call
->rxtx_annotations
[ix
] == RXRPC_TX_ANNO_NAK
))
236 call
->rxtx_annotations
[ix
] = RXRPC_TX_ANNO_UNACK
;
238 if (after(call
->tx_hard_ack
, seq
))
239 seq
= call
->tx_hard_ack
;
241 } while (before_eq(seq
, top
));
244 spin_unlock_bh(&call
->lock
);
249 * Handle retransmission and deferred ACK/abort generation.
251 void rxrpc_process_call(struct work_struct
*work
)
253 struct rxrpc_call
*call
=
254 container_of(work
, struct rxrpc_call
, processor
);
257 rxrpc_see_call(call
);
259 //printk("\n--------------------\n");
260 _enter("{%d,%s,%lx}",
261 call
->debug_id
, rxrpc_call_states
[call
->state
], call
->events
);
264 if (test_and_clear_bit(RXRPC_CALL_EV_ABORT
, &call
->events
)) {
265 rxrpc_send_call_packet(call
, RXRPC_PACKET_TYPE_ABORT
);
269 if (call
->state
== RXRPC_CALL_COMPLETE
) {
270 del_timer_sync(&call
->timer
);
275 if (time_after_eq(now
, call
->expire_at
)) {
276 rxrpc_abort_call("EXP", call
, 0, RX_CALL_TIMEOUT
, ETIME
);
277 set_bit(RXRPC_CALL_EV_ABORT
, &call
->events
);
280 if (test_and_clear_bit(RXRPC_CALL_EV_ACK
, &call
->events
) ||
281 time_after_eq(now
, call
->ack_at
)) {
282 call
->ack_at
= call
->expire_at
;
283 if (call
->ackr_reason
) {
284 rxrpc_send_call_packet(call
, RXRPC_PACKET_TYPE_ACK
);
289 if (test_and_clear_bit(RXRPC_CALL_EV_RESEND
, &call
->events
) ||
290 time_after_eq(now
, call
->resend_at
)) {
295 rxrpc_set_timer(call
);
297 /* other events may have been raised since we started checking */
298 if (call
->events
&& call
->state
< RXRPC_CALL_COMPLETE
) {
299 __rxrpc_queue_call(call
);
304 rxrpc_put_call(call
, rxrpc_call_put
);