David Howells | 17926a7 | 2007-04-26 15:48:28 -0700 | [diff] [blame] | 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 | |
Joe Perches | 9b6d539 | 2016-06-02 12:08:52 -0700 | [diff] [blame] | 12 | #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt |
| 13 | |
David Howells | 17926a7 | 2007-04-26 15:48:28 -0700 | [diff] [blame] | 14 | #include <linux/module.h> |
| 15 | #include <linux/circ_buf.h> |
| 16 | #include <linux/net.h> |
| 17 | #include <linux/skbuff.h> |
Tejun Heo | 5a0e3ad | 2010-03-24 17:04:11 +0900 | [diff] [blame] | 18 | #include <linux/slab.h> |
David Howells | 17926a7 | 2007-04-26 15:48:28 -0700 | [diff] [blame] | 19 | #include <linux/udp.h> |
| 20 | #include <net/sock.h> |
| 21 | #include <net/af_rxrpc.h> |
| 22 | #include "ar-internal.h" |
| 23 | |
David Howells | 5873c08 | 2014-02-07 18:58:44 +0000 | [diff] [blame] | 24 | /* |
David Howells | 248f219 | 2016-09-08 11:10:12 +0100 | [diff] [blame] | 25 | * Set the timer |
| 26 | */ |
David Howells | df0adc7 | 2016-09-26 22:12:49 +0100 | [diff] [blame] | 27 | void rxrpc_set_timer(struct rxrpc_call *call, enum rxrpc_timer_trace why, |
| 28 | ktime_t now) |
David Howells | 248f219 | 2016-09-08 11:10:12 +0100 | [diff] [blame] | 29 | { |
David Howells | df0adc7 | 2016-09-26 22:12:49 +0100 | [diff] [blame] | 30 | unsigned long t_j, now_j = jiffies; |
| 31 | ktime_t t; |
David Howells | 405dea1 | 2016-09-30 09:13:50 +0100 | [diff] [blame^] | 32 | bool queue = false; |
David Howells | 248f219 | 2016-09-08 11:10:12 +0100 | [diff] [blame] | 33 | |
David Howells | 248f219 | 2016-09-08 11:10:12 +0100 | [diff] [blame] | 34 | read_lock_bh(&call->state_lock); |
| 35 | |
| 36 | if (call->state < RXRPC_CALL_COMPLETE) { |
David Howells | 01a88f7 | 2016-09-23 12:39:22 +0100 | [diff] [blame] | 37 | t = call->expire_at; |
David Howells | df0adc7 | 2016-09-26 22:12:49 +0100 | [diff] [blame] | 38 | if (!ktime_after(t, now)) |
David Howells | 01a88f7 | 2016-09-23 12:39:22 +0100 | [diff] [blame] | 39 | goto out; |
| 40 | |
David Howells | 405dea1 | 2016-09-30 09:13:50 +0100 | [diff] [blame^] | 41 | if (!ktime_after(call->resend_at, now)) { |
| 42 | call->resend_at = call->expire_at; |
| 43 | if (!test_and_set_bit(RXRPC_CALL_EV_RESEND, &call->events)) |
| 44 | queue = true; |
| 45 | } else if (ktime_before(call->resend_at, t)) { |
David Howells | 248f219 | 2016-09-08 11:10:12 +0100 | [diff] [blame] | 46 | t = call->resend_at; |
David Howells | 405dea1 | 2016-09-30 09:13:50 +0100 | [diff] [blame^] | 47 | } |
David Howells | 01a88f7 | 2016-09-23 12:39:22 +0100 | [diff] [blame] | 48 | |
David Howells | 405dea1 | 2016-09-30 09:13:50 +0100 | [diff] [blame^] | 49 | if (!ktime_after(call->ack_at, now)) { |
| 50 | call->ack_at = call->expire_at; |
| 51 | if (!test_and_set_bit(RXRPC_CALL_EV_ACK, &call->events)) |
| 52 | queue = true; |
| 53 | } else if (ktime_before(call->ack_at, t)) { |
David Howells | 01a88f7 | 2016-09-23 12:39:22 +0100 | [diff] [blame] | 54 | t = call->ack_at; |
David Howells | 405dea1 | 2016-09-30 09:13:50 +0100 | [diff] [blame^] | 55 | } |
David Howells | 01a88f7 | 2016-09-23 12:39:22 +0100 | [diff] [blame] | 56 | |
David Howells | df0adc7 | 2016-09-26 22:12:49 +0100 | [diff] [blame] | 57 | t_j = nsecs_to_jiffies(ktime_to_ns(ktime_sub(t, now))); |
| 58 | t_j += jiffies; |
| 59 | |
| 60 | /* We have to make sure that the calculated jiffies value falls |
| 61 | * at or after the nsec value, or we may loop ceaselessly |
| 62 | * because the timer times out, but we haven't reached the nsec |
| 63 | * timeout yet. |
| 64 | */ |
| 65 | t_j++; |
| 66 | |
| 67 | if (call->timer.expires != t_j || !timer_pending(&call->timer)) { |
| 68 | mod_timer(&call->timer, t_j); |
| 69 | trace_rxrpc_timer(call, why, now, now_j); |
David Howells | 248f219 | 2016-09-08 11:10:12 +0100 | [diff] [blame] | 70 | } |
David Howells | 405dea1 | 2016-09-30 09:13:50 +0100 | [diff] [blame^] | 71 | |
| 72 | if (queue) |
| 73 | rxrpc_queue_call(call); |
David Howells | 248f219 | 2016-09-08 11:10:12 +0100 | [diff] [blame] | 74 | } |
David Howells | 01a88f7 | 2016-09-23 12:39:22 +0100 | [diff] [blame] | 75 | |
| 76 | out: |
David Howells | 248f219 | 2016-09-08 11:10:12 +0100 | [diff] [blame] | 77 | read_unlock_bh(&call->state_lock); |
| 78 | } |
| 79 | |
| 80 | /* |
David Howells | 17926a7 | 2007-04-26 15:48:28 -0700 | [diff] [blame] | 81 | * propose an ACK be sent |
| 82 | */ |
David Howells | 248f219 | 2016-09-08 11:10:12 +0100 | [diff] [blame] | 83 | static void __rxrpc_propose_ACK(struct rxrpc_call *call, u8 ack_reason, |
| 84 | u16 skew, u32 serial, bool immediate, |
David Howells | 9c7ad43 | 2016-09-23 13:50:40 +0100 | [diff] [blame] | 85 | bool background, |
| 86 | enum rxrpc_propose_ack_trace why) |
David Howells | 17926a7 | 2007-04-26 15:48:28 -0700 | [diff] [blame] | 87 | { |
David Howells | 9c7ad43 | 2016-09-23 13:50:40 +0100 | [diff] [blame] | 88 | enum rxrpc_propose_ack_outcome outcome = rxrpc_propose_ack_use; |
David Howells | df0adc7 | 2016-09-26 22:12:49 +0100 | [diff] [blame] | 89 | unsigned int expiry = rxrpc_soft_ack_delay; |
| 90 | ktime_t now, ack_at; |
David Howells | 17926a7 | 2007-04-26 15:48:28 -0700 | [diff] [blame] | 91 | s8 prior = rxrpc_ack_priority[ack_reason]; |
| 92 | |
David Howells | 248f219 | 2016-09-08 11:10:12 +0100 | [diff] [blame] | 93 | /* Update DELAY, IDLE, REQUESTED and PING_RESPONSE ACK serial |
| 94 | * numbers, but we don't alter the timeout. |
| 95 | */ |
| 96 | _debug("prior %u %u vs %u %u", |
| 97 | ack_reason, prior, |
| 98 | call->ackr_reason, rxrpc_ack_priority[call->ackr_reason]); |
| 99 | if (ack_reason == call->ackr_reason) { |
| 100 | if (RXRPC_ACK_UPDATEABLE & (1 << ack_reason)) { |
David Howells | 9c7ad43 | 2016-09-23 13:50:40 +0100 | [diff] [blame] | 101 | outcome = rxrpc_propose_ack_update; |
David Howells | 17926a7 | 2007-04-26 15:48:28 -0700 | [diff] [blame] | 102 | call->ackr_serial = serial; |
David Howells | 248f219 | 2016-09-08 11:10:12 +0100 | [diff] [blame] | 103 | call->ackr_skew = skew; |
David Howells | 563ea7d | 2016-08-23 15:27:25 +0100 | [diff] [blame] | 104 | } |
David Howells | 248f219 | 2016-09-08 11:10:12 +0100 | [diff] [blame] | 105 | if (!immediate) |
David Howells | 9c7ad43 | 2016-09-23 13:50:40 +0100 | [diff] [blame] | 106 | goto trace; |
David Howells | 248f219 | 2016-09-08 11:10:12 +0100 | [diff] [blame] | 107 | } else if (prior > rxrpc_ack_priority[call->ackr_reason]) { |
| 108 | call->ackr_reason = ack_reason; |
| 109 | call->ackr_serial = serial; |
| 110 | call->ackr_skew = skew; |
David Howells | 9c7ad43 | 2016-09-23 13:50:40 +0100 | [diff] [blame] | 111 | } else { |
| 112 | outcome = rxrpc_propose_ack_subsume; |
David Howells | 17926a7 | 2007-04-26 15:48:28 -0700 | [diff] [blame] | 113 | } |
| 114 | |
David Howells | 17926a7 | 2007-04-26 15:48:28 -0700 | [diff] [blame] | 115 | switch (ack_reason) { |
David Howells | 248f219 | 2016-09-08 11:10:12 +0100 | [diff] [blame] | 116 | case RXRPC_ACK_REQUESTED: |
| 117 | if (rxrpc_requested_ack_delay < expiry) |
| 118 | expiry = rxrpc_requested_ack_delay; |
| 119 | if (serial == 1) |
| 120 | immediate = false; |
| 121 | break; |
| 122 | |
David Howells | 17926a7 | 2007-04-26 15:48:28 -0700 | [diff] [blame] | 123 | case RXRPC_ACK_DELAY: |
David Howells | 248f219 | 2016-09-08 11:10:12 +0100 | [diff] [blame] | 124 | if (rxrpc_soft_ack_delay < expiry) |
| 125 | expiry = rxrpc_soft_ack_delay; |
| 126 | break; |
David Howells | 17926a7 | 2007-04-26 15:48:28 -0700 | [diff] [blame] | 127 | |
David Howells | 0d96796 | 2016-09-24 18:05:27 +0100 | [diff] [blame] | 128 | case RXRPC_ACK_PING: |
David Howells | 17926a7 | 2007-04-26 15:48:28 -0700 | [diff] [blame] | 129 | case RXRPC_ACK_IDLE: |
David Howells | 91c2c7b | 2016-09-13 22:36:21 +0100 | [diff] [blame] | 130 | if (rxrpc_idle_ack_delay < expiry) |
David Howells | 5873c08 | 2014-02-07 18:58:44 +0000 | [diff] [blame] | 131 | expiry = rxrpc_idle_ack_delay; |
David Howells | 248f219 | 2016-09-08 11:10:12 +0100 | [diff] [blame] | 132 | break; |
David Howells | 17926a7 | 2007-04-26 15:48:28 -0700 | [diff] [blame] | 133 | |
| 134 | default: |
David Howells | 248f219 | 2016-09-08 11:10:12 +0100 | [diff] [blame] | 135 | immediate = true; |
| 136 | break; |
David Howells | 17926a7 | 2007-04-26 15:48:28 -0700 | [diff] [blame] | 137 | } |
| 138 | |
David Howells | 248f219 | 2016-09-08 11:10:12 +0100 | [diff] [blame] | 139 | if (test_bit(RXRPC_CALL_EV_ACK, &call->events)) { |
| 140 | _debug("already scheduled"); |
| 141 | } else if (immediate || expiry == 0) { |
| 142 | _debug("immediate ACK %lx", call->events); |
| 143 | if (!test_and_set_bit(RXRPC_CALL_EV_ACK, &call->events) && |
| 144 | background) |
| 145 | rxrpc_queue_call(call); |
| 146 | } else { |
David Howells | df0adc7 | 2016-09-26 22:12:49 +0100 | [diff] [blame] | 147 | now = ktime_get_real(); |
| 148 | ack_at = ktime_add_ms(now, expiry); |
| 149 | if (ktime_before(ack_at, call->ack_at)) { |
David Howells | 248f219 | 2016-09-08 11:10:12 +0100 | [diff] [blame] | 150 | call->ack_at = ack_at; |
David Howells | df0adc7 | 2016-09-26 22:12:49 +0100 | [diff] [blame] | 151 | rxrpc_set_timer(call, rxrpc_timer_set_for_ack, now); |
David Howells | 248f219 | 2016-09-08 11:10:12 +0100 | [diff] [blame] | 152 | } |
| 153 | } |
David Howells | 9c7ad43 | 2016-09-23 13:50:40 +0100 | [diff] [blame] | 154 | |
| 155 | trace: |
| 156 | trace_rxrpc_propose_ack(call, why, ack_reason, serial, immediate, |
| 157 | background, outcome); |
David Howells | 17926a7 | 2007-04-26 15:48:28 -0700 | [diff] [blame] | 158 | } |
| 159 | |
| 160 | /* |
| 161 | * propose an ACK be sent, locking the call structure |
| 162 | */ |
David Howells | 4e36a95 | 2009-09-16 00:01:13 -0700 | [diff] [blame] | 163 | void rxrpc_propose_ACK(struct rxrpc_call *call, u8 ack_reason, |
David Howells | 9c7ad43 | 2016-09-23 13:50:40 +0100 | [diff] [blame] | 164 | u16 skew, u32 serial, bool immediate, bool background, |
| 165 | enum rxrpc_propose_ack_trace why) |
David Howells | 17926a7 | 2007-04-26 15:48:28 -0700 | [diff] [blame] | 166 | { |
David Howells | 248f219 | 2016-09-08 11:10:12 +0100 | [diff] [blame] | 167 | spin_lock_bh(&call->lock); |
| 168 | __rxrpc_propose_ACK(call, ack_reason, skew, serial, |
David Howells | 9c7ad43 | 2016-09-23 13:50:40 +0100 | [diff] [blame] | 169 | immediate, background, why); |
David Howells | 248f219 | 2016-09-08 11:10:12 +0100 | [diff] [blame] | 170 | spin_unlock_bh(&call->lock); |
David Howells | 17926a7 | 2007-04-26 15:48:28 -0700 | [diff] [blame] | 171 | } |
| 172 | |
| 173 | /* |
David Howells | 5749434 | 2016-09-24 18:05:27 +0100 | [diff] [blame] | 174 | * Handle congestion being detected by the retransmit timeout. |
| 175 | */ |
| 176 | static void rxrpc_congestion_timeout(struct rxrpc_call *call) |
| 177 | { |
| 178 | set_bit(RXRPC_CALL_RETRANS_TIMEOUT, &call->flags); |
| 179 | } |
| 180 | |
| 181 | /* |
David Howells | 248f219 | 2016-09-08 11:10:12 +0100 | [diff] [blame] | 182 | * Perform retransmission of NAK'd and unack'd packets. |
David Howells | 17926a7 | 2007-04-26 15:48:28 -0700 | [diff] [blame] | 183 | */ |
David Howells | df0adc7 | 2016-09-26 22:12:49 +0100 | [diff] [blame] | 184 | static void rxrpc_resend(struct rxrpc_call *call, ktime_t now) |
David Howells | 17926a7 | 2007-04-26 15:48:28 -0700 | [diff] [blame] | 185 | { |
| 186 | struct rxrpc_skb_priv *sp; |
David Howells | 17926a7 | 2007-04-26 15:48:28 -0700 | [diff] [blame] | 187 | struct sk_buff *skb; |
David Howells | 248f219 | 2016-09-08 11:10:12 +0100 | [diff] [blame] | 188 | rxrpc_seq_t cursor, seq, top; |
David Howells | df0adc7 | 2016-09-26 22:12:49 +0100 | [diff] [blame] | 189 | ktime_t max_age, oldest, ack_ts; |
David Howells | 248f219 | 2016-09-08 11:10:12 +0100 | [diff] [blame] | 190 | int ix; |
David Howells | 5749434 | 2016-09-24 18:05:27 +0100 | [diff] [blame] | 191 | u8 annotation, anno_type, retrans = 0, unacked = 0; |
David Howells | 17926a7 | 2007-04-26 15:48:28 -0700 | [diff] [blame] | 192 | |
David Howells | 248f219 | 2016-09-08 11:10:12 +0100 | [diff] [blame] | 193 | _enter("{%d,%d}", call->tx_hard_ack, call->tx_top); |
David Howells | 17926a7 | 2007-04-26 15:48:28 -0700 | [diff] [blame] | 194 | |
David Howells | 50235c4 | 2016-09-22 00:29:31 +0100 | [diff] [blame] | 195 | max_age = ktime_sub_ms(now, rxrpc_resend_timeout); |
| 196 | |
David Howells | 17926a7 | 2007-04-26 15:48:28 -0700 | [diff] [blame] | 197 | spin_lock_bh(&call->lock); |
| 198 | |
David Howells | 248f219 | 2016-09-08 11:10:12 +0100 | [diff] [blame] | 199 | cursor = call->tx_hard_ack; |
| 200 | top = call->tx_top; |
| 201 | ASSERT(before_eq(cursor, top)); |
| 202 | if (cursor == top) |
| 203 | goto out_unlock; |
David Howells | 17926a7 | 2007-04-26 15:48:28 -0700 | [diff] [blame] | 204 | |
David Howells | 248f219 | 2016-09-08 11:10:12 +0100 | [diff] [blame] | 205 | /* Scan the packet list without dropping the lock and decide which of |
| 206 | * the packets in the Tx buffer we're going to resend and what the new |
| 207 | * resend timeout will be. |
| 208 | */ |
David Howells | 50235c4 | 2016-09-22 00:29:31 +0100 | [diff] [blame] | 209 | oldest = now; |
David Howells | dfa7d92 | 2016-09-17 10:49:12 +0100 | [diff] [blame] | 210 | for (seq = cursor + 1; before_eq(seq, top); seq++) { |
David Howells | 248f219 | 2016-09-08 11:10:12 +0100 | [diff] [blame] | 211 | ix = seq & RXRPC_RXTX_BUFF_MASK; |
| 212 | annotation = call->rxtx_annotations[ix]; |
David Howells | f07373e | 2016-09-22 00:29:32 +0100 | [diff] [blame] | 213 | anno_type = annotation & RXRPC_TX_ANNO_MASK; |
| 214 | annotation &= ~RXRPC_TX_ANNO_MASK; |
| 215 | if (anno_type == RXRPC_TX_ANNO_ACK) |
David Howells | 248f219 | 2016-09-08 11:10:12 +0100 | [diff] [blame] | 216 | continue; |
| 217 | |
| 218 | skb = call->rxtx_buffer[ix]; |
David Howells | 71f3ca4 | 2016-09-17 10:49:14 +0100 | [diff] [blame] | 219 | rxrpc_see_skb(skb, rxrpc_skb_tx_seen); |
David Howells | 17926a7 | 2007-04-26 15:48:28 -0700 | [diff] [blame] | 220 | sp = rxrpc_skb(skb); |
| 221 | |
David Howells | f07373e | 2016-09-22 00:29:32 +0100 | [diff] [blame] | 222 | if (anno_type == RXRPC_TX_ANNO_UNACK) { |
David Howells | 50235c4 | 2016-09-22 00:29:31 +0100 | [diff] [blame] | 223 | if (ktime_after(skb->tstamp, max_age)) { |
| 224 | if (ktime_before(skb->tstamp, oldest)) |
| 225 | oldest = skb->tstamp; |
David Howells | 248f219 | 2016-09-08 11:10:12 +0100 | [diff] [blame] | 226 | continue; |
| 227 | } |
David Howells | 5749434 | 2016-09-24 18:05:27 +0100 | [diff] [blame] | 228 | if (!(annotation & RXRPC_TX_ANNO_RESENT)) |
| 229 | unacked++; |
David Howells | 17926a7 | 2007-04-26 15:48:28 -0700 | [diff] [blame] | 230 | } |
David Howells | 17926a7 | 2007-04-26 15:48:28 -0700 | [diff] [blame] | 231 | |
David Howells | 248f219 | 2016-09-08 11:10:12 +0100 | [diff] [blame] | 232 | /* Okay, we need to retransmit a packet. */ |
David Howells | f07373e | 2016-09-22 00:29:32 +0100 | [diff] [blame] | 233 | call->rxtx_annotations[ix] = RXRPC_TX_ANNO_RETRANS | annotation; |
David Howells | 5749434 | 2016-09-24 18:05:27 +0100 | [diff] [blame] | 234 | retrans++; |
David Howells | c6672e3 | 2016-09-23 13:58:55 +0100 | [diff] [blame] | 235 | trace_rxrpc_retransmit(call, seq, annotation | anno_type, |
| 236 | ktime_to_ns(ktime_sub(skb->tstamp, max_age))); |
David Howells | dfa7d92 | 2016-09-17 10:49:12 +0100 | [diff] [blame] | 237 | } |
David Howells | 17926a7 | 2007-04-26 15:48:28 -0700 | [diff] [blame] | 238 | |
David Howells | df0adc7 | 2016-09-26 22:12:49 +0100 | [diff] [blame] | 239 | call->resend_at = ktime_add_ms(oldest, rxrpc_resend_timeout); |
David Howells | 17926a7 | 2007-04-26 15:48:28 -0700 | [diff] [blame] | 240 | |
David Howells | 5749434 | 2016-09-24 18:05:27 +0100 | [diff] [blame] | 241 | if (unacked) |
| 242 | rxrpc_congestion_timeout(call); |
| 243 | |
| 244 | /* If there was nothing that needed retransmission then it's likely |
| 245 | * that an ACK got lost somewhere. Send a ping to find out instead of |
| 246 | * retransmitting data. |
| 247 | */ |
| 248 | if (!retrans) { |
David Howells | df0adc7 | 2016-09-26 22:12:49 +0100 | [diff] [blame] | 249 | rxrpc_set_timer(call, rxrpc_timer_set_for_resend, now); |
David Howells | 5749434 | 2016-09-24 18:05:27 +0100 | [diff] [blame] | 250 | spin_unlock_bh(&call->lock); |
| 251 | ack_ts = ktime_sub(now, call->acks_latest_ts); |
| 252 | if (ktime_to_ns(ack_ts) < call->peer->rtt) |
| 253 | goto out; |
| 254 | rxrpc_propose_ACK(call, RXRPC_ACK_PING, 0, 0, true, false, |
| 255 | rxrpc_propose_ack_ping_for_lost_ack); |
| 256 | rxrpc_send_call_packet(call, RXRPC_PACKET_TYPE_ACK); |
| 257 | goto out; |
| 258 | } |
| 259 | |
David Howells | 248f219 | 2016-09-08 11:10:12 +0100 | [diff] [blame] | 260 | /* Now go through the Tx window and perform the retransmissions. We |
| 261 | * have to drop the lock for each send. If an ACK comes in whilst the |
| 262 | * lock is dropped, it may clear some of the retransmission markers for |
| 263 | * packets that it soft-ACKs. |
| 264 | */ |
David Howells | dfa7d92 | 2016-09-17 10:49:12 +0100 | [diff] [blame] | 265 | for (seq = cursor + 1; before_eq(seq, top); seq++) { |
David Howells | 248f219 | 2016-09-08 11:10:12 +0100 | [diff] [blame] | 266 | ix = seq & RXRPC_RXTX_BUFF_MASK; |
| 267 | annotation = call->rxtx_annotations[ix]; |
David Howells | f07373e | 2016-09-22 00:29:32 +0100 | [diff] [blame] | 268 | anno_type = annotation & RXRPC_TX_ANNO_MASK; |
| 269 | if (anno_type != RXRPC_TX_ANNO_RETRANS) |
David Howells | 248f219 | 2016-09-08 11:10:12 +0100 | [diff] [blame] | 270 | continue; |
David Howells | 17926a7 | 2007-04-26 15:48:28 -0700 | [diff] [blame] | 271 | |
David Howells | 248f219 | 2016-09-08 11:10:12 +0100 | [diff] [blame] | 272 | skb = call->rxtx_buffer[ix]; |
David Howells | 71f3ca4 | 2016-09-17 10:49:14 +0100 | [diff] [blame] | 273 | rxrpc_get_skb(skb, rxrpc_skb_tx_got); |
David Howells | 248f219 | 2016-09-08 11:10:12 +0100 | [diff] [blame] | 274 | spin_unlock_bh(&call->lock); |
David Howells | 248f219 | 2016-09-08 11:10:12 +0100 | [diff] [blame] | 275 | |
David Howells | a176707 | 2016-09-29 22:37:15 +0100 | [diff] [blame] | 276 | if (rxrpc_send_data_packet(call, skb, true) < 0) { |
David Howells | 71f3ca4 | 2016-09-17 10:49:14 +0100 | [diff] [blame] | 277 | rxrpc_free_skb(skb, rxrpc_skb_tx_freed); |
David Howells | 248f219 | 2016-09-08 11:10:12 +0100 | [diff] [blame] | 278 | return; |
| 279 | } |
| 280 | |
| 281 | if (rxrpc_is_client_call(call)) |
| 282 | rxrpc_expose_client_call(call); |
David Howells | 248f219 | 2016-09-08 11:10:12 +0100 | [diff] [blame] | 283 | |
David Howells | 71f3ca4 | 2016-09-17 10:49:14 +0100 | [diff] [blame] | 284 | rxrpc_free_skb(skb, rxrpc_skb_tx_freed); |
David Howells | 17926a7 | 2007-04-26 15:48:28 -0700 | [diff] [blame] | 285 | spin_lock_bh(&call->lock); |
David Howells | 17926a7 | 2007-04-26 15:48:28 -0700 | [diff] [blame] | 286 | |
David Howells | 248f219 | 2016-09-08 11:10:12 +0100 | [diff] [blame] | 287 | /* We need to clear the retransmit state, but there are two |
| 288 | * things we need to be aware of: A new ACK/NAK might have been |
| 289 | * received and the packet might have been hard-ACK'd (in which |
| 290 | * case it will no longer be in the buffer). |
| 291 | */ |
David Howells | f07373e | 2016-09-22 00:29:32 +0100 | [diff] [blame] | 292 | if (after(seq, call->tx_hard_ack)) { |
| 293 | annotation = call->rxtx_annotations[ix]; |
| 294 | anno_type = annotation & RXRPC_TX_ANNO_MASK; |
| 295 | if (anno_type == RXRPC_TX_ANNO_RETRANS || |
| 296 | anno_type == RXRPC_TX_ANNO_NAK) { |
| 297 | annotation &= ~RXRPC_TX_ANNO_MASK; |
| 298 | annotation |= RXRPC_TX_ANNO_UNACK; |
| 299 | } |
| 300 | annotation |= RXRPC_TX_ANNO_RESENT; |
| 301 | call->rxtx_annotations[ix] = annotation; |
| 302 | } |
David Howells | 17926a7 | 2007-04-26 15:48:28 -0700 | [diff] [blame] | 303 | |
David Howells | 248f219 | 2016-09-08 11:10:12 +0100 | [diff] [blame] | 304 | if (after(call->tx_hard_ack, seq)) |
| 305 | seq = call->tx_hard_ack; |
David Howells | dfa7d92 | 2016-09-17 10:49:12 +0100 | [diff] [blame] | 306 | } |
David Howells | 248f219 | 2016-09-08 11:10:12 +0100 | [diff] [blame] | 307 | |
| 308 | out_unlock: |
| 309 | spin_unlock_bh(&call->lock); |
David Howells | 5749434 | 2016-09-24 18:05:27 +0100 | [diff] [blame] | 310 | out: |
David Howells | 248f219 | 2016-09-08 11:10:12 +0100 | [diff] [blame] | 311 | _leave(""); |
David Howells | 17926a7 | 2007-04-26 15:48:28 -0700 | [diff] [blame] | 312 | } |
| 313 | |
| 314 | /* |
David Howells | 248f219 | 2016-09-08 11:10:12 +0100 | [diff] [blame] | 315 | * Handle retransmission and deferred ACK/abort generation. |
David Howells | 17926a7 | 2007-04-26 15:48:28 -0700 | [diff] [blame] | 316 | */ |
| 317 | void rxrpc_process_call(struct work_struct *work) |
| 318 | { |
| 319 | struct rxrpc_call *call = |
| 320 | container_of(work, struct rxrpc_call, processor); |
David Howells | df0adc7 | 2016-09-26 22:12:49 +0100 | [diff] [blame] | 321 | ktime_t now; |
David Howells | 17926a7 | 2007-04-26 15:48:28 -0700 | [diff] [blame] | 322 | |
David Howells | e34d423 | 2016-08-30 09:49:29 +0100 | [diff] [blame] | 323 | rxrpc_see_call(call); |
| 324 | |
David Howells | 17926a7 | 2007-04-26 15:48:28 -0700 | [diff] [blame] | 325 | //printk("\n--------------------\n"); |
David Howells | 248f219 | 2016-09-08 11:10:12 +0100 | [diff] [blame] | 326 | _enter("{%d,%s,%lx}", |
| 327 | call->debug_id, rxrpc_call_states[call->state], call->events); |
David Howells | 17926a7 | 2007-04-26 15:48:28 -0700 | [diff] [blame] | 328 | |
David Howells | 248f219 | 2016-09-08 11:10:12 +0100 | [diff] [blame] | 329 | recheck_state: |
| 330 | if (test_and_clear_bit(RXRPC_CALL_EV_ABORT, &call->events)) { |
| 331 | rxrpc_send_call_packet(call, RXRPC_PACKET_TYPE_ABORT); |
| 332 | goto recheck_state; |
David Howells | 8d94aa3 | 2016-09-07 09:19:31 +0100 | [diff] [blame] | 333 | } |
| 334 | |
David Howells | 248f219 | 2016-09-08 11:10:12 +0100 | [diff] [blame] | 335 | if (call->state == RXRPC_CALL_COMPLETE) { |
| 336 | del_timer_sync(&call->timer); |
| 337 | goto out_put; |
David Howells | 17926a7 | 2007-04-26 15:48:28 -0700 | [diff] [blame] | 338 | } |
| 339 | |
David Howells | df0adc7 | 2016-09-26 22:12:49 +0100 | [diff] [blame] | 340 | now = ktime_get_real(); |
| 341 | if (ktime_before(call->expire_at, now)) { |
David Howells | 5a42976 | 2016-09-06 22:19:51 +0100 | [diff] [blame] | 342 | rxrpc_abort_call("EXP", call, 0, RX_CALL_TIMEOUT, ETIME); |
David Howells | 248f219 | 2016-09-08 11:10:12 +0100 | [diff] [blame] | 343 | set_bit(RXRPC_CALL_EV_ABORT, &call->events); |
David Howells | 5749434 | 2016-09-24 18:05:27 +0100 | [diff] [blame] | 344 | goto recheck_state; |
David Howells | 17926a7 | 2007-04-26 15:48:28 -0700 | [diff] [blame] | 345 | } |
| 346 | |
David Howells | 405dea1 | 2016-09-30 09:13:50 +0100 | [diff] [blame^] | 347 | if (test_and_clear_bit(RXRPC_CALL_EV_ACK, &call->events)) { |
David Howells | 248f219 | 2016-09-08 11:10:12 +0100 | [diff] [blame] | 348 | call->ack_at = call->expire_at; |
| 349 | if (call->ackr_reason) { |
| 350 | rxrpc_send_call_packet(call, RXRPC_PACKET_TYPE_ACK); |
| 351 | goto recheck_state; |
David Howells | 17926a7 | 2007-04-26 15:48:28 -0700 | [diff] [blame] | 352 | } |
| 353 | } |
| 354 | |
David Howells | 405dea1 | 2016-09-30 09:13:50 +0100 | [diff] [blame^] | 355 | if (test_and_clear_bit(RXRPC_CALL_EV_RESEND, &call->events)) { |
David Howells | df0adc7 | 2016-09-26 22:12:49 +0100 | [diff] [blame] | 356 | rxrpc_resend(call, now); |
David Howells | 248f219 | 2016-09-08 11:10:12 +0100 | [diff] [blame] | 357 | goto recheck_state; |
David Howells | 17926a7 | 2007-04-26 15:48:28 -0700 | [diff] [blame] | 358 | } |
| 359 | |
David Howells | df0adc7 | 2016-09-26 22:12:49 +0100 | [diff] [blame] | 360 | rxrpc_set_timer(call, rxrpc_timer_set_for_resend, now); |
David Howells | 17926a7 | 2007-04-26 15:48:28 -0700 | [diff] [blame] | 361 | |
| 362 | /* other events may have been raised since we started checking */ |
David Howells | 248f219 | 2016-09-08 11:10:12 +0100 | [diff] [blame] | 363 | if (call->events && call->state < RXRPC_CALL_COMPLETE) { |
David Howells | 8d94aa3 | 2016-09-07 09:19:31 +0100 | [diff] [blame] | 364 | __rxrpc_queue_call(call); |
David Howells | 248f219 | 2016-09-08 11:10:12 +0100 | [diff] [blame] | 365 | goto out; |
David Howells | 17926a7 | 2007-04-26 15:48:28 -0700 | [diff] [blame] | 366 | } |
| 367 | |
David Howells | 248f219 | 2016-09-08 11:10:12 +0100 | [diff] [blame] | 368 | out_put: |
| 369 | rxrpc_put_call(call, rxrpc_call_put); |
| 370 | out: |
David Howells | 17926a7 | 2007-04-26 15:48:28 -0700 | [diff] [blame] | 371 | _leave(""); |
David Howells | 17926a7 | 2007-04-26 15:48:28 -0700 | [diff] [blame] | 372 | } |