ar-internal.h 33.6 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
#define rxrpc_queue_work(WS)	queue_work(rxrpc_workqueue, (WS))
#define rxrpc_queue_delayed_work(WS,D)	\
	queue_delayed_work(rxrpc_workqueue, (WS), (D))

38 39
struct rxrpc_connection;

40 41 42 43 44 45 46 47 48 49 50 51 52 53
/*
 * Mark applied to socket buffers.
 */
enum rxrpc_skb_mark {
	RXRPC_SKB_MARK_DATA,		/* data message */
	RXRPC_SKB_MARK_FINAL_ACK,	/* final ACK received message */
	RXRPC_SKB_MARK_BUSY,		/* server busy message */
	RXRPC_SKB_MARK_REMOTE_ABORT,	/* remote abort message */
	RXRPC_SKB_MARK_LOCAL_ABORT,	/* local abort message */
	RXRPC_SKB_MARK_NET_ERROR,	/* network error message */
	RXRPC_SKB_MARK_LOCAL_ERROR,	/* local error message */
	RXRPC_SKB_MARK_NEW_CALL,	/* local error message */
};

54 55 56 57
/*
 * sk_state for RxRPC sockets
 */
enum {
58 59
	RXRPC_UNBOUND = 0,
	RXRPC_CLIENT_UNBOUND,		/* Unbound socket used as client */
60 61 62 63 64 65
	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 */
};

66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86
/*
 * Service backlog preallocation.
 *
 * This contains circular buffers of preallocated peers, connections and calls
 * for incoming service calls and their head and tail pointers.  This allows
 * calls to be set up in the data_ready handler, thereby avoiding the need to
 * shuffle packets around so much.
 */
struct rxrpc_backlog {
	unsigned short		peer_backlog_head;
	unsigned short		peer_backlog_tail;
	unsigned short		conn_backlog_head;
	unsigned short		conn_backlog_tail;
	unsigned short		call_backlog_head;
	unsigned short		call_backlog_tail;
#define RXRPC_BACKLOG_MAX	32
	struct rxrpc_peer	*peer_backlog[RXRPC_BACKLOG_MAX];
	struct rxrpc_connection	*conn_backlog[RXRPC_BACKLOG_MAX];
	struct rxrpc_call	*call_backlog[RXRPC_BACKLOG_MAX];
};

87 88 89 90 91 92
/*
 * RxRPC socket definition
 */
struct rxrpc_sock {
	/* WARNING: sk has to be the first member */
	struct sock		sk;
93
	rxrpc_notify_new_call_t	notify_new_call; /* Func to notify of new call */
94
	rxrpc_discard_new_call_t discard_new_call; /* Func to discard a new call */
95
	struct rxrpc_local	*local;		/* local endpoint */
96
	struct hlist_node	listen_link;	/* link in the local endpoint's listen list */
97
	struct rxrpc_backlog	*backlog;	/* Preallocation for services */
98 99 100 101 102
	spinlock_t		incoming_lock;	/* Incoming call vs service shutdown lock */
	struct list_head	sock_calls;	/* List of calls owned by this socket */
	struct list_head	to_be_accepted;	/* calls awaiting acceptance */
	struct list_head	recvmsg_q;	/* Calls awaiting recvmsg's attention  */
	rwlock_t		recvmsg_lock;	/* Lock for recvmsg_q */
103 104
	struct key		*key;		/* security for this socket */
	struct key		*securities;	/* list of server security descriptors */
105
	struct rb_root		calls;		/* User ID -> call mapping */
106
	unsigned long		flags;
107
#define RXRPC_SOCK_CONNECTED		0	/* connect_srx is set */
108 109 110
	rwlock_t		call_lock;	/* lock for calls */
	u32			min_sec_level;	/* minimum security level */
#define RXRPC_SECURITY_MAX	RXRPC_SECURITY_ENCRYPT
111 112
	bool			exclusive;	/* Exclusive connection for a client socket */
	sa_family_t		family;		/* Protocol family created with */
113
	struct sockaddr_rxrpc	srx;		/* local address */
114
	struct sockaddr_rxrpc	connect_srx;	/* Default client address from connect() */
115 116 117 118
};

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

119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138
/*
 * 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;

139 140 141 142 143
/*
 * RxRPC socket buffer private variables
 * - max 48 bytes (struct sk_buff::cb)
 */
struct rxrpc_skb_priv {
144 145 146 147 148 149
	union {
		unsigned long	resend_at;	/* time in jiffies at which to resend */
		struct {
			u8	nr_jumbo;	/* Number of jumbo subpackets */
		};
	};
150
	union {
151
		unsigned int	offset;		/* offset into buffer of next read */
152 153 154 155
		int		remain;		/* amount of space remaining for next write */
		u32		error;		/* network error code */
	};

156
	struct rxrpc_host_header hdr;		/* RxRPC packet header from this packet */
157 158 159 160 161 162 163 164 165 166 167
};

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

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

