xref: /openbmc/linux/net/rxrpc/conn_event.c (revision 6b47fe1d)
18c3e34a4SDavid Howells /* connection-level event handling
28c3e34a4SDavid Howells  *
38c3e34a4SDavid Howells  * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
48c3e34a4SDavid Howells  * Written by David Howells (dhowells@redhat.com)
58c3e34a4SDavid Howells  *
68c3e34a4SDavid Howells  * This program is free software; you can redistribute it and/or
78c3e34a4SDavid Howells  * modify it under the terms of the GNU General Public License
88c3e34a4SDavid Howells  * as published by the Free Software Foundation; either version
98c3e34a4SDavid Howells  * 2 of the License, or (at your option) any later version.
108c3e34a4SDavid Howells  */
118c3e34a4SDavid Howells 
128c3e34a4SDavid Howells #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
138c3e34a4SDavid Howells 
148c3e34a4SDavid Howells #include <linux/module.h>
158c3e34a4SDavid Howells #include <linux/net.h>
168c3e34a4SDavid Howells #include <linux/skbuff.h>
178c3e34a4SDavid Howells #include <linux/errqueue.h>
188c3e34a4SDavid Howells #include <net/sock.h>
198c3e34a4SDavid Howells #include <net/af_rxrpc.h>
208c3e34a4SDavid Howells #include <net/ip.h>
218c3e34a4SDavid Howells #include "ar-internal.h"
228c3e34a4SDavid Howells 
238c3e34a4SDavid Howells /*
2418bfeba5SDavid Howells  * Retransmit terminal ACK or ABORT of the previous call.
2518bfeba5SDavid Howells  */
26f5c17aaeSDavid Howells static void rxrpc_conn_retransmit_call(struct rxrpc_connection *conn,
273136ef49SDavid Howells 				       struct sk_buff *skb,
283136ef49SDavid Howells 				       unsigned int channel)
2918bfeba5SDavid Howells {
303136ef49SDavid Howells 	struct rxrpc_skb_priv *sp = skb ? rxrpc_skb(skb) : NULL;
3118bfeba5SDavid Howells 	struct rxrpc_channel *chan;
3218bfeba5SDavid Howells 	struct msghdr msg;
335fc62f6aSDavid Howells 	struct kvec iov[3];
3418bfeba5SDavid Howells 	struct {
3518bfeba5SDavid Howells 		struct rxrpc_wire_header whdr;
3618bfeba5SDavid Howells 		union {
375fc62f6aSDavid Howells 			__be32 abort_code;
3818bfeba5SDavid Howells 			struct rxrpc_ackpacket ack;
3918bfeba5SDavid Howells 		};
4018bfeba5SDavid Howells 	} __attribute__((packed)) pkt;
415fc62f6aSDavid Howells 	struct rxrpc_ackinfo ack_info;
4218bfeba5SDavid Howells 	size_t len;
436b47fe1dSDavid Howells 	int ret, ioc;
445fc62f6aSDavid Howells 	u32 serial, mtu, call_id, padding;
4518bfeba5SDavid Howells 
4618bfeba5SDavid Howells 	_enter("%d", conn->debug_id);
4718bfeba5SDavid Howells 
483136ef49SDavid Howells 	chan = &conn->channels[channel];
4918bfeba5SDavid Howells 
5018bfeba5SDavid Howells 	/* If the last call got moved on whilst we were waiting to run, just
5118bfeba5SDavid Howells 	 * ignore this packet.
5218bfeba5SDavid Howells 	 */
5318bfeba5SDavid Howells 	call_id = READ_ONCE(chan->last_call);
5418bfeba5SDavid Howells 	/* Sync with __rxrpc_disconnect_call() */
5518bfeba5SDavid Howells 	smp_rmb();
563136ef49SDavid Howells 	if (skb && call_id != sp->hdr.callNumber)
5718bfeba5SDavid Howells 		return;
5818bfeba5SDavid Howells 
5918bfeba5SDavid Howells 	msg.msg_name	= &conn->params.peer->srx.transport;
6018bfeba5SDavid Howells 	msg.msg_namelen	= conn->params.peer->srx.transport_len;
6118bfeba5SDavid Howells 	msg.msg_control	= NULL;
6218bfeba5SDavid Howells 	msg.msg_controllen = 0;
6318bfeba5SDavid Howells 	msg.msg_flags	= 0;
6418bfeba5SDavid Howells 
655fc62f6aSDavid Howells 	iov[0].iov_base	= &pkt;
665fc62f6aSDavid Howells 	iov[0].iov_len	= sizeof(pkt.whdr);
675fc62f6aSDavid Howells 	iov[1].iov_base	= &padding;
685fc62f6aSDavid Howells 	iov[1].iov_len	= 3;
695fc62f6aSDavid Howells 	iov[2].iov_base	= &ack_info;
705fc62f6aSDavid Howells 	iov[2].iov_len	= sizeof(ack_info);
715fc62f6aSDavid Howells 
723136ef49SDavid Howells 	pkt.whdr.epoch		= htonl(conn->proto.epoch);
733136ef49SDavid Howells 	pkt.whdr.cid		= htonl(conn->proto.cid);
743136ef49SDavid Howells 	pkt.whdr.callNumber	= htonl(call_id);
7518bfeba5SDavid Howells 	pkt.whdr.seq		= 0;
7618bfeba5SDavid Howells 	pkt.whdr.type		= chan->last_type;
7718bfeba5SDavid Howells 	pkt.whdr.flags		= conn->out_clientflag;
7818bfeba5SDavid Howells 	pkt.whdr.userStatus	= 0;
7918bfeba5SDavid Howells 	pkt.whdr.securityIndex	= conn->security_ix;
8018bfeba5SDavid Howells 	pkt.whdr._rsvd		= 0;
8168d6d1aeSDavid Howells 	pkt.whdr.serviceId	= htons(conn->service_id);
8218bfeba5SDavid Howells 
8318bfeba5SDavid Howells 	len = sizeof(pkt.whdr);
8418bfeba5SDavid Howells 	switch (chan->last_type) {
8518bfeba5SDavid Howells 	case RXRPC_PACKET_TYPE_ABORT:
865fc62f6aSDavid Howells 		pkt.abort_code	= htonl(chan->last_abort);
875fc62f6aSDavid Howells 		iov[0].iov_len += sizeof(pkt.abort_code);
885fc62f6aSDavid Howells 		len += sizeof(pkt.abort_code);
895fc62f6aSDavid Howells 		ioc = 1;
9018bfeba5SDavid Howells 		break;
9118bfeba5SDavid Howells 
9218bfeba5SDavid Howells 	case RXRPC_PACKET_TYPE_ACK:
9318bfeba5SDavid Howells 		mtu = conn->params.peer->if_mtu;
9418bfeba5SDavid Howells 		mtu -= conn->params.peer->hdrsize;
9518bfeba5SDavid Howells 		pkt.ack.bufferSpace	= 0;
963136ef49SDavid Howells 		pkt.ack.maxSkew		= htons(skb ? skb->priority : 0);
973136ef49SDavid Howells 		pkt.ack.firstPacket	= htonl(chan->last_seq + 1);
983136ef49SDavid Howells 		pkt.ack.previousPacket	= htonl(chan->last_seq);
993136ef49SDavid Howells 		pkt.ack.serial		= htonl(skb ? sp->hdr.serial : 0);
1003136ef49SDavid Howells 		pkt.ack.reason		= skb ? RXRPC_ACK_DUPLICATE : RXRPC_ACK_IDLE;
10118bfeba5SDavid Howells 		pkt.ack.nAcks		= 0;
1025fc62f6aSDavid Howells 		ack_info.rxMTU		= htonl(rxrpc_rx_mtu);
1035fc62f6aSDavid Howells 		ack_info.maxMTU		= htonl(mtu);
1045fc62f6aSDavid Howells 		ack_info.rwind		= htonl(rxrpc_rx_window_size);
1055fc62f6aSDavid Howells 		ack_info.jumbo_max	= htonl(rxrpc_rx_jumbo_max);
10657494343SDavid Howells 		pkt.whdr.flags		|= RXRPC_SLOW_START_OK;
1075fc62f6aSDavid Howells 		padding			= 0;
1085fc62f6aSDavid Howells 		iov[0].iov_len += sizeof(pkt.ack);
1095fc62f6aSDavid Howells 		len += sizeof(pkt.ack) + 3 + sizeof(ack_info);
1105fc62f6aSDavid Howells 		ioc = 3;
11118bfeba5SDavid Howells 		break;
1125fc62f6aSDavid Howells 
1135fc62f6aSDavid Howells 	default:
1145fc62f6aSDavid Howells 		return;
11518bfeba5SDavid Howells 	}
11618bfeba5SDavid Howells 
11718bfeba5SDavid Howells 	/* Resync with __rxrpc_disconnect_call() and check that the last call
11818bfeba5SDavid Howells 	 * didn't get advanced whilst we were filling out the packets.
11918bfeba5SDavid Howells 	 */
12018bfeba5SDavid Howells 	smp_rmb();
12118bfeba5SDavid Howells 	if (READ_ONCE(chan->last_call) != call_id)
12218bfeba5SDavid Howells 		return;
12318bfeba5SDavid Howells 
12418bfeba5SDavid Howells 	serial = atomic_inc_return(&conn->serial);
12518bfeba5SDavid Howells 	pkt.whdr.serial = htonl(serial);
12618bfeba5SDavid Howells 
12718bfeba5SDavid Howells 	switch (chan->last_type) {
12818bfeba5SDavid Howells 	case RXRPC_PACKET_TYPE_ABORT:
12918bfeba5SDavid Howells 		_proto("Tx ABORT %%%u { %d } [re]", serial, conn->local_abort);
13018bfeba5SDavid Howells 		break;
13118bfeba5SDavid Howells 	case RXRPC_PACKET_TYPE_ACK:
132be832aecSDavid Howells 		trace_rxrpc_tx_ack(NULL, serial, chan->last_seq, 0,
133be832aecSDavid Howells 				   RXRPC_ACK_DUPLICATE, 0);
13418bfeba5SDavid Howells 		_proto("Tx ACK %%%u [re]", serial);
13518bfeba5SDavid Howells 		break;
13618bfeba5SDavid Howells 	}
13718bfeba5SDavid Howells 
1386b47fe1dSDavid Howells 	ret = kernel_sendmsg(conn->params.local->socket, &msg, iov, ioc, len);
139ace45becSDavid Howells 	conn->params.peer->last_tx_at = ktime_get_real();
1406b47fe1dSDavid Howells 	if (ret < 0)
1416b47fe1dSDavid Howells 		trace_rxrpc_tx_fail(conn->debug_id, serial, ret,
1426b47fe1dSDavid Howells 				    rxrpc_tx_fail_call_final_resend);
1436b47fe1dSDavid Howells 
14418bfeba5SDavid Howells 	_leave("");
14518bfeba5SDavid Howells }
14618bfeba5SDavid Howells 
14718bfeba5SDavid Howells /*
1488c3e34a4SDavid Howells  * pass a connection-level abort onto all calls on that connection
1498c3e34a4SDavid Howells  */
150f5c17aaeSDavid Howells static void rxrpc_abort_calls(struct rxrpc_connection *conn,
151f5c17aaeSDavid Howells 			      enum rxrpc_call_completion compl,
152f5c17aaeSDavid Howells 			      u32 abort_code, int error)
1538c3e34a4SDavid Howells {
1548c3e34a4SDavid Howells 	struct rxrpc_call *call;
155248f219cSDavid Howells 	int i;
1568c3e34a4SDavid Howells 
1578c3e34a4SDavid Howells 	_enter("{%d},%x", conn->debug_id, abort_code);
1588c3e34a4SDavid Howells 
159a1399f8bSDavid Howells 	spin_lock(&conn->channel_lock);
1608c3e34a4SDavid Howells 
161a1399f8bSDavid Howells 	for (i = 0; i < RXRPC_MAXCALLS; i++) {
162a1399f8bSDavid Howells 		call = rcu_dereference_protected(
163a1399f8bSDavid Howells 			conn->channels[i].call,
164a1399f8bSDavid Howells 			lockdep_is_held(&conn->channel_lock));
165ccbd3dbeSDavid Howells 		if (call) {
1665a42976dSDavid Howells 			if (compl == RXRPC_CALL_LOCALLY_ABORTED)
167a25e21f0SDavid Howells 				trace_rxrpc_abort(call->debug_id,
168a25e21f0SDavid Howells 						  "CON", call->cid,
1695a42976dSDavid Howells 						  call->call_id, 0,
1705a42976dSDavid Howells 						  abort_code, error);
171248f219cSDavid Howells 			if (rxrpc_set_call_completion(call, compl,
172248f219cSDavid Howells 						      abort_code, error))
173248f219cSDavid Howells 				rxrpc_notify_socket(call);
1748c3e34a4SDavid Howells 		}
175ccbd3dbeSDavid Howells 	}
1768c3e34a4SDavid Howells 
177a1399f8bSDavid Howells 	spin_unlock(&conn->channel_lock);
1788c3e34a4SDavid Howells 	_leave("");
1798c3e34a4SDavid Howells }
1808c3e34a4SDavid Howells 
1818c3e34a4SDavid Howells /*
1828c3e34a4SDavid Howells  * generate a connection-level abort
1838c3e34a4SDavid Howells  */
1848c3e34a4SDavid Howells static int rxrpc_abort_connection(struct rxrpc_connection *conn,
1853a92789aSDavid Howells 				  int error, u32 abort_code)
1868c3e34a4SDavid Howells {
1878c3e34a4SDavid Howells 	struct rxrpc_wire_header whdr;
1888c3e34a4SDavid Howells 	struct msghdr msg;
1898c3e34a4SDavid Howells 	struct kvec iov[2];
1908c3e34a4SDavid Howells 	__be32 word;
1918c3e34a4SDavid Howells 	size_t len;
1928c3e34a4SDavid Howells 	u32 serial;
1938c3e34a4SDavid Howells 	int ret;
1948c3e34a4SDavid Howells 
1958c3e34a4SDavid Howells 	_enter("%d,,%u,%u", conn->debug_id, error, abort_code);
1968c3e34a4SDavid Howells 
1978c3e34a4SDavid Howells 	/* generate a connection-level abort */
1988c3e34a4SDavid Howells 	spin_lock_bh(&conn->state_lock);
199f5c17aaeSDavid Howells 	if (conn->state >= RXRPC_CONN_REMOTELY_ABORTED) {
2008c3e34a4SDavid Howells 		spin_unlock_bh(&conn->state_lock);
2018c3e34a4SDavid Howells 		_leave(" = 0 [already dead]");
2028c3e34a4SDavid Howells 		return 0;
2038c3e34a4SDavid Howells 	}
2048c3e34a4SDavid Howells 
205f5c17aaeSDavid Howells 	conn->state = RXRPC_CONN_LOCALLY_ABORTED;
206f5c17aaeSDavid Howells 	spin_unlock_bh(&conn->state_lock);
207f5c17aaeSDavid Howells 
208f5c17aaeSDavid Howells 	rxrpc_abort_calls(conn, RXRPC_CALL_LOCALLY_ABORTED, abort_code, error);
2098c3e34a4SDavid Howells 
21085f32278SDavid Howells 	msg.msg_name	= &conn->params.peer->srx.transport;
21185f32278SDavid Howells 	msg.msg_namelen	= conn->params.peer->srx.transport_len;
2128c3e34a4SDavid Howells 	msg.msg_control	= NULL;
2138c3e34a4SDavid Howells 	msg.msg_controllen = 0;
2148c3e34a4SDavid Howells 	msg.msg_flags	= 0;
2158c3e34a4SDavid Howells 
21619ffa01cSDavid Howells 	whdr.epoch	= htonl(conn->proto.epoch);
21719ffa01cSDavid Howells 	whdr.cid	= htonl(conn->proto.cid);
2188c3e34a4SDavid Howells 	whdr.callNumber	= 0;
2198c3e34a4SDavid Howells 	whdr.seq	= 0;
2208c3e34a4SDavid Howells 	whdr.type	= RXRPC_PACKET_TYPE_ABORT;
2218c3e34a4SDavid Howells 	whdr.flags	= conn->out_clientflag;
2228c3e34a4SDavid Howells 	whdr.userStatus	= 0;
2238c3e34a4SDavid Howells 	whdr.securityIndex = conn->security_ix;
2248c3e34a4SDavid Howells 	whdr._rsvd	= 0;
22568d6d1aeSDavid Howells 	whdr.serviceId	= htons(conn->service_id);
2268c3e34a4SDavid Howells 
2278c3e34a4SDavid Howells 	word		= htonl(conn->local_abort);
2288c3e34a4SDavid Howells 
2298c3e34a4SDavid Howells 	iov[0].iov_base	= &whdr;
2308c3e34a4SDavid Howells 	iov[0].iov_len	= sizeof(whdr);
2318c3e34a4SDavid Howells 	iov[1].iov_base	= &word;
2328c3e34a4SDavid Howells 	iov[1].iov_len	= sizeof(word);
2338c3e34a4SDavid Howells 
2348c3e34a4SDavid Howells 	len = iov[0].iov_len + iov[1].iov_len;
2358c3e34a4SDavid Howells 
2368c3e34a4SDavid Howells 	serial = atomic_inc_return(&conn->serial);
2378c3e34a4SDavid Howells 	whdr.serial = htonl(serial);
2388c3e34a4SDavid Howells 	_proto("Tx CONN ABORT %%%u { %d }", serial, conn->local_abort);
2398c3e34a4SDavid Howells 
24085f32278SDavid Howells 	ret = kernel_sendmsg(conn->params.local->socket, &msg, iov, 2, len);
2418c3e34a4SDavid Howells 	if (ret < 0) {
2426b47fe1dSDavid Howells 		trace_rxrpc_tx_fail(conn->debug_id, serial, ret,
2436b47fe1dSDavid Howells 				    rxrpc_tx_fail_conn_abort);
2448c3e34a4SDavid Howells 		_debug("sendmsg failed: %d", ret);
2458c3e34a4SDavid Howells 		return -EAGAIN;
2468c3e34a4SDavid Howells 	}
2478c3e34a4SDavid Howells 
248ace45becSDavid Howells 	conn->params.peer->last_tx_at = ktime_get_real();
249ace45becSDavid Howells 
2508c3e34a4SDavid Howells 	_leave(" = 0");
2518c3e34a4SDavid Howells 	return 0;
2528c3e34a4SDavid Howells }
2538c3e34a4SDavid Howells 
2548c3e34a4SDavid Howells /*
2558c3e34a4SDavid Howells  * mark a call as being on a now-secured channel
256248f219cSDavid Howells  * - must be called with BH's disabled.
2578c3e34a4SDavid Howells  */
2588c3e34a4SDavid Howells static void rxrpc_call_is_secure(struct rxrpc_call *call)
2598c3e34a4SDavid Howells {
2608c3e34a4SDavid Howells 	_enter("%p", call);
2618c3e34a4SDavid Howells 	if (call) {
262248f219cSDavid Howells 		write_lock_bh(&call->state_lock);
263248f219cSDavid Howells 		if (call->state == RXRPC_CALL_SERVER_SECURING) {
264248f219cSDavid Howells 			call->state = RXRPC_CALL_SERVER_ACCEPTING;
265248f219cSDavid Howells 			rxrpc_notify_socket(call);
266248f219cSDavid Howells 		}
267248f219cSDavid Howells 		write_unlock_bh(&call->state_lock);
2688c3e34a4SDavid Howells 	}
2698c3e34a4SDavid Howells }
2708c3e34a4SDavid Howells 
2718c3e34a4SDavid Howells /*
2728c3e34a4SDavid Howells  * connection-level Rx packet processor
2738c3e34a4SDavid Howells  */
2748c3e34a4SDavid Howells static int rxrpc_process_event(struct rxrpc_connection *conn,
2758c3e34a4SDavid Howells 			       struct sk_buff *skb,
2768c3e34a4SDavid Howells 			       u32 *_abort_code)
2778c3e34a4SDavid Howells {
2788c3e34a4SDavid Howells 	struct rxrpc_skb_priv *sp = rxrpc_skb(skb);
2798c3e34a4SDavid Howells 	__be32 wtmp;
2808c3e34a4SDavid Howells 	u32 abort_code;
2818c3e34a4SDavid Howells 	int loop, ret;
2828c3e34a4SDavid Howells 
2838c3e34a4SDavid Howells 	if (conn->state >= RXRPC_CONN_REMOTELY_ABORTED) {
284248f219cSDavid Howells 		_leave(" = -ECONNABORTED [%u]", conn->state);
2858c3e34a4SDavid Howells 		return -ECONNABORTED;
2868c3e34a4SDavid Howells 	}
2878c3e34a4SDavid Howells 
2888c3e34a4SDavid Howells 	_enter("{%d},{%u,%%%u},", conn->debug_id, sp->hdr.type, sp->hdr.serial);
2898c3e34a4SDavid Howells 
2908c3e34a4SDavid Howells 	switch (sp->hdr.type) {
29118bfeba5SDavid Howells 	case RXRPC_PACKET_TYPE_DATA:
29218bfeba5SDavid Howells 	case RXRPC_PACKET_TYPE_ACK:
2933136ef49SDavid Howells 		rxrpc_conn_retransmit_call(conn, skb,
2943136ef49SDavid Howells 					   sp->hdr.cid & RXRPC_CHANNELMASK);
29518bfeba5SDavid Howells 		return 0;
29618bfeba5SDavid Howells 
2974d4a6ac7SDavid Howells 	case RXRPC_PACKET_TYPE_BUSY:
2984d4a6ac7SDavid Howells 		/* Just ignore BUSY packets for now. */
2994d4a6ac7SDavid Howells 		return 0;
3004d4a6ac7SDavid Howells 
3018c3e34a4SDavid Howells 	case RXRPC_PACKET_TYPE_ABORT:
302775e5b71SDavid Howells 		if (skb_copy_bits(skb, sizeof(struct rxrpc_wire_header),
303fb46f6eeSDavid Howells 				  &wtmp, sizeof(wtmp)) < 0) {
304fb46f6eeSDavid Howells 			trace_rxrpc_rx_eproto(NULL, sp->hdr.serial,
305fb46f6eeSDavid Howells 					      tracepoint_string("bad_abort"));
3068c3e34a4SDavid Howells 			return -EPROTO;
307fb46f6eeSDavid Howells 		}
3088c3e34a4SDavid Howells 		abort_code = ntohl(wtmp);
3098c3e34a4SDavid Howells 		_proto("Rx ABORT %%%u { ac=%d }", sp->hdr.serial, abort_code);
3108c3e34a4SDavid Howells 
3118c3e34a4SDavid Howells 		conn->state = RXRPC_CONN_REMOTELY_ABORTED;
312248f219cSDavid Howells 		rxrpc_abort_calls(conn, RXRPC_CALL_REMOTELY_ABORTED,
3133a92789aSDavid Howells 				  abort_code, -ECONNABORTED);
3148c3e34a4SDavid Howells 		return -ECONNABORTED;
3158c3e34a4SDavid Howells 
3168c3e34a4SDavid Howells 	case RXRPC_PACKET_TYPE_CHALLENGE:
3178c3e34a4SDavid Howells 		return conn->security->respond_to_challenge(conn, skb,
3188c3e34a4SDavid Howells 							    _abort_code);
3198c3e34a4SDavid Howells 
3208c3e34a4SDavid Howells 	case RXRPC_PACKET_TYPE_RESPONSE:
3218c3e34a4SDavid Howells 		ret = conn->security->verify_response(conn, skb, _abort_code);
3228c3e34a4SDavid Howells 		if (ret < 0)
3238c3e34a4SDavid Howells 			return ret;
3248c3e34a4SDavid Howells 
3258c3e34a4SDavid Howells 		ret = conn->security->init_connection_security(conn);
3268c3e34a4SDavid Howells 		if (ret < 0)
3278c3e34a4SDavid Howells 			return ret;
3288c3e34a4SDavid Howells 
329a263629dSHerbert Xu 		ret = conn->security->prime_packet_security(conn);
330a263629dSHerbert Xu 		if (ret < 0)
331a263629dSHerbert Xu 			return ret;
332a263629dSHerbert Xu 
333a1399f8bSDavid Howells 		spin_lock(&conn->channel_lock);
3348c3e34a4SDavid Howells 		spin_lock(&conn->state_lock);
3358c3e34a4SDavid Howells 
336bba304dbSDavid Howells 		if (conn->state == RXRPC_CONN_SERVICE_CHALLENGING) {
337bba304dbSDavid Howells 			conn->state = RXRPC_CONN_SERVICE;
338248f219cSDavid Howells 			spin_unlock(&conn->state_lock);
3398c3e34a4SDavid Howells 			for (loop = 0; loop < RXRPC_MAXCALLS; loop++)
340dee46364SDavid Howells 				rxrpc_call_is_secure(
341dee46364SDavid Howells 					rcu_dereference_protected(
342a1399f8bSDavid Howells 						conn->channels[loop].call,
343a1399f8bSDavid Howells 						lockdep_is_held(&conn->channel_lock)));
344248f219cSDavid Howells 		} else {
345248f219cSDavid Howells 			spin_unlock(&conn->state_lock);
3468c3e34a4SDavid Howells 		}
3478c3e34a4SDavid Howells 
348a1399f8bSDavid Howells 		spin_unlock(&conn->channel_lock);
3498c3e34a4SDavid Howells 		return 0;
3508c3e34a4SDavid Howells 
3518c3e34a4SDavid Howells 	default:
352fb46f6eeSDavid Howells 		trace_rxrpc_rx_eproto(NULL, sp->hdr.serial,
353fb46f6eeSDavid Howells 				      tracepoint_string("bad_conn_pkt"));
3548c3e34a4SDavid Howells 		return -EPROTO;
3558c3e34a4SDavid Howells 	}
3568c3e34a4SDavid Howells }
3578c3e34a4SDavid Howells 
3588c3e34a4SDavid Howells /*
3598c3e34a4SDavid Howells  * set up security and issue a challenge
3608c3e34a4SDavid Howells  */
3618c3e34a4SDavid Howells static void rxrpc_secure_connection(struct rxrpc_connection *conn)
3628c3e34a4SDavid Howells {
3638c3e34a4SDavid Howells 	u32 abort_code;
3648c3e34a4SDavid Howells 	int ret;
3658c3e34a4SDavid Howells 
3668c3e34a4SDavid Howells 	_enter("{%d}", conn->debug_id);
3678c3e34a4SDavid Howells 
3688c3e34a4SDavid Howells 	ASSERT(conn->security_ix != 0);
3698c3e34a4SDavid Howells 
37019ffa01cSDavid Howells 	if (!conn->params.key) {
3718c3e34a4SDavid Howells 		_debug("set up security");
3728c3e34a4SDavid Howells 		ret = rxrpc_init_server_conn_security(conn);
3738c3e34a4SDavid Howells 		switch (ret) {
3748c3e34a4SDavid Howells 		case 0:
3758c3e34a4SDavid Howells 			break;
3768c3e34a4SDavid Howells 		case -ENOENT:
3778c3e34a4SDavid Howells 			abort_code = RX_CALL_DEAD;
3788c3e34a4SDavid Howells 			goto abort;
3798c3e34a4SDavid Howells 		default:
3808c3e34a4SDavid Howells 			abort_code = RXKADNOAUTH;
3818c3e34a4SDavid Howells 			goto abort;
3828c3e34a4SDavid Howells 		}
3838c3e34a4SDavid Howells 	}
3848c3e34a4SDavid Howells 
3858c3e34a4SDavid Howells 	if (conn->security->issue_challenge(conn) < 0) {
3868c3e34a4SDavid Howells 		abort_code = RX_CALL_DEAD;
3878c3e34a4SDavid Howells 		ret = -ENOMEM;
3888c3e34a4SDavid Howells 		goto abort;
3898c3e34a4SDavid Howells 	}
3908c3e34a4SDavid Howells 
3918c3e34a4SDavid Howells 	_leave("");
3928c3e34a4SDavid Howells 	return;
3938c3e34a4SDavid Howells 
3948c3e34a4SDavid Howells abort:
3958c3e34a4SDavid Howells 	_debug("abort %d, %d", ret, abort_code);
3963a92789aSDavid Howells 	rxrpc_abort_connection(conn, ret, abort_code);
3978c3e34a4SDavid Howells 	_leave(" [aborted]");
3988c3e34a4SDavid Howells }
3998c3e34a4SDavid Howells 
4008c3e34a4SDavid Howells /*
4013136ef49SDavid Howells  * Process delayed final ACKs that we haven't subsumed into a subsequent call.
4023136ef49SDavid Howells  */
4033136ef49SDavid Howells static void rxrpc_process_delayed_final_acks(struct rxrpc_connection *conn)
4043136ef49SDavid Howells {
4053136ef49SDavid Howells 	unsigned long j = jiffies, next_j;
4063136ef49SDavid Howells 	unsigned int channel;
4073136ef49SDavid Howells 	bool set;
4083136ef49SDavid Howells 
4093136ef49SDavid Howells again:
4103136ef49SDavid Howells 	next_j = j + LONG_MAX;
4113136ef49SDavid Howells 	set = false;
4123136ef49SDavid Howells 	for (channel = 0; channel < RXRPC_MAXCALLS; channel++) {
4133136ef49SDavid Howells 		struct rxrpc_channel *chan = &conn->channels[channel];
4143136ef49SDavid Howells 		unsigned long ack_at;
4153136ef49SDavid Howells 
4163136ef49SDavid Howells 		if (!test_bit(RXRPC_CONN_FINAL_ACK_0 + channel, &conn->flags))
4173136ef49SDavid Howells 			continue;
4183136ef49SDavid Howells 
4193136ef49SDavid Howells 		smp_rmb(); /* vs rxrpc_disconnect_client_call */
4203136ef49SDavid Howells 		ack_at = READ_ONCE(chan->final_ack_at);
4213136ef49SDavid Howells 
4223136ef49SDavid Howells 		if (time_before(j, ack_at)) {
4233136ef49SDavid Howells 			if (time_before(ack_at, next_j)) {
4243136ef49SDavid Howells 				next_j = ack_at;
4253136ef49SDavid Howells 				set = true;
4263136ef49SDavid Howells 			}
4273136ef49SDavid Howells 			continue;
4283136ef49SDavid Howells 		}
4293136ef49SDavid Howells 
4303136ef49SDavid Howells 		if (test_and_clear_bit(RXRPC_CONN_FINAL_ACK_0 + channel,
4313136ef49SDavid Howells 				       &conn->flags))
4323136ef49SDavid Howells 			rxrpc_conn_retransmit_call(conn, NULL, channel);
4333136ef49SDavid Howells 	}
4343136ef49SDavid Howells 
4353136ef49SDavid Howells 	j = jiffies;
4363136ef49SDavid Howells 	if (time_before_eq(next_j, j))
4373136ef49SDavid Howells 		goto again;
4383136ef49SDavid Howells 	if (set)
4393136ef49SDavid Howells 		rxrpc_reduce_conn_timer(conn, next_j);
4403136ef49SDavid Howells }
4413136ef49SDavid Howells 
4423136ef49SDavid Howells /*
4438c3e34a4SDavid Howells  * connection-level event processor
4448c3e34a4SDavid Howells  */
4458c3e34a4SDavid Howells void rxrpc_process_connection(struct work_struct *work)
4468c3e34a4SDavid Howells {
4478c3e34a4SDavid Howells 	struct rxrpc_connection *conn =
4488c3e34a4SDavid Howells 		container_of(work, struct rxrpc_connection, processor);
4498c3e34a4SDavid Howells 	struct sk_buff *skb;
4508c3e34a4SDavid Howells 	u32 abort_code = RX_PROTOCOL_ERROR;
4518c3e34a4SDavid Howells 	int ret;
4528c3e34a4SDavid Howells 
453363deeabSDavid Howells 	rxrpc_see_connection(conn);
4548c3e34a4SDavid Howells 
4552c4579e4SDavid Howells 	if (test_and_clear_bit(RXRPC_CONN_EV_CHALLENGE, &conn->events))
4568c3e34a4SDavid Howells 		rxrpc_secure_connection(conn);
4578c3e34a4SDavid Howells 
4583136ef49SDavid Howells 	/* Process delayed ACKs whose time has come. */
4593136ef49SDavid Howells 	if (conn->flags & RXRPC_CONN_FINAL_ACK_MASK)
4603136ef49SDavid Howells 		rxrpc_process_delayed_final_acks(conn);
4613136ef49SDavid Howells 
4628c3e34a4SDavid Howells 	/* go through the conn-level event packets, releasing the ref on this
4638c3e34a4SDavid Howells 	 * connection that each one has when we've finished with it */
4648c3e34a4SDavid Howells 	while ((skb = skb_dequeue(&conn->rx_queue))) {
46571f3ca40SDavid Howells 		rxrpc_see_skb(skb, rxrpc_skb_rx_seen);
4668c3e34a4SDavid Howells 		ret = rxrpc_process_event(conn, skb, &abort_code);
4678c3e34a4SDavid Howells 		switch (ret) {
4688c3e34a4SDavid Howells 		case -EPROTO:
4698c3e34a4SDavid Howells 		case -EKEYEXPIRED:
4708c3e34a4SDavid Howells 		case -EKEYREJECTED:
4718c3e34a4SDavid Howells 			goto protocol_error;
4728c2f826dSDavid Howells 		case -ENOMEM:
4738c3e34a4SDavid Howells 		case -EAGAIN:
4748c3e34a4SDavid Howells 			goto requeue_and_leave;
4758c3e34a4SDavid Howells 		case -ECONNABORTED:
4768c3e34a4SDavid Howells 		default:
47771f3ca40SDavid Howells 			rxrpc_free_skb(skb, rxrpc_skb_rx_freed);
4788c3e34a4SDavid Howells 			break;
4798c3e34a4SDavid Howells 		}
4808c3e34a4SDavid Howells 	}
4818c3e34a4SDavid Howells 
4828c3e34a4SDavid Howells out:
4838c3e34a4SDavid Howells 	rxrpc_put_connection(conn);
4848c3e34a4SDavid Howells 	_leave("");
4858c3e34a4SDavid Howells 	return;
4868c3e34a4SDavid Howells 
4878c3e34a4SDavid Howells requeue_and_leave:
4888c3e34a4SDavid Howells 	skb_queue_head(&conn->rx_queue, skb);
4898c3e34a4SDavid Howells 	goto out;
4908c3e34a4SDavid Howells 
4918c3e34a4SDavid Howells protocol_error:
4923a92789aSDavid Howells 	if (rxrpc_abort_connection(conn, ret, abort_code) < 0)
4938c3e34a4SDavid Howells 		goto requeue_and_leave;
49471f3ca40SDavid Howells 	rxrpc_free_skb(skb, rxrpc_skb_rx_freed);
4958c3e34a4SDavid Howells 	goto out;
4968c3e34a4SDavid Howells }
497