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

12
#include <linux/atomic.h>
13
#include <linux/seqlock.h>
14
#include <net/sock.h>
15
#include <net/af_rxrpc.h>
16 17 18 19 20 21 22
#include <rxrpc/packet.h>

#if 0
#define CHECK_SLAB_OKAY(X)				     \
	BUG_ON(atomic_read((X)) >> (sizeof(atomic_t) - 2) == \
	       (POISON_FREE << 8 | POISON_FREE))
#else
23
#define CHECK_SLAB_OKAY(X) do {} while (0)
24 25 26 27 28 29
#endif

#define FCRYPT_BSIZE 8
struct rxrpc_crypt {
	union {
		u8	x[FCRYPT_BSIZE];
A
Al Viro 已提交
30
		__be32	n[2];
31 32 33
	};
} __attribute__((aligned(8)));

34 35 36 37 38
#define rxrpc_queue_work(WS)	queue_work(rxrpc_workqueue, (WS))
#define rxrpc_queue_delayed_work(WS,D)	\
	queue_delayed_work(rxrpc_workqueue, (WS), (D))

#define rxrpc_queue_call(CALL)	rxrpc_queue_work(&(CALL)->processor)
39

40 41
struct rxrpc_connection;

42 43 44 45
/*
 * sk_state for RxRPC sockets
 */
enum {
46 47
	RXRPC_UNBOUND = 0,
	RXRPC_CLIENT_UNBOUND,		/* Unbound socket used as client */
48 49 50 51 52 53 54 55 56 57 58 59
	RXRPC_CLIENT_BOUND,		/* client local address bound */
	RXRPC_SERVER_BOUND,		/* server local address bound */
	RXRPC_SERVER_LISTENING,		/* server listening for connections */
	RXRPC_CLOSE,			/* socket is being closed */
};

/*
 * RxRPC socket definition
 */
struct rxrpc_sock {
	/* WARNING: sk has to be the first member */
	struct sock		sk;
60
	rxrpc_interceptor_t	interceptor;	/* kernel service Rx interceptor function */
61 62 63 64 65 66 67 68
	struct rxrpc_local	*local;		/* local endpoint */
	struct list_head	listen_link;	/* link in the local endpoint's listen list */
	struct list_head	secureq;	/* calls awaiting connection security clearance */
	struct list_head	acceptq;	/* calls awaiting acceptance */
	struct key		*key;		/* security for this socket */
	struct key		*securities;	/* list of server security descriptors */
	struct rb_root		calls;		/* outstanding calls on this socket */
	unsigned long		flags;
69
#define RXRPC_SOCK_CONNECTED		0	/* connect_srx is set */
70 71 72
	rwlock_t		call_lock;	/* lock for calls */
	u32			min_sec_level;	/* minimum security level */
#define RXRPC_SECURITY_MAX	RXRPC_SECURITY_ENCRYPT
73 74
	bool			exclusive;	/* Exclusive connection for a client socket */
	sa_family_t		family;		/* Protocol family created with */
75
	struct sockaddr_rxrpc	srx;		/* local address */
76
	struct sockaddr_rxrpc	connect_srx;	/* Default client address from connect() */
77 78 79 80
};

#define rxrpc_sk(__sk) container_of((__sk), struct rxrpc_sock, sk)

81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100
/*
 * CPU-byteorder normalised Rx packet header.
 */
struct rxrpc_host_header {
	u32		epoch;		/* client boot timestamp */
	u32		cid;		/* connection and channel ID */
	u32		callNumber;	/* call ID (0 for connection-level packets) */
	u32		seq;		/* sequence number of pkt in call stream */
	u32		serial;		/* serial number of pkt sent to network */
	u8		type;		/* packet type */
	u8		flags;		/* packet flags */
	u8		userStatus;	/* app-layer defined status */
	u8		securityIndex;	/* security protocol ID */
	union {
		u16	_rsvd;		/* reserved */
		u16	cksum;		/* kerberos security checksum */
	};
	u16		serviceId;	/* service ID */
} __packed;

101 102 103 104 105 106 107 108
/*
 * RxRPC socket buffer private variables
 * - max 48 bytes (struct sk_buff::cb)
 */
struct rxrpc_skb_priv {
	struct rxrpc_call	*call;		/* call with which associated */
	unsigned long		resend_at;	/* time in jiffies at which to resend */
	union {
109
		unsigned int	offset;		/* offset into buffer of next read */
110 111 112 113 114
		int		remain;		/* amount of space remaining for next write */
		u32		error;		/* network error code */
		bool		need_resend;	/* T if needs resending */
	};

115
	struct rxrpc_host_header hdr;		/* RxRPC packet header from this packet */
116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133
};

#define rxrpc_skb(__skb) ((struct rxrpc_skb_priv *) &(__skb)->cb)

enum rxrpc_command {
	RXRPC_CMD_SEND_DATA,		/* send data message */
	RXRPC_CMD_SEND_ABORT,		/* request abort generation */
	RXRPC_CMD_ACCEPT,		/* [server] accept incoming call */
	RXRPC_CMD_REJECT_BUSY,		/* [server] reject a call as busy */
};

/*
 * RxRPC security module interface
 */