168 169 170 171 172 173
	/* Initialise a security service */
	int (*init)(void);

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

174 175 176 177
	/* initialise a connection's security */
	int (*init_connection_security)(struct rxrpc_connection *);

	/* prime a connection's packet security */
178
	int (*prime_packet_security)(struct rxrpc_connection *);
179 180

	/* impose security on a packet */
181
	int (*secure_packet)(struct rxrpc_call *,
182 183 184 185 186
			     struct sk_buff *,
			     size_t,
			     void *);

	/* verify the security on a received packet */
187
	int (*verify_packet)(struct rxrpc_call *, struct sk_buff *,
188 189 190 191 192
			     unsigned int, unsigned int, rxrpc_seq_t, u16);

	/* Locate the data in a received packet that has been verified. */
	void (*locate_data)(struct rxrpc_call *, struct sk_buff *,
			    unsigned int *, unsigned int *);
193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211

	/* 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 *);
};

/*
212 213 214
 * RxRPC local transport endpoint description
 * - owned by a single AF_RXRPC socket
 * - pointed to by transport socket struct sk_user_data
215 216
 */
struct rxrpc_local {
217 218 219
	struct rcu_head		rcu;
	atomic_t		usage;
	struct list_head	link;
220
	struct socket		*socket;	/* my UDP socket */
221
	struct work_struct	processor;
222
	struct hlist_head	services;	/* services listening on this endpoint */
223 224
	struct rw_semaphore	defrag_sem;	/* control re-enablement of IP DF bit */
	struct sk_buff_head	reject_queue;	/* packets awaiting rejection */
225
	struct sk_buff_head	event_queue;	/* endpoint event packets awaiting processing */
226 227
	struct rb_root		client_conns;	/* Client connections by socket params */
	spinlock_t		client_conns_lock; /* Lock for client_conns */
228 229 230
	spinlock_t		lock;		/* access lock */
	rwlock_t		services_lock;	/* lock for services list */
	int			debug_id;	/* debug ID for printks */
231
	bool			dead;
232 233 234 235 236
	struct sockaddr_rxrpc	srx;		/* local address */
};

/*
 * RxRPC remote transport endpoint definition
237
 * - matched by local endpoint, remote port, address and protocol type
238 239
 */
struct rxrpc_peer {
240 241 242 243 244
	struct rcu_head		rcu;		/* This must be first */
	atomic_t		usage;
	unsigned long		hash_key;
	struct hlist_node	hash_link;
	struct rxrpc_local	*local;
245 246
	struct hlist_head	error_targets;	/* targets for net error distribution */
	struct work_struct	error_distributor;
247
	struct rb_root		service_conns;	/* Service connections */
248
	seqlock_t		service_conn_lock;
249
	spinlock_t		lock;		/* access lock */
250 251 252
	unsigned int		if_mtu;		/* interface MTU for this peer */
	unsigned int		mtu;		/* network MTU for this peer */
	unsigned int		maxdata;	/* data size (MTU - hdrsize) */
253 254
	unsigned short		hdrsize;	/* header size (IP + UDP + RxRPC) */
	int			debug_id;	/* debug ID for printks */
255 256
	int			error_report;	/* Net (+0) or local (+1000000) to distribute */
#define RXRPC_LOCAL_ERROR_OFFSET 1000000
257 258 259 260 261
	struct sockaddr_rxrpc	srx;		/* remote address */

	/* calculated RTT cache */
#define RXRPC_RTT_CACHE_SIZE 32
	suseconds_t		rtt;		/* current RTT estimate (in uS) */
262 263
	unsigned int		rtt_point;	/* next entry at which to insert */
	unsigned int		rtt_usage;	/* amount of cache actually used */
264 265 266
	suseconds_t		rtt_cache[RXRPC_RTT_CACHE_SIZE]; /* calculated RTT cache */
};

267 268 269 270
/*
 * Keys for matching a connection.
 */
struct rxrpc_conn_proto {
271 272 273 274 275 276
	union {
		struct {
			u32	epoch;		/* epoch of this connection */
			u32	cid;		/* connection ID */
		};
		u64		index_key;
277 278 279 280 281 282 283 284 285 286 287 288
	};
};

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 */
};

289 290 291 292 293
/*
 * Bits in the connection flags.
 */
