xref: /openbmc/linux/net/rxrpc/ar-internal.h (revision b7019ac5)
1 /* SPDX-License-Identifier: GPL-2.0-or-later */
2 /* AF_RXRPC internal definitions
3  *
4  * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
5  * Written by David Howells (dhowells@redhat.com)
6  */
7 
8 #include <linux/atomic.h>
9 #include <linux/seqlock.h>
10 #include <net/net_namespace.h>
11 #include <net/netns/generic.h>
12 #include <net/sock.h>
13 #include <net/af_rxrpc.h>
14 #include "protocol.h"
15 
16 #if 0
17 #define CHECK_SLAB_OKAY(X)				     \
18 	BUG_ON(atomic_read((X)) >> (sizeof(atomic_t) - 2) == \
19 	       (POISON_FREE << 8 | POISON_FREE))
20 #else
21 #define CHECK_SLAB_OKAY(X) do {} while (0)
22 #endif
23 
24 #define FCRYPT_BSIZE 8
25 struct rxrpc_crypt {
26 	union {
27 		u8	x[FCRYPT_BSIZE];
28 		__be32	n[2];
29 	};
30 } __attribute__((aligned(8)));
31 
32 #define rxrpc_queue_work(WS)	queue_work(rxrpc_workqueue, (WS))
33 #define rxrpc_queue_delayed_work(WS,D)	\
34 	queue_delayed_work(rxrpc_workqueue, (WS), (D))
35 
36 struct rxrpc_connection;
37 
38 /*
39  * Mark applied to socket buffers in skb->mark.  skb->priority is used
40  * to pass supplementary information.
41  */
42 enum rxrpc_skb_mark {
43 	RXRPC_SKB_MARK_REJECT_BUSY,	/* Reject with BUSY */
44 	RXRPC_SKB_MARK_REJECT_ABORT,	/* Reject with ABORT (code in skb->priority) */
45 };
46 
47 /*
48  * sk_state for RxRPC sockets
49  */
50 enum {
51 	RXRPC_UNBOUND = 0,
52 	RXRPC_CLIENT_UNBOUND,		/* Unbound socket used as client */
53 	RXRPC_CLIENT_BOUND,		/* client local address bound */
54 	RXRPC_SERVER_BOUND,		/* server local address bound */
55 	RXRPC_SERVER_BOUND2,		/* second server local address bound */
56 	RXRPC_SERVER_LISTENING,		/* server listening for connections */
57 	RXRPC_SERVER_LISTEN_DISABLED,	/* server listening disabled */
58 	RXRPC_CLOSE,			/* socket is being closed */
59 };
60 
61 /*
62  * Per-network namespace data.
63  */
64 struct rxrpc_net {
65 	struct proc_dir_entry	*proc_net;	/* Subdir in /proc/net */
66 	u32			epoch;		/* Local epoch for detecting local-end reset */
67 	struct list_head	calls;		/* List of calls active in this namespace */
68 	rwlock_t		call_lock;	/* Lock for ->calls */
69 	atomic_t		nr_calls;	/* Count of allocated calls */
70 
71 	atomic_t		nr_conns;
72 	struct list_head	conn_proc_list;	/* List of conns in this namespace for proc */
73 	struct list_head	service_conns;	/* Service conns in this namespace */
74 	rwlock_t		conn_lock;	/* Lock for ->conn_proc_list, ->service_conns */
75 	struct work_struct	service_conn_reaper;
76 	struct timer_list	service_conn_reap_timer;
77 
78 	unsigned int		nr_client_conns;
79 	unsigned int		nr_active_client_conns;
80 	bool			kill_all_client_conns;
81 	bool			live;
82 	spinlock_t		client_conn_cache_lock; /* Lock for ->*_client_conns */
83 	spinlock_t		client_conn_discard_lock; /* Prevent multiple discarders */
84 	struct list_head	waiting_client_conns;
85 	struct list_head	active_client_conns;
86 	struct list_head	idle_client_conns;
87 	struct work_struct	client_conn_reaper;
88 	struct timer_list	client_conn_reap_timer;
89 
90 	struct list_head	local_endpoints;
91 	struct mutex		local_mutex;	/* Lock for ->local_endpoints */
92 
93 	DECLARE_HASHTABLE	(peer_hash, 10);
94 	spinlock_t		peer_hash_lock;	/* Lock for ->peer_hash */
95 
96 #define RXRPC_KEEPALIVE_TIME 20 /* NAT keepalive time in seconds */
97 	u8			peer_keepalive_cursor;
98 	time64_t		peer_keepalive_base;
99 	struct list_head	peer_keepalive[32];
100 	struct list_head	peer_keepalive_new;
101 	struct timer_list	peer_keepalive_timer;
102 	struct work_struct	peer_keepalive_work;
103 };
104 
105 /*
106  * Service backlog preallocation.
107  *
108  * This contains circular buffers of preallocated peers, connections and calls
109  * for incoming service calls and their head and tail pointers.  This allows
110  * calls to be set up in the data_ready handler, thereby avoiding the need to
111  * shuffle packets around so much.
112  */
113 struct rxrpc_backlog {
114 	unsigned short		peer_backlog_head;
115 	unsigned short		peer_backlog_tail;
116 	unsigned short		conn_backlog_head;
117 	unsigned short		conn_backlog_tail;
118 	unsigned short		call_backlog_head;
119 	unsigned short		call_backlog_tail;
120 #define RXRPC_BACKLOG_MAX	32
121 	struct rxrpc_peer	*peer_backlog[RXRPC_BACKLOG_MAX];
122 	struct rxrpc_connection	*conn_backlog[RXRPC_BACKLOG_MAX];
123 	struct rxrpc_call	*call_backlog[RXRPC_BACKLOG_MAX];
124 };
125 
126 /*
127  * RxRPC socket definition
128  */
129 struct rxrpc_sock {
130 	/* WARNING: sk has to be the first member */
131 	struct sock		sk;
132 	rxrpc_notify_new_call_t	notify_new_call; /* Func to notify of new call */
133 	rxrpc_discard_new_call_t discard_new_call; /* Func to discard a new call */
134 	struct rxrpc_local	*local;		/* local endpoint */
135 	struct rxrpc_backlog	*backlog;	/* Preallocation for services */
136 	spinlock_t		incoming_lock;	/* Incoming call vs service shutdown lock */
137 	struct list_head	sock_calls;	/* List of calls owned by this socket */
138 	struct list_head	to_be_accepted;	/* calls awaiting acceptance */
139 	struct list_head	recvmsg_q;	/* Calls awaiting recvmsg's attention  */
140 	rwlock_t		recvmsg_lock;	/* Lock for recvmsg_q */
141 	struct key		*key;		/* security for this socket */
142 	struct key		*securities;	/* list of server security descriptors */
143 	struct rb_root		calls;		/* User ID -> call mapping */
144 	unsigned long		flags;
145 #define RXRPC_SOCK_CONNECTED		0	/* connect_srx is set */
146 	rwlock_t		call_lock;	/* lock for calls */
147 	u32			min_sec_level;	/* minimum security level */
148 #define RXRPC_SECURITY_MAX	RXRPC_SECURITY_ENCRYPT
149 	bool			exclusive;	/* Exclusive connection for a client socket */
150 	u16			second_service;	/* Additional service bound to the endpoint */
151 	struct {
152 		/* Service upgrade information */
153 		u16		from;		/* Service ID to upgrade (if not 0) */
154 		u16		to;		/* service ID to upgrade to */
155 	} service_upgrade;
156 	sa_family_t		family;		/* Protocol family created with */
157 	struct sockaddr_rxrpc	srx;		/* Primary Service/local addresses */
158 	struct sockaddr_rxrpc	connect_srx;	/* Default client address from connect() */
159 };
160 
161 #define rxrpc_sk(__sk) container_of((__sk), struct rxrpc_sock, sk)
162 
163 /*
164  * CPU-byteorder normalised Rx packet header.
165  */
166 struct rxrpc_host_header {
167 	u32		epoch;		/* client boot timestamp */
168 	u32		cid;		/* connection and channel ID */
169 	u32		callNumber;	/* call ID (0 for connection-level packets) */
170 	u32		seq;		/* sequence number of pkt in call stream */
171 	u32		serial;		/* serial number of pkt sent to network */
172 	u8		type;		/* packet type */
173 	u8		flags;		/* packet flags */
174 	u8		userStatus;	/* app-layer defined status */
175 	u8		securityIndex;	/* security protocol ID */
176 	union {
177 		u16	_rsvd;		/* reserved */
178 		u16	cksum;		/* kerberos security checksum */
179 	};
180 	u16		serviceId;	/* service ID */
181 } __packed;
182 
183 /*
184  * RxRPC socket buffer private variables
185  * - max 48 bytes (struct sk_buff::cb)
186  */
187 struct rxrpc_skb_priv {
188 	union {
189 		u8		nr_jumbo;	/* Number of jumbo subpackets */
190 	};
191 	union {
192 		int		remain;		/* amount of space remaining for next write */
193 	};
194 
195 	struct rxrpc_host_header hdr;		/* RxRPC packet header from this packet */
196 };
197 
198 #define rxrpc_skb(__skb) ((struct rxrpc_skb_priv *) &(__skb)->cb)
199 
200 /*
201  * RxRPC security module interface
202  */
203 struct rxrpc_security {
204 	const char		*name;		/* name of this service */
205 	u8			security_index;	/* security type provided */
206 
207 	/* Initialise a security service */
208 	int (*init)(void);
209 
210 	/* Clean up a security service */
211 	void (*exit)(void);
212 
213 	/* initialise a connection's security */
214 	int (*init_connection_security)(struct rxrpc_connection *);
215 
216 	/* prime a connection's packet security */
217 	int (*prime_packet_security)(struct rxrpc_connection *);
218 
219 	/* impose security on a packet */
220 	int (*secure_packet)(struct rxrpc_call *,
221 			     struct sk_buff *,
222 			     size_t,
223 			     void *);
224 
225 	/* verify the security on a received packet */
226 	int (*verify_packet)(struct rxrpc_call *, struct sk_buff *,
227 			     unsigned int, unsigned int, rxrpc_seq_t, u16);
228 
229 	/* Locate the data in a received packet that has been verified. */
230 	void (*locate_data)(struct rxrpc_call *, struct sk_buff *,
231 			    unsigned int *, unsigned int *);
232 
233 	/* issue a challenge */
234 	int (*issue_challenge)(struct rxrpc_connection *);
235 
236 	/* respond to a challenge */
237 	int (*respond_to_challenge)(struct rxrpc_connection *,
238 				    struct sk_buff *,
239 				    u32 *);
240 
241 	/* verify a response */
242 	int (*verify_response)(struct rxrpc_connection *,
243 			       struct sk_buff *,
244 			       u32 *);
245 
246 	/* clear connection security */
247 	void (*clear)(struct rxrpc_connection *);
248 };
249 
250 /*
251  * RxRPC local transport endpoint description
252  * - owned by a single AF_RXRPC socket
253  * - pointed to by transport socket struct sk_user_data
254  */
255 struct rxrpc_local {
256 	struct rcu_head		rcu;
257 	atomic_t		usage;
258 	struct rxrpc_net	*rxnet;		/* The network ns in which this resides */
259 	struct list_head	link;
260 	struct socket		*socket;	/* my UDP socket */
261 	struct work_struct	processor;
262 	struct rxrpc_sock __rcu	*service;	/* Service(s) listening on this endpoint */
263 	struct rw_semaphore	defrag_sem;	/* control re-enablement of IP DF bit */
264 	struct sk_buff_head	reject_queue;	/* packets awaiting rejection */
265 	struct sk_buff_head	event_queue;	/* endpoint event packets awaiting processing */
266 	struct rb_root		client_conns;	/* Client connections by socket params */
267 	spinlock_t		client_conns_lock; /* Lock for client_conns */
268 	spinlock_t		lock;		/* access lock */
269 	rwlock_t		services_lock;	/* lock for services list */
270 	int			debug_id;	/* debug ID for printks */
271 	bool			dead;
272 	bool			service_closed;	/* Service socket closed */
273 	struct sockaddr_rxrpc	srx;		/* local address */
274 };
275 
276 /*
277  * RxRPC remote transport endpoint definition
278  * - matched by local endpoint, remote port, address and protocol type
279  */
280 struct rxrpc_peer {
281 	struct rcu_head		rcu;		/* This must be first */
282 	atomic_t		usage;
283 	unsigned long		hash_key;
284 	struct hlist_node	hash_link;
285 	struct rxrpc_local	*local;
286 	struct hlist_head	error_targets;	/* targets for net error distribution */
287 	struct rb_root		service_conns;	/* Service connections */
288 	struct list_head	keepalive_link;	/* Link in net->peer_keepalive[] */
289 	time64_t		last_tx_at;	/* Last time packet sent here */
290 	seqlock_t		service_conn_lock;
291 	spinlock_t		lock;		/* access lock */
292 	unsigned int		if_mtu;		/* interface MTU for this peer */
293 	unsigned int		mtu;		/* network MTU for this peer */
294 	unsigned int		maxdata;	/* data size (MTU - hdrsize) */
295 	unsigned short		hdrsize;	/* header size (IP + UDP + RxRPC) */
296 	int			debug_id;	/* debug ID for printks */
297 	struct sockaddr_rxrpc	srx;		/* remote address */
298 
299 	/* calculated RTT cache */
300 #define RXRPC_RTT_CACHE_SIZE 32
301 	spinlock_t		rtt_input_lock;	/* RTT lock for input routine */
302 	ktime_t			rtt_last_req;	/* Time of last RTT request */
303 	u64			rtt;		/* Current RTT estimate (in nS) */
304 	u64			rtt_sum;	/* Sum of cache contents */
305 	u64			rtt_cache[RXRPC_RTT_CACHE_SIZE]; /* Determined RTT cache */
306 	u8			rtt_cursor;	/* next entry at which to insert */
307 	u8			rtt_usage;	/* amount of cache actually used */
308 
309 	u8			cong_cwnd;	/* Congestion window size */
310 };
311 
312 /*
313  * Keys for matching a connection.
314  */
315 struct rxrpc_conn_proto {
316 	union {
317 		struct {
318 			u32	epoch;		/* epoch of this connection */
319 			u32	cid;		/* connection ID */
320 		};
321 		u64		index_key;
322 	};
323 };
324 
325 struct rxrpc_conn_parameters {
326 	struct rxrpc_local	*local;		/* Representation of local endpoint */
327 	struct rxrpc_peer	*peer;		/* Remote endpoint */
328 	struct key		*key;		/* Security details */
329 	bool			exclusive;	/* T if conn is exclusive */
330 	bool			upgrade;	/* T if service ID can be upgraded */
331 	u16			service_id;	/* Service ID for this connection */
332 	u32			security_level;	/* Security level selected */
333 };
334 
335 /*
336  * Bits in the connection flags.
337  */
338 enum rxrpc_conn_flag {
339 	RXRPC_CONN_HAS_IDR,		/* Has a client conn ID assigned */
340 	RXRPC_CONN_IN_SERVICE_CONNS,	/* Conn is in peer->service_conns */
341 	RXRPC_CONN_IN_CLIENT_CONNS,	/* Conn is in local->client_conns */
342 	RXRPC_CONN_EXPOSED,		/* Conn has extra ref for exposure */
343 	RXRPC_CONN_DONT_REUSE,		/* Don't reuse this connection */
344 	RXRPC_CONN_COUNTED,		/* Counted by rxrpc_nr_client_conns */
345 	RXRPC_CONN_PROBING_FOR_UPGRADE,	/* Probing for service upgrade */
346 	RXRPC_CONN_FINAL_ACK_0,		/* Need final ACK for channel 0 */
347 	RXRPC_CONN_FINAL_ACK_1,		/* Need final ACK for channel 1 */
348 	RXRPC_CONN_FINAL_ACK_2,		/* Need final ACK for channel 2 */
349 	RXRPC_CONN_FINAL_ACK_3,		/* Need final ACK for channel 3 */
350 };
351 
352 #define RXRPC_CONN_FINAL_ACK_MASK ((1UL << RXRPC_CONN_FINAL_ACK_0) |	\
353 				   (1UL << RXRPC_CONN_FINAL_ACK_1) |	\
354 				   (1UL << RXRPC_CONN_FINAL_ACK_2) |	\
355 				   (1UL << RXRPC_CONN_FINAL_ACK_3))
356 
357 /*
358  * Events that can be raised upon a connection.
359  */
360 enum rxrpc_conn_event {
361 	RXRPC_CONN_EV_CHALLENGE,	/* Send challenge packet */
362 };
363 
364 /*
365  * The connection cache state.
366  */
367 enum rxrpc_conn_cache_state {
368 	RXRPC_CONN_CLIENT_INACTIVE,	/* Conn is not yet listed */
369 	RXRPC_CONN_CLIENT_WAITING,	/* Conn is on wait list, waiting for capacity */
370 	RXRPC_CONN_CLIENT_ACTIVE,	/* Conn is on active list, doing calls */
371 	RXRPC_CONN_CLIENT_UPGRADE,	/* Conn is on active list, probing for upgrade */
372 	RXRPC_CONN_CLIENT_CULLED,	/* Conn is culled and delisted, doing calls */
373 	RXRPC_CONN_CLIENT_IDLE,		/* Conn is on idle list, doing mostly nothing */
374 	RXRPC_CONN__NR_CACHE_STATES
375 };
376 
377 /*
378  * The connection protocol state.
379  */
380 enum rxrpc_conn_proto_state {
381 	RXRPC_CONN_UNUSED,		/* Connection not yet attempted */
382 	RXRPC_CONN_CLIENT,		/* Client connection */
383 	RXRPC_CONN_SERVICE_PREALLOC,	/* Service connection preallocation */
384 	RXRPC_CONN_SERVICE_UNSECURED,	/* Service unsecured connection */
385 	RXRPC_CONN_SERVICE_CHALLENGING,	/* Service challenging for security */
386 	RXRPC_CONN_SERVICE,		/* Service secured connection */
387 	RXRPC_CONN_REMOTELY_ABORTED,	/* Conn aborted by peer */
388 	RXRPC_CONN_LOCALLY_ABORTED,	/* Conn aborted locally */
389 	RXRPC_CONN__NR_STATES
390 };
391 
392 /*
393  * RxRPC connection definition
394  * - matched by { local, peer, epoch, conn_id, direction }
395  * - each connection can only handle four simultaneous calls
396  */
397 struct rxrpc_connection {
398 	struct rxrpc_conn_proto	proto;
399 	struct rxrpc_conn_parameters params;
400 
401 	atomic_t		usage;
402 	struct rcu_head		rcu;
403 	struct list_head	cache_link;
404 
405 	spinlock_t		channel_lock;
406 	unsigned char		active_chans;	/* Mask of active channels */
407 #define RXRPC_ACTIVE_CHANS_MASK	((1 << RXRPC_MAXCALLS) - 1)
408 	struct list_head	waiting_calls;	/* Calls waiting for channels */
409 	struct rxrpc_channel {
410 		unsigned long		final_ack_at;	/* Time at which to issue final ACK */
411 		struct rxrpc_call __rcu	*call;		/* Active call */
412 		unsigned int		call_debug_id;	/* call->debug_id */
413 		u32			call_id;	/* ID of current call */
414 		u32			call_counter;	/* Call ID counter */
415 		u32			last_call;	/* ID of last call */
416 		u8			last_type;	/* Type of last packet */
417 		union {
418 			u32		last_seq;
419 			u32		last_abort;
420 		};
421 	} channels[RXRPC_MAXCALLS];
422 
423 	struct timer_list	timer;		/* Conn event timer */
424 	struct work_struct	processor;	/* connection event processor */
425 	union {
426 		struct rb_node	client_node;	/* Node in local->client_conns */
427 		struct rb_node	service_node;	/* Node in peer->service_conns */
428 	};
429 	struct list_head	proc_link;	/* link in procfs list */
430 	struct list_head	link;		/* link in master connection list */
431 	struct sk_buff_head	rx_queue;	/* received conn-level packets */
432 	const struct rxrpc_security *security;	/* applied security module */
433 	struct key		*server_key;	/* security for this service */
434 	struct crypto_sync_skcipher *cipher;	/* encryption handle */
435 	struct rxrpc_crypt	csum_iv;	/* packet checksum base */
436 	unsigned long		flags;
437 	unsigned long		events;
438 	unsigned long		idle_timestamp;	/* Time at which last became idle */
439 	spinlock_t		state_lock;	/* state-change lock */
440 	enum rxrpc_conn_cache_state cache_state;
441 	enum rxrpc_conn_proto_state state;	/* current state of connection */
442 	u32			abort_code;	/* Abort code of connection abort */
443 	int			debug_id;	/* debug ID for printks */
444 	atomic_t		serial;		/* packet serial number counter */
445 	unsigned int		hi_serial;	/* highest serial number received */
446 	u32			security_nonce;	/* response re-use preventer */
447 	u32			service_id;	/* Service ID, possibly upgraded */
448 	u8			size_align;	/* data size alignment (for security) */
449 	u8			security_size;	/* security header size */
450 	u8			security_ix;	/* security type */
451 	u8			out_clientflag;	/* RXRPC_CLIENT_INITIATED if we are client */
452 	short			error;		/* Local error code */
453 };
454 
455 static inline bool rxrpc_to_server(const struct rxrpc_skb_priv *sp)
456 {
457 	return sp->hdr.flags & RXRPC_CLIENT_INITIATED;
458 }
459 
460 static inline bool rxrpc_to_client(const struct rxrpc_skb_priv *sp)
461 {
462 	return !rxrpc_to_server(sp);
463 }
464 
465 /*
466  * Flags in call->flags.
467  */
468 enum rxrpc_call_flag {
469 	RXRPC_CALL_RELEASED,		/* call has been released - no more message to userspace */
470 	RXRPC_CALL_HAS_USERID,		/* has a user ID attached */
471 	RXRPC_CALL_IS_SERVICE,		/* Call is service call */
472 	RXRPC_CALL_EXPOSED,		/* The call was exposed to the world */
473 	RXRPC_CALL_RX_LAST,		/* Received the last packet (at rxtx_top) */
474 	RXRPC_CALL_TX_LAST,		/* Last packet in Tx buffer (at rxtx_top) */
475 	RXRPC_CALL_SEND_PING,		/* A ping will need to be sent */
476 	RXRPC_CALL_PINGING,		/* Ping in process */
477 	RXRPC_CALL_RETRANS_TIMEOUT,	/* Retransmission due to timeout occurred */
478 	RXRPC_CALL_BEGAN_RX_TIMER,	/* We began the expect_rx_by timer */
479 	RXRPC_CALL_RX_HEARD,		/* The peer responded at least once to this call */
480 	RXRPC_CALL_RX_UNDERRUN,		/* Got data underrun */
481 	RXRPC_CALL_IS_INTR,		/* The call is interruptible */
482 };
483 
484 /*
485  * Events that can be raised on a call.
486  */
487 enum rxrpc_call_event {
488 	RXRPC_CALL_EV_ACK,		/* need to generate ACK */
489 	RXRPC_CALL_EV_ABORT,		/* need to generate abort */
490 	RXRPC_CALL_EV_RESEND,		/* Tx resend required */
491 	RXRPC_CALL_EV_PING,		/* Ping send required */
492 	RXRPC_CALL_EV_EXPIRED,		/* Expiry occurred */
493 	RXRPC_CALL_EV_ACK_LOST,		/* ACK may be lost, send ping */
494 };
495 
496 /*
497  * The states that a call can be in.
498  */
499 enum rxrpc_call_state {
500 	RXRPC_CALL_UNINITIALISED,
501 	RXRPC_CALL_CLIENT_AWAIT_CONN,	/* - client waiting for connection to become available */
502 	RXRPC_CALL_CLIENT_SEND_REQUEST,	/* - client sending request phase */
503 	RXRPC_CALL_CLIENT_AWAIT_REPLY,	/* - client awaiting reply */
504 	RXRPC_CALL_CLIENT_RECV_REPLY,	/* - client receiving reply phase */
505 	RXRPC_CALL_SERVER_PREALLOC,	/* - service preallocation */
506 	RXRPC_CALL_SERVER_SECURING,	/* - server securing request connection */
507 	RXRPC_CALL_SERVER_ACCEPTING,	/* - server accepting request */
508 	RXRPC_CALL_SERVER_RECV_REQUEST,	/* - server receiving request */
509 	RXRPC_CALL_SERVER_ACK_REQUEST,	/* - server pending ACK of request */
510 	RXRPC_CALL_SERVER_SEND_REPLY,	/* - server sending reply */
511 	RXRPC_CALL_SERVER_AWAIT_ACK,	/* - server awaiting final ACK */
512 	RXRPC_CALL_COMPLETE,		/* - call complete */
513 	NR__RXRPC_CALL_STATES
514 };
515 
516 /*
517  * Call completion condition (state == RXRPC_CALL_COMPLETE).
518  */
519 enum rxrpc_call_completion {
520 	RXRPC_CALL_SUCCEEDED,		/* - Normal termination */
521 	RXRPC_CALL_REMOTELY_ABORTED,	/* - call aborted by peer */
522 	RXRPC_CALL_LOCALLY_ABORTED,	/* - call aborted locally on error or close */
523 	RXRPC_CALL_LOCAL_ERROR,		/* - call failed due to local error */
524 	RXRPC_CALL_NETWORK_ERROR,	/* - call terminated by network error */
525 	NR__RXRPC_CALL_COMPLETIONS
526 };
527 
528 /*
529  * Call Tx congestion management modes.
530  */
531 enum rxrpc_congest_mode {
532 	RXRPC_CALL_SLOW_START,
533 	RXRPC_CALL_CONGEST_AVOIDANCE,
534 	RXRPC_CALL_PACKET_LOSS,
535 	RXRPC_CALL_FAST_RETRANSMIT,
536 	NR__RXRPC_CONGEST_MODES
537 };
538 
539 /*
540  * RxRPC call definition
541  * - matched by { connection, call_id }
542  */
543 struct rxrpc_call {
544 	struct rcu_head		rcu;
545 	struct rxrpc_connection	*conn;		/* connection carrying call */
546 	struct rxrpc_peer	*peer;		/* Peer record for remote address */
547 	struct rxrpc_sock __rcu	*socket;	/* socket responsible */
548 	struct rxrpc_net	*rxnet;		/* Network namespace to which call belongs */
549 	struct mutex		user_mutex;	/* User access mutex */
550 	unsigned long		ack_at;		/* When deferred ACK needs to happen */
551 	unsigned long		ack_lost_at;	/* When ACK is figured as lost */
552 	unsigned long		resend_at;	/* When next resend needs to happen */
553 	unsigned long		ping_at;	/* When next to send a ping */
554 	unsigned long		keepalive_at;	/* When next to send a keepalive ping */
555 	unsigned long		expect_rx_by;	/* When we expect to get a packet by */
556 	unsigned long		expect_req_by;	/* When we expect to get a request DATA packet by */
557 	unsigned long		expect_term_by;	/* When we expect call termination by */
558 	u32			next_rx_timo;	/* Timeout for next Rx packet (jif) */
559 	u32			next_req_timo;	/* Timeout for next Rx request packet (jif) */
560 	struct timer_list	timer;		/* Combined event timer */
561 	struct work_struct	processor;	/* Event processor */
562 	rxrpc_notify_rx_t	notify_rx;	/* kernel service Rx notification function */
563 	struct list_head	link;		/* link in master call list */
564 	struct list_head	chan_wait_link;	/* Link in conn->waiting_calls */
565 	struct hlist_node	error_link;	/* link in error distribution list */
566 	struct list_head	accept_link;	/* Link in rx->acceptq */
567 	struct list_head	recvmsg_link;	/* Link in rx->recvmsg_q */
568 	struct list_head	sock_link;	/* Link in rx->sock_calls */
569 	struct rb_node		sock_node;	/* Node in rx->calls */
570 	struct sk_buff		*tx_pending;	/* Tx socket buffer being filled */
571 	wait_queue_head_t	waitq;		/* Wait queue for channel or Tx */
572 	s64			tx_total_len;	/* Total length left to be transmitted (or -1) */
573 	__be32			crypto_buf[2];	/* Temporary packet crypto buffer */
574 	unsigned long		user_call_ID;	/* user-defined call ID */
575 	unsigned long		flags;
576 	unsigned long		events;
577 	spinlock_t		lock;
578 	spinlock_t		notify_lock;	/* Kernel notification lock */
579 	rwlock_t		state_lock;	/* lock for state transition */
580 	u32			abort_code;	/* Local/remote abort code */
581 	int			error;		/* Local error incurred */
582 	enum rxrpc_call_state	state;		/* current state of call */
583 	enum rxrpc_call_completion completion;	/* Call completion condition */
584 	atomic_t		usage;
585 	u16			service_id;	/* service ID */
586 	u8			security_ix;	/* Security type */
587 	u32			call_id;	/* call ID on connection  */
588 	u32			cid;		/* connection ID plus channel index */
589 	int			debug_id;	/* debug ID for printks */
590 	unsigned short		rx_pkt_offset;	/* Current recvmsg packet offset */
591 	unsigned short		rx_pkt_len;	/* Current recvmsg packet len */
592 
593 	/* Rx/Tx circular buffer, depending on phase.
594 	 *
595 	 * In the Rx phase, packets are annotated with 0 or the number of the
596 	 * segment of a jumbo packet each buffer refers to.  There can be up to
597 	 * 47 segments in a maximum-size UDP packet.
598 	 *
599 	 * In the Tx phase, packets are annotated with which buffers have been
600 	 * acked.
601 	 */
602 #define RXRPC_RXTX_BUFF_SIZE	64
603 #define RXRPC_RXTX_BUFF_MASK	(RXRPC_RXTX_BUFF_SIZE - 1)
604 #define RXRPC_INIT_RX_WINDOW_SIZE 63
605 	struct sk_buff		**rxtx_buffer;
606 	u8			*rxtx_annotations;
607 #define RXRPC_TX_ANNO_ACK	0
608 #define RXRPC_TX_ANNO_UNACK	1
609 #define RXRPC_TX_ANNO_NAK	2
610 #define RXRPC_TX_ANNO_RETRANS	3
611 #define RXRPC_TX_ANNO_MASK	0x03
612 #define RXRPC_TX_ANNO_LAST	0x04
613 #define RXRPC_TX_ANNO_RESENT	0x08
614 
615 #define RXRPC_RX_ANNO_JUMBO	0x3f		/* Jumbo subpacket number + 1 if not zero */
616 #define RXRPC_RX_ANNO_JLAST	0x40		/* Set if last element of a jumbo packet */
617 #define RXRPC_RX_ANNO_VERIFIED	0x80		/* Set if verified and decrypted */
618 	rxrpc_seq_t		tx_hard_ack;	/* Dead slot in buffer; the first transmitted but
619 						 * not hard-ACK'd packet follows this.
620 						 */
621 	rxrpc_seq_t		tx_top;		/* Highest Tx slot allocated. */
622 	u16			tx_backoff;	/* Delay to insert due to Tx failure */
623 
624 	/* TCP-style slow-start congestion control [RFC5681].  Since the SMSS
625 	 * is fixed, we keep these numbers in terms of segments (ie. DATA
626 	 * packets) rather than bytes.
627 	 */
628 #define RXRPC_TX_SMSS		RXRPC_JUMBO_DATALEN
629 	u8			cong_cwnd;	/* Congestion window size */
630 	u8			cong_extra;	/* Extra to send for congestion management */
631 	u8			cong_ssthresh;	/* Slow-start threshold */
632 	enum rxrpc_congest_mode	cong_mode:8;	/* Congestion management mode */
633 	u8			cong_dup_acks;	/* Count of ACKs showing missing packets */
634 	u8			cong_cumul_acks; /* Cumulative ACK count */
635 	ktime_t			cong_tstamp;	/* Last time cwnd was changed */
636 
637 	rxrpc_seq_t		rx_hard_ack;	/* Dead slot in buffer; the first received but not
638 						 * consumed packet follows this.
639 						 */
640 	rxrpc_seq_t		rx_top;		/* Highest Rx slot allocated. */
641 	rxrpc_seq_t		rx_expect_next;	/* Expected next packet sequence number */
642 	rxrpc_serial_t		rx_serial;	/* Highest serial received for this call */
643 	u8			rx_winsize;	/* Size of Rx window */
644 	u8			tx_winsize;	/* Maximum size of Tx window */
645 	bool			tx_phase;	/* T if transmission phase, F if receive phase */
646 	u8			nr_jumbo_bad;	/* Number of jumbo dups/exceeds-windows */
647 
648 	spinlock_t		input_lock;	/* Lock for packet input to this call */
649 
650 	/* receive-phase ACK management */
651 	u8			ackr_reason;	/* reason to ACK */
652 	u16			ackr_skew;	/* skew on packet being ACK'd */
653 	rxrpc_serial_t		ackr_serial;	/* serial of packet being ACK'd */
654 	rxrpc_serial_t		ackr_first_seq;	/* first sequence number received */
655 	rxrpc_seq_t		ackr_prev_seq;	/* previous sequence number received */
656 	rxrpc_seq_t		ackr_consumed;	/* Highest packet shown consumed */
657 	rxrpc_seq_t		ackr_seen;	/* Highest packet shown seen */
658 
659 	/* ping management */
660 	rxrpc_serial_t		ping_serial;	/* Last ping sent */
661 	ktime_t			ping_time;	/* Time last ping sent */
662 
663 	/* transmission-phase ACK management */
664 	ktime_t			acks_latest_ts;	/* Timestamp of latest ACK received */
665 	rxrpc_serial_t		acks_latest;	/* serial number of latest ACK received */
666 	rxrpc_seq_t		acks_lowest_nak; /* Lowest NACK in the buffer (or ==tx_hard_ack) */
667 	rxrpc_seq_t		acks_lost_top;	/* tx_top at the time lost-ack ping sent */
668 	rxrpc_serial_t		acks_lost_ping;	/* Serial number of probe ACK */
669 };
670 
671 /*
672  * Summary of a new ACK and the changes it made to the Tx buffer packet states.
673  */
674 struct rxrpc_ack_summary {
675 	u8			ack_reason;
676 	u8			nr_acks;		/* Number of ACKs in packet */
677 	u8			nr_nacks;		/* Number of NACKs in packet */
678 	u8			nr_new_acks;		/* Number of new ACKs in packet */
679 	u8			nr_new_nacks;		/* Number of new NACKs in packet */
680 	u8			nr_rot_new_acks;	/* Number of rotated new ACKs */
681 	bool			new_low_nack;		/* T if new low NACK found */
682 	bool			retrans_timeo;		/* T if reTx due to timeout happened */
683 	u8			flight_size;		/* Number of unreceived transmissions */
684 	/* Place to stash values for tracing */
685 	enum rxrpc_congest_mode	mode:8;
686 	u8			cwnd;
687 	u8			ssthresh;
688 	u8			dup_acks;
689 	u8			cumulative_acks;
690 };
691 
692 /*
693  * sendmsg() cmsg-specified parameters.
694  */
695 enum rxrpc_command {
696 	RXRPC_CMD_SEND_DATA,		/* send data message */
697 	RXRPC_CMD_SEND_ABORT,		/* request abort generation */
698 	RXRPC_CMD_ACCEPT,		/* [server] accept incoming call */
699 	RXRPC_CMD_REJECT_BUSY,		/* [server] reject a call as busy */
700 };
701 
702 struct rxrpc_call_params {
703 	s64			tx_total_len;	/* Total Tx data length (if send data) */
704 	unsigned long		user_call_ID;	/* User's call ID */
705 	struct {
706 		u32		hard;		/* Maximum lifetime (sec) */
707 		u32		idle;		/* Max time since last data packet (msec) */
708 		u32		normal;		/* Max time since last call packet (msec) */
709 	} timeouts;
710 	u8			nr_timeouts;	/* Number of timeouts specified */
711 	bool			intr;		/* The call is interruptible */
712 };
713 
714 struct rxrpc_send_params {
715 	struct rxrpc_call_params call;
716 	u32			abort_code;	/* Abort code to Tx (if abort) */
717 	enum rxrpc_command	command : 8;	/* The command to implement */
718 	bool			exclusive;	/* Shared or exclusive call */
719 	bool			upgrade;	/* If the connection is upgradeable */
720 };
721 
722 #include <trace/events/rxrpc.h>
723 
724 /*
725  * af_rxrpc.c
726  */
727 extern atomic_t rxrpc_n_tx_skbs, rxrpc_n_rx_skbs;
728 extern struct workqueue_struct *rxrpc_workqueue;
729 
730 /*
731  * call_accept.c
732  */
733 int rxrpc_service_prealloc(struct rxrpc_sock *, gfp_t);
734 void rxrpc_discard_prealloc(struct rxrpc_sock *);
735 struct rxrpc_call *rxrpc_new_incoming_call(struct rxrpc_local *,
736 					   struct rxrpc_sock *,
737 					   struct sk_buff *);
738 void rxrpc_accept_incoming_calls(struct rxrpc_local *);
739 struct rxrpc_call *rxrpc_accept_call(struct rxrpc_sock *, unsigned long,
740 				     rxrpc_notify_rx_t);
741 int rxrpc_reject_call(struct rxrpc_sock *);
742 
743 /*
744  * call_event.c
745  */
746 void rxrpc_propose_ACK(struct rxrpc_call *, u8, u16, u32, bool, bool,
747 		       enum rxrpc_propose_ack_trace);
748 void rxrpc_process_call(struct work_struct *);
749 
750 static inline void rxrpc_reduce_call_timer(struct rxrpc_call *call,
751 					   unsigned long expire_at,
752 					   unsigned long now,
753 					   enum rxrpc_timer_trace why)
754 {
755 	trace_rxrpc_timer(call, why, now);
756 	timer_reduce(&call->timer, expire_at);
757 }
758 
759 /*
760  * call_object.c
761  */
762 extern const char *const rxrpc_call_states[];
763 extern const char *const rxrpc_call_completions[];
764 extern unsigned int rxrpc_max_call_lifetime;
765 extern struct kmem_cache *rxrpc_call_jar;
766 
767 struct rxrpc_call *rxrpc_find_call_by_user_ID(struct rxrpc_sock *, unsigned long);
768 struct rxrpc_call *rxrpc_alloc_call(struct rxrpc_sock *, gfp_t, unsigned int);
769 struct rxrpc_call *rxrpc_new_client_call(struct rxrpc_sock *,
770 					 struct rxrpc_conn_parameters *,
771 					 struct sockaddr_rxrpc *,
772 					 struct rxrpc_call_params *, gfp_t,
773 					 unsigned int);
774 void rxrpc_incoming_call(struct rxrpc_sock *, struct rxrpc_call *,
775 			 struct sk_buff *);
776 void rxrpc_release_call(struct rxrpc_sock *, struct rxrpc_call *);
777 void rxrpc_release_calls_on_socket(struct rxrpc_sock *);
778 bool __rxrpc_queue_call(struct rxrpc_call *);
779 bool rxrpc_queue_call(struct rxrpc_call *);
780 void rxrpc_see_call(struct rxrpc_call *);
781 void rxrpc_get_call(struct rxrpc_call *, enum rxrpc_call_trace);
782 void rxrpc_put_call(struct rxrpc_call *, enum rxrpc_call_trace);
783 void rxrpc_cleanup_call(struct rxrpc_call *);
784 void rxrpc_destroy_all_calls(struct rxrpc_net *);
785 
786 static inline bool rxrpc_is_service_call(const struct rxrpc_call *call)
787 {
788 	return test_bit(RXRPC_CALL_IS_SERVICE, &call->flags);
789 }
790 
791 static inline bool rxrpc_is_client_call(const struct rxrpc_call *call)
792 {
793 	return !rxrpc_is_service_call(call);
794 }
795 
796 /*
797  * Transition a call to the complete state.
798  */
799 static inline bool __rxrpc_set_call_completion(struct rxrpc_call *call,
800 					       enum rxrpc_call_completion compl,
801 					       u32 abort_code,
802 					       int error)
803 {
804 	if (call->state < RXRPC_CALL_COMPLETE) {
805 		call->abort_code = abort_code;
806 		call->error = error;
807 		call->completion = compl,
808 		call->state = RXRPC_CALL_COMPLETE;
809 		trace_rxrpc_call_complete(call);
810 		wake_up(&call->waitq);
811 		return true;
812 	}
813 	return false;
814 }
815 
816 static inline bool rxrpc_set_call_completion(struct rxrpc_call *call,
817 					     enum rxrpc_call_completion compl,
818 					     u32 abort_code,
819 					     int error)
820 {
821 	bool ret;
822 
823 	write_lock_bh(&call->state_lock);
824 	ret = __rxrpc_set_call_completion(call, compl, abort_code, error);
825 	write_unlock_bh(&call->state_lock);
826 	return ret;
827 }
828 
829 /*
830  * Record that a call successfully completed.
831  */
832 static inline bool __rxrpc_call_completed(struct rxrpc_call *call)
833 {
834 	return __rxrpc_set_call_completion(call, RXRPC_CALL_SUCCEEDED, 0, 0);
835 }
836 
837 static inline bool rxrpc_call_completed(struct rxrpc_call *call)
838 {
839 	bool ret;
840 
841 	write_lock_bh(&call->state_lock);
842 	ret = __rxrpc_call_completed(call);
843 	write_unlock_bh(&call->state_lock);
844 	return ret;
845 }
846 
847 /*
848  * Record that a call is locally aborted.
849  */
850 static inline bool __rxrpc_abort_call(const char *why, struct rxrpc_call *call,
851 				      rxrpc_seq_t seq,
852 				      u32 abort_code, int error)
853 {
854 	trace_rxrpc_abort(call->debug_id, why, call->cid, call->call_id, seq,
855 			  abort_code, error);
856 	return __rxrpc_set_call_completion(call, RXRPC_CALL_LOCALLY_ABORTED,
857 					   abort_code, error);
858 }
859 
860 static inline bool rxrpc_abort_call(const char *why, struct rxrpc_call *call,
861 				    rxrpc_seq_t seq, u32 abort_code, int error)
862 {
863 	bool ret;
864 
865 	write_lock_bh(&call->state_lock);
866 	ret = __rxrpc_abort_call(why, call, seq, abort_code, error);
867 	write_unlock_bh(&call->state_lock);
868 	return ret;
869 }
870 
871 /*
872  * Abort a call due to a protocol error.
873  */
874 static inline bool __rxrpc_abort_eproto(struct rxrpc_call *call,
875 					struct sk_buff *skb,
876 					const char *eproto_why,
877 					const char *why,
878 					u32 abort_code)
879 {
880 	struct rxrpc_skb_priv *sp = rxrpc_skb(skb);
881 
882 	trace_rxrpc_rx_eproto(call, sp->hdr.serial, eproto_why);
883 	return rxrpc_abort_call(why, call, sp->hdr.seq, abort_code, -EPROTO);
884 }
885 
886 #define rxrpc_abort_eproto(call, skb, eproto_why, abort_why, abort_code) \
887 	__rxrpc_abort_eproto((call), (skb), tracepoint_string(eproto_why), \
888 			     (abort_why), (abort_code))
889 
890 /*
891  * conn_client.c
892  */
893 extern unsigned int rxrpc_max_client_connections;
894 extern unsigned int rxrpc_reap_client_connections;
895 extern unsigned long rxrpc_conn_idle_client_expiry;
896 extern unsigned long rxrpc_conn_idle_client_fast_expiry;
897 extern struct idr rxrpc_client_conn_ids;
898 
899 void rxrpc_destroy_client_conn_ids(void);
900 int rxrpc_connect_call(struct rxrpc_sock *, struct rxrpc_call *,
901 		       struct rxrpc_conn_parameters *, struct sockaddr_rxrpc *,
902 		       gfp_t);
903 void rxrpc_expose_client_call(struct rxrpc_call *);
904 void rxrpc_disconnect_client_call(struct rxrpc_call *);
905 void rxrpc_put_client_conn(struct rxrpc_connection *);
906 void rxrpc_discard_expired_client_conns(struct work_struct *);
907 void rxrpc_destroy_all_client_connections(struct rxrpc_net *);
908 
909 /*
910  * conn_event.c
911  */
912 void rxrpc_process_connection(struct work_struct *);
913 
914 /*
915  * conn_object.c
916  */
917 extern unsigned int rxrpc_connection_expiry;
918 extern unsigned int rxrpc_closed_conn_expiry;
919 
920 struct rxrpc_connection *rxrpc_alloc_connection(gfp_t);
921 struct rxrpc_connection *rxrpc_find_connection_rcu(struct rxrpc_local *,
922 						   struct sk_buff *,
923 						   struct rxrpc_peer **);
924 void __rxrpc_disconnect_call(struct rxrpc_connection *, struct rxrpc_call *);
925 void rxrpc_disconnect_call(struct rxrpc_call *);
926 void rxrpc_kill_connection(struct rxrpc_connection *);
927 bool rxrpc_queue_conn(struct rxrpc_connection *);
928 void rxrpc_see_connection(struct rxrpc_connection *);
929 void rxrpc_get_connection(struct rxrpc_connection *);
930 struct rxrpc_connection *rxrpc_get_connection_maybe(struct rxrpc_connection *);
931 void rxrpc_put_service_conn(struct rxrpc_connection *);
932 void rxrpc_service_connection_reaper(struct work_struct *);
933 void rxrpc_destroy_all_connections(struct rxrpc_net *);
934 
935 static inline bool rxrpc_conn_is_client(const struct rxrpc_connection *conn)
936 {
937 	return conn->out_clientflag;
938 }
939 
940 static inline bool rxrpc_conn_is_service(const struct rxrpc_connection *conn)
941 {
942 	return !rxrpc_conn_is_client(conn);
943 }
944 
945 static inline void rxrpc_put_connection(struct rxrpc_connection *conn)
946 {
947 	if (!conn)
948 		return;
949 
950 	if (rxrpc_conn_is_client(conn))
951 		rxrpc_put_client_conn(conn);
952 	else
953 		rxrpc_put_service_conn(conn);
954 }
955 
956 static inline void rxrpc_reduce_conn_timer(struct rxrpc_connection *conn,
957 					   unsigned long expire_at)
958 {
959 	timer_reduce(&conn->timer, expire_at);
960 }
961 
962 /*
963  * conn_service.c
964  */
965 struct rxrpc_connection *rxrpc_find_service_conn_rcu(struct rxrpc_peer *,
966 						     struct sk_buff *);
967 struct rxrpc_connection *rxrpc_prealloc_service_connection(struct rxrpc_net *, gfp_t);
968 void rxrpc_new_incoming_connection(struct rxrpc_sock *,
969 				   struct rxrpc_connection *, struct sk_buff *);
970 void rxrpc_unpublish_service_conn(struct rxrpc_connection *);
971 
972 /*
973  * input.c
974  */
975 int rxrpc_input_packet(struct sock *, struct sk_buff *);
976 
977 /*
978  * insecure.c
979  */
980 extern const struct rxrpc_security rxrpc_no_security;
981 
982 /*
983  * key.c
984  */
985 extern struct key_type key_type_rxrpc;
986 extern struct key_type key_type_rxrpc_s;
987 
988 int rxrpc_request_key(struct rxrpc_sock *, char __user *, int);
989 int rxrpc_server_keyring(struct rxrpc_sock *, char __user *, int);
990 int rxrpc_get_server_data_key(struct rxrpc_connection *, const void *, time64_t,
991 			      u32);
992 
993 /*
994  * local_event.c
995  */
996 extern void rxrpc_process_local_events(struct rxrpc_local *);
997 
998 /*
999  * local_object.c
1000  */
1001 struct rxrpc_local *rxrpc_lookup_local(struct net *, const struct sockaddr_rxrpc *);
1002 struct rxrpc_local *rxrpc_get_local(struct rxrpc_local *);
1003 struct rxrpc_local *rxrpc_get_local_maybe(struct rxrpc_local *);
1004 void rxrpc_put_local(struct rxrpc_local *);
1005 void rxrpc_queue_local(struct rxrpc_local *);
1006 void rxrpc_destroy_all_locals(struct rxrpc_net *);
1007 
1008 /*
1009  * misc.c
1010  */
1011 extern unsigned int rxrpc_max_backlog __read_mostly;
1012 extern unsigned long rxrpc_requested_ack_delay;
1013 extern unsigned long rxrpc_soft_ack_delay;
1014 extern unsigned long rxrpc_idle_ack_delay;
1015 extern unsigned int rxrpc_rx_window_size;
1016 extern unsigned int rxrpc_rx_mtu;
1017 extern unsigned int rxrpc_rx_jumbo_max;
1018 extern unsigned long rxrpc_resend_timeout;
1019 
1020 extern const s8 rxrpc_ack_priority[];
1021 
1022 /*
1023  * net_ns.c
1024  */
1025 extern unsigned int rxrpc_net_id;
1026 extern struct pernet_operations rxrpc_net_ops;
1027 
1028 static inline struct rxrpc_net *rxrpc_net(struct net *net)
1029 {
1030 	return net_generic(net, rxrpc_net_id);
1031 }
1032 
1033 /*
1034  * output.c
1035  */
1036 int rxrpc_send_ack_packet(struct rxrpc_call *, bool, rxrpc_serial_t *);
1037 int rxrpc_send_abort_packet(struct rxrpc_call *);
1038 int rxrpc_send_data_packet(struct rxrpc_call *, struct sk_buff *, bool);
1039 void rxrpc_reject_packets(struct rxrpc_local *);
1040 void rxrpc_send_keepalive(struct rxrpc_peer *);
1041 
1042 /*
1043  * peer_event.c
1044  */
1045 void rxrpc_error_report(struct sock *);
1046 void rxrpc_peer_add_rtt(struct rxrpc_call *, enum rxrpc_rtt_rx_trace,
1047 			rxrpc_serial_t, rxrpc_serial_t, ktime_t, ktime_t);
1048 void rxrpc_peer_keepalive_worker(struct work_struct *);
1049 
1050 /*
1051  * peer_object.c
1052  */
1053 struct rxrpc_peer *rxrpc_lookup_peer_rcu(struct rxrpc_local *,
1054 					 const struct sockaddr_rxrpc *);
1055 struct rxrpc_peer *rxrpc_lookup_peer(struct rxrpc_sock *, struct rxrpc_local *,
1056 				     struct sockaddr_rxrpc *, gfp_t);
1057 struct rxrpc_peer *rxrpc_alloc_peer(struct rxrpc_local *, gfp_t);
1058 void rxrpc_new_incoming_peer(struct rxrpc_sock *, struct rxrpc_local *,
1059 			     struct rxrpc_peer *);
1060 void rxrpc_destroy_all_peers(struct rxrpc_net *);
1061 struct rxrpc_peer *rxrpc_get_peer(struct rxrpc_peer *);
1062 struct rxrpc_peer *rxrpc_get_peer_maybe(struct rxrpc_peer *);
1063 void rxrpc_put_peer(struct rxrpc_peer *);
1064 
1065 /*
1066  * proc.c
1067  */
1068 extern const struct seq_operations rxrpc_call_seq_ops;
1069 extern const struct seq_operations rxrpc_connection_seq_ops;
1070 extern const struct seq_operations rxrpc_peer_seq_ops;
1071 
1072 /*
1073  * recvmsg.c
1074  */
1075 void rxrpc_notify_socket(struct rxrpc_call *);
1076 int rxrpc_recvmsg(struct socket *, struct msghdr *, size_t, int);
1077 
1078 /*
1079  * rxkad.c
1080  */
1081 #ifdef CONFIG_RXKAD
1082 extern const struct rxrpc_security rxkad;
1083 #endif
1084 
1085 /*
1086  * security.c
1087  */
1088 int __init rxrpc_init_security(void);
1089 void rxrpc_exit_security(void);
1090 int rxrpc_init_client_conn_security(struct rxrpc_connection *);
1091 int rxrpc_init_server_conn_security(struct rxrpc_connection *);
1092 
1093 /*
1094  * sendmsg.c
1095  */
1096 int rxrpc_do_sendmsg(struct rxrpc_sock *, struct msghdr *, size_t);
1097 
1098 /*
1099  * skbuff.c
1100  */
1101 void rxrpc_kernel_data_consumed(struct rxrpc_call *, struct sk_buff *);
1102 void rxrpc_packet_destructor(struct sk_buff *);
1103 void rxrpc_new_skb(struct sk_buff *, enum rxrpc_skb_trace);
1104 void rxrpc_see_skb(struct sk_buff *, enum rxrpc_skb_trace);
1105 void rxrpc_get_skb(struct sk_buff *, enum rxrpc_skb_trace);
1106 void rxrpc_free_skb(struct sk_buff *, enum rxrpc_skb_trace);
1107 void rxrpc_purge_queue(struct sk_buff_head *);
1108 
1109 /*
1110  * sysctl.c
1111  */
1112 #ifdef CONFIG_SYSCTL
1113 extern int __init rxrpc_sysctl_init(void);
1114 extern void rxrpc_sysctl_exit(void);
1115 #else
1116 static inline int __init rxrpc_sysctl_init(void) { return 0; }
1117 static inline void rxrpc_sysctl_exit(void) {}
1118 #endif
1119 
1120 /*
1121  * utils.c
1122  */
1123 int rxrpc_extract_addr_from_skb(struct sockaddr_rxrpc *, struct sk_buff *);
1124 
1125 static inline bool before(u32 seq1, u32 seq2)
1126 {
1127         return (s32)(seq1 - seq2) < 0;
1128 }
1129 static inline bool before_eq(u32 seq1, u32 seq2)
1130 {
1131         return (s32)(seq1 - seq2) <= 0;
1132 }
1133 static inline bool after(u32 seq1, u32 seq2)
1134 {
1135         return (s32)(seq1 - seq2) > 0;
1136 }
1137 static inline bool after_eq(u32 seq1, u32 seq2)
1138 {
1139         return (s32)(seq1 - seq2) >= 0;
1140 }
1141 
1142 /*
1143  * debug tracing
1144  */
1145 extern unsigned int rxrpc_debug;
1146 
1147 #define dbgprintk(FMT,...) \
1148 	printk("[%-6.6s] "FMT"\n", current->comm ,##__VA_ARGS__)
1149 
1150 #define kenter(FMT,...)	dbgprintk("==> %s("FMT")",__func__ ,##__VA_ARGS__)
1151 #define kleave(FMT,...)	dbgprintk("<== %s()"FMT"",__func__ ,##__VA_ARGS__)
1152 #define kdebug(FMT,...)	dbgprintk("    "FMT ,##__VA_ARGS__)
1153 #define kproto(FMT,...)	dbgprintk("### "FMT ,##__VA_ARGS__)
1154 #define knet(FMT,...)	dbgprintk("@@@ "FMT ,##__VA_ARGS__)
1155 
1156 
1157 #if defined(__KDEBUG)
1158 #define _enter(FMT,...)	kenter(FMT,##__VA_ARGS__)
1159 #define _leave(FMT,...)	kleave(FMT,##__VA_ARGS__)
1160 #define _debug(FMT,...)	kdebug(FMT,##__VA_ARGS__)
1161 #define _proto(FMT,...)	kproto(FMT,##__VA_ARGS__)
1162 #define _net(FMT,...)	knet(FMT,##__VA_ARGS__)
1163 
1164 #elif defined(CONFIG_AF_RXRPC_DEBUG)
1165 #define RXRPC_DEBUG_KENTER	0x01
1166 #define RXRPC_DEBUG_KLEAVE	0x02
1167 #define RXRPC_DEBUG_KDEBUG	0x04
1168 #define RXRPC_DEBUG_KPROTO	0x08
1169 #define RXRPC_DEBUG_KNET	0x10
1170 
1171 #define _enter(FMT,...)					\
1172 do {							\
1173 	if (unlikely(rxrpc_debug & RXRPC_DEBUG_KENTER))	\
1174 		kenter(FMT,##__VA_ARGS__);		\
1175 } while (0)
1176 
1177 #define _leave(FMT,...)					\
1178 do {							\
1179 	if (unlikely(rxrpc_debug & RXRPC_DEBUG_KLEAVE))	\
1180 		kleave(FMT,##__VA_ARGS__);		\
1181 } while (0)
1182 
1183 #define _debug(FMT,...)					\
1184 do {							\
1185 	if (unlikely(rxrpc_debug & RXRPC_DEBUG_KDEBUG))	\
1186 		kdebug(FMT,##__VA_ARGS__);		\
1187 } while (0)
1188 
1189 #define _proto(FMT,...)					\
1190 do {							\
1191 	if (unlikely(rxrpc_debug & RXRPC_DEBUG_KPROTO))	\
1192 		kproto(FMT,##__VA_ARGS__);		\
1193 } while (0)
1194 
1195 #define _net(FMT,...)					\
1196 do {							\
1197 	if (unlikely(rxrpc_debug & RXRPC_DEBUG_KNET))	\
1198 		knet(FMT,##__VA_ARGS__);		\
1199 } while (0)
1200 
1201 #else
1202 #define _enter(FMT,...)	no_printk("==> %s("FMT")",__func__ ,##__VA_ARGS__)
1203 #define _leave(FMT,...)	no_printk("<== %s()"FMT"",__func__ ,##__VA_ARGS__)
1204 #define _debug(FMT,...)	no_printk("    "FMT ,##__VA_ARGS__)
1205 #define _proto(FMT,...)	no_printk("### "FMT ,##__VA_ARGS__)
1206 #define _net(FMT,...)	no_printk("@@@ "FMT ,##__VA_ARGS__)
1207 #endif
1208 
1209 /*
1210  * debug assertion checking
1211  */
1212 #if 1 // defined(__KDEBUGALL)
1213 
1214 #define ASSERT(X)						\
1215 do {								\
1216 	if (unlikely(!(X))) {					\
1217 		pr_err("Assertion failed\n");			\
1218 		BUG();						\
1219 	}							\
1220 } while (0)
1221 
1222 #define ASSERTCMP(X, OP, Y)						\
1223 do {									\
1224 	__typeof__(X) _x = (X);						\
1225 	__typeof__(Y) _y = (__typeof__(X))(Y);				\
1226 	if (unlikely(!(_x OP _y))) {					\
1227 		pr_err("Assertion failed - %lu(0x%lx) %s %lu(0x%lx) is false\n", \
1228 		       (unsigned long)_x, (unsigned long)_x, #OP,	\
1229 		       (unsigned long)_y, (unsigned long)_y);		\
1230 		BUG();							\
1231 	}								\
1232 } while (0)
1233 
1234 #define ASSERTIF(C, X)						\
1235 do {								\
1236 	if (unlikely((C) && !(X))) {				\
1237 		pr_err("Assertion failed\n");			\
1238 		BUG();						\
1239 	}							\
1240 } while (0)
1241 
1242 #define ASSERTIFCMP(C, X, OP, Y)					\
1243 do {									\
1244 	__typeof__(X) _x = (X);						\
1245 	__typeof__(Y) _y = (__typeof__(X))(Y);				\
1246 	if (unlikely((C) && !(_x OP _y))) {				\
1247 		pr_err("Assertion failed - %lu(0x%lx) %s %lu(0x%lx) is false\n", \
1248 		       (unsigned long)_x, (unsigned long)_x, #OP,	\
1249 		       (unsigned long)_y, (unsigned long)_y);		\
1250 		BUG();							\
1251 	}								\
1252 } while (0)
1253 
1254 #else
1255 
1256 #define ASSERT(X)				\
1257 do {						\
1258 } while (0)
1259 
1260 #define ASSERTCMP(X, OP, Y)			\
1261 do {						\
1262 } while (0)
1263 
1264 #define ASSERTIF(C, X)				\
1265 do {						\
1266 } while (0)
1267 
1268 #define ASSERTIFCMP(C, X, OP, Y)		\
1269 do {						\
1270 } while (0)
1271 
1272 #endif /* __KDEBUGALL */
1273