conn_event.c (96b4059f43ce69e9c590f77d6ce3e99888d5cfe6) conn_event.c (9d35d880e0e4a3ab32d8c12f9e4d76198aadd42d)
1// SPDX-License-Identifier: GPL-2.0-or-later
2/* connection-level event handling
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

--- 86 unchanged lines hidden (view full) ---

95
96 _enter("%d", conn->debug_id);
97
98 chan = &conn->channels[channel];
99
100 /* If the last call got moved on whilst we were waiting to run, just
101 * ignore this packet.
102 */
1// SPDX-License-Identifier: GPL-2.0-or-later
2/* connection-level event handling
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

--- 86 unchanged lines hidden (view full) ---

95
96 _enter("%d", conn->debug_id);
97
98 chan = &conn->channels[channel];
99
100 /* If the last call got moved on whilst we were waiting to run, just
101 * ignore this packet.
102 */
103 call_id = READ_ONCE(chan->last_call);
104 /* Sync with __rxrpc_disconnect_call() */
105 smp_rmb();
103 call_id = chan->last_call;
106 if (skb && call_id != sp->hdr.callNumber)
107 return;
108
109 msg.msg_name = &conn->peer->srx.transport;
110 msg.msg_namelen = conn->peer->srx.transport_len;
111 msg.msg_control = NULL;
112 msg.msg_controllen = 0;
113 msg.msg_flags = 0;
114
115 iov[0].iov_base = &pkt;
116 iov[0].iov_len = sizeof(pkt.whdr);
117 iov[1].iov_base = &padding;
118 iov[1].iov_len = 3;
119 iov[2].iov_base = &ack_info;
120 iov[2].iov_len = sizeof(ack_info);
121
104 if (skb && call_id != sp->hdr.callNumber)
105 return;
106
107 msg.msg_name = &conn->peer->srx.transport;
108 msg.msg_namelen = conn->peer->srx.transport_len;
109 msg.msg_control = NULL;
110 msg.msg_controllen = 0;
111 msg.msg_flags = 0;
112
113 iov[0].iov_base = &pkt;
114 iov[0].iov_len = sizeof(pkt.whdr);
115 iov[1].iov_base = &padding;
116 iov[1].iov_len = 3;
117 iov[2].iov_base = &ack_info;
118 iov[2].iov_len = sizeof(ack_info);
119
120 serial = atomic_inc_return(&conn->serial);
121
122 pkt.whdr.epoch = htonl(conn->proto.epoch);
123 pkt.whdr.cid = htonl(conn->proto.cid | channel);
124 pkt.whdr.callNumber = htonl(call_id);
122 pkt.whdr.epoch = htonl(conn->proto.epoch);
123 pkt.whdr.cid = htonl(conn->proto.cid | channel);
124 pkt.whdr.callNumber = htonl(call_id);
125 pkt.whdr.serial = htonl(serial);
125 pkt.whdr.seq = 0;
126 pkt.whdr.type = chan->last_type;
127 pkt.whdr.flags = conn->out_clientflag;
128 pkt.whdr.userStatus = 0;
129 pkt.whdr.securityIndex = conn->security_ix;
130 pkt.whdr._rsvd = 0;
131 pkt.whdr.serviceId = htons(conn->service_id);
132

--- 20 unchanged lines hidden (view full) ---

153 ack_info.maxMTU = htonl(mtu);
154 ack_info.rwind = htonl(rxrpc_rx_window_size);
155 ack_info.jumbo_max = htonl(rxrpc_rx_jumbo_max);
156 pkt.whdr.flags |= RXRPC_SLOW_START_OK;
157 padding = 0;
158 iov[0].iov_len += sizeof(pkt.ack);
159 len += sizeof(pkt.ack) + 3 + sizeof(ack_info);
160 ioc = 3;
126 pkt.whdr.seq = 0;
127 pkt.whdr.type = chan->last_type;
128 pkt.whdr.flags = conn->out_clientflag;
129 pkt.whdr.userStatus = 0;
130 pkt.whdr.securityIndex = conn->security_ix;
131 pkt.whdr._rsvd = 0;
132 pkt.whdr.serviceId = htons(conn->service_id);
133

--- 20 unchanged lines hidden (view full) ---

154 ack_info.maxMTU = htonl(mtu);
155 ack_info.rwind = htonl(rxrpc_rx_window_size);
156 ack_info.jumbo_max = htonl(rxrpc_rx_jumbo_max);
157 pkt.whdr.flags |= RXRPC_SLOW_START_OK;
158 padding = 0;
159 iov[0].iov_len += sizeof(pkt.ack);
160 len += sizeof(pkt.ack) + 3 + sizeof(ack_info);
161 ioc = 3;
161 break;
162
162
163 default:
164 return;
165 }
166
167 /* Resync with __rxrpc_disconnect_call() and check that the last call
168 * didn't get advanced whilst we were filling out the packets.
169 */
170 smp_rmb();
171 if (READ_ONCE(chan->last_call) != call_id)
172 return;
173
174 serial = atomic_inc_return(&conn->serial);
175 pkt.whdr.serial = htonl(serial);
176
177 switch (chan->last_type) {
178 case RXRPC_PACKET_TYPE_ABORT:
179 break;
180 case RXRPC_PACKET_TYPE_ACK:
181 trace_rxrpc_tx_ack(chan->call_debug_id, serial,
182 ntohl(pkt.ack.firstPacket),
183 ntohl(pkt.ack.serial),
184 pkt.ack.reason, 0);
185 break;
163 trace_rxrpc_tx_ack(chan->call_debug_id, serial,
164 ntohl(pkt.ack.firstPacket),
165 ntohl(pkt.ack.serial),
166 pkt.ack.reason, 0);
167 break;
168
169 default:
170 return;
186 }
187
188 ret = kernel_sendmsg(conn->local->socket, &msg, iov, ioc, len);
189 conn->peer->last_tx_at = ktime_get_seconds();
190 if (ret < 0)
191 trace_rxrpc_tx_fail(chan->call_debug_id, serial, ret,
192 rxrpc_tx_point_call_final_resend);
193 else

