ar-internal.h 33.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
#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 66 67 68 69 70 71
	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;
72
	rxrpc_notify_new_call_t	notify_new_call; /* Func to notify of new call */
73
	struct rxrpc_local	*local;		/* local endpoint */
74
	struct hlist_node	listen_link;	/* link in the local endpoint's listen list */
75 76 77 78 79 80
	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;
81
#define RXRPC_SOCK_CONNECTED		0	/* connect_srx is set */
82 83 84
	rwlock_t		call_lock;	/* lock for calls */
	u32			min_sec_level;	/* minimum security level */
#define RXRPC_SECURITY_MAX	RXRPC_SECURITY_ENCRYPT
85 86
	bool			exclusive;	/* Exclusive connection for a client socket */
	sa_family_t		family;		/* Protocol family created with */
87
	struct sockaddr_rxrpc	srx;		/* local address */
88
	struct sockaddr_rxrpc	connect_srx;	/* Default client address from connect() */
89 90 91 92
};

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

93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112
/*
 * 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;

113 114 115 116 117 118 119 120
/*
 * 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 {
121
		unsigned int	offset;		/* offset into buffer of next read */
122 123 124 125 126
		int		remain;		/* amount of space remaining for next write */
		u32		error;		/* network error code */
		bool		need_resend;	/* T if needs resending */
	};

127
	struct rxrpc_host_header hdr;		/* RxRPC packet header from this packet */
128 129 130 131 132 133 134 135 136 137 138
};

#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 */

139 140 141 142 143 144
	/* Initialise a security service */
	int (*init)(void);

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

145 146 147 148
	/* initialise a connection's security */
	int (*init_connection_security)(struct rxrpc_connection *);

	/* prime a connection's packet security */
149
	int (*prime_packet_security)(struct rxrpc_connection *);
150 151

	/* impose security on a packet */
152
	int (*secure_packet)(struct rxrpc_call *,
153 154 155 156 157
			     struct sk_buff *,
			     size_t,
			     void *);

	/* verify the security on a received packet */
158 159
	int (*verify_packet)(struct rxrpc_call *, struct sk_buff *,
			     rxrpc_seq_t, u16);
160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178

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

/*
179 180 181
 * RxRPC local transport endpoint description
 * - owned by a single AF_RXRPC socket
 * - pointed to by transport socket struct sk_user_data
182 183
 */
struct rxrpc_local {
184 185 186
	struct rcu_head		rcu;
	atomic_t		usage;
	struct list_head	link;
187
	struct socket		*socket;	/* my UDP socket */
188
	struct work_struct	processor;
189
	struct hlist_head	services;	/* services listening on this endpoint */
190 191 192
	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 */
193
	struct sk_buff_head	event_queue;	/* endpoint event packets awaiting processing */
194 195
	struct rb_root		client_conns;	/* Client connections by socket params */
	spinlock_t		client_conns_lock; /* Lock for client_conns */
196 197 198
	spinlock_t		lock;		/* access lock */
	rwlock_t		services_lock;	/* lock for services list */
	int			debug_id;	/* debug ID for printks */
199
	bool			dead;
200 201 202 203 204
	struct sockaddr_rxrpc	srx;		/* local address */
};

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

	/* calculated RTT cache */
#define RXRPC_RTT_CACHE_SIZE 32
	suseconds_t		rtt;		/* current RTT estimate (in uS) */
230 231
	unsigned int		rtt_point;	/* next entry at which to insert */
	unsigned int		rtt_usage;	/* amount of cache actually used */
232 233 234
	suseconds_t		rtt_cache[RXRPC_RTT_CACHE_SIZE]; /* calculated RTT cache */
};

235 236 237 238
/*
 * Keys for matching a connection.
 */
struct rxrpc_conn_proto {
239 240 241 242 243 244
	union {
		struct {
			u32	epoch;		/* epoch of this connection */
			u32	cid;		/* connection ID */
		};
		u64		index_key;
245 246 247 248 249 250 251 252 253 254 255 256
	};
};

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

257 258 259 260 261
/*
 * Bits in the connection flags.
 */