enum rxrpc_conn_flag {
	RXRPC_CONN_HAS_IDR,		/* Has a client conn ID assigned */
294 295
	RXRPC_CONN_IN_SERVICE_CONNS,	/* Conn is in peer->service_conns */
	RXRPC_CONN_IN_CLIENT_CONNS,	/* Conn is in local->client_conns */
296 297 298
	RXRPC_CONN_EXPOSED,		/* Conn has extra ref for exposure */
	RXRPC_CONN_DONT_REUSE,		/* Don't reuse this connection */
	RXRPC_CONN_COUNTED,		/* Counted by rxrpc_nr_client_conns */
299 300 301 302 303 304 305 306 307
};

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

308 309 310 311 312 313 314 315 316 317 318
/*
 * The connection cache state.
 */
enum rxrpc_conn_cache_state {
	RXRPC_CONN_CLIENT_INACTIVE,	/* Conn is not yet listed */
	RXRPC_CONN_CLIENT_WAITING,	/* Conn is on wait list, waiting for capacity */
	RXRPC_CONN_CLIENT_ACTIVE,	/* Conn is on active list, doing calls */
	RXRPC_CONN_CLIENT_CULLED,	/* Conn is culled and delisted, doing calls */
	RXRPC_CONN_CLIENT_IDLE,		/* Conn is on idle list, doing mostly nothing */
};

319 320 321 322 323 324
/*
 * The connection protocol state.
 */
enum rxrpc_conn_proto_state {
	RXRPC_CONN_UNUSED,		/* Connection not yet attempted */
	RXRPC_CONN_CLIENT,		/* Client connection */
325
	RXRPC_CONN_SERVICE_PREALLOC,	/* Service connection preallocation */
326 327 328 329 330 331 332 333
	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__NR_STATES
};

334 335
/*
 * RxRPC connection definition
336
 * - matched by { local, peer, epoch, conn_id, direction }
337 338 339
 * - each connection can only handle four simultaneous calls
 */
struct rxrpc_connection {
340 341 342
	struct rxrpc_conn_proto	proto;
	struct rxrpc_conn_parameters params;

343 344 345
	atomic_t		usage;
	struct rcu_head		rcu;
	struct list_head	cache_link;
346

347 348 349 350
	spinlock_t		channel_lock;
	unsigned char		active_chans;	/* Mask of active channels */
#define RXRPC_ACTIVE_CHANS_MASK	((1 << RXRPC_MAXCALLS) - 1)
	struct list_head	waiting_calls;	/* Calls waiting for channels */
351 352 353 354 355
	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 */
356 357 358 359 360 361
		u8			last_type;	/* Type of last packet */
		u16			last_service_id;
		union {
			u32		last_seq;
			u32		last_abort;
		};
362
	} channels[RXRPC_MAXCALLS];
363

364
	struct work_struct	processor;	/* connection event processor */
365 366
	union {
		struct rb_node	client_node;	/* Node in local->client_conns */
367
		struct rb_node	service_node;	/* Node in peer->service_conns */
368
	};
369
	struct list_head	proc_link;	/* link in procfs list */
370 371
	struct list_head	link;		/* link in master connection list */
	struct sk_buff_head	rx_queue;	/* received conn-level packets */
372
	const struct rxrpc_security *security;	/* applied security module */
373
	struct key		*server_key;	/* security for this service */
H
Herbert Xu 已提交
374
	struct crypto_skcipher	*cipher;	/* encryption handle */
375
	struct rxrpc_crypt	csum_iv;	/* packet checksum base */
376
	unsigned long		flags;
377
	unsigned long		events;
378
	unsigned long		idle_timestamp;	/* Time at which last became idle */
379
	spinlock_t		state_lock;	/* state-change lock */
380 381
	enum rxrpc_conn_cache_state cache_state;
	enum rxrpc_conn_proto_state state;	/* current state of connection */
382 383
	u32			local_abort;	/* local abort code */
	u32			remote_abort;	/* remote abort code */
384 385
	int			debug_id;	/* debug ID for printks */
	atomic_t		serial;		/* packet serial number counter */
386
	unsigned int		hi_serial;	/* highest serial number received */
387 388 389 390 391 392 393 394
	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 */
};

395 396 397 398 399 400
/*
 * Flags in call->flags.
 */
enum rxrpc_call_flag {
	RXRPC_CALL_RELEASED,		/* call has been released - no more message to userspace */
	RXRPC_CALL_HAS_USERID,		/* has a user ID attached */
401
	RXRPC_CALL_IS_SERVICE,		/* Call is service call */
402
	RXRPC_CALL_EXPOSED,		/* The call was exposed to the world */
403 404
	RXRPC_CALL_RX_LAST,		/* Received the last packet (at rxtx_top) */
	RXRPC_CALL_TX_LAST,		/* Last packet in Tx buffer (at rxtx_top) */
405 406 407 408 409 410
};

/*
 * Events that can be raised on a call.
 */
