ar-internal.h 38.3 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 15
#include <net/net_namespace.h>
#include <net/netns/generic.h>
16
#include <net/sock.h>
17
#include <net/af_rxrpc.h>
18 19 20 21 22 23 24
#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
25
#define CHECK_SLAB_OKAY(X) do {} while (0)
26 27 28 29 30 31
#endif

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

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

40 41
struct rxrpc_connection;

42 43 44 45 46 47 48 49 50 51 52 53 54 55
/*
 * 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 */
};

56 57 58 59
/*
 * sk_state for RxRPC sockets
 */
enum {
60 61
	RXRPC_UNBOUND = 0,
	RXRPC_CLIENT_UNBOUND,		/* Unbound socket used as client */
62 63
	RXRPC_CLIENT_BOUND,		/* client local address bound */
	RXRPC_SERVER_BOUND,		/* server local address bound */
64
	RXRPC_SERVER_BOUND2,		/* second server local address bound */
65
	RXRPC_SERVER_LISTENING,		/* server listening for connections */
66
	RXRPC_SERVER_LISTEN_DISABLED,	/* server listening disabled */
67 68 69
	RXRPC_CLOSE,			/* socket is being closed */
};

70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100
/*
 * Per-network namespace data.
 */
struct rxrpc_net {
	struct proc_dir_entry	*proc_net;	/* Subdir in /proc/net */
	u32			epoch;		/* Local epoch for detecting local-end reset */
	struct list_head	calls;		/* List of calls active in this namespace */
	rwlock_t		call_lock;	/* Lock for ->calls */

	struct list_head	conn_proc_list;	/* List of conns in this namespace for proc */
	struct list_head	service_conns;	/* Service conns in this namespace */
	rwlock_t		conn_lock;	/* Lock for ->conn_proc_list, ->service_conns */
	struct delayed_work	service_conn_reaper;

	unsigned int		nr_client_conns;
	unsigned int		nr_active_client_conns;
	bool			kill_all_client_conns;
	spinlock_t		client_conn_cache_lock; /* Lock for ->*_client_conns */
	spinlock_t		client_conn_discard_lock; /* Prevent multiple discarders */
	struct list_head	waiting_client_conns;
	struct list_head	active_client_conns;
	struct list_head	idle_client_conns;
	struct delayed_work	client_conn_reaper;

	struct list_head	local_endpoints;
	struct mutex		local_mutex;	/* Lock for ->local_endpoints */

	spinlock_t		peer_hash_lock;	/* Lock for ->peer_hash */
	DECLARE_HASHTABLE	(peer_hash, 10);
};

101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121
/*
 * 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];
};

122 123 124 125 126 127
/*
 * RxRPC socket definition
 */
struct rxrpc_sock {
	/* WARNING: sk has to be the first member */
	struct sock		sk;
128
	rxrpc_notify_new_call_t	notify_new_call; /* Func to notify of new call */
129
	rxrpc_discard_new_call_t discard_new_call; /* Func to discard a new call */
130
	struct rxrpc_local	*local;		/* local endpoint */
131
	struct rxrpc_backlog	*backlog;	/* Preallocation for services */
132 133 134 135 136
	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 */
137 138
	struct key		*key;		/* security for this socket */
	struct key		*securities;	/* list of server security descriptors */
139
	struct rb_root		calls;		/* User ID -> call mapping */
140
	unsigned long		flags;
141
#define RXRPC_SOCK_CONNECTED		0	/* connect_srx is set */
142 143 144
	rwlock_t		call_lock;	/* lock for calls */
	u32			min_sec_level;	/* minimum security level */
#define RXRPC_SECURITY_MAX	RXRPC_SECURITY_ENCRYPT
145
	bool			exclusive;	/* Exclusive connection for a client socket */
146
	u16			second_service;	/* Additional service bound to the endpoint */
D
David Howells 已提交
147 148 149 150 151
	struct {
		/* Service upgrade information */
		u16		from;		/* Service ID to upgrade (if not 0) */
		u16		to;		/* service ID to upgrade to */
	} service_upgrade;
152
	sa_family_t		family;		/* Protocol family created with */
D
David Howells 已提交
153
	struct sockaddr_rxrpc	srx;		/* Primary Service/local addresses */
154
	struct sockaddr_rxrpc	connect_srx;	/* Default client address from connect() */
155 156 157 158
};

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

159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178
/*
 * 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;

179 180 181 182 183
/*
 * RxRPC socket buffer private variables
 * - max 48 bytes (struct sk_buff::cb)
 */
struct rxrpc_skb_priv {
184
	union {
185
		u8		nr_jumbo;	/* Number of jumbo subpackets */
186
	};
187 188 189 190
	union {
		int		remain;		/* amount of space remaining for next write */
	};

191
	struct rxrpc_host_header hdr;		/* RxRPC packet header from this packet */
192 193 194 195 196 197 198 199 200 201 202
};

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