struct rxrpc_security {
	const char		*name;		/* name of this service */
	u8			security_index;	/* security type provided */

134 135 136 137 138 139
	/* Initialise a security service */
	int (*init)(void);

	/* Clean up a security service */
	void (*exit)(void);

140 141 142 143
	/* initialise a connection's security */
	int (*init_connection_security)(struct rxrpc_connection *);

	/* prime a connection's packet security */
144
	int (*prime_packet_security)(struct rxrpc_connection *);
145 146

	/* impose security on a packet */
147
	int (*secure_packet)(struct rxrpc_call *,
148 149 150 151 152
			     struct sk_buff *,
			     size_t,
			     void *);

	/* verify the security on a received packet */
153
	int (*verify_packet)(struct rxrpc_call *, struct sk_buff *, u32 *);
154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172

	/* issue a challenge */
	int (*issue_challenge)(struct rxrpc_connection *);

	/* respond to a challenge */
	int (*respond_to_challenge)(struct rxrpc_connection *,
				    struct sk_buff *,
				    u32 *);

	/* verify a response */
	int (*verify_response)(struct rxrpc_connection *,
			       struct sk_buff *,
			       u32 *);

	/* clear connection security */
	void (*clear)(struct rxrpc_connection *);
};

/*
173 174 175
 * RxRPC local transport endpoint description
 * - owned by a single AF_RXRPC socket
 * - pointed to by transport socket struct sk_user_data
176 177
 */
struct rxrpc_local {
178 179 180
	struct rcu_head		rcu;
	atomic_t		usage;
	struct list_head	link;
181
	struct socket		*socket;	/* my UDP socket */
182
	struct work_struct	processor;
183 184 185 186
	struct list_head	services;	/* services listening on this endpoint */
	struct rw_semaphore	defrag_sem;	/* control re-enablement of IP DF bit */
	struct sk_buff_head	accept_queue;	/* incoming calls awaiting acceptance */
	struct sk_buff_head	reject_queue;	/* packets awaiting rejection */
187
	struct sk_buff_head	event_queue;	/* endpoint event packets awaiting processing */
188 189
	struct rb_root		client_conns;	/* Client connections by socket params */
	spinlock_t		client_conns_lock; /* Lock for client_conns */
190 191 192
	spinlock_t		lock;		/* access lock */
	rwlock_t		services_lock;	/* lock for services list */
	int			debug_id;	/* debug ID for printks */
193
	bool			dead;
194 195 196 197 198
	struct sockaddr_rxrpc	srx;		/* local address */
};

/*
 * RxRPC remote transport endpoint definition
199
 * - matched by local endpoint, remote port, address and protocol type
200 201
 */
struct rxrpc_peer {
202 203 204 205 206
	struct rcu_head		rcu;		/* This must be first */
	atomic_t		usage;
	unsigned long		hash_key;
	struct hlist_node	hash_link;
	struct rxrpc_local	*local;
207 208
	struct hlist_head	error_targets;	/* targets for net error distribution */
	struct work_struct	error_distributor;
209
	struct rb_root		service_conns;	/* Service connections */
210
	seqlock_t		service_conn_lock;
211
	spinlock_t		lock;		/* access lock */
212 213 214
	unsigned int		if_mtu;		/* interface MTU for this peer */
	unsigned int		mtu;		/* network MTU for this peer */
	unsigned int		maxdata;	/* data size (MTU - hdrsize) */
215 216
	unsigned short		hdrsize;	/* header size (IP + UDP + RxRPC) */
	int			debug_id;	/* debug ID for printks */
217 218
	int			error_report;	/* Net (+0) or local (+1000000) to distribute */
#define RXRPC_LOCAL_ERROR_OFFSET 1000000
219 220 221 222 223
	struct sockaddr_rxrpc	srx;		/* remote address */

	/* calculated RTT cache */
#define RXRPC_RTT_CACHE_SIZE 32
	suseconds_t		rtt;		/* current RTT estimate (in uS) */
224 225
	unsigned int		rtt_point;	/* next entry at which to insert */
	unsigned int		rtt_usage;	/* amount of cache actually used */
226 227 228
	suseconds_t		rtt_cache[RXRPC_RTT_CACHE_SIZE]; /* calculated RTT cache */
};

229 230 231 232
/*
 * Keys for matching a connection.
 */
struct rxrpc_conn_proto {
233 234 235 236 237 238
	union {
		struct {
			u32	epoch;		/* epoch of this connection */
			u32	cid;		/* connection ID */
		};
		u64		index_key;
239 240 241 242 243 244 245 246 247 248 249 250
	};
};

struct rxrpc_conn_parameters {
	struct rxrpc_local	*local;		/* Representation of local endpoint */
	struct rxrpc_peer	*peer;		/* Remote endpoint */
	struct key		*key;		/* Security details */
	bool			exclusive;	/* T if conn is exclusive */
	u16			service_id;	/* Service ID for this connection */
	u32			security_level;	/* Security level selected */
};

251 252 253 254 255
/*
 * Bits in the connection flags.
 */