enum rxrpc_call_event {
411 412
	RXRPC_CALL_EV_ACK,		/* need to generate ACK */
	RXRPC_CALL_EV_ABORT,		/* need to generate abort */
413
	RXRPC_CALL_EV_TIMER,		/* Timer expired */
414
	RXRPC_CALL_EV_RESEND,		/* Tx resend required */
415 416 417 418 419 420
};

/*
 * The states that a call can be in.
 */
enum rxrpc_call_state {
421 422
	RXRPC_CALL_UNINITIALISED,
	RXRPC_CALL_CLIENT_AWAIT_CONN,	/* - client waiting for connection to become available */
423 424 425
	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 */
426
	RXRPC_CALL_SERVER_PREALLOC,	/* - service preallocation */
427 428 429 430 431 432
	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 */
433 434 435 436 437 438 439 440 441
	RXRPC_CALL_COMPLETE,		/* - call complete */
	NR__RXRPC_CALL_STATES
};

/*
 * Call completion condition (state == RXRPC_CALL_COMPLETE).
 */
enum rxrpc_call_completion {
	RXRPC_CALL_SUCCEEDED,		/* - Normal termination */
442 443
	RXRPC_CALL_REMOTELY_ABORTED,	/* - call aborted by peer */
	RXRPC_CALL_LOCALLY_ABORTED,	/* - call aborted locally on error or close */
444
	RXRPC_CALL_LOCAL_ERROR,		/* - call failed due to local error */
445
	RXRPC_CALL_NETWORK_ERROR,	/* - call terminated by network error */
446
	NR__RXRPC_CALL_COMPLETIONS
447 448
};

449 450 451 452 453
/*
 * RxRPC call definition
 * - matched by { connection, call_id }
 */
struct rxrpc_call {
454
	struct rcu_head		rcu;
455
	struct rxrpc_connection	*conn;		/* connection carrying call */
456
	struct rxrpc_peer	*peer;		/* Peer record for remote address */
457
	struct rxrpc_sock __rcu	*socket;	/* socket responsible */
458 459 460 461 462
	unsigned long		ack_at;		/* When deferred ACK needs to happen */
	unsigned long		resend_at;	/* When next resend needs to happen */
	unsigned long		expire_at;	/* When the call times out */
	struct timer_list	timer;		/* Combined event timer */
	struct work_struct	processor;	/* Event processor */
463
	rxrpc_notify_rx_t	notify_rx;	/* kernel service Rx notification function */
464
	struct list_head	link;		/* link in master call list */
465
	struct list_head	chan_wait_link;	/* Link in conn->waiting_calls */
466
	struct hlist_node	error_link;	/* link in error distribution list */
467 468 469 470
	struct list_head	accept_link;	/* Link in rx->acceptq */
	struct list_head	recvmsg_link;	/* Link in rx->recvmsg_q */
	struct list_head	sock_link;	/* Link in rx->sock_calls */
	struct rb_node		sock_node;	/* Node in rx->calls */
471
	struct sk_buff		*tx_pending;	/* Tx socket buffer being filled */
472
	wait_queue_head_t	waitq;		/* Wait queue for channel or Tx */
473
	__be32			crypto_buf[2];	/* Temporary packet crypto buffer */
474 475 476 477 478
	unsigned long		user_call_ID;	/* user-defined call ID */
	unsigned long		flags;
	unsigned long		events;
	spinlock_t		lock;
	rwlock_t		state_lock;	/* lock for state transition */
479 480
	u32			abort_code;	/* Local/remote abort code */
	int			error;		/* Local error incurred */
481 482
	enum rxrpc_call_state	state;		/* current state of call */
	enum rxrpc_call_completion completion;	/* Call completion condition */
483
	atomic_t		usage;
484
	u16			service_id;	/* service ID */
485
	u8			security_ix;	/* Security type */
486 487 488
	u32			call_id;	/* call ID on connection  */
	u32			cid;		/* connection ID plus channel index */
	int			debug_id;	/* debug ID for printks */
489

490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515
	/* Rx/Tx circular buffer, depending on phase.
	 *
	 * In the Rx phase, packets are annotated with 0 or the number of the
	 * segment of a jumbo packet each buffer refers to.  There can be up to
	 * 47 segments in a maximum-size UDP packet.
	 *
	 * In the Tx phase, packets are annotated with which buffers have been
	 * acked.
	 */
#define RXRPC_RXTX_BUFF_SIZE	64
#define RXRPC_RXTX_BUFF_MASK	(RXRPC_RXTX_BUFF_SIZE - 1)
	struct sk_buff		**rxtx_buffer;
	u8			*rxtx_annotations;
#define RXRPC_TX_ANNO_ACK	0
#define RXRPC_TX_ANNO_UNACK	1
#define RXRPC_TX_ANNO_NAK	2
#define RXRPC_TX_ANNO_RETRANS	3
#define RXRPC_RX_ANNO_JUMBO	0x3f		/* Jumbo subpacket number + 1 if not zero */
#define RXRPC_RX_ANNO_JLAST	0x40		/* Set if last element of a jumbo packet */
#define RXRPC_RX_ANNO_VERIFIED	0x80		/* Set if verified and decrypted */
	rxrpc_seq_t		tx_hard_ack;	/* Dead slot in buffer; the first transmitted but
						 * not hard-ACK'd packet follows this.
						 */
	rxrpc_seq_t		tx_top;		/* Highest Tx slot allocated. */
	rxrpc_seq_t		rx_hard_ack;	/* Dead slot in buffer; the first received but not
						 * consumed packet follows this.
516
						 */
517 518 519 520 521
	rxrpc_seq_t		rx_top;		/* Highest Rx slot allocated. */
	rxrpc_seq_t		rx_expect_next;	/* Expected next packet sequence number */
	u8			rx_winsize;	/* Size of Rx window */
	u8			tx_winsize;	/* Maximum size of Tx window */
	u8			nr_jumbo_dup;	/* Number of jumbo duplicates */
522 523