203 204 205 206 207 208
	/* Initialise a security service */
	int (*init)(void);

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

209 210 211 212
	/* initialise a connection's security */
	int (*init_connection_security)(struct rxrpc_connection *);

	/* prime a connection's packet security */
213
	int (*prime_packet_security)(struct rxrpc_connection *);
214 215

	/* impose security on a packet */
216
	int (*secure_packet)(struct rxrpc_call *,
217 218 219 220 221
			     struct sk_buff *,
			     size_t,
			     void *);

	/* verify the security on a received packet */
222
	int (*verify_packet)(struct rxrpc_call *, struct sk_buff *,
223 224 225 226 227
			     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 *);
228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246

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

/*
247 248 249
 * RxRPC local transport endpoint description
 * - owned by a single AF_RXRPC socket
 * - pointed to by transport socket struct sk_user_data
250 251
 */
struct rxrpc_local {
252 253
	struct rcu_head		rcu;
	atomic_t		usage;
254
	struct rxrpc_net	*rxnet;		/* The network ns in which this resides */
255
	struct list_head	link;
256
	struct socket		*socket;	/* my UDP socket */
257
	struct work_struct	processor;
258
	struct rxrpc_sock __rcu	*service;	/* Service(s) listening on this endpoint */
259 260
	struct rw_semaphore	defrag_sem;	/* control re-enablement of IP DF bit */
	struct sk_buff_head	reject_queue;	/* packets awaiting rejection */
261
	struct sk_buff_head	event_queue;	/* endpoint event packets awaiting processing */
262 263
	struct rb_root		client_conns;	/* Client connections by socket params */
	spinlock_t		client_conns_lock; /* Lock for client_conns */
264 265 266
	spinlock_t		lock;		/* access lock */
	rwlock_t		services_lock;	/* lock for services list */
	int			debug_id;	/* debug ID for printks */
267
	bool			dead;
268 269 270 271 272
	struct sockaddr_rxrpc	srx;		/* local address */
};

/*
 * RxRPC remote transport endpoint definition
273
 * - matched by local endpoint, remote port, address and protocol type
274 275
 */
struct rxrpc_peer {
276 277 278 279 280
	struct rcu_head		rcu;		/* This must be first */
	atomic_t		usage;
	unsigned long		hash_key;
	struct hlist_node	hash_link;
	struct rxrpc_local	*local;
281 282
	struct hlist_head	error_targets;	/* targets for net error distribution */
	struct work_struct	error_distributor;
283
	struct rb_root		service_conns;	/* Service connections */
284
	seqlock_t		service_conn_lock;
285
	spinlock_t		lock;		/* access lock */
286 287 288
	unsigned int		if_mtu;		/* interface MTU for this peer */
	unsigned int		mtu;		/* network MTU for this peer */
	unsigned int		maxdata;	/* data size (MTU - hdrsize) */
289 290
	unsigned short		hdrsize;	/* header size (IP + UDP + RxRPC) */
	int			debug_id;	/* debug ID for printks */
291 292
	int			error_report;	/* Net (+0) or local (+1000000) to distribute */
#define RXRPC_LOCAL_ERROR_OFFSET 1000000
293 294 295 296
	struct sockaddr_rxrpc	srx;		/* remote address */

	/* calculated RTT cache */
#define RXRPC_RTT_CACHE_SIZE 32
297
	ktime_t			rtt_last_req;	/* Time of last RTT request */
D
David Howells 已提交
298 299 300 301 302
	u64			rtt;		/* Current RTT estimate (in nS) */
	u64			rtt_sum;	/* Sum of cache contents */
	u64			rtt_cache[RXRPC_RTT_CACHE_SIZE]; /* Determined RTT cache */
	u8			rtt_cursor;	/* next entry at which to insert */
	u8			rtt_usage;	/* amount of cache actually used */
303 304
};

305 306 307 308
/*
 * Keys for matching a connection.
 */
struct rxrpc_conn_proto {
309 310 311 312 313 314
	union {
		struct {
			u32	epoch;		/* epoch of this connection */
			u32	cid;		/* connection ID */
		};
		u64		index_key;
315 316 317 318 319 320 321 322
	};
};

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 */
323
	bool			upgrade;	/* T if service ID can be upgraded */
324 325 326 327
	u16			service_id;	/* Service ID for this connection */
	u32			security_level;	/* Security level selected */
};

328 329 330 331 332
/*
 * Bits in the connection flags.
 */
enum rxrpc_conn_flag {
	RXRPC_CONN_HAS_IDR,		/* Has a client conn ID assigned */
333 334
	RXRPC_CONN_IN_SERVICE_CONNS,	/* Conn is in peer->service_conns */
	RXRPC_CONN_IN_CLIENT_CONNS,	/* Conn is in local->client_conns */
335 336 337
	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 */
338
	RXRPC_CONN_PROBING_FOR_UPGRADE,	/* Probing for service upgrade */
339 340 341 342 343 344 345 346 347
};

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