enum rxrpc_conn_flag {
	RXRPC_CONN_HAS_IDR,		/* Has a client conn ID assigned */
256 257
	RXRPC_CONN_IN_SERVICE_CONNS,	/* Conn is in peer->service_conns */
	RXRPC_CONN_IN_CLIENT_CONNS,	/* Conn is in local->client_conns */
258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281
};

/*
 * Events that can be raised upon a connection.
 */
enum rxrpc_conn_event {
	RXRPC_CONN_EV_CHALLENGE,	/* Send challenge packet */
};

/*
 * The connection protocol state.
 */
enum rxrpc_conn_proto_state {
	RXRPC_CONN_UNUSED,		/* Connection not yet attempted */
	RXRPC_CONN_CLIENT,		/* Client connection */
	RXRPC_CONN_SERVICE_UNSECURED,	/* Service unsecured connection */
	RXRPC_CONN_SERVICE_CHALLENGING,	/* Service challenging for security */
	RXRPC_CONN_SERVICE,		/* Service secured connection */
	RXRPC_CONN_REMOTELY_ABORTED,	/* Conn aborted by peer */
	RXRPC_CONN_LOCALLY_ABORTED,	/* Conn aborted locally */
	RXRPC_CONN_NETWORK_ERROR,	/* Conn terminated by network error */
	RXRPC_CONN__NR_STATES
};

282 283
/*
 * RxRPC connection definition
284
 * - matched by { local, peer, epoch, conn_id, direction }
285 286 287
 * - each connection can only handle four simultaneous calls
 */
struct rxrpc_connection {
288 289 290
	struct rxrpc_conn_proto	proto;
	struct rxrpc_conn_parameters params;

291
	spinlock_t		channel_lock;
292 293 294 295 296 297

	struct rxrpc_channel {
		struct rxrpc_call __rcu	*call;		/* Active call */
		u32			call_id;	/* ID of current call */
		u32			call_counter;	/* Call ID counter */
		u32			last_call;	/* ID of last call */
298 299 300 301 302 303
		u8			last_type;	/* Type of last packet */
		u16			last_service_id;
		union {
			u32		last_seq;
			u32		last_abort;
		};
304
	} channels[RXRPC_MAXCALLS];
305 306
	wait_queue_head_t	channel_wq;	/* queue to wait for channel to become available */

307
	struct rcu_head		rcu;
308
	struct work_struct	processor;	/* connection event processor */
309 310
	union {
		struct rb_node	client_node;	/* Node in local->client_conns */
311
		struct rb_node	service_node;	/* Node in peer->service_conns */
312
	};
313 314
	struct list_head	link;		/* link in master connection list */
	struct sk_buff_head	rx_queue;	/* received conn-level packets */
315
	const struct rxrpc_security *security;	/* applied security module */
316
	struct key		*server_key;	/* security for this service */
H
Herbert Xu 已提交
317
	struct crypto_skcipher	*cipher;	/* encryption handle */
318
	struct rxrpc_crypt	csum_iv;	/* packet checksum base */
319
	unsigned long		flags;
320
	unsigned long		events;
321
	unsigned long		idle_timestamp;	/* Time at which last became idle */
322 323
	spinlock_t		state_lock;	/* state-change lock */
	atomic_t		usage;
324
	enum rxrpc_conn_proto_state state : 8;	/* current state of connection */
325 326 327
	u32			local_abort;	/* local abort code */
	u32			remote_abort;	/* remote abort code */
	int			error;		/* local error incurred */
328 329
	int			debug_id;	/* debug ID for printks */
	atomic_t		serial;		/* packet serial number counter */
330
	unsigned int		hi_serial;	/* highest serial number received */
331
	atomic_t		avail_chans;	/* number of channels available */
332 333 334 335 336 337 338 339
	u8			size_align;	/* data size alignment (for security) */
	u8			header_size;	/* rxrpc + security header size */
	u8			security_size;	/* security header size */
	u32			security_nonce;	/* response re-use preventer */
	u8			security_ix;	/* security type */
	u8			out_clientflag;	/* RXRPC_CLIENT_INITIATED if we are client */
};

340 341 342 343 344 345 346 347 348 349 350 351
/*
 * Flags in call->flags.
 */
enum rxrpc_call_flag {
	RXRPC_CALL_RELEASED,		/* call has been released - no more message to userspace */
	RXRPC_CALL_TERMINAL_MSG,	/* call has given the socket its final message */
	RXRPC_CALL_RCVD_LAST,		/* all packets received */
	RXRPC_CALL_RUN_RTIMER,		/* Tx resend timer started */
	RXRPC_CALL_TX_SOFT_ACK,		/* sent some soft ACKs */
	RXRPC_CALL_INIT_ACCEPT,		/* acceptance was initiated */
	RXRPC_CALL_HAS_USERID,		/* has a user ID attached */
	RXRPC_CALL_EXPECT_OOS,		/* expect out of sequence packets */
352
	RXRPC_CALL_IS_SERVICE,		/* Call is service call */
353 354 355 356 357 358
};

/*
 * Events that can be raised on a call.
 */