enum rxrpc_conn_flag {
	RXRPC_CONN_HAS_IDR,		/* Has a client conn ID assigned */
262 263
	RXRPC_CONN_IN_SERVICE_CONNS,	/* Conn is in peer->service_conns */
	RXRPC_CONN_IN_CLIENT_CONNS,	/* Conn is in local->client_conns */
264 265 266
	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 */
267 268 269 270 271 272 273 274 275
};

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

276 277 278 279 280 281 282 283 284 285 286
/*
 * 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 */
};

287 288 289 290 291 292 293 294 295 296 297 298 299 300
/*
 * 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__NR_STATES
};

301 302
/*
 * RxRPC connection definition
303
 * - matched by { local, peer, epoch, conn_id, direction }
304 305 306
 * - each connection can only handle four simultaneous calls
 */
struct rxrpc_connection {
307 308 309
	struct rxrpc_conn_proto	proto;
	struct rxrpc_conn_parameters params;

310 311 312
	atomic_t		usage;
	struct rcu_head		rcu;
	struct list_head	cache_link;
313

314 315 316 317
	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 */
318 319 320 321 322
	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 */
323 324 325 326 327 328
		u8			last_type;	/* Type of last packet */
		u16			last_service_id;
		union {
			u32		last_seq;
			u32		last_abort;
		};
329
	} channels[RXRPC_MAXCALLS];
330

331
	struct work_struct	processor;	/* connection event processor */
332 333
	union {
		struct rb_node	client_node;	/* Node in local->client_conns */
334
		struct rb_node	service_node;	/* Node in peer->service_conns */
335
	};
336
	struct list_head	proc_link;	/* link in procfs list */
337 338
	struct list_head	link;		/* link in master connection list */
	struct sk_buff_head	rx_queue;	/* received conn-level packets */
339
	const struct rxrpc_security *security;	/* applied security module */
340
	struct key		*server_key;	/* security for this service */
H
Herbert Xu 已提交
341
	struct crypto_skcipher	*cipher;	/* encryption handle */
342
	struct rxrpc_crypt	csum_iv;	/* packet checksum base */
343
	unsigned long		flags;
344
	unsigned long		events;
345
	unsigned long		idle_timestamp;	/* Time at which last became idle */
346
	spinlock_t		state_lock;	/* state-change lock */
347 348
	enum rxrpc_conn_cache_state cache_state;
	enum rxrpc_conn_proto_state state;	/* current state of connection */
349 350
	u32			local_abort;	/* local abort code */
	u32			remote_abort;	/* remote abort code */
351 352
	int			debug_id;	/* debug ID for printks */
	atomic_t		serial;		/* packet serial number counter */
353
	unsigned int		hi_serial;	/* highest serial number received */
354 355 356 357 358 359 360 361
	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 */
};

362 363 364 365 366 367 368 369 370 371 372 373
/*
 * 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 */
374
	RXRPC_CALL_IS_SERVICE,		/* Call is service call */
375
	RXRPC_CALL_EXPOSED,		/* The call was exposed to the world */
376
	RXRPC_CALL_RX_NO_MORE,		/* Don't indicate MSG_MORE from recvmsg() */
377 378 379 380 381 382
};

/*
 * Events that can be raised on a call.
 */
enum rxrpc_call_event {
383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398
	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 */
399 400 401 402 403 404
};

/*
 * The states that a call can be in.
 */
enum rxrpc_call_state {
405 406
	RXRPC_CALL_UNINITIALISED,
	RXRPC_CALL_CLIENT_AWAIT_CONN,	/* - client waiting for connection to become available */
407 408 409 410 411 412 413 414 415 416
	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 */
417 418 419 420 421 422 423 424 425
	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 */
426 427 428
	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 */
429
	RXRPC_CALL_LOCAL_ERROR,		/* - call failed due to local error */
430
	RXRPC_CALL_NETWORK_ERROR,	/* - call terminated by network error */
431
	NR__RXRPC_CALL_COMPLETIONS
432 433
};

434 435 436 437 438
/*
 * RxRPC call definition
 * - matched by { connection, call_id }
 */