348 349 350 351 352 353 354
/*
 * 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 */
355
	RXRPC_CONN_CLIENT_UPGRADE,	/* Conn is on active list, probing for upgrade */
356 357
	RXRPC_CONN_CLIENT_CULLED,	/* Conn is culled and delisted, doing calls */
	RXRPC_CONN_CLIENT_IDLE,		/* Conn is on idle list, doing mostly nothing */
358
	RXRPC_CONN__NR_CACHE_STATES
359 360
};

361 362 363 364 365 366
/*
 * The connection protocol state.
 */
enum rxrpc_conn_proto_state {
	RXRPC_CONN_UNUSED,		/* Connection not yet attempted */
	RXRPC_CONN_CLIENT,		/* Client connection */
367
	RXRPC_CONN_SERVICE_PREALLOC,	/* Service connection preallocation */
368 369 370 371 372 373 374 375
	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
};

376 377
/*
 * RxRPC connection definition
378
 * - matched by { local, peer, epoch, conn_id, direction }
379 380 381
 * - each connection can only handle four simultaneous calls
 */
struct rxrpc_connection {
382 383 384
	struct rxrpc_conn_proto	proto;
	struct rxrpc_conn_parameters params;

385 386 387
	atomic_t		usage;
	struct rcu_head		rcu;
	struct list_head	cache_link;
388

389 390 391 392
	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 */
393 394 395 396 397
	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 */
398 399 400 401 402
		u8			last_type;	/* Type of last packet */
		union {
			u32		last_seq;
			u32		last_abort;
		};
403
	} channels[RXRPC_MAXCALLS];
404

405
	struct work_struct	processor;	/* connection event processor */
406 407
	union {
		struct rb_node	client_node;	/* Node in local->client_conns */
408
		struct rb_node	service_node;	/* Node in peer->service_conns */
409
	};
410
	struct list_head	proc_link;	/* link in procfs list */
411 412
	struct list_head	link;		/* link in master connection list */
	struct sk_buff_head	rx_queue;	/* received conn-level packets */
413
	const struct rxrpc_security *security;	/* applied security module */
414
	struct key		*server_key;	/* security for this service */
H
Herbert Xu 已提交
415
	struct crypto_skcipher	*cipher;	/* encryption handle */
416
	struct rxrpc_crypt	csum_iv;	/* packet checksum base */
417
	unsigned long		flags;
418
	unsigned long		events;
419
	unsigned long		idle_timestamp;	/* Time at which last became idle */
420
	spinlock_t		state_lock;	/* state-change lock */
421 422
	enum rxrpc_conn_cache_state cache_state;
	enum rxrpc_conn_proto_state state;	/* current state of connection */
423 424
	u32			local_abort;	/* local abort code */
	u32			remote_abort;	/* remote abort code */
425 426
	int			debug_id;	/* debug ID for printks */
	atomic_t		serial;		/* packet serial number counter */
427
	unsigned int		hi_serial;	/* highest serial number received */
428
	u32			security_nonce;	/* response re-use preventer */
429
	u16			service_id;	/* Service ID, possibly upgraded */
430 431 432 433 434 435
	u8			size_align;	/* data size alignment (for security) */
	u8			security_size;	/* security header size */
	u8			security_ix;	/* security type */
	u8			out_clientflag;	/* RXRPC_CLIENT_INITIATED if we are client */
};

436 437 438 439 440 441
/*
 * 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 */
442
	RXRPC_CALL_IS_SERVICE,		/* Call is service call */
443
	RXRPC_CALL_EXPOSED,		/* The call was exposed to the world */
444 445
	RXRPC_CALL_RX_LAST,		/* Received the last packet (at rxtx_top) */
	RXRPC_CALL_TX_LAST,		/* Last packet in Tx buffer (at rxtx_top) */
446
	RXRPC_CALL_SEND_PING,		/* A ping will need to be sent */
447
	RXRPC_CALL_PINGING,		/* Ping in process */
D
David Howells 已提交
448
	RXRPC_CALL_RETRANS_TIMEOUT,	/* Retransmission due to timeout occurred */
449 450 451 452 453 454
};

/*
 * Events that can be raised on a call.
 */
enum rxrpc_call_event {
455 456
	RXRPC_CALL_EV_ACK,		/* need to generate ACK */
	RXRPC_CALL_EV_ABORT,		/* need to generate abort */
457
	RXRPC_CALL_EV_TIMER,		/* Timer expired */
458
	RXRPC_CALL_EV_RESEND,		/* Tx resend required */
459
	RXRPC_CALL_EV_PING,		/* Ping send required */
460 461 462 463 464 465
};

/*
 * The states that a call can be in.
 */