enum rxrpc_call_event {
359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375
	RXRPC_CALL_EV_RCVD_ACKALL,	/* ACKALL or reply received */
	RXRPC_CALL_EV_RCVD_BUSY,	/* busy packet received */
	RXRPC_CALL_EV_RCVD_ABORT,	/* abort packet received */
	RXRPC_CALL_EV_RCVD_ERROR,	/* network error received */
	RXRPC_CALL_EV_ACK_FINAL,	/* need to generate final ACK (and release call) */
	RXRPC_CALL_EV_ACK,		/* need to generate ACK */
	RXRPC_CALL_EV_REJECT_BUSY,	/* need to generate busy message */
	RXRPC_CALL_EV_ABORT,		/* need to generate abort */
	RXRPC_CALL_EV_CONN_ABORT,	/* local connection abort generated */
	RXRPC_CALL_EV_RESEND_TIMER,	/* Tx resend timer expired */
	RXRPC_CALL_EV_RESEND,		/* Tx resend required */
	RXRPC_CALL_EV_DRAIN_RX_OOS,	/* drain the Rx out of sequence queue */
	RXRPC_CALL_EV_LIFE_TIMER,	/* call's lifetimer ran out */
	RXRPC_CALL_EV_ACCEPTED,		/* incoming call accepted by userspace app */
	RXRPC_CALL_EV_SECURED,		/* incoming call's connection is now secure */
	RXRPC_CALL_EV_POST_ACCEPT,	/* need to post an "accept?" message to the app */
	RXRPC_CALL_EV_RELEASE,		/* need to release the call's resources */
376 377 378 379 380 381
};

/*
 * The states that a call can be in.
 */
enum rxrpc_call_state {
382 383
	RXRPC_CALL_UNINITIALISED,
	RXRPC_CALL_CLIENT_AWAIT_CONN,	/* - client waiting for connection to become available */
384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402
	RXRPC_CALL_CLIENT_SEND_REQUEST,	/* - client sending request phase */
	RXRPC_CALL_CLIENT_AWAIT_REPLY,	/* - client awaiting reply */
	RXRPC_CALL_CLIENT_RECV_REPLY,	/* - client receiving reply phase */
	RXRPC_CALL_CLIENT_FINAL_ACK,	/* - client sending final ACK phase */
	RXRPC_CALL_SERVER_SECURING,	/* - server securing request connection */
	RXRPC_CALL_SERVER_ACCEPTING,	/* - server accepting request */
	RXRPC_CALL_SERVER_RECV_REQUEST,	/* - server receiving request */
	RXRPC_CALL_SERVER_ACK_REQUEST,	/* - server pending ACK of request */
	RXRPC_CALL_SERVER_SEND_REPLY,	/* - server sending reply */
	RXRPC_CALL_SERVER_AWAIT_ACK,	/* - server awaiting final ACK */
	RXRPC_CALL_COMPLETE,		/* - call completed */
	RXRPC_CALL_SERVER_BUSY,		/* - call rejected by busy server */
	RXRPC_CALL_REMOTELY_ABORTED,	/* - call aborted by peer */
	RXRPC_CALL_LOCALLY_ABORTED,	/* - call aborted locally on error or close */
	RXRPC_CALL_NETWORK_ERROR,	/* - call terminated by network error */
	RXRPC_CALL_DEAD,		/* - call is dead */
	NR__RXRPC_CALL_STATES
};

403 404 405 406 407
/*
 * RxRPC call definition
 * - matched by { connection, call_id }
 */
struct rxrpc_call {
408
	struct rcu_head		rcu;
409
	struct rxrpc_connection	*conn;		/* connection carrying call */
410
	struct rxrpc_peer	*peer;		/* Peer record for remote address */
411 412 413 414 415 416 417 418
	struct rxrpc_sock	*socket;	/* socket responsible */
	struct timer_list	lifetimer;	/* lifetime remaining on call */
	struct timer_list	deadspan;	/* reap timer for re-ACK'ing, etc  */
	struct timer_list	ack_timer;	/* ACK generation timer */
	struct timer_list	resend_timer;	/* Tx resend timer */
	struct work_struct	destroyer;	/* call destroyer */
	struct work_struct	processor;	/* packet processor and ACK generator */
	struct list_head	link;		/* link in master call list */
419
	struct hlist_node	error_link;	/* link in error distribution list */
420 421 422 423 424 425
	struct list_head	accept_link;	/* calls awaiting acceptance */
	struct rb_node		sock_node;	/* node in socket call tree */
	struct sk_buff_head	rx_queue;	/* received packets */
	struct sk_buff_head	rx_oos_queue;	/* packets received out of sequence */
	struct sk_buff		*tx_pending;	/* Tx socket buffer being filled */
	wait_queue_head_t	tx_waitq;	/* wait for Tx window space to become available */
426
	__be32			crypto_buf[2];	/* Temporary packet crypto buffer */
427 428 429 430 431 432 433
	unsigned long		user_call_ID;	/* user-defined call ID */
	unsigned long		creation_jif;	/* time of call creation */
	unsigned long		flags;
	unsigned long		events;
	spinlock_t		lock;
	rwlock_t		state_lock;	/* lock for state transition */
	atomic_t		usage;
434
	atomic_t		skb_count;	/* Outstanding packets on this call */
435
	atomic_t		sequence;	/* Tx data packet sequence counter */
436 437
	u32			local_abort;	/* local abort code */
	u32			remote_abort;	/* remote abort code */
438 439
	int			error_report;	/* Network error (ICMP/local transport) */
	int			error;		/* Local error incurred */
440
	enum rxrpc_call_state	state : 8;	/* current state of call */
441 442 443 444
	u16			service_id;	/* service ID */
	u32			call_id;	/* call ID on connection  */
	u32			cid;		/* connection ID plus channel index */
	int			debug_id;	/* debug ID for printks */
445 446

