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