--- 8 unchanged lines hidden (view full) ---

202 */
203static void rxrpc_abort_calls(struct rxrpc_connection *conn)
204{
205 struct rxrpc_call *call;
206 int i;
207
208 _enter("{%d},%x", conn->debug_id, conn->abort_code);
209
171 }
172
173 ret = kernel_sendmsg(conn->local->socket, &msg, iov, ioc, len);
174 conn->peer->last_tx_at = ktime_get_seconds();
175 if (ret < 0)
176 trace_rxrpc_tx_fail(chan->call_debug_id, serial, ret,
177 rxrpc_tx_point_call_final_resend);
178 else

--- 8 unchanged lines hidden (view full) ---

187 */
188static void rxrpc_abort_calls(struct rxrpc_connection *conn)
189{
190 struct rxrpc_call *call;
191 int i;
192
193 _enter("{%d},%x", conn->debug_id, conn->abort_code);
194
210 spin_lock(&conn->bundle->channel_lock);
211
212 for (i = 0; i < RXRPC_MAXCALLS; i++) {
195 for (i = 0; i < RXRPC_MAXCALLS; i++) {
213 call = rcu_dereference_protected(
214 conn->channels[i].call,
215 lockdep_is_held(&conn->bundle->channel_lock));
196 call = conn->channels[i].call;
216 if (call)
217 rxrpc_set_call_completion(call,
218 conn->completion,
219 conn->abort_code,
220 conn->error);
221 }
222
197 if (call)
198 rxrpc_set_call_completion(call,
199 conn->completion,
200 conn->abort_code,
201 conn->error);
202 }
203
223 spin_unlock(&conn->bundle->channel_lock);
224 _leave("");
225}
226
227/*
228 * mark a call as being on a now-secured channel
229 * - must be called with BH's disabled.
230 */
231static void rxrpc_call_is_secure(struct rxrpc_call *call)

--- 79 unchanged lines hidden (view full) ---

311 set = false;
312 for (channel = 0; channel < RXRPC_MAXCALLS; channel++) {
313 struct rxrpc_channel *chan = &conn->channels[channel];
314 unsigned long ack_at;
315
316 if (!test_bit(RXRPC_CONN_FINAL_ACK_0 + channel, &conn->flags))
317 continue;
318
204 _leave("");
205}
206
207/*
208 * mark a call as being on a now-secured channel
209 * - must be called with BH's disabled.
210 */
211static void rxrpc_call_is_secure(struct rxrpc_call *call)

--- 79 unchanged lines hidden (view full) ---

291 set = false;
292 for (channel = 0; channel < RXRPC_MAXCALLS; channel++) {
293 struct rxrpc_channel *chan = &conn->channels[channel];
294 unsigned long ack_at;
295
296 if (!test_bit(RXRPC_CONN_FINAL_ACK_0 + channel, &conn->flags))
297 continue;
298
319 smp_rmb(); /* vs rxrpc_disconnect_client_call */
320 ack_at = READ_ONCE(chan->final_ack_at);
321
299 ack_at = chan->final_ack_at;
322 if (time_before(j, ack_at) && !force) {
323 if (time_before(ack_at, next_j)) {
324 next_j = ack_at;
325 set = true;
326 }
327 continue;
328 }
329

--- 111 unchanged lines hidden (view full) ---

441 if (test_and_clear_bit(RXRPC_CONN_EV_ABORT_CALLS, &conn->events))
442 rxrpc_abort_calls(conn);
443
444 switch (skb->mark) {
445 case RXRPC_SKB_MARK_SERVICE_CONN_SECURED:
446 if (conn->state != RXRPC_CONN_SERVICE)
447 break;
448
300 if (time_before(j, ack_at) && !force) {
301 if (time_before(ack_at, next_j)) {
302 next_j = ack_at;
303 set = true;
304 }
305 continue;
306 }
307

--- 111 unchanged lines hidden (view full) ---

419 if (test_and_clear_bit(RXRPC_CONN_EV_ABORT_CALLS, &conn->events))
420 rxrpc_abort_calls(conn);
421
422 switch (skb->mark) {
423 case RXRPC_SKB_MARK_SERVICE_CONN_SECURED:
424 if (conn->state != RXRPC_CONN_SERVICE)
425 break;
426
449 spin_lock(&conn->bundle->channel_lock);
450
451 for (loop = 0; loop < RXRPC_MAXCALLS; loop++)
427 for (loop = 0; loop < RXRPC_MAXCALLS; loop++)
452 rxrpc_call_is_secure(
453 rcu_dereference_protected(
454 conn->channels[loop].call,
455 lockdep_is_held(&conn->bundle->channel_lock)));
456
457 spin_unlock(&conn->bundle->channel_lock);
428 rxrpc_call_is_secure(conn->channels[loop].call);
458 break;
459 }
460
461 /* Process delayed ACKs whose time has come. */
462 if (conn->flags & RXRPC_CONN_FINAL_ACK_MASK)
463 rxrpc_process_delayed_final_acks(conn, false);
464}
429 break;
430 }
431
432 /* Process delayed ACKs whose time has come. */
433 if (conn->flags & RXRPC_CONN_FINAL_ACK_MASK)
434 rxrpc_process_delayed_final_acks(conn, false);
435}