	/* transmission-phase ACK management */
447 448 449 450
	u8			acks_head;	/* offset into window of first entry */
	u8			acks_tail;	/* offset into window of last entry */
	u8			acks_winsz;	/* size of un-ACK'd window */
	u8			acks_unacked;	/* lowest unacked packet in last ACK received */
451 452 453 454 455 456 457 458 459 460 461 462 463
	int			acks_latest;	/* serial number of latest ACK received */
	rxrpc_seq_t		acks_hard;	/* highest definitively ACK'd msg seq */
	unsigned long		*acks_window;	/* sent packet window
						 * - elements are pointers with LSB set if ACK'd
						 */

	/* receive-phase ACK management */
	rxrpc_seq_t		rx_data_expect;	/* next data seq ID expected to be received */
	rxrpc_seq_t		rx_data_post;	/* next data seq ID expected to be posted */
	rxrpc_seq_t		rx_data_recv;	/* last data seq ID encountered by recvmsg */
	rxrpc_seq_t		rx_data_eaten;	/* last data seq ID consumed by recvmsg */
	rxrpc_seq_t		rx_first_oos;	/* first packet in rx_oos_queue (or 0) */
	rxrpc_seq_t		ackr_win_top;	/* top of ACK window (rx_data_eaten is bottom) */
464
	rxrpc_seq_t		ackr_prev_seq;	/* previous sequence number received */
465
	u8			ackr_reason;	/* reason to ACK */
466
	u16			ackr_skew;	/* skew on packet being ACK'd */
467
	rxrpc_serial_t		ackr_serial;	/* serial of packet being ACK'd */
468 469 470 471 472 473 474 475 476 477 478 479 480 481
	atomic_t		ackr_not_idle;	/* number of packets in Rx queue */

	/* received packet records, 1 bit per record */
#define RXRPC_ACKR_WINDOW_ASZ DIV_ROUND_UP(RXRPC_MAXACKS, BITS_PER_LONG)
	unsigned long		ackr_window[RXRPC_ACKR_WINDOW_ASZ + 1];
};

/*
 * locally abort an RxRPC call
 */
static inline void rxrpc_abort_call(struct rxrpc_call *call, u32 abort_code)
{
	write_lock_bh(&call->state_lock);
	if (call->state < RXRPC_CALL_COMPLETE) {
482
		call->local_abort = abort_code;
483
		call->state = RXRPC_CALL_LOCALLY_ABORTED;
484
		set_bit(RXRPC_CALL_EV_ABORT, &call->events);
485 486 487 488
	}
	write_unlock_bh(&call->state_lock);
}

489 490
#include <trace/events/rxrpc.h>

491
/*
492
 * af_rxrpc.c
493
 */
494
extern atomic_t rxrpc_n_skbs;
495
extern u32 rxrpc_epoch;
496 497
extern atomic_t rxrpc_debug_id;
extern struct workqueue_struct *rxrpc_workqueue;
498 499

/*
500
 * call_accept.c
501
 */
502
void rxrpc_accept_incoming_calls(struct rxrpc_local *);
503 504
struct rxrpc_call *rxrpc_accept_call(struct rxrpc_sock *, unsigned long);
int rxrpc_reject_call(struct rxrpc_sock *);
505 506

/*
507
 * call_event.c
508
 */
509 510
void __rxrpc_propose_ACK(struct rxrpc_call *, u8, u16, u32, bool);
void rxrpc_propose_ACK(struct rxrpc_call *, u8, u16, u32, bool);
511
void rxrpc_process_call(struct work_struct *);
512 513

/*
514
 * call_object.c
515
 */
516 517
extern unsigned int rxrpc_max_call_lifetime;
extern unsigned int rxrpc_dead_call_expiry;
518 519 520 521
extern struct kmem_cache *rxrpc_call_jar;
extern struct list_head rxrpc_calls;
extern rwlock_t rxrpc_call_lock;

522 523
struct rxrpc_call *rxrpc_find_call_by_user_ID(struct rxrpc_sock *, unsigned long);
struct rxrpc_call *rxrpc_new_client_call(struct rxrpc_sock *,
524
					 struct rxrpc_conn_parameters *,
525
					 struct sockaddr_rxrpc *,
526
					 unsigned long, gfp_t);
527 528
struct rxrpc_call *rxrpc_incoming_call(struct rxrpc_sock *,
				       struct rxrpc_connection *,
529
				       struct sk_buff *);
530 531 532 533
void rxrpc_release_call(struct rxrpc_call *);
void rxrpc_release_calls_on_socket(struct rxrpc_sock *);
void __rxrpc_put_call(struct rxrpc_call *);
void __exit rxrpc_destroy_all_calls(void);
534