struct rxrpc_call {
439
	struct rcu_head		rcu;
440
	struct rxrpc_connection	*conn;		/* connection carrying call */
441
	struct rxrpc_peer	*peer;		/* Peer record for remote address */
442
	struct rxrpc_sock __rcu	*socket;	/* socket responsible */
443 444 445 446
	struct timer_list	lifetimer;	/* lifetime remaining on call */
	struct timer_list	ack_timer;	/* ACK generation timer */
	struct timer_list	resend_timer;	/* Tx resend timer */
	struct work_struct	processor;	/* packet processor and ACK generator */
447
	rxrpc_notify_rx_t	notify_rx;	/* kernel service Rx notification function */
448
	struct list_head	link;		/* link in master call list */
449
	struct list_head	chan_wait_link;	/* Link in conn->waiting_calls */
450
	struct hlist_node	error_link;	/* link in error distribution list */
451 452 453 454
	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 */
455
	struct sk_buff_head	knlrecv_queue;	/* Queue for kernel_recv [TODO: replace this] */
456
	struct sk_buff		*tx_pending;	/* Tx socket buffer being filled */
457
	wait_queue_head_t	waitq;		/* Wait queue for channel or Tx */
458
	__be32			crypto_buf[2];	/* Temporary packet crypto buffer */
459 460 461 462 463 464
	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 */
465 466
	u32			abort_code;	/* Local/remote abort code */
	int			error;		/* Local error incurred */
467 468
	enum rxrpc_call_state	state;		/* current state of call */
	enum rxrpc_call_completion completion;	/* Call completion condition */
469 470
	atomic_t		usage;
	atomic_t		sequence;	/* Tx data packet sequence counter */
471
	u16			service_id;	/* service ID */
472
	u8			security_ix;	/* Security type */
473 474 475
	u32			call_id;	/* call ID on connection  */
	u32			cid;		/* connection ID plus channel index */
	int			debug_id;	/* debug ID for printks */
476 477

	/* transmission-phase ACK management */
478 479 480 481
	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 */
482 483 484 485 486 487 488 489 490 491 492 493 494
	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) */
495
	rxrpc_seq_t		ackr_prev_seq;	/* previous sequence number received */
496
	u8			ackr_reason;	/* reason to ACK */
497
	u16			ackr_skew;	/* skew on packet being ACK'd */
498
	rxrpc_serial_t		ackr_serial;	/* serial of packet being ACK'd */
499 500 501 502 503 504 505
	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];
};

506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523
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_skb,
	rxrpc_call_got_userid,
	rxrpc_call_put,
	rxrpc_call_put_skb,
	rxrpc_call_put_userid,
	rxrpc_call_put_noqueue,
	rxrpc_call__nr_trace
};

extern const char rxrpc_call_traces[rxrpc_call__nr_trace][4];

524 525
#include <trace/events/rxrpc.h>

526
/*
527
 * af_rxrpc.c
528
 */
529
extern atomic_t rxrpc_n_skbs;
530
extern u32 rxrpc_epoch;
531 532
extern atomic_t rxrpc_debug_id;
extern struct workqueue_struct *rxrpc_workqueue;
533 534

/*
535
 * call_accept.c
536
 */
537
void rxrpc_accept_incoming_calls(struct rxrpc_local *);
538 539
struct rxrpc_call *rxrpc_accept_call(struct rxrpc_sock *, unsigned long,
				     rxrpc_notify_rx_t);
540
int rxrpc_reject_call(struct rxrpc_sock *);
541 542

/*
543
 * call_event.c
544
 */
545 546
void __rxrpc_propose_ACK(struct rxrpc_call *, u8, u16, u32, bool);
void rxrpc_propose_ACK(struct rxrpc_call *, u8, u16, u32, bool);
547
void rxrpc_process_call(struct work_struct *);
548 549

/*
550
 * call_object.c
551
 */
552 553
extern const char *const rxrpc_call_states[];
extern const char *const rxrpc_call_completions[];
554
extern unsigned int rxrpc_max_call_lifetime;
555 556 557 558
extern struct kmem_cache *rxrpc_call_jar;
extern struct list_head rxrpc_calls;
extern rwlock_t rxrpc_call_lock;

