call_event.c 7.7 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11
/* Management of Tx window, Tx resend, ACKs and out-of-sequence reception
 *
 * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
 * Written by David Howells (dhowells@redhat.com)
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version
 * 2 of the License, or (at your option) any later version.
 */

12 13
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

14 15 16 17
#include <linux/module.h>
#include <linux/circ_buf.h>
#include <linux/net.h>
#include <linux/skbuff.h>
18
#include <linux/slab.h>
19 20 21 22 23 24
#include <linux/udp.h>
#include <net/sock.h>
#include <net/af_rxrpc.h>
#include "ar-internal.h"

/*
25
 * Set the timer
26
 */
27
static void rxrpc_set_timer(struct rxrpc_call *call)
28
{
29
	unsigned long t, now = jiffies;
30

31 32 33
	_enter("{%ld,%ld,%ld:%ld}",
	       call->ack_at - now, call->resend_at - now, call->expire_at - now,
	       call->timer.expires - now);
D
David Howells 已提交
34

35
	read_lock_bh(&call->state_lock);
36

37 38 39 40 41 42 43 44 45 46
	if (call->state < RXRPC_CALL_COMPLETE) {
		t = call->ack_at;
		if (time_before(call->resend_at, t))
			t = call->resend_at;
		if (time_before(call->expire_at, t))
			t = call->expire_at;
		if (!timer_pending(&call->timer) ||
		    time_before(t, call->timer.expires)) {
			_debug("set timer %ld", t - now);
			mod_timer(&call->timer, t);
47 48 49 50 51 52
		}
	}
	read_unlock_bh(&call->state_lock);
}

/*
53
 * propose an ACK be sent
54
 */
55 56 57
static void __rxrpc_propose_ACK(struct rxrpc_call *call, u8 ack_reason,
				u16 skew, u32 serial, bool immediate,
				bool background)
58
{
59
	unsigned long now, ack_at, expiry = rxrpc_soft_ack_delay;
60 61
	s8 prior = rxrpc_ack_priority[ack_reason];

62 63
	_enter("{%d},%s,%%%x,%u",
	       call->debug_id, rxrpc_acks(ack_reason), serial, immediate);
64

65 66 67 68 69 70 71 72 73 74
	/* Update DELAY, IDLE, REQUESTED and PING_RESPONSE ACK serial
	 * numbers, but we don't alter the timeout.
	 */
	_debug("prior %u %u vs %u %u",
	       ack_reason, prior,
	       call->ackr_reason, rxrpc_ack_priority[call->ackr_reason]);
	if (ack_reason == call->ackr_reason) {
		if (RXRPC_ACK_UPDATEABLE & (1 << ack_reason)) {
			call->ackr_serial = serial;
			call->ackr_skew = skew;
75
		}
76 77 78 79 80 81
		if (!immediate)
			return;
	} else if (prior > rxrpc_ack_priority[call->ackr_reason]) {
		call->ackr_reason = ack_reason;
		call->ackr_serial = serial;
		call->ackr_skew = skew;
82 83
	}

84 85 86 87 88 89 90
	switch (ack_reason) {
	case RXRPC_ACK_REQUESTED:
		if (rxrpc_requested_ack_delay < expiry)
			expiry = rxrpc_requested_ack_delay;
		if (serial == 1)
			immediate = false;
		break;
91

92 93 94 95
	case RXRPC_ACK_DELAY:
		if (rxrpc_soft_ack_delay < expiry)
			expiry = rxrpc_soft_ack_delay;
		break;
96

97
	case RXRPC_ACK_IDLE:
98
		if (rxrpc_idle_ack_delay < expiry)
99 100
			expiry = rxrpc_idle_ack_delay;
		break;
101

102 103 104
	default:
		immediate = true;
		break;
105 106
	}

107 108 109 110 111 112 113 114 115 116 117 118 119 120
	now = jiffies;
	if (test_bit(RXRPC_CALL_EV_ACK, &call->events)) {
		_debug("already scheduled");
	} else if (immediate || expiry == 0) {
		_debug("immediate ACK %lx", call->events);
		if (!test_and_set_bit(RXRPC_CALL_EV_ACK, &call->events) &&
		    background)
			rxrpc_queue_call(call);
	} else {
		ack_at = now + expiry;
		_debug("deferred ACK %ld < %ld", expiry, call->ack_at - now);
		if (time_before(ack_at, call->ack_at)) {
			call->ack_at = ack_at;
			rxrpc_set_timer(call);
121 122 123 124 125
		}
	}
}