enum rxrpc_call_state {
466 467
	RXRPC_CALL_UNINITIALISED,
	RXRPC_CALL_CLIENT_AWAIT_CONN,	/* - client waiting for connection to become available */
468 469 470
	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 */
471
	RXRPC_CALL_SERVER_PREALLOC,	/* - service preallocation */
472 473 474 475 476 477
	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 */
478 479 480 481 482 483 484 485 486
	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 */
487 488
	RXRPC_CALL_REMOTELY_ABORTED,	/* - call aborted by peer */
	RXRPC_CALL_LOCALLY_ABORTED,	/* - call aborted locally on error or close */
489
	RXRPC_CALL_LOCAL_ERROR,		/* - call failed due to local error */
490
	RXRPC_CALL_NETWORK_ERROR,	/* - call terminated by network error */
491
	NR__RXRPC_CALL_COMPLETIONS
492 493
};

D
David Howells 已提交
494 495 496 497 498 499 500 501 502 503 504
/*
 * Call Tx congestion management modes.
 */
enum rxrpc_congest_mode {
	RXRPC_CALL_SLOW_START,
	RXRPC_CALL_CONGEST_AVOIDANCE,
	RXRPC_CALL_PACKET_LOSS,
	RXRPC_CALL_FAST_RETRANSMIT,
	NR__RXRPC_CONGEST_MODES
};

505 506 507 508 509
/*
 * RxRPC call definition
 * - matched by { connection, call_id }
 */
struct rxrpc_call {
510
	struct rcu_head		rcu;
511
	struct rxrpc_connection	*conn;		/* connection carrying call */
512
	struct rxrpc_peer	*peer;		/* Peer record for remote address */
513
	struct rxrpc_sock __rcu	*socket;	/* socket responsible */
514
	struct mutex		user_mutex;	/* User access mutex */
515 516
	ktime_t			ack_at;		/* When deferred ACK needs to happen */
	ktime_t			resend_at;	/* When next resend needs to happen */
517
	ktime_t			ping_at;	/* When next to send a ping */
518
	ktime_t			expire_at;	/* When the call times out */
519 520
	struct timer_list	timer;		/* Combined event timer */
	struct work_struct	processor;	/* Event processor */
521
	rxrpc_notify_rx_t	notify_rx;	/* kernel service Rx notification function */
522
	struct list_head	link;		/* link in master call list */
523
	struct list_head	chan_wait_link;	/* Link in conn->waiting_calls */
524
	struct hlist_node	error_link;	/* link in error distribution list */
525 526 527 528
	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 */
529
	struct sk_buff		*tx_pending;	/* Tx socket buffer being filled */
530
	wait_queue_head_t	waitq;		/* Wait queue for channel or Tx */
531
	s64			tx_total_len;	/* Total length left to be transmitted (or -1) */
532
	__be32			crypto_buf[2];	/* Temporary packet crypto buffer */
533 534 535 536 537
	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 */
538 539
	u32			abort_code;	/* Local/remote abort code */
	int			error;		/* Local error incurred */
540 541
	enum rxrpc_call_state	state;		/* current state of call */
	enum rxrpc_call_completion completion;	/* Call completion condition */
542
	atomic_t		usage;
543
	u16			service_id;	/* service ID */
544
	u8			security_ix;	/* Security type */
545 546 547
	u32			call_id;	/* call ID on connection  */
	u32			cid;		/* connection ID plus channel index */
	int			debug_id;	/* debug ID for printks */
548 549
	unsigned short		rx_pkt_offset;	/* Current recvmsg packet offset */
	unsigned short		rx_pkt_len;	/* Current recvmsg packet len */
550

551 552 553 554 555 556 557 558 559 560 561
	/* 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)
562
#define RXRPC_INIT_RX_WINDOW_SIZE 32
563 564 565 566 567 568
	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
D
David Howells 已提交
569
#define RXRPC_TX_ANNO_MASK	0x03
570 571 572
#define RXRPC_TX_ANNO_LAST	0x04
#define RXRPC_TX_ANNO_RESENT	0x08

573 574 575 576 577 578 579
#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. */
D
David Howells 已提交
580 581 582 583 584 585 586 587 588 589 590 591 592 593

	/* TCP-style slow-start congestion control [RFC5681].  Since the SMSS
	 * is fixed, we keep these numbers in terms of segments (ie. DATA
	 * packets) rather than bytes.
	 */
#define RXRPC_TX_SMSS		RXRPC_JUMBO_DATALEN
	u8			cong_cwnd;	/* Congestion window size */
	u8			cong_extra;	/* Extra to send for congestion management */
	u8			cong_ssthresh;	/* Slow-start threshold */
	enum rxrpc_congest_mode	cong_mode:8;	/* Congestion management mode */
	u8			cong_dup_acks;	/* Count of ACKs showing missing packets */
	u8			cong_cumul_acks; /* Cumulative ACK count */
	ktime_t			cong_tstamp;	/* Last time cwnd was changed */

594 595
	rxrpc_seq_t		rx_hard_ack;	/* Dead slot in buffer; the first received but not
						 * consumed packet follows this.
596
						 */
597 598 599 600
	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 */
D
David Howells 已提交
601
	bool			tx_phase;	/* T if transmission phase, F if receive phase */
602
	u8			nr_jumbo_bad;	/* Number of jumbo dups/exceeds-windows */
603 604