535 536 537 538 539 540 541 542 543 544
static inline bool rxrpc_is_service_call(const struct rxrpc_call *call)
{
	return test_bit(RXRPC_CALL_IS_SERVICE, &call->flags);
}

static inline bool rxrpc_is_client_call(const struct rxrpc_call *call)
{
	return !rxrpc_is_service_call(call);
}

545 546 547 548 549
/*
 * conn_client.c
 */
extern struct idr rxrpc_client_conn_ids;

550
void rxrpc_destroy_client_conn_ids(void);
551 552
int rxrpc_connect_call(struct rxrpc_call *, struct rxrpc_conn_parameters *,
		       struct sockaddr_rxrpc *, gfp_t);
553
void rxrpc_unpublish_client_conn(struct rxrpc_connection *);
554

555
/*
556 557 558 559
 * conn_event.c
 */
void rxrpc_process_connection(struct work_struct *);
void rxrpc_reject_packet(struct rxrpc_local *, struct sk_buff *);
560
void rxrpc_reject_packets(struct rxrpc_local *);
561 562 563

/*
 * conn_object.c
564
 */
565
extern unsigned int rxrpc_connection_expiry;
566 567 568
extern struct list_head rxrpc_connections;
extern rwlock_t rxrpc_connection_lock;

569
int rxrpc_extract_addr_from_skb(struct sockaddr_rxrpc *, struct sk_buff *);
570
struct rxrpc_connection *rxrpc_alloc_connection(gfp_t);
571 572
struct rxrpc_connection *rxrpc_find_connection_rcu(struct rxrpc_local *,
						   struct sk_buff *);
573
void __rxrpc_disconnect_call(struct rxrpc_call *);
574
void rxrpc_disconnect_call(struct rxrpc_call *);
575
void __rxrpc_put_connection(struct rxrpc_connection *);
576
void __exit rxrpc_destroy_all_connections(void);
577

578 579 580 581 582 583 584
static inline bool rxrpc_conn_is_client(const struct rxrpc_connection *conn)
{
	return conn->out_clientflag;
}

static inline bool rxrpc_conn_is_service(const struct rxrpc_connection *conn)
{
585
	return !rxrpc_conn_is_client(conn);
586 587
}

588 589 590 591 592
static inline void rxrpc_get_connection(struct rxrpc_connection *conn)
{
	atomic_inc(&conn->usage);
}

593 594 595 596 597
static inline
struct rxrpc_connection *rxrpc_get_connection_maybe(struct rxrpc_connection *conn)
{
	return atomic_inc_not_zero(&conn->usage) ? conn : NULL;
}
598

599 600 601 602 603 604 605
static inline void rxrpc_put_connection(struct rxrpc_connection *conn)
{
	if (conn && atomic_dec_return(&conn->usage) == 1)
		__rxrpc_put_connection(conn);
}


606
static inline bool rxrpc_queue_conn(struct rxrpc_connection *conn)
607
{
608 609 610
	if (!rxrpc_get_connection_maybe(conn))
		return false;
	if (!rxrpc_queue_work(&conn->processor))
611
		rxrpc_put_connection(conn);
612
	return true;
613 614
}

615 616 617
/*
 * conn_service.c
 */
618 619
struct rxrpc_connection *rxrpc_find_service_conn_rcu(struct rxrpc_peer *,
						     struct sk_buff *);
620
struct rxrpc_connection *rxrpc_incoming_connection(struct rxrpc_local *,
621
						   struct sockaddr_rxrpc *,
622
						   struct sk_buff *);
623
void rxrpc_unpublish_service_conn(struct rxrpc_connection *);
624

625
/*
626
 * input.c
627
 */
628 629 630
void rxrpc_data_ready(struct sock *);
int rxrpc_queue_rcv_skb(struct rxrpc_call *, struct sk_buff *, bool, bool);
void rxrpc_fast_process_packet(struct rxrpc_call *, struct sk_buff *);
631 632

/*
633
 * insecure.c
634
 */
635
extern const struct rxrpc_security rxrpc_no_security;
636 637

/*
638
 * key.c
639
 */
640 641 642 643 644 645 646
extern struct key_type key_type_rxrpc;
extern struct key_type key_type_rxrpc_s;

int rxrpc_request_key(struct rxrpc_sock *, char __user *, int);
int rxrpc_server_keyring(struct rxrpc_sock *, char __user *, int);
int rxrpc_get_server_data_key(struct rxrpc_connection *, const void *, time_t,
			      u32);
647

648 649 650
/*
 * local_event.c
 */
651
extern void rxrpc_process_local_events(struct rxrpc_local *);
652

653
/*
654
 * local_object.c
655
 */
656 657
struct rxrpc_local *rxrpc_lookup_local(const struct sockaddr_rxrpc *);
void __rxrpc_put_local(struct rxrpc_local *);
658
void __exit rxrpc_destroy_all_locals(void);
659

660 661 662 663 664 665 666 667 668 669 670 671 672
static inline void rxrpc_get_local(struct rxrpc_local *local)
{
	atomic_inc(&local->usage);
}

static inline
struct rxrpc_local *rxrpc_get_local_maybe(struct rxrpc_local *local)
{
	return atomic_inc_not_zero(&local->usage) ? local : NULL;
}