559 560
struct rxrpc_call *rxrpc_find_call_by_user_ID(struct rxrpc_sock *, unsigned long);
struct rxrpc_call *rxrpc_new_client_call(struct rxrpc_sock *,
561
					 struct rxrpc_conn_parameters *,
562
					 struct sockaddr_rxrpc *,
563
					 unsigned long, gfp_t);
564 565
struct rxrpc_call *rxrpc_incoming_call(struct rxrpc_sock *,
				       struct rxrpc_connection *,
566
				       struct sk_buff *);
567
void rxrpc_release_call(struct rxrpc_sock *, struct rxrpc_call *);
568
void rxrpc_release_calls_on_socket(struct rxrpc_sock *);
569 570
bool __rxrpc_queue_call(struct rxrpc_call *);
bool rxrpc_queue_call(struct rxrpc_call *);
571
void rxrpc_see_call(struct rxrpc_call *);
572 573
void rxrpc_get_call(struct rxrpc_call *, enum rxrpc_call_trace);
void rxrpc_put_call(struct rxrpc_call *, enum rxrpc_call_trace);
574 575
void rxrpc_get_call_for_skb(struct rxrpc_call *, struct sk_buff *);
void rxrpc_put_call_for_skb(struct rxrpc_call *, struct sk_buff *);
576
void __exit rxrpc_destroy_all_calls(void);
577

578 579 580 581 582 583 584 585 586 587
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);
}

588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610
/*
 * 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)
{
611
	bool ret;
612 613 614 615 616 617 618 619 620 621

	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.
 */
622
static inline bool __rxrpc_call_completed(struct rxrpc_call *call)
623
{
624
	return __rxrpc_set_call_completion(call, RXRPC_CALL_SUCCEEDED, 0, 0);
625 626
}

627
static inline bool rxrpc_call_completed(struct rxrpc_call *call)
628
{
629 630
	bool ret;

631
	write_lock_bh(&call->state_lock);
632
	ret = __rxrpc_call_completed(call);
633
	write_unlock_bh(&call->state_lock);
634
	return ret;
635 636 637 638 639
}

/*
 * Record that a call is locally aborted.
 */
640 641
static inline bool __rxrpc_abort_call(const char *why, struct rxrpc_call *call,
				      rxrpc_seq_t seq,
642 643
				      u32 abort_code, int error)
{
644 645
	trace_rxrpc_abort(why, call->cid, call->call_id, seq,
			  abort_code, error);
646 647 648 649 650 651 652 653 654
	if (__rxrpc_set_call_completion(call,
					RXRPC_CALL_LOCALLY_ABORTED,
					abort_code, error)) {
		set_bit(RXRPC_CALL_EV_ABORT, &call->events);
		return true;
	}
	return false;
}

655 656
static inline bool rxrpc_abort_call(const char *why, struct rxrpc_call *call,
				    rxrpc_seq_t seq, u32 abort_code, int error)
657 658 659 660
{
	bool ret;

	write_lock_bh(&call->state_lock);
661
	ret = __rxrpc_abort_call(why, call, seq, abort_code, error);
662 663 664 665
	write_unlock_bh(&call->state_lock);
	return ret;
}

666 667 668
/*
 * conn_client.c
 */
669 670 671 672
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;
673 674
extern struct idr rxrpc_client_conn_ids;

675
void rxrpc_destroy_client_conn_ids(void);
676 677
int rxrpc_connect_call(struct rxrpc_call *, struct rxrpc_conn_parameters *,
		       struct sockaddr_rxrpc *, gfp_t);
678 679 680 681
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);
682

683
/*
684 685 686 687
 * conn_event.c
 */
void rxrpc_process_connection(struct work_struct *);
void rxrpc_reject_packet(struct rxrpc_local *, struct sk_buff *);
688
void rxrpc_reject_packets(struct rxrpc_local *);
689 690 691

/*
 * conn_object.c
692
 */
693
extern unsigned int rxrpc_connection_expiry;
694
extern struct list_head rxrpc_connections;
695
extern struct list_head rxrpc_connection_proc_list;
696 697
extern rwlock_t rxrpc_connection_lock;