	/* receive-phase ACK management */
605
	u8			ackr_reason;	/* reason to ACK */
606
	u16			ackr_skew;	/* skew on packet being ACK'd */
607
	rxrpc_serial_t		ackr_serial;	/* serial of packet being ACK'd */
608
	rxrpc_seq_t		ackr_prev_seq;	/* previous sequence number received */
609 610
	rxrpc_seq_t		ackr_consumed;	/* Highest packet shown consumed */
	rxrpc_seq_t		ackr_seen;	/* Highest packet shown seen */
611 612 613 614

	/* ping management */
	rxrpc_serial_t		ping_serial;	/* Last ping sent */
	ktime_t			ping_time;	/* Time last ping sent */
615

616
	/* transmission-phase ACK management */
D
David Howells 已提交
617
	ktime_t			acks_latest_ts;	/* Timestamp of latest ACK received */
618
	rxrpc_serial_t		acks_latest;	/* serial number of latest ACK received */
619 620 621 622
	rxrpc_seq_t		acks_lowest_nak; /* Lowest NACK in the buffer (or ==tx_hard_ack) */
};

/*
D
David Howells 已提交
623
 * Summary of a new ACK and the changes it made to the Tx buffer packet states.
624 625 626 627 628 629 630 631 632
 */
struct rxrpc_ack_summary {
	u8			ack_reason;
	u8			nr_acks;		/* Number of ACKs in packet */
	u8			nr_nacks;		/* Number of NACKs in packet */
	u8			nr_new_acks;		/* Number of new ACKs in packet */
	u8			nr_new_nacks;		/* Number of new NACKs in packet */
	u8			nr_rot_new_acks;	/* Number of rotated new ACKs */
	bool			new_low_nack;		/* T if new low NACK found */
D
David Howells 已提交
633 634 635 636 637 638 639 640
	bool			retrans_timeo;		/* T if reTx due to timeout happened */
	u8			flight_size;		/* Number of unreceived transmissions */
	/* Place to stash values for tracing */
	enum rxrpc_congest_mode	mode:8;
	u8			cwnd;
	u8			ssthresh;
	u8			dup_acks;
	u8			cumulative_acks;
641 642
};

643 644
#include <trace/events/rxrpc.h>

645
/*
646
 * af_rxrpc.c
647
 */
D
David Howells 已提交
648
extern atomic_t rxrpc_n_tx_skbs, rxrpc_n_rx_skbs;
649 650
extern atomic_t rxrpc_debug_id;
extern struct workqueue_struct *rxrpc_workqueue;
651 652

/*
653
 * call_accept.c
654
 */
655 656
int rxrpc_service_prealloc(struct rxrpc_sock *, gfp_t);
void rxrpc_discard_prealloc(struct rxrpc_sock *);
657 658 659
struct rxrpc_call *rxrpc_new_incoming_call(struct rxrpc_local *,
					   struct rxrpc_connection *,
					   struct sk_buff *);
660
void rxrpc_accept_incoming_calls(struct rxrpc_local *);
661 662
struct rxrpc_call *rxrpc_accept_call(struct rxrpc_sock *, unsigned long,
				     rxrpc_notify_rx_t);
663
int rxrpc_reject_call(struct rxrpc_sock *);
664 665

/*
666
 * call_event.c
667
 */
668
void __rxrpc_set_timer(struct rxrpc_call *, enum rxrpc_timer_trace, ktime_t);
669
void rxrpc_set_timer(struct rxrpc_call *, enum rxrpc_timer_trace, ktime_t);
670 671
void rxrpc_propose_ACK(struct rxrpc_call *, u8, u16, u32, bool, bool,
		       enum rxrpc_propose_ack_trace);
672
void rxrpc_process_call(struct work_struct *);
673 674

/*
675
 * call_object.c
676
 */
677 678
extern const char *const rxrpc_call_states[];
extern const char *const rxrpc_call_completions[];
679
extern unsigned int rxrpc_max_call_lifetime;
680 681
extern struct kmem_cache *rxrpc_call_jar;

682
struct rxrpc_call *rxrpc_find_call_by_user_ID(struct rxrpc_sock *, unsigned long);
683
struct rxrpc_call *rxrpc_alloc_call(gfp_t);
684
struct rxrpc_call *rxrpc_new_client_call(struct rxrpc_sock *,
685
					 struct rxrpc_conn_parameters *,
686
					 struct sockaddr_rxrpc *,
687
					 unsigned long, s64, gfp_t);