	/* receive-phase ACK management */
524
	u8			ackr_reason;	/* reason to ACK */
525
	u16			ackr_skew;	/* skew on packet being ACK'd */
526
	rxrpc_serial_t		ackr_serial;	/* serial of packet being ACK'd */
527 528 529
	rxrpc_seq_t		ackr_prev_seq;	/* previous sequence number received */
	unsigned short		rx_pkt_offset;	/* Current recvmsg packet offset */
	unsigned short		rx_pkt_len;	/* Current recvmsg packet len */
530

531 532
	/* transmission-phase ACK management */
	rxrpc_serial_t		acks_latest;	/* serial number of latest ACK received */
533 534
};

535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550
enum rxrpc_call_trace {
	rxrpc_call_new_client,
	rxrpc_call_new_service,
	rxrpc_call_queued,
	rxrpc_call_queued_ref,
	rxrpc_call_seen,
	rxrpc_call_got,
	rxrpc_call_got_userid,
	rxrpc_call_put,
	rxrpc_call_put_userid,
	rxrpc_call_put_noqueue,
	rxrpc_call__nr_trace
};

extern const char rxrpc_call_traces[rxrpc_call__nr_trace][4];

551 552
#include <trace/events/rxrpc.h>

553
/*
554
 * af_rxrpc.c
555
 */
556
extern atomic_t rxrpc_n_skbs;
557
extern u32 rxrpc_epoch;
558 559
extern atomic_t rxrpc_debug_id;
extern struct workqueue_struct *rxrpc_workqueue;
560 561

/*
562
 * call_accept.c
563
 */
564 565
int rxrpc_service_prealloc(struct rxrpc_sock *, gfp_t);
void rxrpc_discard_prealloc(struct rxrpc_sock *);
566 567 568
struct rxrpc_call *rxrpc_new_incoming_call(struct rxrpc_local *,
					   struct rxrpc_connection *,
					   struct sk_buff *);
569
void rxrpc_accept_incoming_calls(struct rxrpc_local *);
570 571
struct rxrpc_call *rxrpc_accept_call(struct rxrpc_sock *, unsigned long,
				     rxrpc_notify_rx_t);
572
int rxrpc_reject_call(struct rxrpc_sock *);
573 574

/*
575
 * call_event.c
576
 */
577
void rxrpc_propose_ACK(struct rxrpc_call *, u8, u16, u32, bool, bool);
578
void rxrpc_process_call(struct work_struct *);
579 580

/*
581
 * call_object.c
582
 */
583 584
extern const char *const rxrpc_call_states[];
extern const char *const rxrpc_call_completions[];
585
extern unsigned int rxrpc_max_call_lifetime;
586 587 588 589
extern struct kmem_cache *rxrpc_call_jar;
extern struct list_head rxrpc_calls;
extern rwlock_t rxrpc_call_lock;

590
struct rxrpc_call *rxrpc_find_call_by_user_ID(struct rxrpc_sock *, unsigned long);
591
struct rxrpc_call *rxrpc_alloc_call(gfp_t);
592
struct rxrpc_call *rxrpc_new_client_call(struct rxrpc_sock *,
593
					 struct rxrpc_conn_parameters *,
594
					 struct sockaddr_rxrpc *,
595
					 unsigned long, gfp_t);
596 597
void rxrpc_incoming_call(struct rxrpc_sock *, struct rxrpc_call *,
			 struct sk_buff *);