698
int rxrpc_extract_addr_from_skb(struct sockaddr_rxrpc *, struct sk_buff *);
699
struct rxrpc_connection *rxrpc_alloc_connection(gfp_t);
700 701
struct rxrpc_connection *rxrpc_find_connection_rcu(struct rxrpc_local *,
						   struct sk_buff *);
702
void __rxrpc_disconnect_call(struct rxrpc_connection *, struct rxrpc_call *);
703
void rxrpc_disconnect_call(struct rxrpc_call *);
704
void rxrpc_kill_connection(struct rxrpc_connection *);
705
void __rxrpc_put_connection(struct rxrpc_connection *);
706
void __exit rxrpc_destroy_all_connections(void);
707

708 709 710 711 712 713 714
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)
{
715
	return !rxrpc_conn_is_client(conn);
716 717
}

718 719 720 721 722
static inline void rxrpc_get_connection(struct rxrpc_connection *conn)
{
	atomic_inc(&conn->usage);
}

723 724 725 726 727
static inline
struct rxrpc_connection *rxrpc_get_connection_maybe(struct rxrpc_connection *conn)
{
	return atomic_inc_not_zero(&conn->usage) ? conn : NULL;
}
728

729 730
static inline void rxrpc_put_connection(struct rxrpc_connection *conn)
{
731 732 733 734 735 736 737 738 739 740
	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);
	}
741 742
}

743
static inline bool rxrpc_queue_conn(struct rxrpc_connection *conn)
744
{
745 746 747
	if (!rxrpc_get_connection_maybe(conn))
		return false;
	if (!rxrpc_queue_work(&conn->processor))
748
		rxrpc_put_connection(conn);
749
	return true;
750 751
}

752 753 754
/*
 * conn_service.c
 */
755 756
struct rxrpc_connection *rxrpc_find_service_conn_rcu(struct rxrpc_peer *,
						     struct sk_buff *);
757
struct rxrpc_connection *rxrpc_incoming_connection(struct rxrpc_local *,
758
						   struct sockaddr_rxrpc *,
759
						   struct sk_buff *);
760
void rxrpc_unpublish_service_conn(struct rxrpc_connection *);
761

762
/*
763
 * input.c
764
 */
765 766 767
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 *);
768 769

/*
770
 * insecure.c
771
 */
772
extern const struct rxrpc_security rxrpc_no_security;
773 774

/*
775
 * key.c
776
 */
777 778 779 780 781 782 783
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);
784

785 786 787
/*
 * local_event.c
 */
788
extern void rxrpc_process_local_events(struct rxrpc_local *);
789

790
/*
791
 * local_object.c
792
 */
793 794
struct rxrpc_local *rxrpc_lookup_local(const struct sockaddr_rxrpc *);
void __rxrpc_put_local(struct rxrpc_local *);
795
void __exit rxrpc_destroy_all_locals(void);
796

797 798 799 800 801 802 803 804 805 806 807 808 809
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)
{
810
	if (local && atomic_dec_and_test(&local->usage))
811 812 813
		__rxrpc_put_local(local);
}

814 815 816 817 818
static inline void rxrpc_queue_local(struct rxrpc_local *local)
{
	rxrpc_queue_work(&local->processor);
}

819
/*
820
 * misc.c
821
 */
822 823 824 825 826 827 828
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;
829
extern unsigned int rxrpc_resend_timeout;
830

831 832 833 834
extern const char *const rxrpc_pkts[];
extern const s8 rxrpc_ack_priority[];

extern const char *rxrpc_acks(u8 reason);
835 836

/*
837
 * output.c
838
 */
839
int rxrpc_send_call_packet(struct rxrpc_call *, u8);
840
int rxrpc_send_data_packet(struct rxrpc_connection *, struct sk_buff *);
841 842

/*
843
 * peer_event.c
844
 */
845
void rxrpc_error_report(struct sock *);
846
void rxrpc_peer_error_distributor(struct work_struct *);
847 848 849

/*
 * peer_object.c
850
 */
851 852 853 854 855 856
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);

857
static inline struct rxrpc_peer *rxrpc_get_peer(struct rxrpc_peer *peer)
858 859
{
	atomic_inc(&peer->usage);
860
	return peer;
861 862 863 864 865 866 867 868 869 870 871
}

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)
{
872
	if (peer && atomic_dec_and_test(&peer->usage))
873 874
		__rxrpc_put_peer(peer);
}
875 876