688 689
void rxrpc_incoming_call(struct rxrpc_sock *, struct rxrpc_call *,
			 struct sk_buff *);
690
void rxrpc_release_call(struct rxrpc_sock *, struct rxrpc_call *);
691
void rxrpc_release_calls_on_socket(struct rxrpc_sock *);
692 693
bool __rxrpc_queue_call(struct rxrpc_call *);
bool rxrpc_queue_call(struct rxrpc_call *);
D
David Howells 已提交
694
void rxrpc_see_call(struct rxrpc_call *);
695 696
void rxrpc_get_call(struct rxrpc_call *, enum rxrpc_call_trace);
void rxrpc_put_call(struct rxrpc_call *, enum rxrpc_call_trace);
697
void rxrpc_cleanup_call(struct rxrpc_call *);
698
void rxrpc_destroy_all_calls(struct rxrpc_net *);
699

700 701 702 703 704 705 706 707 708 709
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);
}

710 711 712 713 714 715 716 717 718 719 720 721 722
/*
 * 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;
723
		wake_up(&call->waitq);
724 725 726 727 728 729 730 731 732 733
		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)
{
734
	bool ret;
735 736 737 738 739 740 741 742 743 744

	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.
 */
745
static inline bool __rxrpc_call_completed(struct rxrpc_call *call)
746
{
747
	return __rxrpc_set_call_completion(call, RXRPC_CALL_SUCCEEDED, 0, 0);
748 749
}

750
static inline bool rxrpc_call_completed(struct rxrpc_call *call)
751
{
752 753
	bool ret;

754
	write_lock_bh(&call->state_lock);
755
	ret = __rxrpc_call_completed(call);
756
	write_unlock_bh(&call->state_lock);
757
	return ret;
758 759 760 761 762
}

/*
 * Record that a call is locally aborted.
 */
763 764
static inline bool __rxrpc_abort_call(const char *why, struct rxrpc_call *call,
				      rxrpc_seq_t seq,
765 766
				      u32 abort_code, int error)
{
767 768
	trace_rxrpc_abort(why, call->cid, call->call_id, seq,
			  abort_code, error);
769 770
	return __rxrpc_set_call_completion(call, RXRPC_CALL_LOCALLY_ABORTED,
					   abort_code, error);
771 772
}

773 774
static inline bool rxrpc_abort_call(const char *why, struct rxrpc_call *call,
				    rxrpc_seq_t seq, u32 abort_code, int error)
775 776 777 778
{
	bool ret;

	write_lock_bh(&call->state_lock);
779
	ret = __rxrpc_abort_call(why, call, seq, abort_code, error);
780 781 782 783
	write_unlock_bh(&call->state_lock);
	return ret;
}

784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802
/*
 * Abort a call due to a protocol error.
 */
static inline bool __rxrpc_abort_eproto(struct rxrpc_call *call,
					struct sk_buff *skb,
					const char *eproto_why,
					const char *why,
					u32 abort_code)
{
	struct rxrpc_skb_priv *sp = rxrpc_skb(skb);

	trace_rxrpc_rx_eproto(call, sp->hdr.serial, eproto_why);
	return rxrpc_abort_call(why, call, sp->hdr.seq, abort_code, -EPROTO);
}

#define rxrpc_abort_eproto(call, skb, eproto_why, abort_why, abort_code) \
	__rxrpc_abort_eproto((call), (skb), tracepoint_string(eproto_why), \
			     (abort_why), (abort_code))

803 804 805
/*
 * conn_client.c
 */
806 807 808 809
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;
810 811
extern struct idr rxrpc_client_conn_ids;

812
void rxrpc_destroy_client_conn_ids(void);
813 814
int rxrpc_connect_call(struct rxrpc_call *, struct rxrpc_conn_parameters *,
		       struct sockaddr_rxrpc *, gfp_t);
815 816 817
void rxrpc_expose_client_call(struct rxrpc_call *);
void rxrpc_disconnect_client_call(struct rxrpc_call *);
void rxrpc_put_client_conn(struct rxrpc_connection *);
818 819
void rxrpc_discard_expired_client_conns(struct work_struct *);
void rxrpc_destroy_all_client_connections(struct rxrpc_net *);
820

821
/*
822 823 824 825 826 827
 * conn_event.c
 */
void rxrpc_process_connection(struct work_struct *);

/*
 * conn_object.c
828
 */
829
extern unsigned int rxrpc_connection_expiry;
830

831
int rxrpc_extract_addr_from_skb(struct sockaddr_rxrpc *, struct sk_buff *);
832
struct rxrpc_connection *rxrpc_alloc_connection(gfp_t);
833 834
struct rxrpc_connection *rxrpc_find_connection_rcu(struct rxrpc_local *,
						   struct sk_buff *);
