1 /* SPDX-License-Identifier: GPL-2.0-or-later */
2 /* AF_RXRPC internal definitions
3 *
4 * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
5 * Written by David Howells (dhowells@redhat.com)
6 */
7
8 #include <linux/atomic.h>
9 #include <linux/seqlock.h>
10 #include <linux/win_minmax.h>
11 #include <net/net_namespace.h>
12 #include <net/netns/generic.h>
13 #include <net/sock.h>
14 #include <net/af_rxrpc.h>
15 #include <keys/rxrpc-type.h>
16 #include "protocol.h"
17
18 #define FCRYPT_BSIZE 8
19 struct rxrpc_crypt {
20 union {
21 u8 x[FCRYPT_BSIZE];
22 __be32 n[2];
23 };
24 } __attribute__((aligned(8)));
25
26 #define rxrpc_queue_work(WS) queue_work(rxrpc_workqueue, (WS))
27 #define rxrpc_queue_delayed_work(WS,D) \
28 queue_delayed_work(rxrpc_workqueue, (WS), (D))
29
30 struct key_preparsed_payload;
31 struct rxrpc_connection;
32 struct rxrpc_txbuf;
33 struct rxrpc_txqueue;
34
35 /*
36 * Mark applied to socket buffers in skb->mark. skb->priority is used
37 * to pass supplementary information.
38 */
39 enum rxrpc_skb_mark {
40 RXRPC_SKB_MARK_PACKET, /* Received packet */
41 RXRPC_SKB_MARK_ERROR, /* Error notification */
42 RXRPC_SKB_MARK_SERVICE_CONN_SECURED, /* Service connection response has been verified */
43 RXRPC_SKB_MARK_REJECT_BUSY, /* Reject with BUSY */
44 RXRPC_SKB_MARK_REJECT_ABORT, /* Reject with ABORT (code in skb->priority) */
45 };
46
47 /*
48 * sk_state for RxRPC sockets
49 */
50 enum {
51 RXRPC_UNBOUND = 0,
52 RXRPC_CLIENT_UNBOUND, /* Unbound socket used as client */
53 RXRPC_CLIENT_BOUND, /* client local address bound */
54 RXRPC_SERVER_BOUND, /* server local address bound */
55 RXRPC_SERVER_BOUND2, /* second server local address bound */
56 RXRPC_SERVER_LISTENING, /* server listening for connections */
57 RXRPC_SERVER_LISTEN_DISABLED, /* server listening disabled */
58 RXRPC_CLOSE, /* socket is being closed */
59 };
60
61 /*
62 * Per-network namespace data.
63 */
64 struct rxrpc_net {
65 struct proc_dir_entry *proc_net; /* Subdir in /proc/net */
66 u32 epoch; /* Local epoch for detecting local-end reset */
67 struct list_head calls; /* List of calls active in this namespace */
68 spinlock_t call_lock; /* Lock for ->calls */
69 atomic_t nr_calls; /* Count of allocated calls */
70
71 atomic_t nr_conns;
72 struct list_head bundle_proc_list; /* List of bundles for proc */
73 struct list_head conn_proc_list; /* List of conns in this namespace for proc */
74 struct list_head service_conns; /* Service conns in this namespace */
75 rwlock_t conn_lock; /* Lock for ->conn_proc_list, ->service_conns */
76 struct work_struct service_conn_reaper;
77 struct timer_list service_conn_reap_timer;
78
79 bool live;
80
81 atomic_t nr_client_conns;
82
83 struct hlist_head local_endpoints;
84 struct mutex local_mutex; /* Lock for ->local_endpoints */
85
86 DECLARE_HASHTABLE (peer_hash, 10);
87 spinlock_t peer_hash_lock; /* Lock for ->peer_hash */
88
89 #define RXRPC_KEEPALIVE_TIME 20 /* NAT keepalive time in seconds */
90 u8 peer_keepalive_cursor;
91 time64_t peer_keepalive_base;
92 struct list_head peer_keepalive[32];
93 struct list_head peer_keepalive_new;
94 struct timer_list peer_keepalive_timer;
95 struct work_struct peer_keepalive_work;
96
97 atomic_t stat_tx_data;
98 atomic_t stat_tx_data_retrans;
99 atomic_t stat_tx_data_send;
100 atomic_t stat_tx_data_send_frag;
101 atomic_t stat_tx_data_send_fail;
102 atomic_t stat_tx_data_send_msgsize;
103 atomic_t stat_tx_data_underflow;
104 atomic_t stat_tx_data_cwnd_reset;
105 atomic_t stat_rx_data;
106 atomic_t stat_rx_data_reqack;
107 atomic_t stat_rx_data_jumbo;
108
109 atomic_t stat_tx_ack_fill;
110 atomic_t stat_tx_ack_send;
111 atomic_t stat_tx_ack_skip;
112 atomic_t stat_tx_acks[256];
113 atomic_t stat_rx_acks[256];
114 atomic_t stat_tx_jumbo[10];
115 atomic_t stat_rx_jumbo[10];
116
117 atomic_t stat_why_req_ack[8];
118
119 atomic_t stat_io_loop;
120 };
121
122 /*
123 * Service backlog preallocation.
124 *
125 * This contains circular buffers of preallocated peers, connections and calls
126 * for incoming service calls and their head and tail pointers. This allows
127 * calls to be set up in the data_ready handler, thereby avoiding the need to
128 * shuffle packets around so much.
129 */
130 struct rxrpc_backlog {
131 unsigned short peer_backlog_head;
132 unsigned short peer_backlog_tail;
133 unsigned short conn_backlog_head;
134 unsigned short conn_backlog_tail;
135 unsigned short call_backlog_head;
136 unsigned short call_backlog_tail;
137 #define RXRPC_BACKLOG_MAX 32
138 struct rxrpc_peer *peer_backlog[RXRPC_BACKLOG_MAX];
139 struct rxrpc_connection *conn_backlog[RXRPC_BACKLOG_MAX];
140 struct rxrpc_call *call_backlog[RXRPC_BACKLOG_MAX];
141 };
142
143 /*
144 * RxRPC socket definition
145 */
146 struct rxrpc_sock {
147 /* WARNING: sk has to be the first member */
148 struct sock sk;
149 rxrpc_notify_new_call_t notify_new_call; /* Func to notify of new call */
150 rxrpc_discard_new_call_t discard_new_call; /* Func to discard a new call */
151 struct rxrpc_local *local; /* local endpoint */
152 struct rxrpc_backlog *backlog; /* Preallocation for services */
153 spinlock_t incoming_lock; /* Incoming call vs service shutdown lock */
154 struct list_head sock_calls; /* List of calls owned by this socket */
155 struct list_head to_be_accepted; /* calls awaiting acceptance */
156 struct list_head recvmsg_q; /* Calls awaiting recvmsg's attention */
157 spinlock_t recvmsg_lock; /* Lock for recvmsg_q */
158 struct key *key; /* security for this socket */
159 struct key *securities; /* list of server security descriptors */
160 struct rb_root calls; /* User ID -> call mapping */
161 unsigned long flags;
162 #define RXRPC_SOCK_CONNECTED 0 /* connect_srx is set */
163 rwlock_t call_lock; /* lock for calls */
164 u32 min_sec_level; /* minimum security level */
165 #define RXRPC_SECURITY_MAX RXRPC_SECURITY_ENCRYPT
166 bool exclusive; /* Exclusive connection for a client socket */
167 u16 second_service; /* Additional service bound to the endpoint */
168 struct {
169 /* Service upgrade information */
170 u16 from; /* Service ID to upgrade (if not 0) */
171 u16 to; /* service ID to upgrade to */
172 } service_upgrade;
173 sa_family_t family; /* Protocol family created with */
174 struct sockaddr_rxrpc srx; /* Primary Service/local addresses */
175 struct sockaddr_rxrpc connect_srx; /* Default client address from connect() */
176 };
177
178 #define rxrpc_sk(__sk) container_of((__sk), struct rxrpc_sock, sk)
179
180 /*
181 * CPU-byteorder normalised Rx packet header.
182 */
183 struct rxrpc_host_header {
184 u32 epoch; /* client boot timestamp */
185 u32 cid; /* connection and channel ID */
186 u32 callNumber; /* call ID (0 for connection-level packets) */
187 u32 seq; /* sequence number of pkt in call stream */
188 u32 serial; /* serial number of pkt sent to network */
189 u8 type; /* packet type */
190 u8 flags; /* packet flags */
191 u8 userStatus; /* app-layer defined status */
192 u8 securityIndex; /* security protocol ID */
193 union {
194 u16 _rsvd; /* reserved */
195 u16 cksum; /* kerberos security checksum */
196 };
197 u16 serviceId; /* service ID */
198 } __packed;
199
200 /*
201 * RxRPC socket buffer private variables
202 * - max 48 bytes (struct sk_buff::cb)
203 */
204 struct rxrpc_skb_priv {
205 union {
206 struct rxrpc_connection *conn; /* Connection referred to (poke packet) */
207 struct {
208 u16 offset; /* Offset of data */
209 u16 len; /* Length of data */
210 u8 flags;
211 #define RXRPC_RX_VERIFIED 0x01
212 };
213 struct {
214 rxrpc_seq_t first_ack; /* First packet in acks table */
215 rxrpc_seq_t prev_ack; /* Highest seq seen */
216 rxrpc_serial_t acked_serial; /* Packet in response to (or 0) */
217 u16 nr_acks; /* Number of acks+nacks */
218 u8 reason; /* Reason for ack */
219 } ack;
220 };
221 struct rxrpc_host_header hdr; /* RxRPC packet header from this packet */
222 };
223
224 #define rxrpc_skb(__skb) ((struct rxrpc_skb_priv *) &(__skb)->cb)
225
226 /*
227 * RxRPC security module interface
228 */
229 struct rxrpc_security {
230 const char *name; /* name of this service */
231 u8 security_index; /* security type provided */
232 u32 no_key_abort; /* Abort code indicating no key */
233
234 /* Initialise a security service */
235 int (*init)(void);
236
237 /* Clean up a security service */
238 void (*exit)(void);
239
240 /* Parse the information from a server key */
241 int (*preparse_server_key)(struct key_preparsed_payload *);
242
243 /* Clean up the preparse buffer after parsing a server key */
244 void (*free_preparse_server_key)(struct key_preparsed_payload *);
245
246 /* Destroy the payload of a server key */
247 void (*destroy_server_key)(struct key *);
248
249 /* Describe a server key */
250 void (*describe_server_key)(const struct key *, struct seq_file *);
251
252 /* initialise a connection's security */
253 int (*init_connection_security)(struct rxrpc_connection *,
254 struct rxrpc_key_token *);
255
256 /* Work out how much data we can store in a packet, given an estimate
257 * of the amount of data remaining and allocate a data buffer.
258 */
259 struct rxrpc_txbuf *(*alloc_txbuf)(struct rxrpc_call *call, size_t remaining, gfp_t gfp);
260
261 /* impose security on a packet */
262 int (*secure_packet)(struct rxrpc_call *, struct rxrpc_txbuf *);
263
264 /* verify the security on a received packet */
265 int (*verify_packet)(struct rxrpc_call *, struct sk_buff *);
266
267 /* Free crypto request on a call */
268 void (*free_call_crypto)(struct rxrpc_call *);
269
270 /* issue a challenge */
271 int (*issue_challenge)(struct rxrpc_connection *);
272
273 /* respond to a challenge */
274 int (*respond_to_challenge)(struct rxrpc_connection *,
275 struct sk_buff *);
276
277 /* verify a response */
278 int (*verify_response)(struct rxrpc_connection *,
279 struct sk_buff *);
280
281 /* clear connection security */
282 void (*clear)(struct rxrpc_connection *);
283 };
284
285 /*
286 * RxRPC local transport endpoint description
287 * - owned by a single AF_RXRPC socket
288 * - pointed to by transport socket struct sk_user_data
289 */
290 struct rxrpc_local {
291 struct rcu_head rcu;
292 atomic_t active_users; /* Number of users of the local endpoint */
293 refcount_t ref; /* Number of references to the structure */
294 struct net *net; /* The network namespace */
295 struct rxrpc_net *rxnet; /* Our bits in the network namespace */
296 struct hlist_node link;
297 struct socket *socket; /* my UDP socket */
298 struct task_struct *io_thread;
299 struct completion io_thread_ready; /* Indication that the I/O thread started */
300 struct page_frag_cache tx_alloc; /* Tx control packet allocation (I/O thread only) */
301 struct rxrpc_sock *service; /* Service(s) listening on this endpoint */
302 #ifdef CONFIG_AF_RXRPC_INJECT_RX_DELAY
303 struct sk_buff_head rx_delay_queue; /* Delay injection queue */
304 #endif
305 struct sk_buff_head rx_queue; /* Received packets */
306 struct list_head conn_attend_q; /* Conns requiring immediate attention */
307 struct list_head call_attend_q; /* Calls requiring immediate attention */
308
309 struct rb_root client_bundles; /* Client connection bundles by socket params */
310 spinlock_t client_bundles_lock; /* Lock for client_bundles */
311 bool kill_all_client_conns;
312 struct list_head idle_client_conns;
313 struct timer_list client_conn_reap_timer;
314 unsigned long client_conn_flags;
315 #define RXRPC_CLIENT_CONN_REAP_TIMER 0 /* The client conn reap timer expired */
316
317 spinlock_t lock; /* access lock */
318 rwlock_t services_lock; /* lock for services list */
319 int debug_id; /* debug ID for printks */
320 bool dead;
321 bool service_closed; /* Service socket closed */
322 struct idr conn_ids; /* List of connection IDs */
323 struct list_head new_client_calls; /* Newly created client calls need connection */
324 spinlock_t client_call_lock; /* Lock for ->new_client_calls */
325 struct sockaddr_rxrpc srx; /* local address */
326 /* Provide a kvec table sufficiently large to manage either a DATA
327 * packet with a maximum set of jumbo subpackets or a PING ACK padded
328 * out to 64K with zeropages for PMTUD.
329 */
330 struct kvec kvec[1 + RXRPC_MAX_NR_JUMBO > 3 + 16 ?
331 1 + RXRPC_MAX_NR_JUMBO : 3 + 16];
332 };
333
334 /*
335 * RxRPC remote transport endpoint definition
336 * - matched by local endpoint, remote port, address and protocol type
337 */
338 struct rxrpc_peer {
339 struct rcu_head rcu; /* This must be first */
340 refcount_t ref;
341 unsigned long hash_key;
342 struct hlist_node hash_link;
343 struct rxrpc_local *local;
344 struct hlist_head error_targets; /* targets for net error distribution */
345 struct rb_root service_conns; /* Service connections */
346 struct list_head keepalive_link; /* Link in net->peer_keepalive[] */
347 unsigned long app_data; /* Application data (e.g. afs_server) */
348 time64_t last_tx_at; /* Last time packet sent here */
349 seqlock_t service_conn_lock;
350 spinlock_t lock; /* access lock */
351 int debug_id; /* debug ID for printks */
352 struct sockaddr_rxrpc srx; /* remote address */
353
354 /* Path MTU discovery [RFC8899] */
355 unsigned int pmtud_trial; /* Current MTU probe size */
356 unsigned int pmtud_good; /* Largest working MTU probe we've tried */
357 unsigned int pmtud_bad; /* Smallest non-working MTU probe we've tried */
358 bool pmtud_lost; /* T if MTU probe was lost */
359 bool pmtud_probing; /* T if we have an active probe outstanding */
360 bool pmtud_pending; /* T if a call to this peer should send a probe */
361 u8 pmtud_jumbo; /* Max jumbo packets for the MTU */
362 bool ackr_adv_pmtud; /* T if the peer advertises path-MTU */
363 unsigned int ackr_max_data; /* Maximum data advertised by peer */
364 unsigned int if_mtu; /* Local interface MTU (- hdrsize) for this peer */
365 unsigned int max_data; /* Maximum packet data capacity for this peer */
366 unsigned short hdrsize; /* header size (IP + UDP + RxRPC) */
367 unsigned short tx_seg_max; /* Maximum number of transmissable segments */
368
369 /* Calculated RTT cache */
370 unsigned int recent_srtt_us;
371 unsigned int recent_rto_us;
372
373 u8 cong_ssthresh; /* Congestion slow-start threshold */
374 };
375
376 /*
377 * Keys for matching a connection.
378 */
379 struct rxrpc_conn_proto {
380 union {
381 struct {
382 u32 epoch; /* epoch of this connection */
383 u32 cid; /* connection ID */
384 };
385 u64 index_key;
386 };
387 };
388
389 struct rxrpc_conn_parameters {
390 struct rxrpc_local *local; /* Representation of local endpoint */
391 struct rxrpc_peer *peer; /* Representation of remote endpoint */
392 struct key *key; /* Security details */
393 bool exclusive; /* T if conn is exclusive */
394 bool upgrade; /* T if service ID can be upgraded */
395 u16 service_id; /* Service ID for this connection */
396 u32 security_level; /* Security level selected */
397 };
398
399 /*
400 * Call completion condition (state == RXRPC_CALL_COMPLETE).
401 */
402 enum rxrpc_call_completion {
403 RXRPC_CALL_SUCCEEDED, /* - Normal termination */
404 RXRPC_CALL_REMOTELY_ABORTED, /* - call aborted by peer */
405 RXRPC_CALL_LOCALLY_ABORTED, /* - call aborted locally on error or close */
406 RXRPC_CALL_LOCAL_ERROR, /* - call failed due to local error */
407 RXRPC_CALL_NETWORK_ERROR, /* - call terminated by network error */
408 NR__RXRPC_CALL_COMPLETIONS
409 };
410
411 /*
412 * Bits in the connection flags.
413 */
414 enum rxrpc_conn_flag {
415 RXRPC_CONN_IN_SERVICE_CONNS, /* Conn is in peer->service_conns */
416 RXRPC_CONN_DONT_REUSE, /* Don't reuse this connection */
417 RXRPC_CONN_PROBING_FOR_UPGRADE, /* Probing for service upgrade */
418 RXRPC_CONN_FINAL_ACK_0, /* Need final ACK for channel 0 */
419 RXRPC_CONN_FINAL_ACK_1, /* Need final ACK for channel 1 */
420 RXRPC_CONN_FINAL_ACK_2, /* Need final ACK for channel 2 */
421 RXRPC_CONN_FINAL_ACK_3, /* Need final ACK for channel 3 */
422 };
423
424 #define RXRPC_CONN_FINAL_ACK_MASK ((1UL << RXRPC_CONN_FINAL_ACK_0) | \
425 (1UL << RXRPC_CONN_FINAL_ACK_1) | \
426 (1UL << RXRPC_CONN_FINAL_ACK_2) | \
427 (1UL << RXRPC_CONN_FINAL_ACK_3))
428
429 /*
430 * Events that can be raised upon a connection.
431 */
432 enum rxrpc_conn_event {
433 RXRPC_CONN_EV_CHALLENGE, /* Send challenge packet */
434 RXRPC_CONN_EV_ABORT_CALLS, /* Abort attached calls */
435 };
436
437 /*
438 * The connection protocol state.
439 */
440 enum rxrpc_conn_proto_state {
441 RXRPC_CONN_UNUSED, /* Connection not yet attempted */
442 RXRPC_CONN_CLIENT_UNSECURED, /* Client connection needs security init */
443 RXRPC_CONN_CLIENT, /* Client connection */
444 RXRPC_CONN_SERVICE_PREALLOC, /* Service connection preallocation */
445 RXRPC_CONN_SERVICE_UNSECURED, /* Service unsecured connection */
446 RXRPC_CONN_SERVICE_CHALLENGING, /* Service challenging for security */
447 RXRPC_CONN_SERVICE, /* Service secured connection */
448 RXRPC_CONN_ABORTED, /* Conn aborted */
449 RXRPC_CONN__NR_STATES
450 };
451
452 /*
453 * RxRPC client connection bundle.
454 */
455 struct rxrpc_bundle {
456 struct rxrpc_local *local; /* Representation of local endpoint */
457 struct rxrpc_peer *peer; /* Remote endpoint */
458 struct key *key; /* Security details */
459 struct list_head proc_link; /* Link in net->bundle_proc_list */
460 const struct rxrpc_security *security; /* applied security module */
461 refcount_t ref;
462 atomic_t active; /* Number of active users */
463 unsigned int debug_id;
464 u32 security_level; /* Security level selected */
465 u16 service_id; /* Service ID for this connection */
466 bool try_upgrade; /* True if the bundle is attempting upgrade */
467 bool exclusive; /* T if conn is exclusive */
468 bool upgrade; /* T if service ID can be upgraded */
469 unsigned short alloc_error; /* Error from last conn allocation */
470 struct rb_node local_node; /* Node in local->client_conns */
471 struct list_head waiting_calls; /* Calls waiting for channels */
472 unsigned long avail_chans; /* Mask of available channels */
473 unsigned int conn_ids[4]; /* Connection IDs. */
474 struct rxrpc_connection *conns[4]; /* The connections in the bundle (max 4) */
475 };
476
477 /*
478 * RxRPC connection definition
479 * - matched by { local, peer, epoch, conn_id, direction }
480 * - each connection can only handle four simultaneous calls
481 */
482 struct rxrpc_connection {
483 struct rxrpc_conn_proto proto;
484 struct rxrpc_local *local; /* Representation of local endpoint */
485 struct rxrpc_peer *peer; /* Remote endpoint */
486 struct rxrpc_net *rxnet; /* Network namespace to which call belongs */
487 struct key *key; /* Security details */
488 struct list_head attend_link; /* Link in local->conn_attend_q */
489
490 refcount_t ref;
491 atomic_t active; /* Active count for service conns */
492 struct rcu_head rcu;
493 struct list_head cache_link;
494
495 unsigned char act_chans; /* Mask of active channels */
496 struct rxrpc_channel {
497 unsigned long final_ack_at; /* Time at which to issue final ACK */
498 struct rxrpc_call *call; /* Active call */
499 unsigned int call_debug_id; /* call->debug_id */
500 u32 call_id; /* ID of current call */
501 u32 call_counter; /* Call ID counter */
502 u32 last_call; /* ID of last call */
503 u8 last_type; /* Type of last packet */
504 union {
505 u32 last_seq;
506 u32 last_abort;
507 };
508 } channels[RXRPC_MAXCALLS];
509
510 struct timer_list timer; /* Conn event timer */
511 struct work_struct processor; /* connection event processor */
512 struct work_struct destructor; /* In-process-context destroyer */
513 struct rxrpc_bundle *bundle; /* Client connection bundle */
514 struct rb_node service_node; /* Node in peer->service_conns */
515 struct list_head proc_link; /* link in procfs list */
516 struct list_head link; /* link in master connection list */
517 struct sk_buff_head rx_queue; /* received conn-level packets */
518 struct page_frag_cache tx_data_alloc; /* Tx DATA packet allocation */
519 struct mutex tx_data_alloc_lock;
520
521 struct mutex security_lock; /* Lock for security management */
522 const struct rxrpc_security *security; /* applied security module */
523 union {
524 struct {
525 struct crypto_sync_skcipher *cipher; /* encryption handle */
526 struct rxrpc_crypt csum_iv; /* packet checksum base */
527 u32 nonce; /* response re-use preventer */
528 } rxkad;
529 };
530 unsigned long flags;
531 unsigned long events;
532 unsigned long idle_timestamp; /* Time at which last became idle */
533 spinlock_t state_lock; /* state-change lock */
534 enum rxrpc_conn_proto_state state; /* current state of connection */
535 enum rxrpc_call_completion completion; /* Completion condition */
536 s32 abort_code; /* Abort code of connection abort */
537 int debug_id; /* debug ID for printks */
538 rxrpc_serial_t tx_serial; /* Outgoing packet serial number counter */
539 unsigned int hi_serial; /* highest serial number received */
540 rxrpc_serial_t pmtud_probe; /* Serial of MTU probe (or 0) */
541 unsigned int pmtud_call; /* ID of call used for probe */
542 u32 service_id; /* Service ID, possibly upgraded */
543 u32 security_level; /* Security level selected */
544 u8 security_ix; /* security type */
545 u8 out_clientflag; /* RXRPC_CLIENT_INITIATED if we are client */
546 u8 bundle_shift; /* Index into bundle->avail_chans */
547 bool exclusive; /* T if conn is exclusive */
548 bool upgrade; /* T if service ID can be upgraded */
549 u16 orig_service_id; /* Originally requested service ID */
550 short error; /* Local error code */
551 };
552
rxrpc_to_server(const struct rxrpc_skb_priv * sp)553 static inline bool rxrpc_to_server(const struct rxrpc_skb_priv *sp)
554 {
555 return sp->hdr.flags & RXRPC_CLIENT_INITIATED;
556 }
557
rxrpc_to_client(const struct rxrpc_skb_priv * sp)558 static inline bool rxrpc_to_client(const struct rxrpc_skb_priv *sp)
559 {
560 return !rxrpc_to_server(sp);
561 }
562
563 /*
564 * Flags in call->flags.
565 */
566 enum rxrpc_call_flag {
567 RXRPC_CALL_RELEASED, /* call has been released - no more message to userspace */
568 RXRPC_CALL_HAS_USERID, /* has a user ID attached */
569 RXRPC_CALL_IS_SERVICE, /* Call is service call */
570 RXRPC_CALL_EXPOSED, /* The call was exposed to the world */
571 RXRPC_CALL_RX_LAST, /* Received the last packet (at rxtx_top) */
572 RXRPC_CALL_TX_LAST, /* Last packet in Tx buffer (at rxtx_top) */
573 RXRPC_CALL_TX_ALL_ACKED, /* Last packet has been hard-acked */
574 RXRPC_CALL_TX_NO_MORE, /* No more data to transmit (MSG_MORE deasserted) */
575 RXRPC_CALL_SEND_PING, /* A ping will need to be sent */
576 RXRPC_CALL_RETRANS_TIMEOUT, /* Retransmission due to timeout occurred */
577 RXRPC_CALL_BEGAN_RX_TIMER, /* We began the expect_rx_by timer */
578 RXRPC_CALL_RX_HEARD, /* The peer responded at least once to this call */
579 RXRPC_CALL_DISCONNECTED, /* The call has been disconnected */
580 RXRPC_CALL_KERNEL, /* The call was made by the kernel */
581 RXRPC_CALL_UPGRADE, /* Service upgrade was requested for the call */
582 RXRPC_CALL_EXCLUSIVE, /* The call uses a once-only connection */
583 RXRPC_CALL_RX_IS_IDLE, /* recvmsg() is idle - send an ACK */
584 RXRPC_CALL_RECVMSG_READ_ALL, /* recvmsg() read all of the received data */
585 RXRPC_CALL_CONN_CHALLENGING, /* The connection is being challenged */
586 };
587
588 /*
589 * Events that can be raised on a call.
590 */
591 enum rxrpc_call_event {
592 RXRPC_CALL_EV_ACK_LOST, /* ACK may be lost, send ping */
593 RXRPC_CALL_EV_INITIAL_PING, /* Send initial ping for a new service call */
594 };
595
596 /*
597 * The states that a call can be in.
598 */
599 enum rxrpc_call_state {
600 RXRPC_CALL_UNINITIALISED,
601 RXRPC_CALL_CLIENT_AWAIT_CONN, /* - client waiting for connection to become available */
602 RXRPC_CALL_CLIENT_SEND_REQUEST, /* - client sending request phase */
603 RXRPC_CALL_CLIENT_AWAIT_REPLY, /* - client awaiting reply */
604 RXRPC_CALL_CLIENT_RECV_REPLY, /* - client receiving reply phase */
605 RXRPC_CALL_SERVER_PREALLOC, /* - service preallocation */
606 RXRPC_CALL_SERVER_RECV_REQUEST, /* - server receiving request */
607 RXRPC_CALL_SERVER_ACK_REQUEST, /* - server pending ACK of request */
608 RXRPC_CALL_SERVER_SEND_REPLY, /* - server sending reply */
609 RXRPC_CALL_SERVER_AWAIT_ACK, /* - server awaiting final ACK */
610 RXRPC_CALL_COMPLETE, /* - call complete */
611 NR__RXRPC_CALL_STATES
612 };
613
614 /*
615 * Call Tx congestion management modes.
616 */
617 enum rxrpc_ca_state {
618 RXRPC_CA_SLOW_START,
619 RXRPC_CA_CONGEST_AVOIDANCE,
620 RXRPC_CA_PACKET_LOSS,
621 RXRPC_CA_FAST_RETRANSMIT,
622 NR__RXRPC_CA_STATES
623 } __mode(byte);
624
625 /*
626 * Current purpose of call RACK timer. According to the RACK-TLP protocol
627 * [RFC8985], the transmission timer (call->rack_timo_at) may only be used for
628 * one of these at once.
629 */
630 enum rxrpc_rack_timer_mode {
631 RXRPC_CALL_RACKTIMER_OFF, /* Timer not running */
632 RXRPC_CALL_RACKTIMER_RACK_REORDER, /* RACK reordering timer */
633 RXRPC_CALL_RACKTIMER_TLP_PTO, /* TLP timeout */
634 RXRPC_CALL_RACKTIMER_RTO, /* Retransmission timeout */
635 } __mode(byte);
636
637 /*
638 * RxRPC call definition
639 * - matched by { connection, call_id }
640 */
641 struct rxrpc_call {
642 struct rcu_head rcu;
643 struct rxrpc_connection *conn; /* connection carrying call */
644 struct rxrpc_bundle *bundle; /* Connection bundle to use */
645 struct rxrpc_peer *peer; /* Peer record for remote address */
646 struct rxrpc_local *local; /* Representation of local endpoint */
647 struct rxrpc_sock __rcu *socket; /* socket responsible */
648 struct rxrpc_net *rxnet; /* Network namespace to which call belongs */
649 struct key *key; /* Security details */
650 const struct rxrpc_security *security; /* applied security module */
651 struct mutex user_mutex; /* User access mutex */
652 struct sockaddr_rxrpc dest_srx; /* Destination address */
653 ktime_t delay_ack_at; /* When DELAY ACK needs to happen */
654 ktime_t rack_timo_at; /* When ACK is figured as lost */
655 ktime_t ping_at; /* When next to send a ping */
656 ktime_t keepalive_at; /* When next to send a keepalive ping */
657 ktime_t expect_rx_by; /* When we expect to get a packet by */
658 ktime_t expect_req_by; /* When we expect to get a request DATA packet by */
659 ktime_t expect_term_by; /* When we expect call termination by */
660 u32 next_rx_timo; /* Timeout for next Rx packet (ms) */
661 u32 next_req_timo; /* Timeout for next Rx request packet (ms) */
662 u32 hard_timo; /* Maximum lifetime or 0 (s) */
663 struct timer_list timer; /* Combined event timer */
664 struct work_struct destroyer; /* In-process-context destroyer */
665 rxrpc_notify_rx_t notify_rx; /* kernel service Rx notification function */
666 struct list_head link; /* link in master call list */
667 struct list_head wait_link; /* Link in local->new_client_calls */
668 struct hlist_node error_link; /* link in error distribution list */
669 struct list_head accept_link; /* Link in rx->acceptq */
670 struct list_head recvmsg_link; /* Link in rx->recvmsg_q */
671 struct list_head sock_link; /* Link in rx->sock_calls */
672 struct rb_node sock_node; /* Node in rx->calls */
673 struct list_head attend_link; /* Link in local->call_attend_q */
674 struct rxrpc_txbuf *tx_pending; /* Tx buffer being filled */
675 wait_queue_head_t waitq; /* Wait queue for channel or Tx */
676 s64 tx_total_len; /* Total length left to be transmitted (or -1) */
677 unsigned long user_call_ID; /* user-defined call ID */
678 unsigned long flags;
679 unsigned long events;
680 spinlock_t notify_lock; /* Kernel notification lock */
681 unsigned int send_abort_why; /* Why the abort [enum rxrpc_abort_reason] */
682 s32 send_abort; /* Abort code to be sent */
683 short send_abort_err; /* Error to be associated with the abort */
684 rxrpc_seq_t send_abort_seq; /* DATA packet that incurred the abort (or 0) */
685 s32 abort_code; /* Local/remote abort code */
686 int error; /* Local error incurred */
687 enum rxrpc_call_state _state; /* Current state of call (needs barrier) */
688 enum rxrpc_call_completion completion; /* Call completion condition */
689 refcount_t ref;
690 u8 security_ix; /* Security type */
691 enum rxrpc_interruptibility interruptibility; /* At what point call may be interrupted */
692 u32 call_id; /* call ID on connection */
693 u32 cid; /* connection ID plus channel index */
694 u32 security_level; /* Security level selected */
695 int debug_id; /* debug ID for printks */
696 unsigned short rx_pkt_offset; /* Current recvmsg packet offset */
697 unsigned short rx_pkt_len; /* Current recvmsg packet len */
698
699 /* Sendmsg data tracking. */
700 rxrpc_seq_t send_top; /* Highest Tx slot filled by sendmsg. */
701 struct rxrpc_txqueue *send_queue; /* Queue that sendmsg is writing into */
702
703 /* Transmitted data tracking. */
704 struct rxrpc_txqueue *tx_queue; /* Start of transmission buffers */
705 struct rxrpc_txqueue *tx_qtail; /* End of transmission buffers */
706 rxrpc_seq_t tx_qbase; /* First slot in tx_queue */
707 rxrpc_seq_t tx_bottom; /* First packet in buffer */
708 rxrpc_seq_t tx_transmitted; /* Highest packet transmitted */
709 rxrpc_seq_t tx_top; /* Highest Tx slot allocated. */
710 rxrpc_serial_t tx_last_serial; /* Serial of last DATA transmitted */
711 u16 tx_backoff; /* Delay to insert due to Tx failure (ms) */
712 u16 tx_nr_sent; /* Number of packets sent, but unacked */
713 u16 tx_nr_lost; /* Number of packets marked lost */
714 u16 tx_nr_resent; /* Number of packets resent, but unacked */
715 u16 tx_winsize; /* Maximum size of Tx window */
716 #define RXRPC_TX_MAX_WINDOW 128
717 u8 tx_jumbo_max; /* Maximum subpkts peer will accept */
718 ktime_t tx_last_sent; /* Last time a transmission occurred */
719
720 /* Received data tracking */
721 struct sk_buff_head recvmsg_queue; /* Queue of packets ready for recvmsg() */
722 struct sk_buff_head rx_queue; /* Queue of packets for this call to receive */
723 struct sk_buff_head rx_oos_queue; /* Queue of out of sequence packets */
724
725 rxrpc_seq_t rx_highest_seq; /* Higest sequence number received */
726 rxrpc_seq_t rx_consumed; /* Highest packet consumed */
727 rxrpc_serial_t rx_serial; /* Highest serial received for this call */
728 u8 rx_winsize; /* Size of Rx window */
729
730 /* TCP-style slow-start congestion control [RFC5681]. Since the SMSS
731 * is fixed, we keep these numbers in terms of segments (ie. DATA
732 * packets) rather than bytes.
733 */
734 #define RXRPC_TX_SMSS RXRPC_JUMBO_DATALEN
735 #define RXRPC_MIN_CWND 4
736 enum rxrpc_ca_state cong_ca_state; /* Congestion control state */
737 u8 cong_extra; /* Extra to send for congestion management */
738 u16 cong_cwnd; /* Congestion window size */
739 u16 cong_ssthresh; /* Slow-start threshold */
740 u16 cong_dup_acks; /* Count of ACKs showing missing packets */
741 u16 cong_cumul_acks; /* Cumulative ACK count */
742 ktime_t cong_tstamp; /* Last time cwnd was changed */
743
744 /* RACK-TLP [RFC8985] state. */
745 ktime_t rack_xmit_ts; /* Latest transmission timestamp */
746 ktime_t rack_rtt; /* RTT of most recently ACK'd segment */
747 ktime_t rack_rtt_ts; /* Timestamp of rack_rtt */
748 ktime_t rack_reo_wnd; /* Reordering window */
749 unsigned int rack_reo_wnd_mult; /* Multiplier applied to rack_reo_wnd */
750 int rack_reo_wnd_persist; /* Num loss recoveries before reset reo_wnd */
751 rxrpc_seq_t rack_fack; /* Highest sequence so far ACK'd */
752 rxrpc_seq_t rack_end_seq; /* Highest sequence seen */
753 rxrpc_seq_t rack_dsack_round; /* DSACK opt recv'd in latest roundtrip */
754 bool rack_dsack_round_none; /* T if dsack_round is "None" */
755 bool rack_reordering_seen; /* T if detected reordering event */
756 enum rxrpc_rack_timer_mode rack_timer_mode; /* Current mode of RACK timer */
757 bool tlp_is_retrans; /* T if unacked TLP retransmission */
758 rxrpc_serial_t tlp_serial; /* Serial of TLP probe (or 0 if none in progress) */
759 rxrpc_seq_t tlp_seq; /* Sequence of TLP probe */
760 unsigned int tlp_rtt_taken; /* Last time RTT taken */
761 ktime_t tlp_max_ack_delay; /* Sender budget for max delayed ACK interval */
762
763 /* Receive-phase ACK management (ACKs we send). */
764 u8 ackr_reason; /* reason to ACK */
765 u16 ackr_sack_base; /* Starting slot in SACK table ring */
766 rxrpc_seq_t ackr_window; /* Base of SACK window */
767 rxrpc_seq_t ackr_wtop; /* Base of SACK window */
768 unsigned int ackr_nr_unacked; /* Number of unacked packets */
769 atomic_t ackr_nr_consumed; /* Number of packets needing hard ACK */
770 struct {
771 #define RXRPC_SACK_SIZE 256
772 /* SACK table for soft-acked packets */
773 u8 ackr_sack_table[RXRPC_SACK_SIZE];
774 } __aligned(8);
775
776 /* RTT management */
777 rxrpc_serial_t rtt_serial[4]; /* Serial number of DATA or PING sent */
778 ktime_t rtt_sent_at[4]; /* Time packet sent */
779 unsigned long rtt_avail; /* Mask of available slots in bits 0-3,
780 * Mask of pending samples in 8-11 */
781 #define RXRPC_CALL_RTT_AVAIL_MASK 0xf
782 #define RXRPC_CALL_RTT_PEND_SHIFT 8
783
784 /* Transmission-phase ACK management (ACKs we've received). */
785 ktime_t acks_latest_ts; /* Timestamp of latest ACK received */
786 rxrpc_seq_t acks_hard_ack; /* Highest sequence hard acked */
787 rxrpc_seq_t acks_prev_seq; /* Highest previousPacket received */
788 rxrpc_seq_t acks_lowest_nak; /* Lowest NACK in the buffer (or ==tx_hard_ack) */
789 rxrpc_serial_t acks_highest_serial; /* Highest serial number ACK'd */
790 unsigned short acks_nr_sacks; /* Number of soft acks recorded */
791 unsigned short acks_nr_snacks; /* Number of soft nacks recorded */
792
793 /* Calculated RTT cache */
794 ktime_t rtt_last_req; /* Time of last RTT request */
795 unsigned int rtt_count; /* Number of samples we've got */
796 unsigned int rtt_taken; /* Number of samples taken (wrapping) */
797 struct minmax min_rtt; /* Estimated minimum RTT */
798 u32 srtt_us; /* smoothed round trip time << 3 in usecs */
799 u32 mdev_us; /* medium deviation */
800 u32 mdev_max_us; /* maximal mdev for the last rtt period */
801 u32 rttvar_us; /* smoothed mdev_max */
802 u32 rto_us; /* Retransmission timeout in usec */
803 u8 backoff; /* Backoff timeout (as shift) */
804 };
805
806 /*
807 * Summary of a new ACK and the changes it made to the Tx buffer packet states.
808 */
809 struct rxrpc_ack_summary {
810 rxrpc_serial_t ack_serial; /* Serial number of ACK */
811 rxrpc_serial_t acked_serial; /* Serial number ACK'd */
812 u16 in_flight; /* Number of unreceived transmissions */
813 u16 nr_new_hacks; /* Number of rotated new ACKs */
814 u16 nr_new_sacks; /* Number of new soft ACKs in packet */
815 u16 nr_new_snacks; /* Number of new soft nacks in packet */
816 u8 ack_reason;
817 bool new_low_snack:1; /* T if new low soft NACK found */
818 bool retrans_timeo:1; /* T if reTx due to timeout happened */
819 bool need_retransmit:1; /* T if we need transmission */
820 bool rtt_sample_avail:1; /* T if RTT sample available */
821 bool in_fast_or_rto_recovery:1;
822 bool exiting_fast_or_rto_recovery:1;
823 bool tlp_probe_acked:1; /* T if the TLP probe seq was acked */
824 u8 /*enum rxrpc_congest_change*/ change;
825 };
826
827 /*
828 * sendmsg() cmsg-specified parameters.
829 */
830 enum rxrpc_command {
831 RXRPC_CMD_SEND_DATA, /* send data message */
832 RXRPC_CMD_SEND_ABORT, /* request abort generation */
833 RXRPC_CMD_REJECT_BUSY, /* [server] reject a call as busy */
834 RXRPC_CMD_CHARGE_ACCEPT, /* [server] charge accept preallocation */
835 };
836
837 struct rxrpc_call_params {
838 s64 tx_total_len; /* Total Tx data length (if send data) */
839 unsigned long user_call_ID; /* User's call ID */
840 struct {
841 u32 hard; /* Maximum lifetime (sec) */
842 u32 idle; /* Max time since last data packet (msec) */
843 u32 normal; /* Max time since last call packet (msec) */
844 } timeouts;
845 u8 nr_timeouts; /* Number of timeouts specified */
846 bool kernel; /* T if kernel is making the call */
847 enum rxrpc_interruptibility interruptibility; /* How is interruptible is the call? */
848 };
849
850 struct rxrpc_send_params {
851 struct rxrpc_call_params call;
852 u32 abort_code; /* Abort code to Tx (if abort) */
853 enum rxrpc_command command : 8; /* The command to implement */
854 bool exclusive; /* Shared or exclusive call */
855 bool upgrade; /* If the connection is upgradeable */
856 };
857
858 /*
859 * Buffer of data to be output as a packet.
860 */
861 struct rxrpc_txbuf {
862 refcount_t ref;
863 rxrpc_seq_t seq; /* Sequence number of this packet */
864 rxrpc_serial_t serial; /* Last serial number transmitted with */
865 unsigned int call_debug_id;
866 unsigned int debug_id;
867 unsigned short len; /* Amount of data in buffer */
868 unsigned short space; /* Remaining data space */
869 unsigned short offset; /* Offset of fill point */
870 unsigned short pkt_len; /* Size of packet content */
871 unsigned short alloc_size; /* Amount of bufferage allocated */
872 unsigned int flags;
873 #define RXRPC_TXBUF_WIRE_FLAGS 0xff /* The wire protocol flags */
874 #define RXRPC_TXBUF_RESENT 0x100 /* Set if has been resent */
875 __be16 cksum; /* Checksum to go in header */
876 bool jumboable; /* Can be non-terminal jumbo subpacket */
877 void *data; /* Data with preceding jumbo header */
878 };
879
rxrpc_sending_to_server(const struct rxrpc_txbuf * txb)880 static inline bool rxrpc_sending_to_server(const struct rxrpc_txbuf *txb)
881 {
882 return txb->flags & RXRPC_CLIENT_INITIATED;
883 }
884
rxrpc_sending_to_client(const struct rxrpc_txbuf * txb)885 static inline bool rxrpc_sending_to_client(const struct rxrpc_txbuf *txb)
886 {
887 return !rxrpc_sending_to_server(txb);
888 }
889
890 /*
891 * Transmit queue element, including RACK [RFC8985] per-segment metadata. The
892 * transmission timestamp is in usec from the base.
893 */
894 struct rxrpc_txqueue {
895 /* Start with the members we want to prefetch. */
896 struct rxrpc_txqueue *next;
897 ktime_t xmit_ts_base;
898 rxrpc_seq_t qbase;
899 u8 nr_reported_acks; /* Number of segments explicitly acked/nacked */
900 unsigned long segment_acked; /* Bit-per-buf: Set if ACK'd */
901 unsigned long segment_lost; /* Bit-per-buf: Set if declared lost */
902 unsigned long segment_retransmitted; /* Bit-per-buf: Set if retransmitted */
903 unsigned long rtt_samples; /* Bit-per-buf: Set if available for RTT */
904 unsigned long ever_retransmitted; /* Bit-per-buf: Set if ever retransmitted */
905
906 /* The arrays we want to pack into as few cache lines as possible. */
907 struct {
908 #define RXRPC_NR_TXQUEUE BITS_PER_LONG
909 #define RXRPC_TXQ_MASK (RXRPC_NR_TXQUEUE - 1)
910 struct rxrpc_txbuf *bufs[RXRPC_NR_TXQUEUE];
911 unsigned int segment_serial[RXRPC_NR_TXQUEUE];
912 unsigned int segment_xmit_ts[RXRPC_NR_TXQUEUE];
913 } ____cacheline_aligned;
914 };
915
916 /*
917 * Data transmission request.
918 */
919 struct rxrpc_send_data_req {
920 ktime_t now; /* Current time */
921 struct rxrpc_txqueue *tq; /* Tx queue segment holding first DATA */
922 rxrpc_seq_t seq; /* Sequence of first data */
923 int n; /* Number of DATA packets to glue into jumbo */
924 bool retrans; /* T if this is a retransmission */
925 bool did_send; /* T if did actually send */
926 bool tlp_probe; /* T if this is a TLP probe */
927 int /* enum rxrpc_txdata_trace */ trace;
928 };
929
930 #include <trace/events/rxrpc.h>
931
932 /*
933 * Allocate the next serial number on a connection. 0 must be skipped.
934 */
rxrpc_get_next_serial(struct rxrpc_connection * conn)935 static inline rxrpc_serial_t rxrpc_get_next_serial(struct rxrpc_connection *conn)
936 {
937 rxrpc_serial_t serial;
938
939 serial = conn->tx_serial;
940 if (serial == 0)
941 serial = 1;
942 conn->tx_serial = serial + 1;
943 return serial;
944 }
945
946 /*
947 * Allocate the next serial n numbers on a connection. 0 must be skipped.
948 */
rxrpc_get_next_serials(struct rxrpc_connection * conn,unsigned int n)949 static inline rxrpc_serial_t rxrpc_get_next_serials(struct rxrpc_connection *conn,
950 unsigned int n)
951 {
952 rxrpc_serial_t serial;
953
954 serial = conn->tx_serial;
955 if (serial + n <= n)
956 serial = 1;
957 conn->tx_serial = serial + n;
958 return serial;
959 }
960
961 /*
962 * af_rxrpc.c
963 */
964 extern atomic_t rxrpc_n_rx_skbs;
965 extern struct workqueue_struct *rxrpc_workqueue;
966
967 /*
968 * call_accept.c
969 */
970 int rxrpc_service_prealloc(struct rxrpc_sock *, gfp_t);
971 void rxrpc_discard_prealloc(struct rxrpc_sock *);
972 bool rxrpc_new_incoming_call(struct rxrpc_local *local,
973 struct rxrpc_peer *peer,
974 struct rxrpc_connection *conn,
975 struct sockaddr_rxrpc *peer_srx,
976 struct sk_buff *skb);
977 int rxrpc_user_charge_accept(struct rxrpc_sock *, unsigned long);
978
979 /*
980 * call_event.c
981 */
982 void rxrpc_propose_ping(struct rxrpc_call *call, u32 serial,
983 enum rxrpc_propose_ack_trace why);
984 void rxrpc_propose_delay_ACK(struct rxrpc_call *, rxrpc_serial_t,
985 enum rxrpc_propose_ack_trace);
986 void rxrpc_resend_tlp(struct rxrpc_call *call);
987 void rxrpc_transmit_some_data(struct rxrpc_call *call, unsigned int limit,
988 enum rxrpc_txdata_trace trace);
989 bool rxrpc_input_call_event(struct rxrpc_call *call);
990
991 /*
992 * call_object.c
993 */
994 extern const char *const rxrpc_call_states[];
995 extern const char *const rxrpc_call_completions[];
996 extern struct kmem_cache *rxrpc_call_jar;
997
998 void rxrpc_poke_call(struct rxrpc_call *call, enum rxrpc_call_poke_trace what);
999 struct rxrpc_call *rxrpc_find_call_by_user_ID(struct rxrpc_sock *, unsigned long);
1000 struct rxrpc_call *rxrpc_alloc_call(struct rxrpc_sock *, gfp_t, unsigned int);
1001 struct rxrpc_call *rxrpc_new_client_call(struct rxrpc_sock *,
1002 struct rxrpc_conn_parameters *,
1003 struct rxrpc_call_params *, gfp_t,
1004 unsigned int);
1005 void rxrpc_start_call_timer(struct rxrpc_call *call);
1006 void rxrpc_incoming_call(struct rxrpc_sock *, struct rxrpc_call *,
1007 struct sk_buff *);
1008 void rxrpc_release_call(struct rxrpc_sock *, struct rxrpc_call *);
1009 void rxrpc_release_calls_on_socket(struct rxrpc_sock *);
1010 void rxrpc_see_call(struct rxrpc_call *, enum rxrpc_call_trace);
1011 struct rxrpc_call *rxrpc_try_get_call(struct rxrpc_call *, enum rxrpc_call_trace);
1012 void rxrpc_get_call(struct rxrpc_call *, enum rxrpc_call_trace);
1013 void rxrpc_put_call(struct rxrpc_call *, enum rxrpc_call_trace);
1014 void rxrpc_cleanup_call(struct rxrpc_call *);
1015 void rxrpc_destroy_all_calls(struct rxrpc_net *);
1016
rxrpc_is_service_call(const struct rxrpc_call * call)1017 static inline bool rxrpc_is_service_call(const struct rxrpc_call *call)
1018 {
1019 return test_bit(RXRPC_CALL_IS_SERVICE, &call->flags);
1020 }
1021
rxrpc_is_client_call(const struct rxrpc_call * call)1022 static inline bool rxrpc_is_client_call(const struct rxrpc_call *call)
1023 {
1024 return !rxrpc_is_service_call(call);
1025 }
1026
1027 /*
1028 * call_state.c
1029 */
1030 bool rxrpc_set_call_completion(struct rxrpc_call *call,
1031 enum rxrpc_call_completion compl,
1032 u32 abort_code,
1033 int error);
1034 bool rxrpc_call_completed(struct rxrpc_call *call);
1035 bool rxrpc_abort_call(struct rxrpc_call *call, rxrpc_seq_t seq,
1036 u32 abort_code, int error, enum rxrpc_abort_reason why);
1037 void rxrpc_prefail_call(struct rxrpc_call *call, enum rxrpc_call_completion compl,
1038 int error);
1039
rxrpc_set_call_state(struct rxrpc_call * call,enum rxrpc_call_state state)1040 static inline void rxrpc_set_call_state(struct rxrpc_call *call,
1041 enum rxrpc_call_state state)
1042 {
1043 /* Order write of completion info before write of ->state. */
1044 smp_store_release(&call->_state, state);
1045 wake_up(&call->waitq);
1046 }
1047
__rxrpc_call_state(const struct rxrpc_call * call)1048 static inline enum rxrpc_call_state __rxrpc_call_state(const struct rxrpc_call *call)
1049 {
1050 return call->_state; /* Only inside I/O thread */
1051 }
1052
__rxrpc_call_is_complete(const struct rxrpc_call * call)1053 static inline bool __rxrpc_call_is_complete(const struct rxrpc_call *call)
1054 {
1055 return __rxrpc_call_state(call) == RXRPC_CALL_COMPLETE;
1056 }
1057
rxrpc_call_state(const struct rxrpc_call * call)1058 static inline enum rxrpc_call_state rxrpc_call_state(const struct rxrpc_call *call)
1059 {
1060 /* Order read ->state before read of completion info. */
1061 return smp_load_acquire(&call->_state);
1062 }
1063
rxrpc_call_is_complete(const struct rxrpc_call * call)1064 static inline bool rxrpc_call_is_complete(const struct rxrpc_call *call)
1065 {
1066 return rxrpc_call_state(call) == RXRPC_CALL_COMPLETE;
1067 }
1068
rxrpc_call_has_failed(const struct rxrpc_call * call)1069 static inline bool rxrpc_call_has_failed(const struct rxrpc_call *call)
1070 {
1071 return rxrpc_call_is_complete(call) && call->completion != RXRPC_CALL_SUCCEEDED;
1072 }
1073
1074 /*
1075 * conn_client.c
1076 */
1077 extern unsigned int rxrpc_reap_client_connections;
1078 extern unsigned long rxrpc_conn_idle_client_expiry;
1079 extern unsigned long rxrpc_conn_idle_client_fast_expiry;
1080
1081 void rxrpc_purge_client_connections(struct rxrpc_local *local);
1082 struct rxrpc_bundle *rxrpc_get_bundle(struct rxrpc_bundle *, enum rxrpc_bundle_trace);
1083 void rxrpc_put_bundle(struct rxrpc_bundle *, enum rxrpc_bundle_trace);
1084 int rxrpc_look_up_bundle(struct rxrpc_call *call, gfp_t gfp);
1085 void rxrpc_connect_client_calls(struct rxrpc_local *local);
1086 void rxrpc_expose_client_call(struct rxrpc_call *);
1087 void rxrpc_disconnect_client_call(struct rxrpc_bundle *, struct rxrpc_call *);
1088 void rxrpc_deactivate_bundle(struct rxrpc_bundle *bundle);
1089 void rxrpc_discard_expired_client_conns(struct rxrpc_local *local);
1090 void rxrpc_clean_up_local_conns(struct rxrpc_local *);
1091
1092 /*
1093 * conn_event.c
1094 */
1095 void rxrpc_conn_retransmit_call(struct rxrpc_connection *conn, struct sk_buff *skb,
1096 unsigned int channel);
1097 int rxrpc_abort_conn(struct rxrpc_connection *conn, struct sk_buff *skb,
1098 s32 abort_code, int err, enum rxrpc_abort_reason why);
1099 void rxrpc_process_connection(struct work_struct *);
1100 void rxrpc_process_delayed_final_acks(struct rxrpc_connection *, bool);
1101 bool rxrpc_input_conn_packet(struct rxrpc_connection *conn, struct sk_buff *skb);
1102 void rxrpc_input_conn_event(struct rxrpc_connection *conn, struct sk_buff *skb);
1103
rxrpc_is_conn_aborted(const struct rxrpc_connection * conn)1104 static inline bool rxrpc_is_conn_aborted(const struct rxrpc_connection *conn)
1105 {
1106 /* Order reading the abort info after the state check. */
1107 return smp_load_acquire(&conn->state) == RXRPC_CONN_ABORTED;
1108 }
1109
1110 /*
1111 * conn_object.c
1112 */
1113 extern unsigned int rxrpc_connection_expiry;
1114 extern unsigned int rxrpc_closed_conn_expiry;
1115
1116 void rxrpc_poke_conn(struct rxrpc_connection *conn, enum rxrpc_conn_trace why);
1117 struct rxrpc_connection *rxrpc_alloc_connection(struct rxrpc_net *, gfp_t);
1118 struct rxrpc_connection *rxrpc_find_client_connection_rcu(struct rxrpc_local *,
1119 struct sockaddr_rxrpc *,
1120 struct sk_buff *);
1121 void __rxrpc_disconnect_call(struct rxrpc_connection *, struct rxrpc_call *);
1122 void rxrpc_disconnect_call(struct rxrpc_call *);
1123 void rxrpc_kill_client_conn(struct rxrpc_connection *);
1124 void rxrpc_queue_conn(struct rxrpc_connection *, enum rxrpc_conn_trace);
1125 void rxrpc_see_connection(struct rxrpc_connection *, enum rxrpc_conn_trace);
1126 struct rxrpc_connection *rxrpc_get_connection(struct rxrpc_connection *,
1127 enum rxrpc_conn_trace);
1128 struct rxrpc_connection *rxrpc_get_connection_maybe(struct rxrpc_connection *,
1129 enum rxrpc_conn_trace);
1130 void rxrpc_put_connection(struct rxrpc_connection *, enum rxrpc_conn_trace);
1131 void rxrpc_service_connection_reaper(struct work_struct *);
1132 void rxrpc_destroy_all_connections(struct rxrpc_net *);
1133
rxrpc_conn_is_client(const struct rxrpc_connection * conn)1134 static inline bool rxrpc_conn_is_client(const struct rxrpc_connection *conn)
1135 {
1136 return conn->out_clientflag;
1137 }
1138
rxrpc_conn_is_service(const struct rxrpc_connection * conn)1139 static inline bool rxrpc_conn_is_service(const struct rxrpc_connection *conn)
1140 {
1141 return !rxrpc_conn_is_client(conn);
1142 }
1143
rxrpc_reduce_conn_timer(struct rxrpc_connection * conn,unsigned long expire_at)1144 static inline void rxrpc_reduce_conn_timer(struct rxrpc_connection *conn,
1145 unsigned long expire_at)
1146 {
1147 timer_reduce(&conn->timer, expire_at);
1148 }
1149
1150 /*
1151 * conn_service.c
1152 */
1153 struct rxrpc_connection *rxrpc_find_service_conn_rcu(struct rxrpc_peer *,
1154 struct sk_buff *);
1155 struct rxrpc_connection *rxrpc_prealloc_service_connection(struct rxrpc_net *, gfp_t);
1156 void rxrpc_new_incoming_connection(struct rxrpc_sock *, struct rxrpc_connection *,
1157 const struct rxrpc_security *, struct sk_buff *);
1158 void rxrpc_unpublish_service_conn(struct rxrpc_connection *);
1159
1160 /*
1161 * input.c
1162 */
1163 void rxrpc_congestion_degrade(struct rxrpc_call *);
1164 void rxrpc_input_call_packet(struct rxrpc_call *, struct sk_buff *);
1165 void rxrpc_implicit_end_call(struct rxrpc_call *, struct sk_buff *);
1166
1167 /*
1168 * input_rack.c
1169 */
1170 void rxrpc_input_rack_one(struct rxrpc_call *call,
1171 struct rxrpc_ack_summary *summary,
1172 struct rxrpc_txqueue *tq,
1173 unsigned int ix);
1174 void rxrpc_input_rack(struct rxrpc_call *call,
1175 struct rxrpc_ack_summary *summary,
1176 struct rxrpc_txqueue *tq,
1177 unsigned long new_acks);
1178 void rxrpc_rack_detect_loss_and_arm_timer(struct rxrpc_call *call,
1179 struct rxrpc_ack_summary *summary);
1180 ktime_t rxrpc_tlp_calc_pto(struct rxrpc_call *call, ktime_t now);
1181 void rxrpc_tlp_send_probe(struct rxrpc_call *call);
1182 void rxrpc_tlp_process_ack(struct rxrpc_call *call, struct rxrpc_ack_summary *summary);
1183 void rxrpc_rack_timer_expired(struct rxrpc_call *call, ktime_t overran_by);
1184
1185 /* Initialise TLP state [RFC8958 7.1]. */
rxrpc_tlp_init(struct rxrpc_call * call)1186 static inline void rxrpc_tlp_init(struct rxrpc_call *call)
1187 {
1188 call->tlp_serial = 0;
1189 call->tlp_seq = call->acks_hard_ack;
1190 call->tlp_is_retrans = false;
1191 }
1192
1193 /*
1194 * io_thread.c
1195 */
1196 int rxrpc_encap_rcv(struct sock *, struct sk_buff *);
1197 void rxrpc_error_report(struct sock *);
1198 bool rxrpc_direct_abort(struct sk_buff *skb, enum rxrpc_abort_reason why,
1199 s32 abort_code, int err);
1200 int rxrpc_io_thread(void *data);
rxrpc_wake_up_io_thread(struct rxrpc_local * local)1201 static inline void rxrpc_wake_up_io_thread(struct rxrpc_local *local)
1202 {
1203 wake_up_process(READ_ONCE(local->io_thread));
1204 }
1205
rxrpc_protocol_error(struct sk_buff * skb,enum rxrpc_abort_reason why)1206 static inline bool rxrpc_protocol_error(struct sk_buff *skb, enum rxrpc_abort_reason why)
1207 {
1208 return rxrpc_direct_abort(skb, why, RX_PROTOCOL_ERROR, -EPROTO);
1209 }
1210
1211 /*
1212 * insecure.c
1213 */
1214 extern const struct rxrpc_security rxrpc_no_security;
1215
1216 /*
1217 * key.c
1218 */
1219 extern struct key_type key_type_rxrpc;
1220
1221 int rxrpc_request_key(struct rxrpc_sock *, sockptr_t , int);
1222 int rxrpc_get_server_data_key(struct rxrpc_connection *, const void *, time64_t,
1223 u32);
1224
1225 /*
1226 * local_event.c
1227 */
1228 void rxrpc_gen_version_string(void);
1229 void rxrpc_send_version_request(struct rxrpc_local *local,
1230 struct rxrpc_host_header *hdr,
1231 struct sk_buff *skb);
1232
1233 /*
1234 * local_object.c
1235 */
1236 void rxrpc_local_dont_fragment(const struct rxrpc_local *local, bool set);
1237 struct rxrpc_local *rxrpc_lookup_local(struct net *, const struct sockaddr_rxrpc *);
1238 struct rxrpc_local *rxrpc_get_local(struct rxrpc_local *, enum rxrpc_local_trace);
1239 struct rxrpc_local *rxrpc_get_local_maybe(struct rxrpc_local *, enum rxrpc_local_trace);
1240 void rxrpc_put_local(struct rxrpc_local *, enum rxrpc_local_trace);
1241 struct rxrpc_local *rxrpc_use_local(struct rxrpc_local *, enum rxrpc_local_trace);
1242 void rxrpc_unuse_local(struct rxrpc_local *, enum rxrpc_local_trace);
1243 void rxrpc_destroy_local(struct rxrpc_local *local);
1244 void rxrpc_destroy_all_locals(struct rxrpc_net *);
1245
__rxrpc_use_local(struct rxrpc_local * local,enum rxrpc_local_trace why)1246 static inline bool __rxrpc_use_local(struct rxrpc_local *local,
1247 enum rxrpc_local_trace why)
1248 {
1249 int r, u;
1250
1251 r = refcount_read(&local->ref);
1252 u = atomic_fetch_add_unless(&local->active_users, 1, 0);
1253 trace_rxrpc_local(local->debug_id, why, r, u);
1254 return u != 0;
1255 }
1256
rxrpc_see_local(struct rxrpc_local * local,enum rxrpc_local_trace why)1257 static inline void rxrpc_see_local(struct rxrpc_local *local,
1258 enum rxrpc_local_trace why)
1259 {
1260 int r, u;
1261
1262 r = refcount_read(&local->ref);
1263 u = atomic_read(&local->active_users);
1264 trace_rxrpc_local(local->debug_id, why, r, u);
1265 }
1266
1267 /*
1268 * misc.c
1269 */
1270 extern unsigned int rxrpc_max_backlog __read_mostly;
1271 extern unsigned long rxrpc_soft_ack_delay;
1272 extern unsigned long rxrpc_idle_ack_delay;
1273 extern unsigned int rxrpc_rx_window_size;
1274 extern unsigned int rxrpc_rx_mtu;
1275 extern unsigned int rxrpc_rx_jumbo_max;
1276 #ifdef CONFIG_AF_RXRPC_INJECT_RX_DELAY
1277 extern unsigned long rxrpc_inject_rx_delay;
1278 #endif
1279
1280 /*
1281 * net_ns.c
1282 */
1283 extern unsigned int rxrpc_net_id;
1284 extern struct pernet_operations rxrpc_net_ops;
1285
rxrpc_net(struct net * net)1286 static inline struct rxrpc_net *rxrpc_net(struct net *net)
1287 {
1288 return net_generic(net, rxrpc_net_id);
1289 }
1290
1291 /*
1292 * output.c
1293 */
1294 void rxrpc_send_ACK(struct rxrpc_call *call, u8 ack_reason,
1295 rxrpc_serial_t serial, enum rxrpc_propose_ack_trace why);
1296 void rxrpc_send_probe_for_pmtud(struct rxrpc_call *call);
1297 int rxrpc_send_abort_packet(struct rxrpc_call *);
1298 void rxrpc_send_data_packet(struct rxrpc_call *call, struct rxrpc_send_data_req *req);
1299 void rxrpc_send_conn_abort(struct rxrpc_connection *conn);
1300 void rxrpc_reject_packet(struct rxrpc_local *local, struct sk_buff *skb);
1301 void rxrpc_send_keepalive(struct rxrpc_peer *);
1302
1303 /*
1304 * peer_event.c
1305 */
1306 void rxrpc_input_error(struct rxrpc_local *, struct sk_buff *);
1307 void rxrpc_peer_keepalive_worker(struct work_struct *);
1308 void rxrpc_input_probe_for_pmtud(struct rxrpc_connection *conn, rxrpc_serial_t acked_serial,
1309 bool sendmsg_fail);
1310
1311 /*
1312 * peer_object.c
1313 */
1314 struct rxrpc_peer *rxrpc_lookup_peer_rcu(struct rxrpc_local *,
1315 const struct sockaddr_rxrpc *);
1316 struct rxrpc_peer *rxrpc_lookup_peer(struct rxrpc_local *local,
1317 struct sockaddr_rxrpc *srx, gfp_t gfp);
1318 struct rxrpc_peer *rxrpc_alloc_peer(struct rxrpc_local *, gfp_t,
1319 enum rxrpc_peer_trace);
1320 void rxrpc_new_incoming_peer(struct rxrpc_local *local, struct rxrpc_peer *peer);
1321 void rxrpc_destroy_all_peers(struct rxrpc_net *);
1322 struct rxrpc_peer *rxrpc_get_peer(struct rxrpc_peer *, enum rxrpc_peer_trace);
1323 struct rxrpc_peer *rxrpc_get_peer_maybe(struct rxrpc_peer *, enum rxrpc_peer_trace);
1324 void rxrpc_put_peer(struct rxrpc_peer *, enum rxrpc_peer_trace);
1325
1326 /*
1327 * proc.c
1328 */
1329 extern const struct seq_operations rxrpc_call_seq_ops;
1330 extern const struct seq_operations rxrpc_connection_seq_ops;
1331 extern const struct seq_operations rxrpc_bundle_seq_ops;
1332 extern const struct seq_operations rxrpc_peer_seq_ops;
1333 extern const struct seq_operations rxrpc_local_seq_ops;
1334
1335 /*
1336 * recvmsg.c
1337 */
1338 void rxrpc_notify_socket(struct rxrpc_call *);
1339 int rxrpc_recvmsg(struct socket *, struct msghdr *, size_t, int);
1340
1341 /*
1342 * Abort a call due to a protocol error.
1343 */
rxrpc_abort_eproto(struct rxrpc_call * call,struct sk_buff * skb,s32 abort_code,enum rxrpc_abort_reason why)1344 static inline int rxrpc_abort_eproto(struct rxrpc_call *call,
1345 struct sk_buff *skb,
1346 s32 abort_code,
1347 enum rxrpc_abort_reason why)
1348 {
1349 struct rxrpc_skb_priv *sp = rxrpc_skb(skb);
1350
1351 rxrpc_abort_call(call, sp->hdr.seq, abort_code, -EPROTO, why);
1352 return -EPROTO;
1353 }
1354
1355 /*
1356 * rtt.c
1357 */
1358 void rxrpc_call_add_rtt(struct rxrpc_call *call, enum rxrpc_rtt_rx_trace why,
1359 int rtt_slot,
1360 rxrpc_serial_t send_serial, rxrpc_serial_t resp_serial,
1361 ktime_t send_time, ktime_t resp_time);
1362 ktime_t rxrpc_get_rto_backoff(struct rxrpc_call *call, bool retrans);
1363 void rxrpc_call_init_rtt(struct rxrpc_call *call);
1364
1365 /*
1366 * rxkad.c
1367 */
1368 #ifdef CONFIG_RXKAD
1369 extern const struct rxrpc_security rxkad;
1370 #endif
1371
1372 /*
1373 * security.c
1374 */
1375 int __init rxrpc_init_security(void);
1376 const struct rxrpc_security *rxrpc_security_lookup(u8);
1377 void rxrpc_exit_security(void);
1378 int rxrpc_init_client_call_security(struct rxrpc_call *);
1379 int rxrpc_init_client_conn_security(struct rxrpc_connection *);
1380 const struct rxrpc_security *rxrpc_get_incoming_security(struct rxrpc_sock *,
1381 struct sk_buff *);
1382 struct key *rxrpc_look_up_server_security(struct rxrpc_connection *,
1383 struct sk_buff *, u32, u32);
1384
1385 /*
1386 * sendmsg.c
1387 */
1388 bool rxrpc_propose_abort(struct rxrpc_call *call, s32 abort_code, int error,
1389 enum rxrpc_abort_reason why);
1390 int rxrpc_do_sendmsg(struct rxrpc_sock *, struct msghdr *, size_t);
1391
1392 /*
1393 * server_key.c
1394 */
1395 extern struct key_type key_type_rxrpc_s;
1396
1397 int rxrpc_server_keyring(struct rxrpc_sock *, sockptr_t, int);
1398
1399 /*
1400 * skbuff.c
1401 */
1402 void rxrpc_kernel_data_consumed(struct rxrpc_call *, struct sk_buff *);
1403 void rxrpc_new_skb(struct sk_buff *, enum rxrpc_skb_trace);
1404 void rxrpc_see_skb(struct sk_buff *, enum rxrpc_skb_trace);
1405 void rxrpc_eaten_skb(struct sk_buff *, enum rxrpc_skb_trace);
1406 void rxrpc_get_skb(struct sk_buff *, enum rxrpc_skb_trace);
1407 void rxrpc_free_skb(struct sk_buff *, enum rxrpc_skb_trace);
1408 void rxrpc_purge_queue(struct sk_buff_head *);
1409
1410 /*
1411 * stats.c
1412 */
1413 int rxrpc_stats_show(struct seq_file *seq, void *v);
1414 int rxrpc_stats_clear(struct file *file, char *buf, size_t size);
1415
1416 #define rxrpc_inc_stat(rxnet, s) atomic_inc(&(rxnet)->s)
1417 #define rxrpc_dec_stat(rxnet, s) atomic_dec(&(rxnet)->s)
1418
1419 /*
1420 * sysctl.c
1421 */
1422 #ifdef CONFIG_SYSCTL
1423 extern int __init rxrpc_sysctl_init(void);
1424 extern void rxrpc_sysctl_exit(void);
1425 #else
rxrpc_sysctl_init(void)1426 static inline int __init rxrpc_sysctl_init(void) { return 0; }
rxrpc_sysctl_exit(void)1427 static inline void rxrpc_sysctl_exit(void) {}
1428 #endif
1429
1430 /*
1431 * txbuf.c
1432 */
1433 extern atomic_t rxrpc_nr_txbuf;
1434 struct rxrpc_txbuf *rxrpc_alloc_data_txbuf(struct rxrpc_call *call, size_t data_size,
1435 size_t data_align, gfp_t gfp);
1436 void rxrpc_get_txbuf(struct rxrpc_txbuf *txb, enum rxrpc_txbuf_trace what);
1437 void rxrpc_see_txbuf(struct rxrpc_txbuf *txb, enum rxrpc_txbuf_trace what);
1438 void rxrpc_put_txbuf(struct rxrpc_txbuf *txb, enum rxrpc_txbuf_trace what);
1439
1440 /*
1441 * utils.c
1442 */
1443 int rxrpc_extract_addr_from_skb(struct sockaddr_rxrpc *, struct sk_buff *);
1444
before(u32 seq1,u32 seq2)1445 static inline bool before(u32 seq1, u32 seq2)
1446 {
1447 return (s32)(seq1 - seq2) < 0;
1448 }
before_eq(u32 seq1,u32 seq2)1449 static inline bool before_eq(u32 seq1, u32 seq2)
1450 {
1451 return (s32)(seq1 - seq2) <= 0;
1452 }
after(u32 seq1,u32 seq2)1453 static inline bool after(u32 seq1, u32 seq2)
1454 {
1455 return (s32)(seq1 - seq2) > 0;
1456 }
after_eq(u32 seq1,u32 seq2)1457 static inline bool after_eq(u32 seq1, u32 seq2)
1458 {
1459 return (s32)(seq1 - seq2) >= 0;
1460 }
1461
earliest(u32 seq1,u32 seq2)1462 static inline u32 earliest(u32 seq1, u32 seq2)
1463 {
1464 return before(seq1, seq2) ? seq1 : seq2;
1465 }
1466
latest(u32 seq1,u32 seq2)1467 static inline u32 latest(u32 seq1, u32 seq2)
1468 {
1469 return after(seq1, seq2) ? seq1 : seq2;
1470 }
1471
rxrpc_seq_in_txq(const struct rxrpc_txqueue * tq,rxrpc_seq_t seq)1472 static inline bool rxrpc_seq_in_txq(const struct rxrpc_txqueue *tq, rxrpc_seq_t seq)
1473 {
1474 return (seq & (RXRPC_NR_TXQUEUE - 1)) == tq->qbase;
1475 }
1476
rxrpc_queue_rx_call_packet(struct rxrpc_call * call,struct sk_buff * skb)1477 static inline void rxrpc_queue_rx_call_packet(struct rxrpc_call *call, struct sk_buff *skb)
1478 {
1479 rxrpc_get_skb(skb, rxrpc_skb_get_call_rx);
1480 __skb_queue_tail(&call->rx_queue, skb);
1481 rxrpc_poke_call(call, rxrpc_call_poke_rx_packet);
1482 }
1483
1484 /*
1485 * Calculate how much space there is for transmitting more DATA packets.
1486 */
rxrpc_tx_window_space(const struct rxrpc_call * call)1487 static inline unsigned int rxrpc_tx_window_space(const struct rxrpc_call *call)
1488 {
1489 int winsize = umin(call->tx_winsize, call->cong_cwnd + call->cong_extra);
1490 int transmitted = call->tx_top - call->tx_bottom;
1491
1492 return max(winsize - transmitted, 0);
1493 }
1494
rxrpc_left_out(const struct rxrpc_call * call)1495 static inline unsigned int rxrpc_left_out(const struct rxrpc_call *call)
1496 {
1497 return call->acks_nr_sacks + call->tx_nr_lost;
1498 }
1499
1500 /*
1501 * Calculate the number of transmitted DATA packets assumed to be in flight
1502 * [approx RFC6675].
1503 */
rxrpc_tx_in_flight(const struct rxrpc_call * call)1504 static inline unsigned int rxrpc_tx_in_flight(const struct rxrpc_call *call)
1505 {
1506 return call->tx_nr_sent - rxrpc_left_out(call) + call->tx_nr_resent;
1507 }
1508
1509 /*
1510 * debug tracing
1511 */
1512 extern unsigned int rxrpc_debug;
1513
1514 #define dbgprintk(FMT,...) \
1515 printk("[%-6.6s] "FMT"\n", current->comm ,##__VA_ARGS__)
1516
1517 #define kenter(FMT,...) dbgprintk("==> %s("FMT")",__func__ ,##__VA_ARGS__)
1518 #define kleave(FMT,...) dbgprintk("<== %s()"FMT"",__func__ ,##__VA_ARGS__)
1519 #define kdebug(FMT,...) dbgprintk(" "FMT ,##__VA_ARGS__)
1520
1521
1522 #if defined(__KDEBUG)
1523 #define _enter(FMT,...) kenter(FMT,##__VA_ARGS__)
1524 #define _leave(FMT,...) kleave(FMT,##__VA_ARGS__)
1525 #define _debug(FMT,...) kdebug(FMT,##__VA_ARGS__)
1526
1527 #elif defined(CONFIG_AF_RXRPC_DEBUG)
1528 #define RXRPC_DEBUG_KENTER 0x01
1529 #define RXRPC_DEBUG_KLEAVE 0x02
1530 #define RXRPC_DEBUG_KDEBUG 0x04
1531
1532 #define _enter(FMT,...) \
1533 do { \
1534 if (unlikely(rxrpc_debug & RXRPC_DEBUG_KENTER)) \
1535 kenter(FMT,##__VA_ARGS__); \
1536 } while (0)
1537
1538 #define _leave(FMT,...) \
1539 do { \
1540 if (unlikely(rxrpc_debug & RXRPC_DEBUG_KLEAVE)) \
1541 kleave(FMT,##__VA_ARGS__); \
1542 } while (0)
1543
1544 #define _debug(FMT,...) \
1545 do { \
1546 if (unlikely(rxrpc_debug & RXRPC_DEBUG_KDEBUG)) \
1547 kdebug(FMT,##__VA_ARGS__); \
1548 } while (0)
1549
1550 #else
1551 #define _enter(FMT,...) no_printk("==> %s("FMT")",__func__ ,##__VA_ARGS__)
1552 #define _leave(FMT,...) no_printk("<== %s()"FMT"",__func__ ,##__VA_ARGS__)
1553 #define _debug(FMT,...) no_printk(" "FMT ,##__VA_ARGS__)
1554 #endif
1555
1556 /*
1557 * debug assertion checking
1558 */
1559 #if 1 // defined(__KDEBUGALL)
1560
1561 #define ASSERT(X) \
1562 do { \
1563 if (unlikely(!(X))) { \
1564 pr_err("Assertion failed\n"); \
1565 BUG(); \
1566 } \
1567 } while (0)
1568
1569 #define ASSERTCMP(X, OP, Y) \
1570 do { \
1571 __typeof__(X) _x = (X); \
1572 __typeof__(Y) _y = (__typeof__(X))(Y); \
1573 if (unlikely(!(_x OP _y))) { \
1574 pr_err("Assertion failed - %lu(0x%lx) %s %lu(0x%lx) is false\n", \
1575 (unsigned long)_x, (unsigned long)_x, #OP, \
1576 (unsigned long)_y, (unsigned long)_y); \
1577 BUG(); \
1578 } \
1579 } while (0)
1580
1581 #define ASSERTIF(C, X) \
1582 do { \
1583 if (unlikely((C) && !(X))) { \
1584 pr_err("Assertion failed\n"); \
1585 BUG(); \
1586 } \
1587 } while (0)
1588
1589 #define ASSERTIFCMP(C, X, OP, Y) \
1590 do { \
1591 __typeof__(X) _x = (X); \
1592 __typeof__(Y) _y = (__typeof__(X))(Y); \
1593 if (unlikely((C) && !(_x OP _y))) { \
1594 pr_err("Assertion failed - %lu(0x%lx) %s %lu(0x%lx) is false\n", \
1595 (unsigned long)_x, (unsigned long)_x, #OP, \
1596 (unsigned long)_y, (unsigned long)_y); \
1597 BUG(); \
1598 } \
1599 } while (0)
1600
1601 #else
1602
1603 #define ASSERT(X) \
1604 do { \
1605 } while (0)
1606
1607 #define ASSERTCMP(X, OP, Y) \
1608 do { \
1609 } while (0)
1610
1611 #define ASSERTIF(C, X) \
1612 do { \
1613 } while (0)
1614
1615 #define ASSERTIFCMP(C, X, OP, Y) \
1616 do { \
1617 } while (0)
1618
1619 #endif /* __KDEBUGALL */
1620