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 time64_t last_tx_at; /* Last time packet sent here */
348 seqlock_t service_conn_lock;
349 spinlock_t lock; /* access lock */
350 int debug_id; /* debug ID for printks */
351 struct sockaddr_rxrpc srx; /* remote address */
352
353 /* Path MTU discovery [RFC8899] */
354 unsigned int pmtud_trial; /* Current MTU probe size */
355 unsigned int pmtud_good; /* Largest working MTU probe we've tried */
356 unsigned int pmtud_bad; /* Smallest non-working MTU probe we've tried */
357 bool pmtud_lost; /* T if MTU probe was lost */
358 bool pmtud_probing; /* T if we have an active probe outstanding */
359 bool pmtud_pending; /* T if a call to this peer should send a probe */
360 u8 pmtud_jumbo; /* Max jumbo packets for the MTU */
361 bool ackr_adv_pmtud; /* T if the peer advertises path-MTU */
362 unsigned int ackr_max_data; /* Maximum data advertised by peer */
363 unsigned int if_mtu; /* Local interface MTU (- hdrsize) for this peer */
364 unsigned int max_data; /* Maximum packet data capacity for this peer */
365 unsigned short hdrsize; /* header size (IP + UDP + RxRPC) */
366 unsigned short tx_seg_max; /* Maximum number of transmissable segments */
367
368 /* Calculated RTT cache */
369 unsigned int recent_srtt_us;
370 unsigned int recent_rto_us;
371
372 u8 cong_ssthresh; /* Congestion slow-start threshold */
373 };
374
375 /*
376 * Keys for matching a connection.
377 */
378 struct rxrpc_conn_proto {
379 union {
380 struct {
381 u32 epoch; /* epoch of this connection */
382 u32 cid; /* connection ID */
383 };
384 u64 index_key;
385 };
386 };
387
388 struct rxrpc_conn_parameters {
389 struct rxrpc_local *local; /* Representation of local endpoint */
390 struct rxrpc_peer *peer; /* Representation of remote endpoint */
391 struct key *key; /* Security details */
392 bool exclusive; /* T if conn is exclusive */
393 bool upgrade; /* T if service ID can be upgraded */
394 u16 service_id; /* Service ID for this connection */
395 u32 security_level; /* Security level selected */
396 };
397
398 /*
399 * Call completion condition (state == RXRPC_CALL_COMPLETE).
400 */
401 enum rxrpc_call_completion {
402 RXRPC_CALL_SUCCEEDED, /* - Normal termination */
403 RXRPC_CALL_REMOTELY_ABORTED, /* - call aborted by peer */
404 RXRPC_CALL_LOCALLY_ABORTED, /* - call aborted locally on error or close */
405 RXRPC_CALL_LOCAL_ERROR, /* - call failed due to local error */
406 RXRPC_CALL_NETWORK_ERROR, /* - call terminated by network error */
407 NR__RXRPC_CALL_COMPLETIONS
408 };
409
410 /*
411 * Bits in the connection flags.
412 */
413 enum rxrpc_conn_flag {
414 RXRPC_CONN_IN_SERVICE_CONNS, /* Conn is in peer->service_conns */
415 RXRPC_CONN_DONT_REUSE, /* Don't reuse this connection */
416 RXRPC_CONN_PROBING_FOR_UPGRADE, /* Probing for service upgrade */
417 RXRPC_CONN_FINAL_ACK_0, /* Need final ACK for channel 0 */
418 RXRPC_CONN_FINAL_ACK_1, /* Need final ACK for channel 1 */
419 RXRPC_CONN_FINAL_ACK_2, /* Need final ACK for channel 2 */
420 RXRPC_CONN_FINAL_ACK_3, /* Need final ACK for channel 3 */
421 };
422
423 #define RXRPC_CONN_FINAL_ACK_MASK ((1UL << RXRPC_CONN_FINAL_ACK_0) | \
424 (1UL << RXRPC_CONN_FINAL_ACK_1) | \
425 (1UL << RXRPC_CONN_FINAL_ACK_2) | \
426 (1UL << RXRPC_CONN_FINAL_ACK_3))
427
428 /*
429 * Events that can be raised upon a connection.
430 */
431 enum rxrpc_conn_event {
432 RXRPC_CONN_EV_CHALLENGE, /* Send challenge packet */
433 RXRPC_CONN_EV_ABORT_CALLS, /* Abort attached calls */
434 };
435
436 /*
437 * The connection protocol state.
438 */
439 enum rxrpc_conn_proto_state {
440 RXRPC_CONN_UNUSED, /* Connection not yet attempted */
441 RXRPC_CONN_CLIENT_UNSECURED, /* Client connection needs security init */
442 RXRPC_CONN_CLIENT, /* Client connection */
443 RXRPC_CONN_SERVICE_PREALLOC, /* Service connection preallocation */
444 RXRPC_CONN_SERVICE_UNSECURED, /* Service unsecured connection */
445 RXRPC_CONN_SERVICE_CHALLENGING, /* Service challenging for security */
446 RXRPC_CONN_SERVICE, /* Service secured connection */
447 RXRPC_CONN_ABORTED, /* Conn aborted */
448 RXRPC_CONN__NR_STATES
449 };
450
451 /*
452 * RxRPC client connection bundle.
453 */
454 struct rxrpc_bundle {
455 struct rxrpc_local *local; /* Representation of local endpoint */
456 struct rxrpc_peer *peer; /* Remote endpoint */
457 struct key *key; /* Security details */
458 struct list_head proc_link; /* Link in net->bundle_proc_list */
459 const struct rxrpc_security *security; /* applied security module */
460 refcount_t ref;
461 atomic_t active; /* Number of active users */
462 unsigned int debug_id;
463 u32 security_level; /* Security level selected */
464 u16 service_id; /* Service ID for this connection */
465 bool try_upgrade; /* True if the bundle is attempting upgrade */
466 bool exclusive; /* T if conn is exclusive */
467 bool upgrade; /* T if service ID can be upgraded */
468 unsigned short alloc_error; /* Error from last conn allocation */
469 struct rb_node local_node; /* Node in local->client_conns */
470 struct list_head waiting_calls; /* Calls waiting for channels */
471 unsigned long avail_chans; /* Mask of available channels */
472 unsigned int conn_ids[4]; /* Connection IDs. */
473 struct rxrpc_connection *conns[4]; /* The connections in the bundle (max 4) */
474 };
475
476 /*
477 * RxRPC connection definition
478 * - matched by { local, peer, epoch, conn_id, direction }
479 * - each connection can only handle four simultaneous calls
480 */
481 struct rxrpc_connection {
482 struct rxrpc_conn_proto proto;
483 struct rxrpc_local *local; /* Representation of local endpoint */
484 struct rxrpc_peer *peer; /* Remote endpoint */
485 struct rxrpc_net *rxnet; /* Network namespace to which call belongs */
486 struct key *key; /* Security details */
487 struct list_head attend_link; /* Link in local->conn_attend_q */
488
489 refcount_t ref;
490 atomic_t active; /* Active count for service conns */
491 struct rcu_head rcu;
492 struct list_head cache_link;
493
494 unsigned char act_chans; /* Mask of active channels */
495 struct rxrpc_channel {
496 unsigned long final_ack_at; /* Time at which to issue final ACK */
497 struct rxrpc_call *call; /* Active call */
498 unsigned int call_debug_id; /* call->debug_id */
499 u32 call_id; /* ID of current call */
500 u32 call_counter; /* Call ID counter */
501 u32 last_call; /* ID of last call */
502 u8 last_type; /* Type of last packet */
503 union {
504 u32 last_seq;
505 u32 last_abort;
506 };
507 } channels[RXRPC_MAXCALLS];
508
509 struct timer_list timer; /* Conn event timer */
510 struct work_struct processor; /* connection event processor */
511 struct work_struct destructor; /* In-process-context destroyer */
512 struct rxrpc_bundle *bundle; /* Client connection bundle */
513 struct rb_node service_node; /* Node in peer->service_conns */
514 struct list_head proc_link; /* link in procfs list */
515 struct list_head link; /* link in master connection list */
516 struct sk_buff_head rx_queue; /* received conn-level packets */
517 struct page_frag_cache tx_data_alloc; /* Tx DATA packet allocation */
518 struct mutex tx_data_alloc_lock;
519
520 struct mutex security_lock; /* Lock for security management */
521 const struct rxrpc_security *security; /* applied security module */
522 union {
523 struct {
524 struct crypto_sync_skcipher *cipher; /* encryption handle */
525 struct rxrpc_crypt csum_iv; /* packet checksum base */
526 u32 nonce; /* response re-use preventer */
527 } rxkad;
528 };
529 unsigned long flags;
530 unsigned long events;
531 unsigned long idle_timestamp; /* Time at which last became idle */
532 spinlock_t state_lock; /* state-change lock */
533 enum rxrpc_conn_proto_state state; /* current state of connection */
534 enum rxrpc_call_completion completion; /* Completion condition */
535 s32 abort_code; /* Abort code of connection abort */
536 int debug_id; /* debug ID for printks */
537 rxrpc_serial_t tx_serial; /* Outgoing packet serial number counter */
538 unsigned int hi_serial; /* highest serial number received */
539 rxrpc_serial_t pmtud_probe; /* Serial of MTU probe (or 0) */
540 unsigned int pmtud_call; /* ID of call used for probe */
541 u32 service_id; /* Service ID, possibly upgraded */
542 u32 security_level; /* Security level selected */
543 u8 security_ix; /* security type */
544 u8 out_clientflag; /* RXRPC_CLIENT_INITIATED if we are client */
545 u8 bundle_shift; /* Index into bundle->avail_chans */
546 bool exclusive; /* T if conn is exclusive */
547 bool upgrade; /* T if service ID can be upgraded */
548 u16 orig_service_id; /* Originally requested service ID */
549 short error; /* Local error code */
550 };
551
rxrpc_to_server(const struct rxrpc_skb_priv * sp)552 static inline bool rxrpc_to_server(const struct rxrpc_skb_priv *sp)
553 {
554 return sp->hdr.flags & RXRPC_CLIENT_INITIATED;
555 }
556
rxrpc_to_client(const struct rxrpc_skb_priv * sp)557 static inline bool rxrpc_to_client(const struct rxrpc_skb_priv *sp)
558 {
559 return !rxrpc_to_server(sp);
560 }
561
562 /*
563 * Flags in call->flags.
564 */
565 enum rxrpc_call_flag {
566 RXRPC_CALL_RELEASED, /* call has been released - no more message to userspace */
567 RXRPC_CALL_HAS_USERID, /* has a user ID attached */
568 RXRPC_CALL_IS_SERVICE, /* Call is service call */
569 RXRPC_CALL_EXPOSED, /* The call was exposed to the world */
570 RXRPC_CALL_RX_LAST, /* Received the last packet (at rxtx_top) */
571 RXRPC_CALL_TX_LAST, /* Last packet in Tx buffer (at rxtx_top) */
572 RXRPC_CALL_TX_ALL_ACKED, /* Last packet has been hard-acked */
573 RXRPC_CALL_TX_NO_MORE, /* No more data to transmit (MSG_MORE deasserted) */
574 RXRPC_CALL_SEND_PING, /* A ping will need to be sent */
575 RXRPC_CALL_RETRANS_TIMEOUT, /* Retransmission due to timeout occurred */
576 RXRPC_CALL_BEGAN_RX_TIMER, /* We began the expect_rx_by timer */
577 RXRPC_CALL_RX_HEARD, /* The peer responded at least once to this call */
578 RXRPC_CALL_DISCONNECTED, /* The call has been disconnected */
579 RXRPC_CALL_KERNEL, /* The call was made by the kernel */
580 RXRPC_CALL_UPGRADE, /* Service upgrade was requested for the call */
581 RXRPC_CALL_EXCLUSIVE, /* The call uses a once-only connection */
582 RXRPC_CALL_RX_IS_IDLE, /* recvmsg() is idle - send an ACK */
583 RXRPC_CALL_RECVMSG_READ_ALL, /* recvmsg() read all of the received data */
584 RXRPC_CALL_CONN_CHALLENGING, /* The connection is being challenged */
585 };
586
587 /*
588 * Events that can be raised on a call.
589 */
590 enum rxrpc_call_event {
591 RXRPC_CALL_EV_ACK_LOST, /* ACK may be lost, send ping */
592 RXRPC_CALL_EV_INITIAL_PING, /* Send initial ping for a new service call */
593 };
594
595 /*
596 * The states that a call can be in.
597 */
598 enum rxrpc_call_state {
599 RXRPC_CALL_UNINITIALISED,
600 RXRPC_CALL_CLIENT_AWAIT_CONN, /* - client waiting for connection to become available */
601 RXRPC_CALL_CLIENT_SEND_REQUEST, /* - client sending request phase */
602 RXRPC_CALL_CLIENT_AWAIT_REPLY, /* - client awaiting reply */
603 RXRPC_CALL_CLIENT_RECV_REPLY, /* - client receiving reply phase */
604 RXRPC_CALL_SERVER_PREALLOC, /* - service preallocation */
605 RXRPC_CALL_SERVER_RECV_REQUEST, /* - server receiving request */
606 RXRPC_CALL_SERVER_ACK_REQUEST, /* - server pending ACK of request */
607 RXRPC_CALL_SERVER_SEND_REPLY, /* - server sending reply */
608 RXRPC_CALL_SERVER_AWAIT_ACK, /* - server awaiting final ACK */
609 RXRPC_CALL_COMPLETE, /* - call complete */
610 NR__RXRPC_CALL_STATES
611 };
612
613 /*
614 * Call Tx congestion management modes.
615 */
616 enum rxrpc_ca_state {
617 RXRPC_CA_SLOW_START,
618 RXRPC_CA_CONGEST_AVOIDANCE,
619 RXRPC_CA_PACKET_LOSS,
620 RXRPC_CA_FAST_RETRANSMIT,
621 NR__RXRPC_CA_STATES
622 } __mode(byte);
623
624 /*
625 * Current purpose of call RACK timer. According to the RACK-TLP protocol
626 * [RFC8985], the transmission timer (call->rack_timo_at) may only be used for
627 * one of these at once.
628 */
629 enum rxrpc_rack_timer_mode {
630 RXRPC_CALL_RACKTIMER_OFF, /* Timer not running */
631 RXRPC_CALL_RACKTIMER_RACK_REORDER, /* RACK reordering timer */
632 RXRPC_CALL_RACKTIMER_TLP_PTO, /* TLP timeout */
633 RXRPC_CALL_RACKTIMER_RTO, /* Retransmission timeout */
634 } __mode(byte);
635
636 /*
637 * RxRPC call definition
638 * - matched by { connection, call_id }
639 */
640 struct rxrpc_call {
641 struct rcu_head rcu;
642 struct rxrpc_connection *conn; /* connection carrying call */
643 struct rxrpc_bundle *bundle; /* Connection bundle to use */
644 struct rxrpc_peer *peer; /* Peer record for remote address */
645 struct rxrpc_local *local; /* Representation of local endpoint */
646 struct rxrpc_sock __rcu *socket; /* socket responsible */
647 struct rxrpc_net *rxnet; /* Network namespace to which call belongs */
648 struct key *key; /* Security details */
649 const struct rxrpc_security *security; /* applied security module */
650 struct mutex user_mutex; /* User access mutex */
651 struct sockaddr_rxrpc dest_srx; /* Destination address */
652 ktime_t delay_ack_at; /* When DELAY ACK needs to happen */
653 ktime_t rack_timo_at; /* When ACK is figured as lost */
654 ktime_t ping_at; /* When next to send a ping */
655 ktime_t keepalive_at; /* When next to send a keepalive ping */
656 ktime_t expect_rx_by; /* When we expect to get a packet by */
657 ktime_t expect_req_by; /* When we expect to get a request DATA packet by */
658 ktime_t expect_term_by; /* When we expect call termination by */
659 u32 next_rx_timo; /* Timeout for next Rx packet (ms) */
660 u32 next_req_timo; /* Timeout for next Rx request packet (ms) */
661 u32 hard_timo; /* Maximum lifetime or 0 (s) */
662 struct timer_list timer; /* Combined event timer */
663 struct work_struct destroyer; /* In-process-context destroyer */
664 rxrpc_notify_rx_t notify_rx; /* kernel service Rx notification function */
665 struct list_head link; /* link in master call list */
666 struct list_head wait_link; /* Link in local->new_client_calls */
667 struct hlist_node error_link; /* link in error distribution list */
668 struct list_head accept_link; /* Link in rx->acceptq */
669 struct list_head recvmsg_link; /* Link in rx->recvmsg_q */
670 struct list_head sock_link; /* Link in rx->sock_calls */
671 struct rb_node sock_node; /* Node in rx->calls */
672 struct list_head attend_link; /* Link in local->call_attend_q */
673 struct rxrpc_txbuf *tx_pending; /* Tx buffer being filled */
674 wait_queue_head_t waitq; /* Wait queue for channel or Tx */
675 s64 tx_total_len; /* Total length left to be transmitted (or -1) */
676 unsigned long user_call_ID; /* user-defined call ID */
677 unsigned long flags;
678 unsigned long events;
679 spinlock_t notify_lock; /* Kernel notification lock */
680 unsigned int send_abort_why; /* Why the abort [enum rxrpc_abort_reason] */
681 s32 send_abort; /* Abort code to be sent */
682 short send_abort_err; /* Error to be associated with the abort */
683 rxrpc_seq_t send_abort_seq; /* DATA packet that incurred the abort (or 0) */
684 s32 abort_code; /* Local/remote abort code */
685 int error; /* Local error incurred */
686 enum rxrpc_call_state _state; /* Current state of call (needs barrier) */
687 enum rxrpc_call_completion completion; /* Call completion condition */
688 refcount_t ref;
689 u8 security_ix; /* Security type */
690 enum rxrpc_interruptibility interruptibility; /* At what point call may be interrupted */
691 u32 call_id; /* call ID on connection */
692 u32 cid; /* connection ID plus channel index */
693 u32 security_level; /* Security level selected */
694 int debug_id; /* debug ID for printks */
695 unsigned short rx_pkt_offset; /* Current recvmsg packet offset */
696 unsigned short rx_pkt_len; /* Current recvmsg packet len */
697
698 /* Sendmsg data tracking. */
699 rxrpc_seq_t send_top; /* Highest Tx slot filled by sendmsg. */
700 struct rxrpc_txqueue *send_queue; /* Queue that sendmsg is writing into */
701
702 /* Transmitted data tracking. */
703 struct rxrpc_txqueue *tx_queue; /* Start of transmission buffers */
704 struct rxrpc_txqueue *tx_qtail; /* End of transmission buffers */
705 rxrpc_seq_t tx_qbase; /* First slot in tx_queue */
706 rxrpc_seq_t tx_bottom; /* First packet in buffer */
707 rxrpc_seq_t tx_transmitted; /* Highest packet transmitted */
708 rxrpc_seq_t tx_top; /* Highest Tx slot allocated. */
709 rxrpc_serial_t tx_last_serial; /* Serial of last DATA transmitted */
710 u16 tx_backoff; /* Delay to insert due to Tx failure (ms) */
711 u16 tx_nr_sent; /* Number of packets sent, but unacked */
712 u16 tx_nr_lost; /* Number of packets marked lost */
713 u16 tx_nr_resent; /* Number of packets resent, but unacked */
714 u16 tx_winsize; /* Maximum size of Tx window */
715 #define RXRPC_TX_MAX_WINDOW 128
716 u8 tx_jumbo_max; /* Maximum subpkts peer will accept */
717 ktime_t tx_last_sent; /* Last time a transmission occurred */
718
719 /* Received data tracking */
720 struct sk_buff_head recvmsg_queue; /* Queue of packets ready for recvmsg() */
721 struct sk_buff_head rx_queue; /* Queue of packets for this call to receive */
722 struct sk_buff_head rx_oos_queue; /* Queue of out of sequence packets */
723
724 rxrpc_seq_t rx_highest_seq; /* Higest sequence number received */
725 rxrpc_seq_t rx_consumed; /* Highest packet consumed */
726 rxrpc_serial_t rx_serial; /* Highest serial received for this call */
727 u8 rx_winsize; /* Size of Rx window */
728
729 /* TCP-style slow-start congestion control [RFC5681]. Since the SMSS
730 * is fixed, we keep these numbers in terms of segments (ie. DATA
731 * packets) rather than bytes.
732 */
733 #define RXRPC_TX_SMSS RXRPC_JUMBO_DATALEN
734 #define RXRPC_MIN_CWND 4
735 enum rxrpc_ca_state cong_ca_state; /* Congestion control state */
736 u8 cong_extra; /* Extra to send for congestion management */
737 u16 cong_cwnd; /* Congestion window size */
738 u16 cong_ssthresh; /* Slow-start threshold */
739 u16 cong_dup_acks; /* Count of ACKs showing missing packets */
740 u16 cong_cumul_acks; /* Cumulative ACK count */
741 ktime_t cong_tstamp; /* Last time cwnd was changed */
742
743 /* RACK-TLP [RFC8985] state. */
744 ktime_t rack_xmit_ts; /* Latest transmission timestamp */
745 ktime_t rack_rtt; /* RTT of most recently ACK'd segment */
746 ktime_t rack_rtt_ts; /* Timestamp of rack_rtt */
747 ktime_t rack_reo_wnd; /* Reordering window */
748 unsigned int rack_reo_wnd_mult; /* Multiplier applied to rack_reo_wnd */
749 int rack_reo_wnd_persist; /* Num loss recoveries before reset reo_wnd */
750 rxrpc_seq_t rack_fack; /* Highest sequence so far ACK'd */
751 rxrpc_seq_t rack_end_seq; /* Highest sequence seen */
752 rxrpc_seq_t rack_dsack_round; /* DSACK opt recv'd in latest roundtrip */
753 bool rack_dsack_round_none; /* T if dsack_round is "None" */
754 bool rack_reordering_seen; /* T if detected reordering event */
755 enum rxrpc_rack_timer_mode rack_timer_mode; /* Current mode of RACK timer */
756 bool tlp_is_retrans; /* T if unacked TLP retransmission */
757 rxrpc_serial_t tlp_serial; /* Serial of TLP probe (or 0 if none in progress) */
758 rxrpc_seq_t tlp_seq; /* Sequence of TLP probe */
759 unsigned int tlp_rtt_taken; /* Last time RTT taken */
760 ktime_t tlp_max_ack_delay; /* Sender budget for max delayed ACK interval */
761
762 /* Receive-phase ACK management (ACKs we send). */
763 u8 ackr_reason; /* reason to ACK */
764 u16 ackr_sack_base; /* Starting slot in SACK table ring */
765 rxrpc_seq_t ackr_window; /* Base of SACK window */
766 rxrpc_seq_t ackr_wtop; /* Base of SACK window */
767 unsigned int ackr_nr_unacked; /* Number of unacked packets */
768 atomic_t ackr_nr_consumed; /* Number of packets needing hard ACK */
769 struct {
770 #define RXRPC_SACK_SIZE 256
771 /* SACK table for soft-acked packets */
772 u8 ackr_sack_table[RXRPC_SACK_SIZE];
773 } __aligned(8);
774
775 /* RTT management */
776 rxrpc_serial_t rtt_serial[4]; /* Serial number of DATA or PING sent */
777 ktime_t rtt_sent_at[4]; /* Time packet sent */
778 unsigned long rtt_avail; /* Mask of available slots in bits 0-3,
779 * Mask of pending samples in 8-11 */
780 #define RXRPC_CALL_RTT_AVAIL_MASK 0xf
781 #define RXRPC_CALL_RTT_PEND_SHIFT 8
782
783 /* Transmission-phase ACK management (ACKs we've received). */
784 ktime_t acks_latest_ts; /* Timestamp of latest ACK received */
785 rxrpc_seq_t acks_hard_ack; /* Highest sequence hard acked */
786 rxrpc_seq_t acks_prev_seq; /* Highest previousPacket received */
787 rxrpc_seq_t acks_lowest_nak; /* Lowest NACK in the buffer (or ==tx_hard_ack) */
788 rxrpc_serial_t acks_highest_serial; /* Highest serial number ACK'd */
789 unsigned short acks_nr_sacks; /* Number of soft acks recorded */
790 unsigned short acks_nr_snacks; /* Number of soft nacks recorded */
791
792 /* Calculated RTT cache */
793 ktime_t rtt_last_req; /* Time of last RTT request */
794 unsigned int rtt_count; /* Number of samples we've got */
795 unsigned int rtt_taken; /* Number of samples taken (wrapping) */
796 struct minmax min_rtt; /* Estimated minimum RTT */
797 u32 srtt_us; /* smoothed round trip time << 3 in usecs */
798 u32 mdev_us; /* medium deviation */
799 u32 mdev_max_us; /* maximal mdev for the last rtt period */
800 u32 rttvar_us; /* smoothed mdev_max */
801 u32 rto_us; /* Retransmission timeout in usec */
802 u8 backoff; /* Backoff timeout (as shift) */
803 };
804
805 /*
806 * Summary of a new ACK and the changes it made to the Tx buffer packet states.
807 */
808 struct rxrpc_ack_summary {
809 rxrpc_serial_t ack_serial; /* Serial number of ACK */
810 rxrpc_serial_t acked_serial; /* Serial number ACK'd */
811 u16 in_flight; /* Number of unreceived transmissions */
812 u16 nr_new_hacks; /* Number of rotated new ACKs */
813 u16 nr_new_sacks; /* Number of new soft ACKs in packet */
814 u16 nr_new_snacks; /* Number of new soft nacks in packet */
815 u8 ack_reason;
816 bool new_low_snack:1; /* T if new low soft NACK found */
817 bool retrans_timeo:1; /* T if reTx due to timeout happened */
818 bool need_retransmit:1; /* T if we need transmission */
819 bool rtt_sample_avail:1; /* T if RTT sample available */
820 bool in_fast_or_rto_recovery:1;
821 bool exiting_fast_or_rto_recovery:1;
822 bool tlp_probe_acked:1; /* T if the TLP probe seq was acked */
823 u8 /*enum rxrpc_congest_change*/ change;
824 };
825
826 /*
827 * sendmsg() cmsg-specified parameters.
828 */
829 enum rxrpc_command {
830 RXRPC_CMD_SEND_DATA, /* send data message */
831 RXRPC_CMD_SEND_ABORT, /* request abort generation */
832 RXRPC_CMD_REJECT_BUSY, /* [server] reject a call as busy */
833 RXRPC_CMD_CHARGE_ACCEPT, /* [server] charge accept preallocation */
834 };
835
836 struct rxrpc_call_params {
837 s64 tx_total_len; /* Total Tx data length (if send data) */
838 unsigned long user_call_ID; /* User's call ID */
839 struct {
840 u32 hard; /* Maximum lifetime (sec) */
841 u32 idle; /* Max time since last data packet (msec) */
842 u32 normal; /* Max time since last call packet (msec) */
843 } timeouts;
844 u8 nr_timeouts; /* Number of timeouts specified */
845 bool kernel; /* T if kernel is making the call */
846 enum rxrpc_interruptibility interruptibility; /* How is interruptible is the call? */
847 };
848
849 struct rxrpc_send_params {
850 struct rxrpc_call_params call;
851 u32 abort_code; /* Abort code to Tx (if abort) */
852 enum rxrpc_command command : 8; /* The command to implement */
853 bool exclusive; /* Shared or exclusive call */
854 bool upgrade; /* If the connection is upgradeable */
855 };
856
857 /*
858 * Buffer of data to be output as a packet.
859 */
860 struct rxrpc_txbuf {
861 refcount_t ref;
862 rxrpc_seq_t seq; /* Sequence number of this packet */
863 rxrpc_serial_t serial; /* Last serial number transmitted with */
864 unsigned int call_debug_id;
865 unsigned int debug_id;
866 unsigned short len; /* Amount of data in buffer */
867 unsigned short space; /* Remaining data space */
868 unsigned short offset; /* Offset of fill point */
869 unsigned short pkt_len; /* Size of packet content */
870 unsigned short alloc_size; /* Amount of bufferage allocated */
871 unsigned int flags;
872 #define RXRPC_TXBUF_WIRE_FLAGS 0xff /* The wire protocol flags */
873 #define RXRPC_TXBUF_RESENT 0x100 /* Set if has been resent */
874 __be16 cksum; /* Checksum to go in header */
875 bool jumboable; /* Can be non-terminal jumbo subpacket */
876 void *data; /* Data with preceding jumbo header */
877 };
878
rxrpc_sending_to_server(const struct rxrpc_txbuf * txb)879 static inline bool rxrpc_sending_to_server(const struct rxrpc_txbuf *txb)
880 {
881 return txb->flags & RXRPC_CLIENT_INITIATED;
882 }
883
rxrpc_sending_to_client(const struct rxrpc_txbuf * txb)884 static inline bool rxrpc_sending_to_client(const struct rxrpc_txbuf *txb)
885 {
886 return !rxrpc_sending_to_server(txb);
887 }
888
889 /*
890 * Transmit queue element, including RACK [RFC8985] per-segment metadata. The
891 * transmission timestamp is in usec from the base.
892 */
893 struct rxrpc_txqueue {
894 /* Start with the members we want to prefetch. */
895 struct rxrpc_txqueue *next;
896 ktime_t xmit_ts_base;
897 rxrpc_seq_t qbase;
898 u8 nr_reported_acks; /* Number of segments explicitly acked/nacked */
899 unsigned long segment_acked; /* Bit-per-buf: Set if ACK'd */
900 unsigned long segment_lost; /* Bit-per-buf: Set if declared lost */
901 unsigned long segment_retransmitted; /* Bit-per-buf: Set if retransmitted */
902 unsigned long rtt_samples; /* Bit-per-buf: Set if available for RTT */
903 unsigned long ever_retransmitted; /* Bit-per-buf: Set if ever retransmitted */
904
905 /* The arrays we want to pack into as few cache lines as possible. */
906 struct {
907 #define RXRPC_NR_TXQUEUE BITS_PER_LONG
908 #define RXRPC_TXQ_MASK (RXRPC_NR_TXQUEUE - 1)
909 struct rxrpc_txbuf *bufs[RXRPC_NR_TXQUEUE];
910 unsigned int segment_serial[RXRPC_NR_TXQUEUE];
911 unsigned int segment_xmit_ts[RXRPC_NR_TXQUEUE];
912 } ____cacheline_aligned;
913 };
914
915 /*
916 * Data transmission request.
917 */
918 struct rxrpc_send_data_req {
919 ktime_t now; /* Current time */
920 struct rxrpc_txqueue *tq; /* Tx queue segment holding first DATA */
921 rxrpc_seq_t seq; /* Sequence of first data */
922 int n; /* Number of DATA packets to glue into jumbo */
923 bool retrans; /* T if this is a retransmission */
924 bool did_send; /* T if did actually send */
925 bool tlp_probe; /* T if this is a TLP probe */
926 int /* enum rxrpc_txdata_trace */ trace;
927 };
928
929 #include <trace/events/rxrpc.h>
930
931 /*
932 * Allocate the next serial number on a connection. 0 must be skipped.
933 */
rxrpc_get_next_serial(struct rxrpc_connection * conn)934 static inline rxrpc_serial_t rxrpc_get_next_serial(struct rxrpc_connection *conn)
935 {
936 rxrpc_serial_t serial;
937
938 serial = conn->tx_serial;
939 if (serial == 0)
940 serial = 1;
941 conn->tx_serial = serial + 1;
942 return serial;
943 }
944
945 /*
946 * Allocate the next serial n numbers on a connection. 0 must be skipped.
947 */
rxrpc_get_next_serials(struct rxrpc_connection * conn,unsigned int n)948 static inline rxrpc_serial_t rxrpc_get_next_serials(struct rxrpc_connection *conn,
949 unsigned int n)
950 {
951 rxrpc_serial_t serial;
952
953 serial = conn->tx_serial;
954 if (serial + n <= n)
955 serial = 1;
956 conn->tx_serial = serial + n;
957 return serial;
958 }
959
960 /*
961 * af_rxrpc.c
962 */
963 extern atomic_t rxrpc_n_rx_skbs;
964 extern struct workqueue_struct *rxrpc_workqueue;
965
966 /*
967 * call_accept.c
968 */
969 int rxrpc_service_prealloc(struct rxrpc_sock *, gfp_t);
970 void rxrpc_discard_prealloc(struct rxrpc_sock *);
971 bool rxrpc_new_incoming_call(struct rxrpc_local *local,
972 struct rxrpc_peer *peer,
973 struct rxrpc_connection *conn,
974 struct sockaddr_rxrpc *peer_srx,
975 struct sk_buff *skb);
976 int rxrpc_user_charge_accept(struct rxrpc_sock *, unsigned long);
977
978 /*
979 * call_event.c
980 */
981 void rxrpc_propose_ping(struct rxrpc_call *call, u32 serial,
982 enum rxrpc_propose_ack_trace why);
983 void rxrpc_propose_delay_ACK(struct rxrpc_call *, rxrpc_serial_t,
984 enum rxrpc_propose_ack_trace);
985 void rxrpc_resend_tlp(struct rxrpc_call *call);
986 void rxrpc_transmit_some_data(struct rxrpc_call *call, unsigned int limit,
987 enum rxrpc_txdata_trace trace);
988 bool rxrpc_input_call_event(struct rxrpc_call *call);
989
990 /*
991 * call_object.c
992 */
993 extern const char *const rxrpc_call_states[];
994 extern const char *const rxrpc_call_completions[];
995 extern struct kmem_cache *rxrpc_call_jar;
996
997 void rxrpc_poke_call(struct rxrpc_call *call, enum rxrpc_call_poke_trace what);
998 struct rxrpc_call *rxrpc_find_call_by_user_ID(struct rxrpc_sock *, unsigned long);
999 struct rxrpc_call *rxrpc_alloc_call(struct rxrpc_sock *, gfp_t, unsigned int);
1000 struct rxrpc_call *rxrpc_new_client_call(struct rxrpc_sock *,
1001 struct rxrpc_conn_parameters *,
1002 struct rxrpc_call_params *, gfp_t,
1003 unsigned int);
1004 void rxrpc_start_call_timer(struct rxrpc_call *call);
1005 void rxrpc_incoming_call(struct rxrpc_sock *, struct rxrpc_call *,
1006 struct sk_buff *);
1007 void rxrpc_release_call(struct rxrpc_sock *, struct rxrpc_call *);
1008 void rxrpc_release_calls_on_socket(struct rxrpc_sock *);
1009 void rxrpc_see_call(struct rxrpc_call *, enum rxrpc_call_trace);
1010 struct rxrpc_call *rxrpc_try_get_call(struct rxrpc_call *, enum rxrpc_call_trace);
1011 void rxrpc_get_call(struct rxrpc_call *, enum rxrpc_call_trace);
1012 void rxrpc_put_call(struct rxrpc_call *, enum rxrpc_call_trace);
1013 void rxrpc_cleanup_call(struct rxrpc_call *);
1014 void rxrpc_destroy_all_calls(struct rxrpc_net *);
1015
rxrpc_is_service_call(const struct rxrpc_call * call)1016 static inline bool rxrpc_is_service_call(const struct rxrpc_call *call)
1017 {
1018 return test_bit(RXRPC_CALL_IS_SERVICE, &call->flags);
1019 }
1020
rxrpc_is_client_call(const struct rxrpc_call * call)1021 static inline bool rxrpc_is_client_call(const struct rxrpc_call *call)
1022 {
1023 return !rxrpc_is_service_call(call);
1024 }
1025
1026 /*
1027 * call_state.c
1028 */
1029 bool rxrpc_set_call_completion(struct rxrpc_call *call,
1030 enum rxrpc_call_completion compl,
1031 u32 abort_code,
1032 int error);
1033 bool rxrpc_call_completed(struct rxrpc_call *call);
1034 bool rxrpc_abort_call(struct rxrpc_call *call, rxrpc_seq_t seq,
1035 u32 abort_code, int error, enum rxrpc_abort_reason why);
1036 void rxrpc_prefail_call(struct rxrpc_call *call, enum rxrpc_call_completion compl,
1037 int error);
1038
rxrpc_set_call_state(struct rxrpc_call * call,enum rxrpc_call_state state)1039 static inline void rxrpc_set_call_state(struct rxrpc_call *call,
1040 enum rxrpc_call_state state)
1041 {
1042 /* Order write of completion info before write of ->state. */
1043 smp_store_release(&call->_state, state);
1044 wake_up(&call->waitq);
1045 }
1046
__rxrpc_call_state(const struct rxrpc_call * call)1047 static inline enum rxrpc_call_state __rxrpc_call_state(const struct rxrpc_call *call)
1048 {
1049 return call->_state; /* Only inside I/O thread */
1050 }
1051
__rxrpc_call_is_complete(const struct rxrpc_call * call)1052 static inline bool __rxrpc_call_is_complete(const struct rxrpc_call *call)
1053 {
1054 return __rxrpc_call_state(call) == RXRPC_CALL_COMPLETE;
1055 }
1056
rxrpc_call_state(const struct rxrpc_call * call)1057 static inline enum rxrpc_call_state rxrpc_call_state(const struct rxrpc_call *call)
1058 {
1059 /* Order read ->state before read of completion info. */
1060 return smp_load_acquire(&call->_state);
1061 }
1062
rxrpc_call_is_complete(const struct rxrpc_call * call)1063 static inline bool rxrpc_call_is_complete(const struct rxrpc_call *call)
1064 {
1065 return rxrpc_call_state(call) == RXRPC_CALL_COMPLETE;
1066 }
1067
rxrpc_call_has_failed(const struct rxrpc_call * call)1068 static inline bool rxrpc_call_has_failed(const struct rxrpc_call *call)
1069 {
1070 return rxrpc_call_is_complete(call) && call->completion != RXRPC_CALL_SUCCEEDED;
1071 }
1072
1073 /*
1074 * conn_client.c
1075 */
1076 extern unsigned int rxrpc_reap_client_connections;
1077 extern unsigned long rxrpc_conn_idle_client_expiry;
1078 extern unsigned long rxrpc_conn_idle_client_fast_expiry;
1079
1080 void rxrpc_purge_client_connections(struct rxrpc_local *local);
1081 struct rxrpc_bundle *rxrpc_get_bundle(struct rxrpc_bundle *, enum rxrpc_bundle_trace);
1082 void rxrpc_put_bundle(struct rxrpc_bundle *, enum rxrpc_bundle_trace);
1083 int rxrpc_look_up_bundle(struct rxrpc_call *call, gfp_t gfp);
1084 void rxrpc_connect_client_calls(struct rxrpc_local *local);
1085 void rxrpc_expose_client_call(struct rxrpc_call *);
1086 void rxrpc_disconnect_client_call(struct rxrpc_bundle *, struct rxrpc_call *);
1087 void rxrpc_deactivate_bundle(struct rxrpc_bundle *bundle);
1088 void rxrpc_discard_expired_client_conns(struct rxrpc_local *local);
1089 void rxrpc_clean_up_local_conns(struct rxrpc_local *);
1090
1091 /*
1092 * conn_event.c
1093 */
1094 void rxrpc_conn_retransmit_call(struct rxrpc_connection *conn, struct sk_buff *skb,
1095 unsigned int channel);
1096 int rxrpc_abort_conn(struct rxrpc_connection *conn, struct sk_buff *skb,
1097 s32 abort_code, int err, enum rxrpc_abort_reason why);
1098 void rxrpc_process_connection(struct work_struct *);
1099 void rxrpc_process_delayed_final_acks(struct rxrpc_connection *, bool);
1100 bool rxrpc_input_conn_packet(struct rxrpc_connection *conn, struct sk_buff *skb);
1101 void rxrpc_input_conn_event(struct rxrpc_connection *conn, struct sk_buff *skb);
1102
rxrpc_is_conn_aborted(const struct rxrpc_connection * conn)1103 static inline bool rxrpc_is_conn_aborted(const struct rxrpc_connection *conn)
1104 {
1105 /* Order reading the abort info after the state check. */
1106 return smp_load_acquire(&conn->state) == RXRPC_CONN_ABORTED;
1107 }
1108
1109 /*
1110 * conn_object.c
1111 */
1112 extern unsigned int rxrpc_connection_expiry;
1113 extern unsigned int rxrpc_closed_conn_expiry;
1114
1115 void rxrpc_poke_conn(struct rxrpc_connection *conn, enum rxrpc_conn_trace why);
1116 struct rxrpc_connection *rxrpc_alloc_connection(struct rxrpc_net *, gfp_t);
1117 struct rxrpc_connection *rxrpc_find_client_connection_rcu(struct rxrpc_local *,
1118 struct sockaddr_rxrpc *,
1119 struct sk_buff *);
1120 void __rxrpc_disconnect_call(struct rxrpc_connection *, struct rxrpc_call *);
1121 void rxrpc_disconnect_call(struct rxrpc_call *);
1122 void rxrpc_kill_client_conn(struct rxrpc_connection *);
1123 void rxrpc_queue_conn(struct rxrpc_connection *, enum rxrpc_conn_trace);
1124 void rxrpc_see_connection(struct rxrpc_connection *, enum rxrpc_conn_trace);
1125 struct rxrpc_connection *rxrpc_get_connection(struct rxrpc_connection *,
1126 enum rxrpc_conn_trace);
1127 struct rxrpc_connection *rxrpc_get_connection_maybe(struct rxrpc_connection *,
1128 enum rxrpc_conn_trace);
1129 void rxrpc_put_connection(struct rxrpc_connection *, enum rxrpc_conn_trace);
1130 void rxrpc_service_connection_reaper(struct work_struct *);
1131 void rxrpc_destroy_all_connections(struct rxrpc_net *);
1132
rxrpc_conn_is_client(const struct rxrpc_connection * conn)1133 static inline bool rxrpc_conn_is_client(const struct rxrpc_connection *conn)
1134 {
1135 return conn->out_clientflag;
1136 }
1137
rxrpc_conn_is_service(const struct rxrpc_connection * conn)1138 static inline bool rxrpc_conn_is_service(const struct rxrpc_connection *conn)
1139 {
1140 return !rxrpc_conn_is_client(conn);
1141 }
1142
rxrpc_reduce_conn_timer(struct rxrpc_connection * conn,unsigned long expire_at)1143 static inline void rxrpc_reduce_conn_timer(struct rxrpc_connection *conn,
1144 unsigned long expire_at)
1145 {
1146 timer_reduce(&conn->timer, expire_at);
1147 }
1148
1149 /*
1150 * conn_service.c
1151 */
1152 struct rxrpc_connection *rxrpc_find_service_conn_rcu(struct rxrpc_peer *,
1153 struct sk_buff *);
1154 struct rxrpc_connection *rxrpc_prealloc_service_connection(struct rxrpc_net *, gfp_t);
1155 void rxrpc_new_incoming_connection(struct rxrpc_sock *, struct rxrpc_connection *,
1156 const struct rxrpc_security *, struct sk_buff *);
1157 void rxrpc_unpublish_service_conn(struct rxrpc_connection *);
1158
1159 /*
1160 * input.c
1161 */
1162 void rxrpc_congestion_degrade(struct rxrpc_call *);
1163 void rxrpc_input_call_packet(struct rxrpc_call *, struct sk_buff *);
1164 void rxrpc_implicit_end_call(struct rxrpc_call *, struct sk_buff *);
1165
1166 /*
1167 * input_rack.c
1168 */
1169 void rxrpc_input_rack_one(struct rxrpc_call *call,
1170 struct rxrpc_ack_summary *summary,
1171 struct rxrpc_txqueue *tq,
1172 unsigned int ix);
1173 void rxrpc_input_rack(struct rxrpc_call *call,
1174 struct rxrpc_ack_summary *summary,
1175 struct rxrpc_txqueue *tq,
1176 unsigned long new_acks);
1177 void rxrpc_rack_detect_loss_and_arm_timer(struct rxrpc_call *call,
1178 struct rxrpc_ack_summary *summary);
1179 ktime_t rxrpc_tlp_calc_pto(struct rxrpc_call *call, ktime_t now);
1180 void rxrpc_tlp_send_probe(struct rxrpc_call *call);
1181 void rxrpc_tlp_process_ack(struct rxrpc_call *call, struct rxrpc_ack_summary *summary);
1182 void rxrpc_rack_timer_expired(struct rxrpc_call *call, ktime_t overran_by);
1183
1184 /* Initialise TLP state [RFC8958 7.1]. */
rxrpc_tlp_init(struct rxrpc_call * call)1185 static inline void rxrpc_tlp_init(struct rxrpc_call *call)
1186 {
1187 call->tlp_serial = 0;
1188 call->tlp_seq = call->acks_hard_ack;
1189 call->tlp_is_retrans = false;
1190 }
1191
1192 /*
1193 * io_thread.c
1194 */
1195 int rxrpc_encap_rcv(struct sock *, struct sk_buff *);
1196 void rxrpc_error_report(struct sock *);
1197 bool rxrpc_direct_abort(struct sk_buff *skb, enum rxrpc_abort_reason why,
1198 s32 abort_code, int err);
1199 int rxrpc_io_thread(void *data);
rxrpc_wake_up_io_thread(struct rxrpc_local * local)1200 static inline void rxrpc_wake_up_io_thread(struct rxrpc_local *local)
1201 {
1202 wake_up_process(READ_ONCE(local->io_thread));
1203 }
1204
rxrpc_protocol_error(struct sk_buff * skb,enum rxrpc_abort_reason why)1205 static inline bool rxrpc_protocol_error(struct sk_buff *skb, enum rxrpc_abort_reason why)
1206 {
1207 return rxrpc_direct_abort(skb, why, RX_PROTOCOL_ERROR, -EPROTO);
1208 }
1209
1210 /*
1211 * insecure.c
1212 */
1213 extern const struct rxrpc_security rxrpc_no_security;
1214
1215 /*
1216 * key.c
1217 */
1218 extern struct key_type key_type_rxrpc;
1219
1220 int rxrpc_request_key(struct rxrpc_sock *, sockptr_t , int);
1221 int rxrpc_get_server_data_key(struct rxrpc_connection *, const void *, time64_t,
1222 u32);
1223
1224 /*
1225 * local_event.c
1226 */
1227 void rxrpc_gen_version_string(void);
1228 void rxrpc_send_version_request(struct rxrpc_local *local,
1229 struct rxrpc_host_header *hdr,
1230 struct sk_buff *skb);
1231
1232 /*
1233 * local_object.c
1234 */
1235 void rxrpc_local_dont_fragment(const struct rxrpc_local *local, bool set);
1236 struct rxrpc_local *rxrpc_lookup_local(struct net *, const struct sockaddr_rxrpc *);
1237 struct rxrpc_local *rxrpc_get_local(struct rxrpc_local *, enum rxrpc_local_trace);
1238 struct rxrpc_local *rxrpc_get_local_maybe(struct rxrpc_local *, enum rxrpc_local_trace);
1239 void rxrpc_put_local(struct rxrpc_local *, enum rxrpc_local_trace);
1240 struct rxrpc_local *rxrpc_use_local(struct rxrpc_local *, enum rxrpc_local_trace);
1241 void rxrpc_unuse_local(struct rxrpc_local *, enum rxrpc_local_trace);
1242 void rxrpc_destroy_local(struct rxrpc_local *local);
1243 void rxrpc_destroy_all_locals(struct rxrpc_net *);
1244
__rxrpc_use_local(struct rxrpc_local * local,enum rxrpc_local_trace why)1245 static inline bool __rxrpc_use_local(struct rxrpc_local *local,
1246 enum rxrpc_local_trace why)
1247 {
1248 int r, u;
1249
1250 r = refcount_read(&local->ref);
1251 u = atomic_fetch_add_unless(&local->active_users, 1, 0);
1252 trace_rxrpc_local(local->debug_id, why, r, u);
1253 return u != 0;
1254 }
1255
rxrpc_see_local(struct rxrpc_local * local,enum rxrpc_local_trace why)1256 static inline void rxrpc_see_local(struct rxrpc_local *local,
1257 enum rxrpc_local_trace why)
1258 {
1259 int r, u;
1260
1261 r = refcount_read(&local->ref);
1262 u = atomic_read(&local->active_users);
1263 trace_rxrpc_local(local->debug_id, why, r, u);
1264 }
1265
1266 /*
1267 * misc.c
1268 */
1269 extern unsigned int rxrpc_max_backlog __read_mostly;
1270 extern unsigned long rxrpc_soft_ack_delay;
1271 extern unsigned long rxrpc_idle_ack_delay;
1272 extern unsigned int rxrpc_rx_window_size;
1273 extern unsigned int rxrpc_rx_mtu;
1274 extern unsigned int rxrpc_rx_jumbo_max;
1275 #ifdef CONFIG_AF_RXRPC_INJECT_RX_DELAY
1276 extern unsigned long rxrpc_inject_rx_delay;
1277 #endif
1278
1279 /*
1280 * net_ns.c
1281 */
1282 extern unsigned int rxrpc_net_id;
1283 extern struct pernet_operations rxrpc_net_ops;
1284
rxrpc_net(struct net * net)1285 static inline struct rxrpc_net *rxrpc_net(struct net *net)
1286 {
1287 return net_generic(net, rxrpc_net_id);
1288 }
1289
1290 /*
1291 * output.c
1292 */
1293 void rxrpc_send_ACK(struct rxrpc_call *call, u8 ack_reason,
1294 rxrpc_serial_t serial, enum rxrpc_propose_ack_trace why);
1295 void rxrpc_send_probe_for_pmtud(struct rxrpc_call *call);
1296 int rxrpc_send_abort_packet(struct rxrpc_call *);
1297 void rxrpc_send_data_packet(struct rxrpc_call *call, struct rxrpc_send_data_req *req);
1298 void rxrpc_send_conn_abort(struct rxrpc_connection *conn);
1299 void rxrpc_reject_packet(struct rxrpc_local *local, struct sk_buff *skb);
1300 void rxrpc_send_keepalive(struct rxrpc_peer *);
1301
1302 /*
1303 * peer_event.c
1304 */
1305 void rxrpc_input_error(struct rxrpc_local *, struct sk_buff *);
1306 void rxrpc_peer_keepalive_worker(struct work_struct *);
1307 void rxrpc_input_probe_for_pmtud(struct rxrpc_connection *conn, rxrpc_serial_t acked_serial,
1308 bool sendmsg_fail);
1309
1310 /*
1311 * peer_object.c
1312 */
1313 struct rxrpc_peer *rxrpc_lookup_peer_rcu(struct rxrpc_local *,
1314 const struct sockaddr_rxrpc *);
1315 struct rxrpc_peer *rxrpc_lookup_peer(struct rxrpc_local *local,
1316 struct sockaddr_rxrpc *srx, gfp_t gfp);
1317 struct rxrpc_peer *rxrpc_alloc_peer(struct rxrpc_local *, gfp_t,
1318 enum rxrpc_peer_trace);
1319 void rxrpc_new_incoming_peer(struct rxrpc_local *local, struct rxrpc_peer *peer);
1320 void rxrpc_destroy_all_peers(struct rxrpc_net *);
1321 struct rxrpc_peer *rxrpc_get_peer(struct rxrpc_peer *, enum rxrpc_peer_trace);
1322 struct rxrpc_peer *rxrpc_get_peer_maybe(struct rxrpc_peer *, enum rxrpc_peer_trace);
1323 void rxrpc_put_peer(struct rxrpc_peer *, enum rxrpc_peer_trace);
1324
1325 /*
1326 * proc.c
1327 */
1328 extern const struct seq_operations rxrpc_call_seq_ops;
1329 extern const struct seq_operations rxrpc_connection_seq_ops;
1330 extern const struct seq_operations rxrpc_bundle_seq_ops;
1331 extern const struct seq_operations rxrpc_peer_seq_ops;
1332 extern const struct seq_operations rxrpc_local_seq_ops;
1333
1334 /*
1335 * recvmsg.c
1336 */
1337 void rxrpc_notify_socket(struct rxrpc_call *);
1338 int rxrpc_recvmsg(struct socket *, struct msghdr *, size_t, int);
1339
1340 /*
1341 * Abort a call due to a protocol error.
1342 */
rxrpc_abort_eproto(struct rxrpc_call * call,struct sk_buff * skb,s32 abort_code,enum rxrpc_abort_reason why)1343 static inline int rxrpc_abort_eproto(struct rxrpc_call *call,
1344 struct sk_buff *skb,
1345 s32 abort_code,
1346 enum rxrpc_abort_reason why)
1347 {
1348 struct rxrpc_skb_priv *sp = rxrpc_skb(skb);
1349
1350 rxrpc_abort_call(call, sp->hdr.seq, abort_code, -EPROTO, why);
1351 return -EPROTO;
1352 }
1353
1354 /*
1355 * rtt.c
1356 */
1357 void rxrpc_call_add_rtt(struct rxrpc_call *call, enum rxrpc_rtt_rx_trace why,
1358 int rtt_slot,
1359 rxrpc_serial_t send_serial, rxrpc_serial_t resp_serial,
1360 ktime_t send_time, ktime_t resp_time);
1361 ktime_t rxrpc_get_rto_backoff(struct rxrpc_call *call, bool retrans);
1362 void rxrpc_call_init_rtt(struct rxrpc_call *call);
1363
1364 /*
1365 * rxkad.c
1366 */
1367 #ifdef CONFIG_RXKAD
1368 extern const struct rxrpc_security rxkad;
1369 #endif
1370
1371 /*
1372 * security.c
1373 */
1374 int __init rxrpc_init_security(void);
1375 const struct rxrpc_security *rxrpc_security_lookup(u8);
1376 void rxrpc_exit_security(void);
1377 int rxrpc_init_client_call_security(struct rxrpc_call *);
1378 int rxrpc_init_client_conn_security(struct rxrpc_connection *);
1379 const struct rxrpc_security *rxrpc_get_incoming_security(struct rxrpc_sock *,
1380 struct sk_buff *);
1381 struct key *rxrpc_look_up_server_security(struct rxrpc_connection *,
1382 struct sk_buff *, u32, u32);
1383
1384 /*
1385 * sendmsg.c
1386 */
1387 bool rxrpc_propose_abort(struct rxrpc_call *call, s32 abort_code, int error,
1388 enum rxrpc_abort_reason why);
1389 int rxrpc_do_sendmsg(struct rxrpc_sock *, struct msghdr *, size_t);
1390
1391 /*
1392 * server_key.c
1393 */
1394 extern struct key_type key_type_rxrpc_s;
1395
1396 int rxrpc_server_keyring(struct rxrpc_sock *, sockptr_t, int);
1397
1398 /*
1399 * skbuff.c
1400 */
1401 void rxrpc_kernel_data_consumed(struct rxrpc_call *, struct sk_buff *);
1402 void rxrpc_new_skb(struct sk_buff *, enum rxrpc_skb_trace);
1403 void rxrpc_see_skb(struct sk_buff *, enum rxrpc_skb_trace);
1404 void rxrpc_eaten_skb(struct sk_buff *, enum rxrpc_skb_trace);
1405 void rxrpc_get_skb(struct sk_buff *, enum rxrpc_skb_trace);
1406 void rxrpc_free_skb(struct sk_buff *, enum rxrpc_skb_trace);
1407 void rxrpc_purge_queue(struct sk_buff_head *);
1408
1409 /*
1410 * stats.c
1411 */
1412 int rxrpc_stats_show(struct seq_file *seq, void *v);
1413 int rxrpc_stats_clear(struct file *file, char *buf, size_t size);
1414
1415 #define rxrpc_inc_stat(rxnet, s) atomic_inc(&(rxnet)->s)
1416 #define rxrpc_dec_stat(rxnet, s) atomic_dec(&(rxnet)->s)
1417
1418 /*
1419 * sysctl.c
1420 */
1421 #ifdef CONFIG_SYSCTL
1422 extern int __init rxrpc_sysctl_init(void);
1423 extern void rxrpc_sysctl_exit(void);
1424 #else
rxrpc_sysctl_init(void)1425 static inline int __init rxrpc_sysctl_init(void) { return 0; }
rxrpc_sysctl_exit(void)1426 static inline void rxrpc_sysctl_exit(void) {}
1427 #endif
1428
1429 /*
1430 * txbuf.c
1431 */
1432 extern atomic_t rxrpc_nr_txbuf;
1433 struct rxrpc_txbuf *rxrpc_alloc_data_txbuf(struct rxrpc_call *call, size_t data_size,
1434 size_t data_align, gfp_t gfp);
1435 void rxrpc_get_txbuf(struct rxrpc_txbuf *txb, enum rxrpc_txbuf_trace what);
1436 void rxrpc_see_txbuf(struct rxrpc_txbuf *txb, enum rxrpc_txbuf_trace what);
1437 void rxrpc_put_txbuf(struct rxrpc_txbuf *txb, enum rxrpc_txbuf_trace what);
1438
1439 /*
1440 * utils.c
1441 */
1442 int rxrpc_extract_addr_from_skb(struct sockaddr_rxrpc *, struct sk_buff *);
1443
before(u32 seq1,u32 seq2)1444 static inline bool before(u32 seq1, u32 seq2)
1445 {
1446 return (s32)(seq1 - seq2) < 0;
1447 }
before_eq(u32 seq1,u32 seq2)1448 static inline bool before_eq(u32 seq1, u32 seq2)
1449 {
1450 return (s32)(seq1 - seq2) <= 0;
1451 }
after(u32 seq1,u32 seq2)1452 static inline bool after(u32 seq1, u32 seq2)
1453 {
1454 return (s32)(seq1 - seq2) > 0;
1455 }
after_eq(u32 seq1,u32 seq2)1456 static inline bool after_eq(u32 seq1, u32 seq2)
1457 {
1458 return (s32)(seq1 - seq2) >= 0;
1459 }
1460
earliest(u32 seq1,u32 seq2)1461 static inline u32 earliest(u32 seq1, u32 seq2)
1462 {
1463 return before(seq1, seq2) ? seq1 : seq2;
1464 }
1465
latest(u32 seq1,u32 seq2)1466 static inline u32 latest(u32 seq1, u32 seq2)
1467 {
1468 return after(seq1, seq2) ? seq1 : seq2;
1469 }
1470
rxrpc_seq_in_txq(const struct rxrpc_txqueue * tq,rxrpc_seq_t seq)1471 static inline bool rxrpc_seq_in_txq(const struct rxrpc_txqueue *tq, rxrpc_seq_t seq)
1472 {
1473 return (seq & (RXRPC_NR_TXQUEUE - 1)) == tq->qbase;
1474 }
1475
rxrpc_queue_rx_call_packet(struct rxrpc_call * call,struct sk_buff * skb)1476 static inline void rxrpc_queue_rx_call_packet(struct rxrpc_call *call, struct sk_buff *skb)
1477 {
1478 rxrpc_get_skb(skb, rxrpc_skb_get_call_rx);
1479 __skb_queue_tail(&call->rx_queue, skb);
1480 rxrpc_poke_call(call, rxrpc_call_poke_rx_packet);
1481 }
1482
1483 /*
1484 * Calculate how much space there is for transmitting more DATA packets.
1485 */
rxrpc_tx_window_space(const struct rxrpc_call * call)1486 static inline unsigned int rxrpc_tx_window_space(const struct rxrpc_call *call)
1487 {
1488 int winsize = umin(call->tx_winsize, call->cong_cwnd + call->cong_extra);
1489 int transmitted = call->tx_top - call->tx_bottom;
1490
1491 return max(winsize - transmitted, 0);
1492 }
1493
rxrpc_left_out(const struct rxrpc_call * call)1494 static inline unsigned int rxrpc_left_out(const struct rxrpc_call *call)
1495 {
1496 return call->acks_nr_sacks + call->tx_nr_lost;
1497 }
1498
1499 /*
1500 * Calculate the number of transmitted DATA packets assumed to be in flight
1501 * [approx RFC6675].
1502 */
rxrpc_tx_in_flight(const struct rxrpc_call * call)1503 static inline unsigned int rxrpc_tx_in_flight(const struct rxrpc_call *call)
1504 {
1505 return call->tx_nr_sent - rxrpc_left_out(call) + call->tx_nr_resent;
1506 }
1507
1508 /*
1509 * debug tracing
1510 */
1511 extern unsigned int rxrpc_debug;
1512
1513 #define dbgprintk(FMT,...) \
1514 printk("[%-6.6s] "FMT"\n", current->comm ,##__VA_ARGS__)
1515
1516 #define kenter(FMT,...) dbgprintk("==> %s("FMT")",__func__ ,##__VA_ARGS__)
1517 #define kleave(FMT,...) dbgprintk("<== %s()"FMT"",__func__ ,##__VA_ARGS__)
1518 #define kdebug(FMT,...) dbgprintk(" "FMT ,##__VA_ARGS__)
1519
1520
1521 #if defined(__KDEBUG)
1522 #define _enter(FMT,...) kenter(FMT,##__VA_ARGS__)
1523 #define _leave(FMT,...) kleave(FMT,##__VA_ARGS__)
1524 #define _debug(FMT,...) kdebug(FMT,##__VA_ARGS__)
1525
1526 #elif defined(CONFIG_AF_RXRPC_DEBUG)
1527 #define RXRPC_DEBUG_KENTER 0x01
1528 #define RXRPC_DEBUG_KLEAVE 0x02
1529 #define RXRPC_DEBUG_KDEBUG 0x04
1530
1531 #define _enter(FMT,...) \
1532 do { \
1533 if (unlikely(rxrpc_debug & RXRPC_DEBUG_KENTER)) \
1534 kenter(FMT,##__VA_ARGS__); \
1535 } while (0)
1536
1537 #define _leave(FMT,...) \
1538 do { \
1539 if (unlikely(rxrpc_debug & RXRPC_DEBUG_KLEAVE)) \
1540 kleave(FMT,##__VA_ARGS__); \
1541 } while (0)
1542
1543 #define _debug(FMT,...) \
1544 do { \
1545 if (unlikely(rxrpc_debug & RXRPC_DEBUG_KDEBUG)) \
1546 kdebug(FMT,##__VA_ARGS__); \
1547 } while (0)
1548
1549 #else
1550 #define _enter(FMT,...) no_printk("==> %s("FMT")",__func__ ,##__VA_ARGS__)
1551 #define _leave(FMT,...) no_printk("<== %s()"FMT"",__func__ ,##__VA_ARGS__)
1552 #define _debug(FMT,...) no_printk(" "FMT ,##__VA_ARGS__)
1553 #endif
1554
1555 /*
1556 * debug assertion checking
1557 */
1558 #if 1 // defined(__KDEBUGALL)
1559
1560 #define ASSERT(X) \
1561 do { \
1562 if (unlikely(!(X))) { \
1563 pr_err("Assertion failed\n"); \
1564 BUG(); \
1565 } \
1566 } while (0)
1567
1568 #define ASSERTCMP(X, OP, Y) \
1569 do { \
1570 __typeof__(X) _x = (X); \
1571 __typeof__(Y) _y = (__typeof__(X))(Y); \
1572 if (unlikely(!(_x OP _y))) { \
1573 pr_err("Assertion failed - %lu(0x%lx) %s %lu(0x%lx) is false\n", \
1574 (unsigned long)_x, (unsigned long)_x, #OP, \
1575 (unsigned long)_y, (unsigned long)_y); \
1576 BUG(); \
1577 } \
1578 } while (0)
1579
1580 #define ASSERTIF(C, X) \
1581 do { \
1582 if (unlikely((C) && !(X))) { \
1583 pr_err("Assertion failed\n"); \
1584 BUG(); \
1585 } \
1586 } while (0)
1587
1588 #define ASSERTIFCMP(C, X, OP, Y) \
1589 do { \
1590 __typeof__(X) _x = (X); \
1591 __typeof__(Y) _y = (__typeof__(X))(Y); \
1592 if (unlikely((C) && !(_x OP _y))) { \
1593 pr_err("Assertion failed - %lu(0x%lx) %s %lu(0x%lx) is false\n", \
1594 (unsigned long)_x, (unsigned long)_x, #OP, \
1595 (unsigned long)_y, (unsigned long)_y); \
1596 BUG(); \
1597 } \
1598 } while (0)
1599
1600 #else
1601
1602 #define ASSERT(X) \
1603 do { \
1604 } while (0)
1605
1606 #define ASSERTCMP(X, OP, Y) \
1607 do { \
1608 } while (0)
1609
1610 #define ASSERTIF(C, X) \
1611 do { \
1612 } while (0)
1613
1614 #define ASSERTIFCMP(C, X, OP, Y) \
1615 do { \
1616 } while (0)
1617
1618 #endif /* __KDEBUGALL */
1619