835
void __rxrpc_disconnect_call(struct rxrpc_connection *, struct rxrpc_call *);
836
void rxrpc_disconnect_call(struct rxrpc_call *);
837
void rxrpc_kill_connection(struct rxrpc_connection *);
838 839 840 841 842
bool rxrpc_queue_conn(struct rxrpc_connection *);
void rxrpc_see_connection(struct rxrpc_connection *);
void rxrpc_get_connection(struct rxrpc_connection *);
struct rxrpc_connection *rxrpc_get_connection_maybe(struct rxrpc_connection *);
void rxrpc_put_service_conn(struct rxrpc_connection *);
843 844
void rxrpc_service_connection_reaper(struct work_struct *);
void rxrpc_destroy_all_connections(struct rxrpc_net *);
845

846 847 848 849 850 851 852
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)
{
853
	return !rxrpc_conn_is_client(conn);
854 855
}

856 857
static inline void rxrpc_put_connection(struct rxrpc_connection *conn)
{
858 859 860
	if (!conn)
		return;

861 862 863 864
	if (rxrpc_conn_is_client(conn))
		rxrpc_put_client_conn(conn);
	else
		rxrpc_put_service_conn(conn);
865 866
}

867 868 869
/*
 * conn_service.c
 */
870 871
struct rxrpc_connection *rxrpc_find_service_conn_rcu(struct rxrpc_peer *,
						     struct sk_buff *);
872
struct rxrpc_connection *rxrpc_prealloc_service_connection(struct rxrpc_net *, gfp_t);
D
David Howells 已提交
873 874
void rxrpc_new_incoming_connection(struct rxrpc_sock *,
				   struct rxrpc_connection *, struct sk_buff *);
875
void rxrpc_unpublish_service_conn(struct rxrpc_connection *);
876

877
/*
878
 * input.c
879
 */
880
void rxrpc_data_ready(struct sock *);
881 882

/*
883
 * insecure.c
884
 */
885
extern const struct rxrpc_security rxrpc_no_security;
886 887

/*
888
 * key.c
889
 */
890 891 892 893 894 895 896
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);
897

898 899 900
/*
 * local_event.c
 */
901
extern void rxrpc_process_local_events(struct rxrpc_local *);
902

903
/*
904
 * local_object.c
905
 */
906
struct rxrpc_local *rxrpc_lookup_local(struct net *, const struct sockaddr_rxrpc *);
907
void __rxrpc_put_local(struct rxrpc_local *);
908
void rxrpc_destroy_all_locals(struct rxrpc_net *);
909

910 911 912 913 914 915 916 917 918 919 920 921 922
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)
{
923
	if (local && atomic_dec_and_test(&local->usage))
924 925 926
		__rxrpc_put_local(local);
}

927 928 929 930 931
static inline void rxrpc_queue_local(struct rxrpc_local *local)
{
	rxrpc_queue_work(&local->processor);
}

932
/*
933
 * misc.c
934
 */
935 936 937 938 939 940 941
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;
942
extern unsigned int rxrpc_resend_timeout;
943

944 945
extern const s8 rxrpc_ack_priority[];

946 947 948 949 950 951 952 953 954 955 956
/*
 * net_ns.c
 */
extern unsigned int rxrpc_net_id;
extern struct pernet_operations rxrpc_net_ops;

static inline struct rxrpc_net *rxrpc_net(struct net *net)
{
	return net_generic(net, rxrpc_net_id);
}

957
/*
958
 * output.c
959
 */
960
int rxrpc_send_ack_packet(struct rxrpc_call *, bool);
961
int rxrpc_send_abort_packet(struct rxrpc_call *);
962
int rxrpc_send_data_packet(struct rxrpc_call *, struct sk_buff *, bool);
963
void rxrpc_reject_packets(struct rxrpc_local *);
964 965

/*
966
 * peer_event.c
967
 */
968
void rxrpc_error_report(struct sock *);
969
void rxrpc_peer_error_distributor(struct work_struct *);
D
David Howells 已提交
970 971
void rxrpc_peer_add_rtt(struct rxrpc_call *, enum rxrpc_rtt_rx_trace,
			rxrpc_serial_t, rxrpc_serial_t, ktime_t, ktime_t);
972 973 974

/*
 * peer_object.c
975
 */
976 977 978 979 980
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);
981 982
struct rxrpc_peer *rxrpc_lookup_incoming_peer(struct rxrpc_local *,
					      struct rxrpc_peer *);
983

984
static inline struct rxrpc_peer *rxrpc_get_peer(struct rxrpc_peer *peer)
985 986
{
	atomic_inc(&peer->usage);
987
	return peer;
988 989 990 991 992 993 994 995 996 997 998
}

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)
{
999
	if (peer && atomic_dec_and_test(&peer->usage))
1000 1001
		__rxrpc_put_peer(peer);
}
1002 1003