static inline void rxrpc_put_local(struct rxrpc_local *local)
{
673
	if (local && atomic_dec_and_test(&local->usage))
674 675 676
		__rxrpc_put_local(local);
}

677 678 679 680 681
static inline void rxrpc_queue_local(struct rxrpc_local *local)
{
	rxrpc_queue_work(&local->processor);
}

682
/*
683
 * misc.c
684
 */
685 686 687 688 689 690 691
extern unsigned int rxrpc_max_backlog __read_mostly;
extern unsigned int rxrpc_requested_ack_delay;
extern unsigned int rxrpc_soft_ack_delay;
extern unsigned int rxrpc_idle_ack_delay;
extern unsigned int rxrpc_rx_window_size;
extern unsigned int rxrpc_rx_mtu;
extern unsigned int rxrpc_rx_jumbo_max;
692

693 694 695 696
extern const char *const rxrpc_pkts[];
extern const s8 rxrpc_ack_priority[];

extern const char *rxrpc_acks(u8 reason);
697 698

/*
699
 * output.c
700
 */
701
extern unsigned int rxrpc_resend_timeout;
702

703
int rxrpc_send_data_packet(struct rxrpc_connection *, struct sk_buff *);
704
int rxrpc_do_sendmsg(struct rxrpc_sock *, struct msghdr *, size_t);
705 706

/*
707
 * peer_event.c
708
 */
709
void rxrpc_error_report(struct sock *);
710
void rxrpc_peer_error_distributor(struct work_struct *);
711 712 713

/*
 * peer_object.c
714
 */
715 716 717 718 719 720
struct rxrpc_peer *rxrpc_lookup_peer_rcu(struct rxrpc_local *,
					 const struct sockaddr_rxrpc *);
struct rxrpc_peer *rxrpc_lookup_peer(struct rxrpc_local *,
				     struct sockaddr_rxrpc *, gfp_t);
struct rxrpc_peer *rxrpc_alloc_peer(struct rxrpc_local *, gfp_t);

721
static inline struct rxrpc_peer *rxrpc_get_peer(struct rxrpc_peer *peer)
722 723
{
	atomic_inc(&peer->usage);
724
	return peer;
725 726 727 728 729 730 731 732 733 734 735
}

static inline
struct rxrpc_peer *rxrpc_get_peer_maybe(struct rxrpc_peer *peer)
{
	return atomic_inc_not_zero(&peer->usage) ? peer : NULL;
}

extern void __rxrpc_put_peer(struct rxrpc_peer *peer);
static inline void rxrpc_put_peer(struct rxrpc_peer *peer)
{
736
	if (peer && atomic_dec_and_test(&peer->usage))
737 738
		__rxrpc_put_peer(peer);
}
739 740

/*
741
 * proc.c
742
 */
743 744 745
extern const char *const rxrpc_call_states[];
extern const struct file_operations rxrpc_call_seq_fops;
extern const struct file_operations rxrpc_connection_seq_fops;
746 747

/*
748
 * recvmsg.c
749
 */
750
void rxrpc_remove_user_ID(struct rxrpc_sock *, struct rxrpc_call *);
751
int rxrpc_recvmsg(struct socket *, struct msghdr *, size_t, int);
752 753

/*
754 755 756 757 758 759 760 761
 * rxkad.c
 */
#ifdef CONFIG_RXKAD
extern const struct rxrpc_security rxkad;
#endif

/*
 * security.c
762
 */
763 764
int __init rxrpc_init_security(void);
void rxrpc_exit_security(void);
765 766
int rxrpc_init_client_conn_security(struct rxrpc_connection *);
int rxrpc_init_server_conn_security(struct rxrpc_connection *);
767 768

/*
769
 * skbuff.c
770
 */
771
void rxrpc_packet_destructor(struct sk_buff *);
772 773 774 775 776
void rxrpc_new_skb(struct sk_buff *);
void rxrpc_see_skb(struct sk_buff *);
void rxrpc_get_skb(struct sk_buff *);
void rxrpc_free_skb(struct sk_buff *);
void rxrpc_purge_queue(struct sk_buff_head *);
777

778 779 780 781 782 783 784 785 786 787 788
/*
 * sysctl.c
 */
#ifdef CONFIG_SYSCTL
extern int __init rxrpc_sysctl_init(void);
extern void rxrpc_sysctl_exit(void);
#else
static inline int __init rxrpc_sysctl_init(void) { return 0; }
static inline void rxrpc_sysctl_exit(void) {}
#endif

789 790 791
/*
 * utils.c
 */
792
int rxrpc_extract_addr_from_skb(struct sockaddr_rxrpc *, struct sk_buff *);
793

794 795 796
/*
 * debug tracing
 */
797
extern unsigned int rxrpc_debug;
798 799