598
void rxrpc_release_call(struct rxrpc_sock *, struct rxrpc_call *);
599
void rxrpc_release_calls_on_socket(struct rxrpc_sock *);
600 601
bool __rxrpc_queue_call(struct rxrpc_call *);
bool rxrpc_queue_call(struct rxrpc_call *);
D
David Howells 已提交
602
void rxrpc_see_call(struct rxrpc_call *);
603 604
void rxrpc_get_call(struct rxrpc_call *, enum rxrpc_call_trace);
void rxrpc_put_call(struct rxrpc_call *, enum rxrpc_call_trace);
605
void rxrpc_cleanup_call(struct rxrpc_call *);
606
void __exit rxrpc_destroy_all_calls(void);
607

608 609 610 611 612 613 614 615 616 617
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);
}

618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640
/*
 * Transition a call to the complete state.
 */
static inline bool __rxrpc_set_call_completion(struct rxrpc_call *call,
					       enum rxrpc_call_completion compl,
					       u32 abort_code,
					       int error)
{
	if (call->state < RXRPC_CALL_COMPLETE) {
		call->abort_code = abort_code;
		call->error = error;
		call->completion = compl,
		call->state = RXRPC_CALL_COMPLETE;
		return true;
	}
	return false;
}

static inline bool rxrpc_set_call_completion(struct rxrpc_call *call,
					     enum rxrpc_call_completion compl,
					     u32 abort_code,
					     int error)
{
641
	bool ret;
642 643 644 645 646 647 648 649 650 651

	write_lock_bh(&call->state_lock);
	ret = __rxrpc_set_call_completion(call, compl, abort_code, error);
	write_unlock_bh(&call->state_lock);
	return ret;
}

/*
 * Record that a call successfully completed.
 */
652
static inline bool __rxrpc_call_completed(struct rxrpc_call *call)
653
{
654
	return __rxrpc_set_call_completion(call, RXRPC_CALL_SUCCEEDED, 0, 0);
655 656
}

657
static inline bool rxrpc_call_completed(struct rxrpc_call *call)
658
{
659 660
	bool ret;

661
	write_lock_bh(&call->state_lock);
662
	ret = __rxrpc_call_completed(call);
663
	write_unlock_bh(&call->state_lock);
664
	return ret;
665 666 667 668 669
}

/*
 * Record that a call is locally aborted.
 */
670 671
static inline bool __rxrpc_abort_call(const char *why, struct rxrpc_call *call,
				      rxrpc_seq_t seq,
672 673
				      u32 abort_code, int error)
{
674 675
	trace_rxrpc_abort(why, call->cid, call->call_id, seq,
			  abort_code, error);
676 677
	return __rxrpc_set_call_completion(call, RXRPC_CALL_LOCALLY_ABORTED,
					   abort_code, error);
678 679
}

680 681
static inline bool rxrpc_abort_call(const char *why, struct rxrpc_call *call,
				    rxrpc_seq_t seq, u32 abort_code, int error)
682 683 684 685
{
	bool ret;

	write_lock_bh(&call->state_lock);
686
	ret = __rxrpc_abort_call(why, call, seq, abort_code, error);
687 688 689 690
	write_unlock_bh(&call->state_lock);
	return ret;
}

691 692 693
/*
 * conn_client.c
 */
694 695 696 697
extern unsigned int rxrpc_max_client_connections;
extern unsigned int rxrpc_reap_client_connections;
extern unsigned int rxrpc_conn_idle_client_expiry;
extern unsigned int rxrpc_conn_idle_client_fast_expiry;
698 699
extern struct idr rxrpc_client_conn_ids;

700
void rxrpc_destroy_client_conn_ids(void);
701 702
int rxrpc_connect_call(struct rxrpc_call *, struct rxrpc_conn_parameters *,
		       struct sockaddr_rxrpc *, gfp_t);
703 704 705 706
void rxrpc_expose_client_call(struct rxrpc_call *);
void rxrpc_disconnect_client_call(struct rxrpc_call *);
void rxrpc_put_client_conn(struct rxrpc_connection *);
void __exit rxrpc_destroy_all_client_connections(void);
707

708
/*
709 710 711 712 713 714
 * conn_event.c
 */
void rxrpc_process_connection(struct work_struct *);

/*
 * conn_object.c
715
 */
716
extern unsigned int rxrpc_connection_expiry;
717
extern struct list_head rxrpc_connections;
718
extern struct list_head rxrpc_connection_proc_list;
719 720
extern rwlock_t rxrpc_connection_lock;

721
int rxrpc_extract_addr_from_skb(struct sockaddr_rxrpc *, struct sk_buff *);
722
struct rxrpc_connection *rxrpc_alloc_connection(gfp_t);
723 724
struct rxrpc_connection *rxrpc_find_connection_rcu(struct rxrpc_local *,
						   struct sk_buff *);