/*
1004
 * proc.c
1005
 */
1006 1007
extern const struct file_operations rxrpc_call_seq_fops;
extern const struct file_operations rxrpc_connection_seq_fops;
1008 1009

/*
1010
 * recvmsg.c
1011
 */
1012
void rxrpc_notify_socket(struct rxrpc_call *);
1013
int rxrpc_recvmsg(struct socket *, struct msghdr *, size_t, int);
1014 1015

/*
1016 1017 1018 1019 1020 1021 1022 1023
 * rxkad.c
 */
#ifdef CONFIG_RXKAD
extern const struct rxrpc_security rxkad;
#endif

/*
 * security.c
1024
 */
1025 1026
int __init rxrpc_init_security(void);
void rxrpc_exit_security(void);
1027 1028
int rxrpc_init_client_conn_security(struct rxrpc_connection *);
int rxrpc_init_server_conn_security(struct rxrpc_connection *);
D
David Howells 已提交
1029

1030 1031 1032 1033
/*
 * sendmsg.c
 */
int rxrpc_do_sendmsg(struct rxrpc_sock *, struct msghdr *, size_t);
1034 1035

/*
1036
 * skbuff.c
1037
 */
1038
void rxrpc_kernel_data_consumed(struct rxrpc_call *, struct sk_buff *);
1039
void rxrpc_packet_destructor(struct sk_buff *);
D
David Howells 已提交
1040 1041 1042 1043 1044
void rxrpc_new_skb(struct sk_buff *, enum rxrpc_skb_trace);
void rxrpc_see_skb(struct sk_buff *, enum rxrpc_skb_trace);
void rxrpc_get_skb(struct sk_buff *, enum rxrpc_skb_trace);
void rxrpc_free_skb(struct sk_buff *, enum rxrpc_skb_trace);
void rxrpc_lose_skb(struct sk_buff *, enum rxrpc_skb_trace);
1045
void rxrpc_purge_queue(struct sk_buff_head *);
1046

1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057
/*
 * 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

1058 1059 1060
/*
 * utils.c
 */
1061
int rxrpc_extract_addr_from_skb(struct sockaddr_rxrpc *, struct sk_buff *);
1062

1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079
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;
}

1080 1081 1082
/*
 * debug tracing
 */
1083
extern unsigned int rxrpc_debug;
1084 1085

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

1088 1089
#define kenter(FMT,...)	dbgprintk("==> %s("FMT")",__func__ ,##__VA_ARGS__)
#define kleave(FMT,...)	dbgprintk("<== %s()"FMT"",__func__ ,##__VA_ARGS__)
1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139
#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
1140 1141 1142 1143 1144
#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__)
1145 1146 1147 1148 1149 1150 1151 1152 1153 1154
#endif

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

#define ASSERT(X)						\
do {								\
	if (unlikely(!(X))) {					\
1155
		pr_err("Assertion failed\n");			\
1156 1157
		BUG();						\
	}							\
1158
} while (0)
1159 1160 1161

#define ASSERTCMP(X, OP, Y)						\
do {									\
1162 1163
	__typeof__(X) _x = (X);						\
	__typeof__(Y) _y = (__typeof__(X))(Y);				\
1164
	if (unlikely(!(_x OP _y))) {					\
1165 1166 1167
		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);		\
1168 1169
		BUG();							\
	}								\
1170
} while (0)
1171 1172 1173 1174

#define ASSERTIF(C, X)						\
do {								\
	if (unlikely((C) && !(X))) {				\
1175
		pr_err("Assertion failed\n");			\
1176 1177
		BUG();						\
	}							\
1178
} while (0)
1179 1180 1181

#define ASSERTIFCMP(C, X, OP, Y)					\
do {									\
1182 1183
	__typeof__(X) _x = (X);						\
	__typeof__(Y) _y = (__typeof__(X))(Y);				\
1184 1185
	if (unlikely((C) && !(_x OP _y))) {				\
		pr_err("Assertion failed - %lu(0x%lx) %s %lu(0x%lx) is false\n", \
1186 1187
		       (unsigned long)_x, (unsigned long)_x, #OP,	\
		       (unsigned long)_y, (unsigned long)_y);		\
1188 1189
		BUG();							\
	}								\
1190
} while (0)
1191 1192 1193 1194 1195

#else

#define ASSERT(X)				\
do {						\
1196
} while (0)
1197 1198 1199

#define ASSERTCMP(X, OP, Y)			\
do {						\
1200
} while (0)
1201 1202 1203

#define ASSERTIF(C, X)				\
do {						\
1204
} while (0)
1205 1206 1207

#define ASSERTIFCMP(C, X, OP, Y)		\
do {						\
1208
} while (0)
1209 1210

#endif /* __KDEBUGALL */