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