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