725
void __rxrpc_disconnect_call(struct rxrpc_connection *, struct rxrpc_call *);
726
void rxrpc_disconnect_call(struct rxrpc_call *);
727
void rxrpc_kill_connection(struct rxrpc_connection *);
728
void __rxrpc_put_connection(struct rxrpc_connection *);
729
void __exit rxrpc_destroy_all_connections(void);
730

731 732 733 734 735 736 737
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)
{
738
	return !rxrpc_conn_is_client(conn);
739 740
}

741 742 743 744 745
static inline void rxrpc_get_connection(struct rxrpc_connection *conn)
{
	atomic_inc(&conn->usage);
}

746 747 748 749 750
static inline
struct rxrpc_connection *rxrpc_get_connection_maybe(struct rxrpc_connection *conn)
{
	return atomic_inc_not_zero(&conn->usage) ? conn : NULL;
}
751

752 753
static inline void rxrpc_put_connection(struct rxrpc_connection *conn)
{
754 755 756 757 758 759 760 761 762 763
	if (!conn)
		return;

	if (rxrpc_conn_is_client(conn)) {
		if (atomic_dec_and_test(&conn->usage))
			rxrpc_put_client_conn(conn);
	} else {
		if (atomic_dec_return(&conn->usage) == 1)
			__rxrpc_put_connection(conn);
	}
764 765
}

766
static inline bool rxrpc_queue_conn(struct rxrpc_connection *conn)
767
{
768 769 770
	if (!rxrpc_get_connection_maybe(conn))
		return false;
	if (!rxrpc_queue_work(&conn->processor))
771
		rxrpc_put_connection(conn);
772
	return true;
773 774
}

775 776 777
/*
 * conn_service.c
 */
778 779
struct rxrpc_connection *rxrpc_find_service_conn_rcu(struct rxrpc_peer *,
						     struct sk_buff *);
780
struct rxrpc_connection *rxrpc_prealloc_service_connection(gfp_t);
781
void rxrpc_new_incoming_connection(struct rxrpc_connection *, struct sk_buff *);
782
void rxrpc_unpublish_service_conn(struct rxrpc_connection *);
783

784
/*
785
 * input.c
786
 */
787
void rxrpc_data_ready(struct sock *);
788 789

/*
790
 * insecure.c
791
 */
792
extern const struct rxrpc_security rxrpc_no_security;
793 794

/*
795
 * key.c
796
 */
797 798 799 800 801 802 803
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);
804

805 806 807
/*
 * local_event.c
 */
808
extern void rxrpc_process_local_events(struct rxrpc_local *);
809

810
/*
811
 * local_object.c
812
 */
813 814
struct rxrpc_local *rxrpc_lookup_local(const struct sockaddr_rxrpc *);
void __rxrpc_put_local(struct rxrpc_local *);
815
void __exit rxrpc_destroy_all_locals(void);
816

817 818 819 820 821 822 823 824 825 826 827 828 829
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)
{
830
	if (local && atomic_dec_and_test(&local->usage))
831 832 833
		__rxrpc_put_local(local);
}

834 835 836 837 838
static inline void rxrpc_queue_local(struct rxrpc_local *local)
{
	rxrpc_queue_work(&local->processor);
}

839
/*
840
 * misc.c
841
 */
842 843 844 845 846 847 848
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;
849
extern unsigned int rxrpc_resend_timeout;
850

851 852 853 854
extern const char *const rxrpc_pkts[];
extern const s8 rxrpc_ack_priority[];

extern const char *rxrpc_acks(u8 reason);
855 856

/*
857
 * output.c
858
 */
859
int rxrpc_send_call_packet(struct rxrpc_call *, u8);
860
int rxrpc_send_data_packet(struct rxrpc_connection *, struct sk_buff *);
861
void rxrpc_reject_packets(struct rxrpc_local *);
862 863

/*
864
 * peer_event.c
865
 */
866
void rxrpc_error_report(struct sock *);
867
void rxrpc_peer_error_distributor(struct work_struct *);
868 869 870

/*
 * peer_object.c
871
 */
872 873 874 875 876
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);
877 878
struct rxrpc_peer *rxrpc_lookup_incoming_peer(struct rxrpc_local *,
					      struct rxrpc_peer *);
879

880
static inline struct rxrpc_peer *rxrpc_get_peer(struct rxrpc_peer *peer)
881 882
{
	atomic_inc(&peer->usage);
883
	return peer;
884 885 886 887 888 889 890 891 892 893 894
}

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)
{
895
	if (peer && atomic_dec_and_test(&peer->usage))
896 897
		__rxrpc_put_peer(peer);
}
898 899

/*
900
 * proc.c
901
 */