#define dbgprintk(FMT,...) \
800
	printk("[%-6.6s] "FMT"\n", current->comm ,##__VA_ARGS__)
801

802 803
#define kenter(FMT,...)	dbgprintk("==> %s("FMT")",__func__ ,##__VA_ARGS__)
#define kleave(FMT,...)	dbgprintk("<== %s()"FMT"",__func__ ,##__VA_ARGS__)
804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853
#define kdebug(FMT,...)	dbgprintk("    "FMT ,##__VA_ARGS__)
#define kproto(FMT,...)	dbgprintk("### "FMT ,##__VA_ARGS__)
#define knet(FMT,...)	dbgprintk("@@@ "FMT ,##__VA_ARGS__)


#if defined(__KDEBUG)
#define _enter(FMT,...)	kenter(FMT,##__VA_ARGS__)
#define _leave(FMT,...)	kleave(FMT,##__VA_ARGS__)
#define _debug(FMT,...)	kdebug(FMT,##__VA_ARGS__)
#define _proto(FMT,...)	kproto(FMT,##__VA_ARGS__)
#define _net(FMT,...)	knet(FMT,##__VA_ARGS__)

#elif defined(CONFIG_AF_RXRPC_DEBUG)
#define RXRPC_DEBUG_KENTER	0x01
#define RXRPC_DEBUG_KLEAVE	0x02
#define RXRPC_DEBUG_KDEBUG	0x04
#define RXRPC_DEBUG_KPROTO	0x08
#define RXRPC_DEBUG_KNET	0x10

#define _enter(FMT,...)					\
do {							\
	if (unlikely(rxrpc_debug & RXRPC_DEBUG_KENTER))	\
		kenter(FMT,##__VA_ARGS__);		\
} while (0)

#define _leave(FMT,...)					\
do {							\
	if (unlikely(rxrpc_debug & RXRPC_DEBUG_KLEAVE))	\
		kleave(FMT,##__VA_ARGS__);		\
} while (0)

#define _debug(FMT,...)					\
do {							\
	if (unlikely(rxrpc_debug & RXRPC_DEBUG_KDEBUG))	\
		kdebug(FMT,##__VA_ARGS__);		\
} while (0)

#define _proto(FMT,...)					\
do {							\
	if (unlikely(rxrpc_debug & RXRPC_DEBUG_KPROTO))	\
		kproto(FMT,##__VA_ARGS__);		\
} while (0)

#define _net(FMT,...)					\
do {							\
	if (unlikely(rxrpc_debug & RXRPC_DEBUG_KNET))	\
		knet(FMT,##__VA_ARGS__);		\
} while (0)

#else
854 855 856 857 858
#define _enter(FMT,...)	no_printk("==> %s("FMT")",__func__ ,##__VA_ARGS__)
#define _leave(FMT,...)	no_printk("<== %s()"FMT"",__func__ ,##__VA_ARGS__)
#define _debug(FMT,...)	no_printk("    "FMT ,##__VA_ARGS__)
#define _proto(FMT,...)	no_printk("### "FMT ,##__VA_ARGS__)
#define _net(FMT,...)	no_printk("@@@ "FMT ,##__VA_ARGS__)
859 860 861 862 863 864 865 866 867 868
#endif

/*
 * debug assertion checking
 */
#if 1 // defined(__KDEBUGALL)

#define ASSERT(X)						\
do {								\
	if (unlikely(!(X))) {					\
869
		pr_err("Assertion failed\n");			\
870 871
		BUG();						\
	}							\
872
} while (0)
873 874 875

#define ASSERTCMP(X, OP, Y)						\
do {									\
876 877 878 879 880
	unsigned long _x = (unsigned long)(X);				\
	unsigned long _y = (unsigned long)(Y);				\
	if (unlikely(!(_x OP _y))) {					\
		pr_err("Assertion failed - %lu(0x%lx) %s %lu(0x%lx) is false\n",			\
		       _x, _x, #OP, _y, _y);				\
881 882
		BUG();							\
	}								\
883
} while (0)
884 885 886 887

#define ASSERTIF(C, X)						\
do {								\
	if (unlikely((C) && !(X))) {				\
888
		pr_err("Assertion failed\n");			\
889 890
		BUG();						\
	}							\
891
} while (0)
892 893 894

#define ASSERTIFCMP(C, X, OP, Y)					\
do {									\
895 896 897 898 899
	unsigned long _x = (unsigned long)(X);				\
	unsigned long _y = (unsigned long)(Y);				\
	if (unlikely((C) && !(_x OP _y))) {				\
		pr_err("Assertion failed - %lu(0x%lx) %s %lu(0x%lx) is false\n", \
		       _x, _x, #OP, _y, _y);				\
900 901
		BUG();							\
	}								\
902
} while (0)
903 904 905 906 907

#else

#define ASSERT(X)				\
do {						\
908
} while (0)
909 910 911

#define ASSERTCMP(X, OP, Y)			\
do {						\
912
} while (0)
913 914 915

#define ASSERTIF(C, X)				\
do {						\
916
} while (0)
917 918 919

#define ASSERTIFCMP(C, X, OP, Y)		\
do {						\
920
} while (0)
921 922 923 924 925 926 927 928 929

#endif /* __KDEBUGALL */


#define rxrpc_get_call(CALL)				\
do {							\
	CHECK_SLAB_OKAY(&(CALL)->usage);		\
	if (atomic_inc_return(&(CALL)->usage) == 1)	\
		BUG();					\
930
} while (0)
931 932 933 934

#define rxrpc_put_call(CALL)				\
do {							\
	__rxrpc_put_call(CALL);				\
935
} while (0)