/*
126
 * propose an ACK be sent, locking the call structure
127
 */
128 129
void rxrpc_propose_ACK(struct rxrpc_call *call, u8 ack_reason,
		       u16 skew, u32 serial, bool immediate, bool background)
130
{
131 132 133 134
	spin_lock_bh(&call->lock);
	__rxrpc_propose_ACK(call, ack_reason, skew, serial,
			    immediate, background);
	spin_unlock_bh(&call->lock);
135 136 137
}

/*
138
 * Perform retransmission of NAK'd and unack'd packets.
139
 */
140
static void rxrpc_resend(struct rxrpc_call *call)
141 142 143
{
	struct rxrpc_skb_priv *sp;
	struct sk_buff *skb;
144 145 146 147
	rxrpc_seq_t cursor, seq, top;
	unsigned long resend_at, now;
	int ix;
	u8 annotation;
148

149
	_enter("{%d,%d}", call->tx_hard_ack, call->tx_top);
150 151 152

	spin_lock_bh(&call->lock);

153 154 155 156 157 158 159 160 161 162 163 164
	cursor = call->tx_hard_ack;
	top = call->tx_top;
	ASSERT(before_eq(cursor, top));
	if (cursor == top)
		goto out_unlock;

	/* Scan the packet list without dropping the lock and decide which of
	 * the packets in the Tx buffer we're going to resend and what the new
	 * resend timeout will be.
	 */
	now = jiffies;
	resend_at = now + rxrpc_resend_timeout;
165
	for (seq = cursor + 1; before_eq(seq, top); seq++) {
166 167 168 169
		ix = seq & RXRPC_RXTX_BUFF_MASK;
		annotation = call->rxtx_annotations[ix];
		if (annotation == RXRPC_TX_ANNO_ACK)
			continue;
170

171
		skb = call->rxtx_buffer[ix];
D
David Howells 已提交
172
		rxrpc_see_skb(skb, rxrpc_skb_tx_seen);
173 174
		sp = rxrpc_skb(skb);

175 176 177 178 179
		if (annotation == RXRPC_TX_ANNO_UNACK) {
			if (time_after(sp->resend_at, now)) {
				if (time_before(sp->resend_at, resend_at))
					resend_at = sp->resend_at;
				continue;
180
			}
181 182
		}

183 184
		/* Okay, we need to retransmit a packet. */
		call->rxtx_annotations[ix] = RXRPC_TX_ANNO_RETRANS;
185
	}
186 187 188 189 190 191 192 193

	call->resend_at = resend_at;

	/* Now go through the Tx window and perform the retransmissions.  We
	 * have to drop the lock for each send.  If an ACK comes in whilst the
	 * lock is dropped, it may clear some of the retransmission markers for
	 * packets that it soft-ACKs.
	 */
194
	for (seq = cursor + 1; before_eq(seq, top); seq++) {
195 196 197 198
		ix = seq & RXRPC_RXTX_BUFF_MASK;
		annotation = call->rxtx_annotations[ix];
		if (annotation != RXRPC_TX_ANNO_RETRANS)
			continue;
199

200
		skb = call->rxtx_buffer[ix];
D
David Howells 已提交
201
		rxrpc_get_skb(skb, rxrpc_skb_tx_got);
202 203
		spin_unlock_bh(&call->lock);

204
		if (rxrpc_send_data_packet(call, skb) < 0) {
205
			call->resend_at = now + 2;
D
David Howells 已提交
206
			rxrpc_free_skb(skb, rxrpc_skb_tx_freed);
207 208
			return;
		}
209

210 211
		if (rxrpc_is_client_call(call))
			rxrpc_expose_client_call(call);
212
		sp = rxrpc_skb(skb);
213
		sp->resend_at = now + rxrpc_resend_timeout;
214

D
David Howells 已提交
215
		rxrpc_free_skb(skb, rxrpc_skb_tx_freed);
216 217
		spin_lock_bh(&call->lock);

218 219 220 221 222 223 224 225 226 227 228 229
		/* We need to clear the retransmit state, but there are two
		 * things we need to be aware of: A new ACK/NAK might have been
		 * received and the packet might have been hard-ACK'd (in which
		 * case it will no longer be in the buffer).
		 */
		if (after(seq, call->tx_hard_ack) &&
		    (call->rxtx_annotations[ix] == RXRPC_TX_ANNO_RETRANS ||
		     call->rxtx_annotations[ix] == RXRPC_TX_ANNO_NAK))
			call->rxtx_annotations[ix] = RXRPC_TX_ANNO_UNACK;

		if (after(call->tx_hard_ack, seq))
			seq = call->tx_hard_ack;
230
	}
231 232 233 234

out_unlock:
	spin_unlock_bh(&call->lock);
	_leave("");
235 236 237
}