/*
877
 * proc.c
878
 */
879 880
extern const struct file_operations rxrpc_call_seq_fops;
extern const struct file_operations rxrpc_connection_seq_fops;
881 882

/*
883
 * recvmsg.c
884
 */
885
int rxrpc_recvmsg(struct socket *, struct msghdr *, size_t, int);
886 887

/*
888 889 890 891 892 893 894 895
 * rxkad.c
 */
#ifdef CONFIG_RXKAD
extern const struct rxrpc_security rxkad;
#endif

/*
 * security.c
896
 */
897 898
int __init rxrpc_init_security(void);
void rxrpc_exit_security(void);
899 900
int rxrpc_init_client_conn_security(struct rxrpc_connection *);
int rxrpc_init_server_conn_security(struct rxrpc_connection *);
901

902 903 904 905
/*
 * sendmsg.c
 */
int rxrpc_do_sendmsg(struct rxrpc_sock *, struct msghdr *, size_t);
906 907

/*
908
 * skbuff.c
909
 */
910
void rxrpc_kernel_data_consumed(struct rxrpc_call *, struct sk_buff *);
911
void rxrpc_packet_destructor(struct sk_buff *);
912 913 914 915 916
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 *);
917

918 919 920 921 922 923 924 925 926 927 928
/*
 * 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

929 930 931
/*
 * utils.c
 */
932
int rxrpc_extract_addr_from_skb(struct sockaddr_rxrpc *, struct sk_buff *);
933

934 935 936
/*
 * debug tracing
 */
937
extern unsigned int rxrpc_debug;
938 939

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

942 943
#define kenter(FMT,...)	dbgprintk("==> %s("FMT")",__func__ ,##__VA_ARGS__)
#define kleave(FMT,...)	dbgprintk("<== %s()"FMT"",__func__ ,##__VA_ARGS__)
944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993
#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
994 995 996 997 998
#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__)
999 1000 1001 1002 1003 1004 1005 1006 1007 1008
#endif

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

#define ASSERT(X)						\
do {								\
	if (unlikely(!(X))) {					\
1009
		pr_err("Assertion failed\n");			\
1010 1011
		BUG();						\
	}							\
1012
} while (0)
1013 1014 1015

#define ASSERTCMP(X, OP, Y)						\
do {									\
1016 1017
	__typeof__(X) _x = (X);						\
	__typeof__(Y) _y = (__typeof__(X))(Y);				\
1018
	if (unlikely(!(_x OP _y))) {					\
1019 1020 1021
		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);		\
1022 1023
		BUG();							\
	}								\
1024
} while (0)
1025 1026 1027 1028

#define ASSERTIF(C, X)						\
do {								\
	if (unlikely((C) && !(X))) {				\
1029
		pr_err("Assertion failed\n");			\
1030 1031
		BUG();						\
	}							\
1032
} while (0)
1033 1034 1035

#define ASSERTIFCMP(C, X, OP, Y)					\
do {									\
1036 1037
	__typeof__(X) _x = (X);						\
	__typeof__(Y) _y = (__typeof__(X))(Y);				\
1038 1039
	if (unlikely((C) && !(_x OP _y))) {				\
		pr_err("Assertion failed - %lu(0x%lx) %s %lu(0x%lx) is false\n", \
1040 1041
		       (unsigned long)_x, (unsigned long)_x, #OP,	\
		       (unsigned long)_y, (unsigned long)_y);		\
1042 1043
		BUG();							\
	}								\
1044
} while (0)
1045 1046 1047 1048 1049

#else

#define ASSERT(X)				\
do {						\
1050
} while (0)
1051 1052 1053

#define ASSERTCMP(X, OP, Y)			\
do {						\
1054
} while (0)
1055 1056 1057

#define ASSERTIF(C, X)				\
do {						\
1058
} while (0)
1059 1060 1061

#define ASSERTIFCMP(C, X, OP, Y)		\
do {						\
1062
} while (0)
1063 1064

#endif /* __KDEBUGALL */
新手
引导
客服 返回
顶部