902 903
extern const struct file_operations rxrpc_call_seq_fops;
extern const struct file_operations rxrpc_connection_seq_fops;
904 905

/*
906
 * recvmsg.c
907
 */
908
void rxrpc_notify_socket(struct rxrpc_call *);
909
int rxrpc_recvmsg(struct socket *, struct msghdr *, size_t, int);
910 911

/*
912 913 914 915 916 917 918 919
 * rxkad.c
 */
#ifdef CONFIG_RXKAD
extern const struct rxrpc_security rxkad;
#endif

/*
 * security.c
920
 */
921 922
int __init rxrpc_init_security(void);
void rxrpc_exit_security(void);
923 924
int rxrpc_init_client_conn_security(struct rxrpc_connection *);
int rxrpc_init_server_conn_security(struct rxrpc_connection *);
D
David Howells 已提交
925

926 927 928 929
/*
 * sendmsg.c
 */
int rxrpc_do_sendmsg(struct rxrpc_sock *, struct msghdr *, size_t);
930 931

/*
932
 * skbuff.c
933
 */
934
void rxrpc_kernel_data_consumed(struct rxrpc_call *, struct sk_buff *);
935
void rxrpc_packet_destructor(struct sk_buff *);
936 937 938 939 940
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 *);
941

942 943 944 945 946 947 948 949 950 951 952
/*
 * 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

953 954 955
/*
 * utils.c
 */
956
int rxrpc_extract_addr_from_skb(struct sockaddr_rxrpc *, struct sk_buff *);
957

958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974
static inline bool before(u32 seq1, u32 seq2)
{
        return (s32)(seq1 - seq2) < 0;
}
static inline bool before_eq(u32 seq1, u32 seq2)
{
        return (s32)(seq1 - seq2) <= 0;
}
static inline bool after(u32 seq1, u32 seq2)
{
        return (s32)(seq1 - seq2) > 0;
}
static inline bool after_eq(u32 seq1, u32 seq2)
{
        return (s32)(seq1 - seq2) >= 0;
}

975 976 977
/*
 * debug tracing
 */
978
extern unsigned int rxrpc_debug;
979 980

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

983 984
#define kenter(FMT,...)	dbgprintk("==> %s("FMT")",__func__ ,##__VA_ARGS__)
#define kleave(FMT,...)	dbgprintk("<== %s()"FMT"",__func__ ,##__VA_ARGS__)
985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034
#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
1035 1036 1037 1038 1039
#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__)
1040 1041 1042 1043 1044 1045 1046 1047 1048 1049
#endif

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

#define ASSERT(X)						\
do {								\
	if (unlikely(!(X))) {					\
1050
		pr_err("Assertion failed\n");			\
1051 1052
		BUG();						\
	}							\
1053
} while (0)
1054 1055 1056

#define ASSERTCMP(X, OP, Y)						\
do {									\
1057 1058
	__typeof__(X) _x = (X);						\
	__typeof__(Y) _y = (__typeof__(X))(Y);				\
1059
	if (unlikely(!(_x OP _y))) {					\
1060 1061 1062
		pr_err("Assertion failed - %lu(0x%lx) %s %lu(0x%lx) is false\n", \
		       (unsigned long)_x, (unsigned long)_x, #OP,	\
		       (unsigned long)_y, (unsigned long)_y);		\
1063 1064
		BUG();							\
	}								\
1065
} while (0)
1066 1067 1068 1069

#define ASSERTIF(C, X)						\
do {								\
	if (unlikely((C) && !(X))) {				\
1070
		pr_err("Assertion failed\n");			\
1071 1072
		BUG();						\
	}							\
1073
} while (0)
1074 1075 1076

#define ASSERTIFCMP(C, X, OP, Y)					\
do {									\
1077 1078
	__typeof__(X) _x = (X);						\
	__typeof__(Y) _y = (__typeof__(X))(Y);				\
1079 1080
	if (unlikely((C) && !(_x OP _y))) {				\
		pr_err("Assertion failed - %lu(0x%lx) %s %lu(0x%lx) is false\n", \
1081 1082
		       (unsigned long)_x, (unsigned long)_x, #OP,	\
		       (unsigned long)_y, (unsigned long)_y);		\
1083 1084
		BUG();							\
	}								\
1085
} while (0)
1086 1087 1088 1089 1090

#else

#define ASSERT(X)				\
do {						\
1091
} while (0)
1092 1093 1094

#define ASSERTCMP(X, OP, Y)			\
do {						\
1095
} while (0)
1096 1097 1098

#define ASSERTIF(C, X)				\
do {						\
1099
} while (0)
1100 1101 1102

#define ASSERTIFCMP(C, X, OP, Y)		\
do {						\
1103
} while (0)
1104 1105

#endif /* __KDEBUGALL */