/*
238
 * Handle retransmission and deferred ACK/abort generation.
239 240 241 242 243
 */
void rxrpc_process_call(struct work_struct *work)
{
	struct rxrpc_call *call =
		container_of(work, struct rxrpc_call, processor);
244
	unsigned long now;
245

D
David Howells 已提交
246 247
	rxrpc_see_call(call);

248
	//printk("\n--------------------\n");
249 250
	_enter("{%d,%s,%lx}",
	       call->debug_id, rxrpc_call_states[call->state], call->events);
251

252 253 254 255
recheck_state:
	if (test_and_clear_bit(RXRPC_CALL_EV_ABORT, &call->events)) {
		rxrpc_send_call_packet(call, RXRPC_PACKET_TYPE_ABORT);
		goto recheck_state;
256 257
	}

258 259 260
	if (call->state == RXRPC_CALL_COMPLETE) {
		del_timer_sync(&call->timer);
		goto out_put;
261 262
	}

263 264
	now = jiffies;
	if (time_after_eq(now, call->expire_at)) {
265
		rxrpc_abort_call("EXP", call, 0, RX_CALL_TIMEOUT, ETIME);
266
		set_bit(RXRPC_CALL_EV_ABORT, &call->events);
267 268
	}

269 270 271 272 273 274
	if (test_and_clear_bit(RXRPC_CALL_EV_ACK, &call->events) ||
	    time_after_eq(now, call->ack_at)) {
		call->ack_at = call->expire_at;
		if (call->ackr_reason) {
			rxrpc_send_call_packet(call, RXRPC_PACKET_TYPE_ACK);
			goto recheck_state;
275 276 277
		}
	}

278 279
	if (test_and_clear_bit(RXRPC_CALL_EV_RESEND, &call->events) ||
	    time_after_eq(now, call->resend_at)) {
280
		rxrpc_resend(call);
281
		goto recheck_state;
282 283
	}

284
	rxrpc_set_timer(call);
285 286

	/* other events may have been raised since we started checking */
287
	if (call->events && call->state < RXRPC_CALL_COMPLETE) {
288
		__rxrpc_queue_call(call);
289
		goto out;
290 291
	}

292 293 294
out_put:
	rxrpc_put_call(call, rxrpc_call_put);
out:
295 296
	_leave("");
}