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 };
48
49 /*
50 * sk_state for RxRPC sockets
51 */
52 enum {
53 RXRPC_UNBOUND = 0,
54 RXRPC_CLIENT_UNBOUND, /* Unbound socket used as client */
55 RXRPC_CLIENT_BOUND, /* client local address bound */
56 RXRPC_SERVER_BOUND, /* server local address bound */
57 RXRPC_SERVER_BOUND2, /* second server local address bound */
58 RXRPC_SERVER_LISTENING, /* server listening for connections */
59 RXRPC_SERVER_LISTEN_DISABLED, /* server listening disabled */
60 RXRPC_CLOSE, /* socket is being closed */
61 };
62
63 /*
64 * Per-network namespace data.
65 */
66 struct rxrpc_net {
67 struct proc_dir_entry *proc_net; /* Subdir in /proc/net */
68 u32 epoch; /* Local epoch for detecting local-end reset */
69 struct list_head calls; /* List of calls active in this namespace */
70 spinlock_t call_lock; /* Lock for ->calls */
71 atomic_t nr_calls; /* Count of allocated calls */
72
73 atomic_t nr_conns;
74 struct list_head bundle_proc_list; /* List of bundles for proc */
75 struct list_head conn_proc_list; /* List of conns in this namespace for proc */
76 struct list_head service_conns; /* Service conns in this namespace */
77 rwlock_t conn_lock; /* Lock for ->conn_proc_list, ->service_conns */
78 struct work_struct service_conn_reaper;
79 struct timer_list service_conn_reap_timer;
80
81 bool live;
82
83 atomic_t nr_client_conns;
84
85 struct hlist_head local_endpoints;
86 struct mutex local_mutex; /* Lock for ->local_endpoints */
87
88 DECLARE_HASHTABLE (peer_hash, 10);
89 spinlock_t peer_hash_lock; /* Lock for ->peer_hash */
90
91 #define RXRPC_KEEPALIVE_TIME 20 /* NAT keepalive time in seconds */
92 u8 peer_keepalive_cursor;
93 time64_t peer_keepalive_base;
94 struct list_head peer_keepalive[32];
95 struct list_head peer_keepalive_new;
96 struct timer_list peer_keepalive_timer;
97 struct work_struct peer_keepalive_work;
98
99 atomic_t stat_tx_data;
100 atomic_t stat_tx_data_retrans;
101 atomic_t stat_tx_data_send;
102 atomic_t stat_tx_data_send_frag;
103 atomic_t stat_tx_data_send_fail;
104 atomic_t stat_tx_data_send_msgsize;
105 atomic_t stat_tx_data_underflow;
106 atomic_t stat_tx_data_cwnd_reset;
107 atomic_t stat_rx_data;
108 atomic_t stat_rx_data_reqack;
109 atomic_t stat_rx_data_jumbo;
110
111 atomic_t stat_tx_ack_fill;
112 atomic_t stat_tx_ack_send;
113 atomic_t stat_tx_ack_skip;
114 atomic_t stat_tx_acks[256];
115 atomic_t stat_rx_acks[256];
116 atomic_t stat_tx_jumbo[10];
117 atomic_t stat_rx_jumbo[10];
118
119 atomic_t stat_why_req_ack[8];
120
121 atomic_t stat_io_loop;
122 };
123
124 /*
125 * Service backlog preallocation.
126 *
127 * This contains circular buffers of preallocated peers, connections and calls
128 * for incoming service calls and their head and tail pointers. This allows
129 * calls to be set up in the data_ready handler, thereby avoiding the need to
130 * shuffle packets around so much.
131 */
132 struct rxrpc_backlog {
133 unsigned short peer_backlog_head;
134 unsigned short peer_backlog_tail;
135 unsigned short conn_backlog_head;
136 unsigned short conn_backlog_tail;
137 unsigned short call_backlog_head;
138 unsigned short call_backlog_tail;
139 #define RXRPC_BACKLOG_MAX 32
140 struct rxrpc_peer *peer_backlog[RXRPC_BACKLOG_MAX];
141 struct rxrpc_connection *conn_backlog[RXRPC_BACKLOG_MAX];
142 struct rxrpc_call *call_backlog[RXRPC_BACKLOG_MAX];
143 };
144
145 /*
146 * RxRPC socket definition
147 */
148 struct rxrpc_sock {
149 /* WARNING: sk has to be the first member */
150 struct sock sk;
151 const struct rxrpc_kernel_ops *app_ops; /* Table of kernel app notification funcs */
152 struct rxrpc_local *local; /* local endpoint */
153 struct rxrpc_backlog *backlog; /* Preallocation for services */
154 struct sk_buff_head recvmsg_oobq; /* OOB messages for recvmsg to pick up */
155 struct rb_root pending_oobq; /* OOB messages awaiting userspace to respond to */
156 u64 oob_id_counter; /* OOB message ID counter */
157 spinlock_t incoming_lock; /* Incoming call vs service shutdown lock */
158 struct list_head sock_calls; /* List of calls owned by this socket */
159 struct list_head to_be_accepted; /* calls awaiting acceptance */
160 struct list_head recvmsg_q; /* Calls awaiting recvmsg's attention */
161 spinlock_t recvmsg_lock; /* Lock for recvmsg_q */
162 struct key *key; /* security for this socket */
163 struct key *securities; /* list of server security descriptors */
164 struct rb_root calls; /* User ID -> call mapping */
165 unsigned long flags;
166 #define RXRPC_SOCK_CONNECTED 0 /* connect_srx is set */
167 #define RXRPC_SOCK_MANAGE_RESPONSE 1 /* User wants to manage RESPONSE packets */
168 rwlock_t call_lock; /* lock for calls */
169 u32 min_sec_level; /* minimum security level */
170 #define RXRPC_SECURITY_MAX RXRPC_SECURITY_ENCRYPT
171 bool exclusive; /* Exclusive connection for a client socket */
172 u16 second_service; /* Additional service bound to the endpoint */
173 struct {
174 /* Service upgrade information */
175 u16 from; /* Service ID to upgrade (if not 0) */
176 u16 to; /* service ID to upgrade to */
177 } service_upgrade;
178 sa_family_t family; /* Protocol family created with */
179 struct sockaddr_rxrpc srx; /* Primary Service/local addresses */
180 struct sockaddr_rxrpc connect_srx; /* Default client address from connect() */
181 };
182
183 #define rxrpc_sk(__sk) container_of((__sk), struct rxrpc_sock, sk)
184
185 /*
186 * CPU-byteorder normalised Rx packet header.
187 */
188 struct rxrpc_host_header {
189 u32 epoch; /* client boot timestamp */
190 u32 cid; /* connection and channel ID */
191 u32 callNumber; /* call ID (0 for connection-level packets) */
192 u32 seq; /* sequence number of pkt in call stream */
193 u32 serial; /* serial number of pkt sent to network */
194 u8 type; /* packet type */
195 u8 flags; /* packet flags */
196 u8 userStatus; /* app-layer defined status */
197 u8 securityIndex; /* security protocol ID */
198 union {
199 u16 _rsvd; /* reserved */
200 u16 cksum; /* kerberos security checksum */
201 };
202 u16 serviceId; /* service ID */
203 } __packed;
204
205 /*
206 * RxRPC socket buffer private variables
207 * - max 48 bytes (struct sk_buff::cb)
208 */
209 struct rxrpc_skb_priv {
210 union {
211 struct rxrpc_connection *poke_conn; /* Conn referred to (poke packet) */
212 struct {
213 u16 offset; /* Offset of data */
214 u16 len; /* Length of data */
215 u8 flags;
216 #define RXRPC_RX_VERIFIED 0x01
217 };
218 struct {
219 rxrpc_seq_t first_ack; /* First packet in acks table */
220 rxrpc_seq_t prev_ack; /* Highest seq seen */
221 rxrpc_serial_t acked_serial; /* Packet in response to (or 0) */
222 u16 nr_acks; /* Number of acks+nacks */
223 u8 reason; /* Reason for ack */
224 } ack;
225 struct {
226 struct rxrpc_connection *conn; /* Connection referred to */
227 union {
228 u32 rxkad_nonce;
229 };
230 } chall;
231 struct {
232 rxrpc_serial_t challenge_serial;
233 u32 kvno;
234 u32 version;
235 u16 len;
236 u16 ticket_len;
237 } resp;
238 };
239 struct rxrpc_host_header hdr; /* RxRPC packet header from this packet */
240 };
241
242 #define rxrpc_skb(__skb) ((struct rxrpc_skb_priv *) &(__skb)->cb)
243
244 /*
245 * RxRPC security module interface
246 */
247 struct rxrpc_security {
248 const char *name; /* name of this service */
249 u8 security_index; /* security type provided */
250 u32 no_key_abort; /* Abort code indicating no key */
251
252 /* Initialise a security service */
253 int (*init)(void);
254
255 /* Clean up a security service */
256 void (*exit)(void);
257
258 /* Parse the information from a server key */
259 int (*preparse_server_key)(struct key_preparsed_payload *);
260
261 /* Clean up the preparse buffer after parsing a server key */
262 void (*free_preparse_server_key)(struct key_preparsed_payload *);
263
264 /* Destroy the payload of a server key */
265 void (*destroy_server_key)(struct key *);
266
267 /* Describe a server key */
268 void (*describe_server_key)(const struct key *, struct seq_file *);
269
270 /* initialise a connection's security */
271 int (*init_connection_security)(struct rxrpc_connection *,
272 struct rxrpc_key_token *);
273
274 /* Work out how much data we can store in a packet, given an estimate
275 * of the amount of data remaining and allocate a data buffer.
276 */
277 struct rxrpc_txbuf *(*alloc_txbuf)(struct rxrpc_call *call, size_t remaining, gfp_t gfp);
278
279 /* impose security on a packet */
280 int (*secure_packet)(struct rxrpc_call *, struct rxrpc_txbuf *);
281
282 /* verify the security on a received packet */
283 int (*verify_packet)(struct rxrpc_call *, struct sk_buff *);
284
285 /* Free crypto request on a call */
286 void (*free_call_crypto)(struct rxrpc_call *);
287
288 /* issue a challenge */
289 int (*issue_challenge)(struct rxrpc_connection *);
290
291 /* Validate a challenge packet */
292 bool (*validate_challenge)(struct rxrpc_connection *conn,
293 struct sk_buff *skb);
294
295 /* Fill out the cmsg for recvmsg() to pass on a challenge to userspace.
296 * The security class gets to add additional information.
297 */
298 int (*challenge_to_recvmsg)(struct rxrpc_connection *conn,
299 struct sk_buff *challenge,
300 struct msghdr *msg);
301
302 /* Parse sendmsg() control message and respond to challenge. */
303 int (*sendmsg_respond_to_challenge)(struct sk_buff *challenge,
304 struct msghdr *msg);
305
306 /* respond to a challenge */
307 int (*respond_to_challenge)(struct rxrpc_connection *conn,
308 struct sk_buff *challenge);
309
310 /* verify a response */
311 int (*verify_response)(struct rxrpc_connection *,
312 struct sk_buff *);
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 unsigned int ticket_offset, 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 time64_t last_tx_at; /* Last time packet sent here */
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
777 rxrpc_seq_t rx_highest_seq; /* Higest sequence number received */
778 rxrpc_seq_t rx_consumed; /* Highest packet consumed */
779 rxrpc_serial_t rx_serial; /* Highest serial received for this call */
780 u8 rx_winsize; /* Size of Rx window */
781
782 /* TCP-style slow-start congestion control [RFC5681]. Since the SMSS
783 * is fixed, we keep these numbers in terms of segments (ie. DATA
784 * packets) rather than bytes.
785 */
786 #define RXRPC_TX_SMSS RXRPC_JUMBO_DATALEN
787 #define RXRPC_MIN_CWND 4
788 enum rxrpc_ca_state cong_ca_state; /* Congestion control state */
789 u8 cong_extra; /* Extra to send for congestion management */
790 u16 cong_cwnd; /* Congestion window size */
791 u16 cong_ssthresh; /* Slow-start threshold */
792 u16 cong_dup_acks; /* Count of ACKs showing missing packets */
793 u16 cong_cumul_acks; /* Cumulative ACK count */
794 ktime_t cong_tstamp; /* Last time cwnd was changed */
795
796 /* RACK-TLP [RFC8985] state. */
797 ktime_t rack_xmit_ts; /* Latest transmission timestamp */
798 ktime_t rack_rtt; /* RTT of most recently ACK'd segment */
799 ktime_t rack_rtt_ts; /* Timestamp of rack_rtt */
800 ktime_t rack_reo_wnd; /* Reordering window */
801 unsigned int rack_reo_wnd_mult; /* Multiplier applied to rack_reo_wnd */
802 int rack_reo_wnd_persist; /* Num loss recoveries before reset reo_wnd */
803 rxrpc_seq_t rack_fack; /* Highest sequence so far ACK'd */
804 rxrpc_seq_t rack_end_seq; /* Highest sequence seen */
805 rxrpc_seq_t rack_dsack_round; /* DSACK opt recv'd in latest roundtrip */
806 bool rack_dsack_round_none; /* T if dsack_round is "None" */
807 bool rack_reordering_seen; /* T if detected reordering event */
808 enum rxrpc_rack_timer_mode rack_timer_mode; /* Current mode of RACK timer */
809 bool tlp_is_retrans; /* T if unacked TLP retransmission */
810 rxrpc_serial_t tlp_serial; /* Serial of TLP probe (or 0 if none in progress) */
811 rxrpc_seq_t tlp_seq; /* Sequence of TLP probe */
812 unsigned int tlp_rtt_taken; /* Last time RTT taken */
813 ktime_t tlp_max_ack_delay; /* Sender budget for max delayed ACK interval */
814
815 /* Receive-phase ACK management (ACKs we send). */
816 u8 ackr_reason; /* reason to ACK */
817 u16 ackr_sack_base; /* Starting slot in SACK table ring */
818 rxrpc_seq_t ackr_window; /* Base of SACK window */
819 rxrpc_seq_t ackr_wtop; /* Base of SACK window */
820 unsigned int ackr_nr_unacked; /* Number of unacked packets */
821 atomic_t ackr_nr_consumed; /* Number of packets needing hard ACK */
822 struct {
823 #define RXRPC_SACK_SIZE 256
824 /* SACK table for soft-acked packets */
825 u8 ackr_sack_table[RXRPC_SACK_SIZE];
826 } __aligned(8);
827
828 /* RTT management */
829 rxrpc_serial_t rtt_serial[4]; /* Serial number of DATA or PING sent */
830 ktime_t rtt_sent_at[4]; /* Time packet sent */
831 unsigned long rtt_avail; /* Mask of available slots in bits 0-3,
832 * Mask of pending samples in 8-11 */
833 #define RXRPC_CALL_RTT_AVAIL_MASK 0xf
834 #define RXRPC_CALL_RTT_PEND_SHIFT 8
835
836 /* Transmission-phase ACK management (ACKs we've received). */
837 ktime_t acks_latest_ts; /* Timestamp of latest ACK received */
838 rxrpc_seq_t acks_hard_ack; /* Highest sequence hard acked */
839 rxrpc_seq_t acks_prev_seq; /* Highest previousPacket received */
840 rxrpc_seq_t acks_lowest_nak; /* Lowest NACK in the buffer (or ==tx_hard_ack) */
841 rxrpc_serial_t acks_highest_serial; /* Highest serial number ACK'd */
842 unsigned short acks_nr_sacks; /* Number of soft acks recorded */
843 unsigned short acks_nr_snacks; /* Number of soft nacks recorded */
844
845 /* Calculated RTT cache */
846 ktime_t rtt_last_req; /* Time of last RTT request */
847 unsigned int rtt_count; /* Number of samples we've got */
848 unsigned int rtt_taken; /* Number of samples taken (wrapping) */
849 struct minmax min_rtt; /* Estimated minimum RTT */
850 u32 srtt_us; /* smoothed round trip time << 3 in usecs */
851 u32 mdev_us; /* medium deviation */
852 u32 mdev_max_us; /* maximal mdev for the last rtt period */
853 u32 rttvar_us; /* smoothed mdev_max */
854 u32 rto_us; /* Retransmission timeout in usec */
855 u8 backoff; /* Backoff timeout (as shift) */
856 };
857
858 /*
859 * Summary of a new ACK and the changes it made to the Tx buffer packet states.
860 */
861 struct rxrpc_ack_summary {
862 rxrpc_serial_t ack_serial; /* Serial number of ACK */
863 rxrpc_serial_t acked_serial; /* Serial number ACK'd */
864 u16 in_flight; /* Number of unreceived transmissions */
865 u16 nr_new_hacks; /* Number of rotated new ACKs */
866 u16 nr_new_sacks; /* Number of new soft ACKs in packet */
867 u16 nr_new_snacks; /* Number of new soft nacks in packet */
868 u8 ack_reason;
869 bool new_low_snack:1; /* T if new low soft NACK found */
870 bool retrans_timeo:1; /* T if reTx due to timeout happened */
871 bool need_retransmit:1; /* T if we need transmission */
872 bool rtt_sample_avail:1; /* T if RTT sample available */
873 bool in_fast_or_rto_recovery:1;
874 bool exiting_fast_or_rto_recovery:1;
875 bool tlp_probe_acked:1; /* T if the TLP probe seq was acked */
876 u8 /*enum rxrpc_congest_change*/ change;
877 };
878
879 /*
880 * sendmsg() cmsg-specified parameters.
881 */
882 enum rxrpc_command {
883 RXRPC_CMD_SEND_DATA, /* send data message */
884 RXRPC_CMD_SEND_ABORT, /* request abort generation */
885 RXRPC_CMD_REJECT_BUSY, /* [server] reject a call as busy */
886 RXRPC_CMD_CHARGE_ACCEPT, /* [server] charge accept preallocation */
887 };
888
889 struct rxrpc_call_params {
890 s64 tx_total_len; /* Total Tx data length (if send data) */
891 unsigned long user_call_ID; /* User's call ID */
892 struct {
893 u32 hard; /* Maximum lifetime (sec) */
894 u32 idle; /* Max time since last data packet (msec) */
895 u32 normal; /* Max time since last call packet (msec) */
896 } timeouts;
897 u8 nr_timeouts; /* Number of timeouts specified */
898 bool kernel; /* T if kernel is making the call */
899 enum rxrpc_interruptibility interruptibility; /* How is interruptible is the call? */
900 };
901
902 struct rxrpc_send_params {
903 struct rxrpc_call_params call;
904 u32 abort_code; /* Abort code to Tx (if abort) */
905 enum rxrpc_command command : 8; /* The command to implement */
906 bool exclusive; /* Shared or exclusive call */
907 bool upgrade; /* If the connection is upgradeable */
908 };
909
910 /*
911 * Buffer of data to be output as a packet.
912 */
913 struct rxrpc_txbuf {
914 refcount_t ref;
915 rxrpc_seq_t seq; /* Sequence number of this packet */
916 rxrpc_serial_t serial; /* Last serial number transmitted with */
917 unsigned int call_debug_id;
918 unsigned int debug_id;
919 unsigned short len; /* Amount of data in buffer */
920 unsigned short space; /* Remaining data space */
921 unsigned short offset; /* Offset of fill point */
922 unsigned short crypto_header; /* Size of crypto header */
923 unsigned short sec_header; /* Size of security header */
924 unsigned short pkt_len; /* Size of packet content */
925 unsigned short alloc_size; /* Amount of bufferage allocated */
926 unsigned int flags;
927 #define RXRPC_TXBUF_WIRE_FLAGS 0xff /* The wire protocol flags */
928 #define RXRPC_TXBUF_RESENT 0x100 /* Set if has been resent */
929 __be16 cksum; /* Checksum to go in header */
930 bool jumboable; /* Can be non-terminal jumbo subpacket */
931 void *data; /* Data with preceding jumbo header */
932 };
933
rxrpc_sending_to_server(const struct rxrpc_txbuf * txb)934 static inline bool rxrpc_sending_to_server(const struct rxrpc_txbuf *txb)
935 {
936 return txb->flags & RXRPC_CLIENT_INITIATED;
937 }
938
rxrpc_sending_to_client(const struct rxrpc_txbuf * txb)939 static inline bool rxrpc_sending_to_client(const struct rxrpc_txbuf *txb)
940 {
941 return !rxrpc_sending_to_server(txb);
942 }
943
944 /*
945 * Transmit queue element, including RACK [RFC8985] per-segment metadata. The
946 * transmission timestamp is in usec from the base.
947 */
948 struct rxrpc_txqueue {
949 /* Start with the members we want to prefetch. */
950 struct rxrpc_txqueue *next;
951 ktime_t xmit_ts_base;
952 rxrpc_seq_t qbase;
953 u8 nr_reported_acks; /* Number of segments explicitly acked/nacked */
954 unsigned long segment_acked; /* Bit-per-buf: Set if ACK'd */
955 unsigned long segment_lost; /* Bit-per-buf: Set if declared lost */
956 unsigned long segment_retransmitted; /* Bit-per-buf: Set if retransmitted */
957 unsigned long rtt_samples; /* Bit-per-buf: Set if available for RTT */
958 unsigned long ever_retransmitted; /* Bit-per-buf: Set if ever retransmitted */
959
960 /* The arrays we want to pack into as few cache lines as possible. */
961 struct {
962 #define RXRPC_NR_TXQUEUE BITS_PER_LONG
963 #define RXRPC_TXQ_MASK (RXRPC_NR_TXQUEUE - 1)
964 struct rxrpc_txbuf *bufs[RXRPC_NR_TXQUEUE];
965 unsigned int segment_serial[RXRPC_NR_TXQUEUE];
966 unsigned int segment_xmit_ts[RXRPC_NR_TXQUEUE];
967 } ____cacheline_aligned;
968 };
969
970 /*
971 * Data transmission request.
972 */
973 struct rxrpc_send_data_req {
974 ktime_t now; /* Current time */
975 struct rxrpc_txqueue *tq; /* Tx queue segment holding first DATA */
976 rxrpc_seq_t seq; /* Sequence of first data */
977 int n; /* Number of DATA packets to glue into jumbo */
978 bool retrans; /* T if this is a retransmission */
979 bool did_send; /* T if did actually send */
980 bool tlp_probe; /* T if this is a TLP probe */
981 int /* enum rxrpc_txdata_trace */ trace;
982 };
983
984 #include <trace/events/rxrpc.h>
985
986 /*
987 * Allocate the next serial number on a connection. 0 must be skipped.
988 */
rxrpc_get_next_serial(struct rxrpc_connection * conn)989 static inline rxrpc_serial_t rxrpc_get_next_serial(struct rxrpc_connection *conn)
990 {
991 rxrpc_serial_t serial;
992
993 serial = conn->tx_serial;
994 if (serial == 0)
995 serial = 1;
996 conn->tx_serial = serial + 1;
997 return serial;
998 }
999
1000 /*
1001 * Allocate the next serial n numbers on a connection. 0 must be skipped.
1002 */
rxrpc_get_next_serials(struct rxrpc_connection * conn,unsigned int n)1003 static inline rxrpc_serial_t rxrpc_get_next_serials(struct rxrpc_connection *conn,
1004 unsigned int n)
1005 {
1006 rxrpc_serial_t serial;
1007
1008 serial = conn->tx_serial;
1009 if (serial + n <= n)
1010 serial = 1;
1011 conn->tx_serial = serial + n;
1012 return serial;
1013 }
1014
1015 /*
1016 * af_rxrpc.c
1017 */
1018 extern atomic_t rxrpc_n_rx_skbs;
1019 extern struct workqueue_struct *rxrpc_workqueue;
1020
1021 /*
1022 * call_accept.c
1023 */
1024 int rxrpc_service_prealloc(struct rxrpc_sock *, gfp_t);
1025 void rxrpc_discard_prealloc(struct rxrpc_sock *);
1026 bool rxrpc_new_incoming_call(struct rxrpc_local *local,
1027 struct rxrpc_peer *peer,
1028 struct rxrpc_connection *conn,
1029 struct sockaddr_rxrpc *peer_srx,
1030 struct sk_buff *skb);
1031 int rxrpc_user_charge_accept(struct rxrpc_sock *, unsigned long);
1032
1033 /*
1034 * call_event.c
1035 */
1036 void rxrpc_propose_ping(struct rxrpc_call *call, u32 serial,
1037 enum rxrpc_propose_ack_trace why);
1038 void rxrpc_propose_delay_ACK(struct rxrpc_call *, rxrpc_serial_t,
1039 enum rxrpc_propose_ack_trace);
1040 void rxrpc_resend_tlp(struct rxrpc_call *call);
1041 void rxrpc_transmit_some_data(struct rxrpc_call *call, unsigned int limit,
1042 enum rxrpc_txdata_trace trace);
1043 bool rxrpc_input_call_event(struct rxrpc_call *call);
1044
1045 /*
1046 * call_object.c
1047 */
1048 extern const char *const rxrpc_call_states[];
1049 extern const char *const rxrpc_call_completions[];
1050 extern struct kmem_cache *rxrpc_call_jar;
1051
1052 void rxrpc_poke_call(struct rxrpc_call *call, enum rxrpc_call_poke_trace what);
1053 struct rxrpc_call *rxrpc_find_call_by_user_ID(struct rxrpc_sock *, unsigned long);
1054 struct rxrpc_call *rxrpc_alloc_call(struct rxrpc_sock *, gfp_t, unsigned int);
1055 struct rxrpc_call *rxrpc_new_client_call(struct rxrpc_sock *,
1056 struct rxrpc_conn_parameters *,
1057 struct rxrpc_call_params *, gfp_t,
1058 unsigned int)
1059 __releases(&rx->sk.sk_lock)
1060 __acquires(&call->user_mutex);
1061 void rxrpc_start_call_timer(struct rxrpc_call *call);
1062 void rxrpc_incoming_call(struct rxrpc_sock *, struct rxrpc_call *,
1063 struct sk_buff *);
1064 void rxrpc_release_call(struct rxrpc_sock *, struct rxrpc_call *);
1065 void rxrpc_release_calls_on_socket(struct rxrpc_sock *);
1066 void rxrpc_see_call(struct rxrpc_call *, enum rxrpc_call_trace);
1067 struct rxrpc_call *rxrpc_try_get_call(struct rxrpc_call *, enum rxrpc_call_trace);
1068 void rxrpc_get_call(struct rxrpc_call *, enum rxrpc_call_trace);
1069 void rxrpc_put_call(struct rxrpc_call *, enum rxrpc_call_trace);
1070 void rxrpc_cleanup_call(struct rxrpc_call *);
1071 void rxrpc_destroy_all_calls(struct rxrpc_net *);
1072
rxrpc_is_service_call(const struct rxrpc_call * call)1073 static inline bool rxrpc_is_service_call(const struct rxrpc_call *call)
1074 {
1075 return test_bit(RXRPC_CALL_IS_SERVICE, &call->flags);
1076 }
1077
rxrpc_is_client_call(const struct rxrpc_call * call)1078 static inline bool rxrpc_is_client_call(const struct rxrpc_call *call)
1079 {
1080 return !rxrpc_is_service_call(call);
1081 }
1082
1083 /*
1084 * call_state.c
1085 */
1086 bool rxrpc_set_call_completion(struct rxrpc_call *call,
1087 enum rxrpc_call_completion compl,
1088 u32 abort_code,
1089 int error);
1090 bool rxrpc_call_completed(struct rxrpc_call *call);
1091 bool rxrpc_abort_call(struct rxrpc_call *call, rxrpc_seq_t seq,
1092 u32 abort_code, int error, enum rxrpc_abort_reason why);
1093 void rxrpc_prefail_call(struct rxrpc_call *call, enum rxrpc_call_completion compl,
1094 int error);
1095
rxrpc_set_call_state(struct rxrpc_call * call,enum rxrpc_call_state state)1096 static inline void rxrpc_set_call_state(struct rxrpc_call *call,
1097 enum rxrpc_call_state state)
1098 {
1099 /* Order write of completion info before write of ->state. */
1100 smp_store_release(&call->_state, state);
1101 wake_up(&call->waitq);
1102 }
1103
__rxrpc_call_state(const struct rxrpc_call * call)1104 static inline enum rxrpc_call_state __rxrpc_call_state(const struct rxrpc_call *call)
1105 {
1106 return call->_state; /* Only inside I/O thread */
1107 }
1108
__rxrpc_call_is_complete(const struct rxrpc_call * call)1109 static inline bool __rxrpc_call_is_complete(const struct rxrpc_call *call)
1110 {
1111 return __rxrpc_call_state(call) == RXRPC_CALL_COMPLETE;
1112 }
1113
rxrpc_call_state(const struct rxrpc_call * call)1114 static inline enum rxrpc_call_state rxrpc_call_state(const struct rxrpc_call *call)
1115 {
1116 /* Order read ->state before read of completion info. */
1117 return smp_load_acquire(&call->_state);
1118 }
1119
rxrpc_call_is_complete(const struct rxrpc_call * call)1120 static inline bool rxrpc_call_is_complete(const struct rxrpc_call *call)
1121 {
1122 return rxrpc_call_state(call) == RXRPC_CALL_COMPLETE;
1123 }
1124
rxrpc_call_has_failed(const struct rxrpc_call * call)1125 static inline bool rxrpc_call_has_failed(const struct rxrpc_call *call)
1126 {
1127 return rxrpc_call_is_complete(call) && call->completion != RXRPC_CALL_SUCCEEDED;
1128 }
1129
1130 /*
1131 * conn_client.c
1132 */
1133 extern unsigned int rxrpc_reap_client_connections;
1134 extern unsigned long rxrpc_conn_idle_client_expiry;
1135 extern unsigned long rxrpc_conn_idle_client_fast_expiry;
1136
1137 void rxrpc_purge_client_connections(struct rxrpc_local *local);
1138 struct rxrpc_bundle *rxrpc_get_bundle(struct rxrpc_bundle *, enum rxrpc_bundle_trace);
1139 void rxrpc_put_bundle(struct rxrpc_bundle *, enum rxrpc_bundle_trace);
1140 int rxrpc_look_up_bundle(struct rxrpc_call *call, gfp_t gfp);
1141 void rxrpc_connect_client_calls(struct rxrpc_local *local);
1142 void rxrpc_expose_client_call(struct rxrpc_call *);
1143 void rxrpc_disconnect_client_call(struct rxrpc_bundle *, struct rxrpc_call *);
1144 void rxrpc_deactivate_bundle(struct rxrpc_bundle *bundle);
1145 void rxrpc_discard_expired_client_conns(struct rxrpc_local *local);
1146 void rxrpc_clean_up_local_conns(struct rxrpc_local *);
1147
1148 /*
1149 * conn_event.c
1150 */
1151 void rxrpc_conn_retransmit_call(struct rxrpc_connection *conn, struct sk_buff *skb,
1152 unsigned int channel);
1153 int rxrpc_abort_conn(struct rxrpc_connection *conn, struct sk_buff *skb,
1154 s32 abort_code, int err, enum rxrpc_abort_reason why);
1155 void rxrpc_process_connection(struct work_struct *);
1156 void rxrpc_process_delayed_final_acks(struct rxrpc_connection *, bool);
1157 bool rxrpc_input_conn_packet(struct rxrpc_connection *conn, struct sk_buff *skb);
1158 void rxrpc_input_conn_event(struct rxrpc_connection *conn, struct sk_buff *skb);
1159
rxrpc_is_conn_aborted(const struct rxrpc_connection * conn)1160 static inline bool rxrpc_is_conn_aborted(const struct rxrpc_connection *conn)
1161 {
1162 /* Order reading the abort info after the state check. */
1163 return smp_load_acquire(&conn->state) == RXRPC_CONN_ABORTED;
1164 }
1165
1166 /*
1167 * conn_object.c
1168 */
1169 extern unsigned int rxrpc_connection_expiry;
1170 extern unsigned int rxrpc_closed_conn_expiry;
1171
1172 void rxrpc_poke_conn(struct rxrpc_connection *conn, enum rxrpc_conn_trace why);
1173 struct rxrpc_connection *rxrpc_alloc_connection(struct rxrpc_net *, gfp_t);
1174 struct rxrpc_connection *rxrpc_find_client_connection_rcu(struct rxrpc_local *,
1175 struct sockaddr_rxrpc *,
1176 struct sk_buff *);
1177 void __rxrpc_disconnect_call(struct rxrpc_connection *, struct rxrpc_call *);
1178 void rxrpc_disconnect_call(struct rxrpc_call *);
1179 void rxrpc_kill_client_conn(struct rxrpc_connection *);
1180 void rxrpc_queue_conn(struct rxrpc_connection *, enum rxrpc_conn_trace);
1181 void rxrpc_see_connection(struct rxrpc_connection *, enum rxrpc_conn_trace);
1182 struct rxrpc_connection *rxrpc_get_connection(struct rxrpc_connection *,
1183 enum rxrpc_conn_trace);
1184 struct rxrpc_connection *rxrpc_get_connection_maybe(struct rxrpc_connection *,
1185 enum rxrpc_conn_trace);
1186 void rxrpc_put_connection(struct rxrpc_connection *, enum rxrpc_conn_trace);
1187 void rxrpc_service_connection_reaper(struct work_struct *);
1188 void rxrpc_destroy_all_connections(struct rxrpc_net *);
1189
rxrpc_conn_is_client(const struct rxrpc_connection * conn)1190 static inline bool rxrpc_conn_is_client(const struct rxrpc_connection *conn)
1191 {
1192 return conn->out_clientflag;
1193 }
1194
rxrpc_conn_is_service(const struct rxrpc_connection * conn)1195 static inline bool rxrpc_conn_is_service(const struct rxrpc_connection *conn)
1196 {
1197 return !rxrpc_conn_is_client(conn);
1198 }
1199
rxrpc_reduce_conn_timer(struct rxrpc_connection * conn,unsigned long expire_at)1200 static inline void rxrpc_reduce_conn_timer(struct rxrpc_connection *conn,
1201 unsigned long expire_at)
1202 {
1203 timer_reduce(&conn->timer, expire_at);
1204 }
1205
1206 /*
1207 * conn_service.c
1208 */
1209 struct rxrpc_connection *rxrpc_find_service_conn_rcu(struct rxrpc_peer *,
1210 struct sk_buff *);
1211 struct rxrpc_connection *rxrpc_prealloc_service_connection(struct rxrpc_net *, gfp_t);
1212 void rxrpc_new_incoming_connection(struct rxrpc_sock *, struct rxrpc_connection *,
1213 const struct rxrpc_security *, struct sk_buff *);
1214 void rxrpc_unpublish_service_conn(struct rxrpc_connection *);
1215
1216 /*
1217 * input.c
1218 */
1219 void rxrpc_congestion_degrade(struct rxrpc_call *);
1220 void rxrpc_input_call_packet(struct rxrpc_call *, struct sk_buff *);
1221 void rxrpc_implicit_end_call(struct rxrpc_call *, struct sk_buff *);
1222
1223 /*
1224 * input_rack.c
1225 */
1226 void rxrpc_input_rack_one(struct rxrpc_call *call,
1227 struct rxrpc_ack_summary *summary,
1228 struct rxrpc_txqueue *tq,
1229 unsigned int ix);
1230 void rxrpc_input_rack(struct rxrpc_call *call,
1231 struct rxrpc_ack_summary *summary,
1232 struct rxrpc_txqueue *tq,
1233 unsigned long new_acks);
1234 void rxrpc_rack_detect_loss_and_arm_timer(struct rxrpc_call *call,
1235 struct rxrpc_ack_summary *summary);
1236 ktime_t rxrpc_tlp_calc_pto(struct rxrpc_call *call, ktime_t now);
1237 void rxrpc_tlp_send_probe(struct rxrpc_call *call);
1238 void rxrpc_tlp_process_ack(struct rxrpc_call *call, struct rxrpc_ack_summary *summary);
1239 void rxrpc_rack_timer_expired(struct rxrpc_call *call, ktime_t overran_by);
1240
1241 /* Initialise TLP state [RFC8958 7.1]. */
rxrpc_tlp_init(struct rxrpc_call * call)1242 static inline void rxrpc_tlp_init(struct rxrpc_call *call)
1243 {
1244 call->tlp_serial = 0;
1245 call->tlp_seq = call->acks_hard_ack;
1246 call->tlp_is_retrans = false;
1247 }
1248
1249 /*
1250 * io_thread.c
1251 */
1252 int rxrpc_encap_rcv(struct sock *, struct sk_buff *);
1253 void rxrpc_error_report(struct sock *);
1254 bool rxrpc_direct_abort(struct sk_buff *skb, enum rxrpc_abort_reason why,
1255 s32 abort_code, int err);
1256 int rxrpc_io_thread(void *data);
1257 void rxrpc_post_response(struct rxrpc_connection *conn, struct sk_buff *skb);
rxrpc_wake_up_io_thread(struct rxrpc_local * local)1258 static inline void rxrpc_wake_up_io_thread(struct rxrpc_local *local)
1259 {
1260 if (!local->io_thread)
1261 return;
1262 wake_up_process(READ_ONCE(local->io_thread));
1263 }
1264
rxrpc_protocol_error(struct sk_buff * skb,enum rxrpc_abort_reason why)1265 static inline bool rxrpc_protocol_error(struct sk_buff *skb, enum rxrpc_abort_reason why)
1266 {
1267 return rxrpc_direct_abort(skb, why, RX_PROTOCOL_ERROR, -EPROTO);
1268 }
1269
1270 /*
1271 * insecure.c
1272 */
1273 extern const struct rxrpc_security rxrpc_no_security;
1274
1275 /*
1276 * key.c
1277 */
1278 extern struct key_type key_type_rxrpc;
1279
1280 int rxrpc_request_key(struct rxrpc_sock *, sockptr_t , int);
1281 int rxrpc_get_server_data_key(struct rxrpc_connection *, const void *, time64_t,
1282 u32);
1283
1284 /*
1285 * local_event.c
1286 */
1287 void rxrpc_gen_version_string(void);
1288 void rxrpc_send_version_request(struct rxrpc_local *local,
1289 struct rxrpc_host_header *hdr,
1290 struct sk_buff *skb);
1291
1292 /*
1293 * local_object.c
1294 */
1295 void rxrpc_local_dont_fragment(const struct rxrpc_local *local, bool set);
1296 struct rxrpc_local *rxrpc_lookup_local(struct net *, const struct sockaddr_rxrpc *);
1297 struct rxrpc_local *rxrpc_get_local(struct rxrpc_local *, enum rxrpc_local_trace);
1298 struct rxrpc_local *rxrpc_get_local_maybe(struct rxrpc_local *, enum rxrpc_local_trace);
1299 void rxrpc_put_local(struct rxrpc_local *, enum rxrpc_local_trace);
1300 struct rxrpc_local *rxrpc_use_local(struct rxrpc_local *, enum rxrpc_local_trace);
1301 void rxrpc_unuse_local(struct rxrpc_local *, enum rxrpc_local_trace);
1302 void rxrpc_destroy_local(struct rxrpc_local *local);
1303 void rxrpc_destroy_all_locals(struct rxrpc_net *);
1304
__rxrpc_use_local(struct rxrpc_local * local,enum rxrpc_local_trace why)1305 static inline bool __rxrpc_use_local(struct rxrpc_local *local,
1306 enum rxrpc_local_trace why)
1307 {
1308 int r, u;
1309
1310 r = refcount_read(&local->ref);
1311 u = atomic_fetch_add_unless(&local->active_users, 1, 0);
1312 trace_rxrpc_local(local->debug_id, why, r, u);
1313 return u != 0;
1314 }
1315
rxrpc_see_local(struct rxrpc_local * local,enum rxrpc_local_trace why)1316 static inline void rxrpc_see_local(struct rxrpc_local *local,
1317 enum rxrpc_local_trace why)
1318 {
1319 int r, u;
1320
1321 r = refcount_read(&local->ref);
1322 u = atomic_read(&local->active_users);
1323 trace_rxrpc_local(local->debug_id, why, r, u);
1324 }
1325
1326 /*
1327 * misc.c
1328 */
1329 extern unsigned int rxrpc_max_backlog __read_mostly;
1330 extern unsigned long rxrpc_soft_ack_delay;
1331 extern unsigned long rxrpc_idle_ack_delay;
1332 extern unsigned int rxrpc_rx_window_size;
1333 extern unsigned int rxrpc_rx_mtu;
1334 extern unsigned int rxrpc_rx_jumbo_max;
1335 #ifdef CONFIG_AF_RXRPC_INJECT_RX_DELAY
1336 extern unsigned long rxrpc_inject_rx_delay;
1337 #endif
1338
1339 /*
1340 * net_ns.c
1341 */
1342 extern unsigned int rxrpc_net_id;
1343 extern struct pernet_operations rxrpc_net_ops;
1344
rxrpc_net(struct net * net)1345 static inline struct rxrpc_net *rxrpc_net(struct net *net)
1346 {
1347 return net_generic(net, rxrpc_net_id);
1348 }
1349
1350 /*
1351 * out_of_band.c
1352 */
1353 void rxrpc_notify_socket_oob(struct rxrpc_call *call, struct sk_buff *skb);
1354 void rxrpc_add_pending_oob(struct rxrpc_sock *rx, struct sk_buff *skb);
1355 int rxrpc_sendmsg_oob(struct rxrpc_sock *rx, struct msghdr *msg, size_t len);
1356
1357 /*
1358 * output.c
1359 */
1360 ssize_t do_udp_sendmsg(struct socket *socket, struct msghdr *msg, size_t len);
1361 void rxrpc_send_ACK(struct rxrpc_call *call, u8 ack_reason,
1362 rxrpc_serial_t serial, enum rxrpc_propose_ack_trace why);
1363 void rxrpc_send_probe_for_pmtud(struct rxrpc_call *call);
1364 int rxrpc_send_abort_packet(struct rxrpc_call *);
1365 void rxrpc_send_data_packet(struct rxrpc_call *call, struct rxrpc_send_data_req *req);
1366 void rxrpc_send_conn_abort(struct rxrpc_connection *conn);
1367 void rxrpc_reject_packet(struct rxrpc_local *local, struct sk_buff *skb);
1368 void rxrpc_send_keepalive(struct rxrpc_peer *);
1369 void rxrpc_send_response(struct rxrpc_connection *conn, struct sk_buff *skb);
1370
1371 /*
1372 * peer_event.c
1373 */
1374 void rxrpc_input_error(struct rxrpc_local *, struct sk_buff *);
1375 void rxrpc_peer_keepalive_worker(struct work_struct *);
1376 void rxrpc_input_probe_for_pmtud(struct rxrpc_connection *conn, rxrpc_serial_t acked_serial,
1377 bool sendmsg_fail);
1378
1379 /*
1380 * peer_object.c
1381 */
1382 struct rxrpc_peer *rxrpc_lookup_peer_rcu(struct rxrpc_local *,
1383 const struct sockaddr_rxrpc *);
1384 struct rxrpc_peer *rxrpc_lookup_peer(struct rxrpc_local *local,
1385 struct sockaddr_rxrpc *srx, gfp_t gfp);
1386 struct rxrpc_peer *rxrpc_alloc_peer(struct rxrpc_local *, gfp_t,
1387 enum rxrpc_peer_trace);
1388 void rxrpc_new_incoming_peer(struct rxrpc_local *local, struct rxrpc_peer *peer);
1389 void rxrpc_destroy_all_peers(struct rxrpc_net *);
1390 struct rxrpc_peer *rxrpc_get_peer(struct rxrpc_peer *, enum rxrpc_peer_trace);
1391 struct rxrpc_peer *rxrpc_get_peer_maybe(struct rxrpc_peer *, enum rxrpc_peer_trace);
1392 void rxrpc_put_peer(struct rxrpc_peer *, enum rxrpc_peer_trace);
1393
1394 /*
1395 * proc.c
1396 */
1397 extern const struct seq_operations rxrpc_call_seq_ops;
1398 extern const struct seq_operations rxrpc_connection_seq_ops;
1399 extern const struct seq_operations rxrpc_bundle_seq_ops;
1400 extern const struct seq_operations rxrpc_peer_seq_ops;
1401 extern const struct seq_operations rxrpc_local_seq_ops;
1402
1403 /*
1404 * recvmsg.c
1405 */
1406 void rxrpc_notify_socket(struct rxrpc_call *);
1407 int rxrpc_recvmsg(struct socket *, struct msghdr *, size_t, int);
1408
1409 /*
1410 * Abort a call due to a protocol error.
1411 */
rxrpc_abort_eproto(struct rxrpc_call * call,struct sk_buff * skb,s32 abort_code,enum rxrpc_abort_reason why)1412 static inline int rxrpc_abort_eproto(struct rxrpc_call *call,
1413 struct sk_buff *skb,
1414 s32 abort_code,
1415 enum rxrpc_abort_reason why)
1416 {
1417 struct rxrpc_skb_priv *sp = rxrpc_skb(skb);
1418
1419 rxrpc_abort_call(call, sp->hdr.seq, abort_code, -EPROTO, why);
1420 return -EPROTO;
1421 }
1422
1423 /*
1424 * rtt.c
1425 */
1426 void rxrpc_call_add_rtt(struct rxrpc_call *call, enum rxrpc_rtt_rx_trace why,
1427 int rtt_slot,
1428 rxrpc_serial_t send_serial, rxrpc_serial_t resp_serial,
1429 ktime_t send_time, ktime_t resp_time);
1430 ktime_t rxrpc_get_rto_backoff(struct rxrpc_call *call, bool retrans);
1431 void rxrpc_call_init_rtt(struct rxrpc_call *call);
1432
1433 /*
1434 * rxgk.c
1435 */
1436 extern const struct rxrpc_security rxgk_yfs;
1437
1438 /*
1439 * rxkad.c
1440 */
1441 #ifdef CONFIG_RXKAD
1442 extern const struct rxrpc_security rxkad;
1443 #endif
1444
1445 /*
1446 * security.c
1447 */
1448 int __init rxrpc_init_security(void);
1449 const struct rxrpc_security *rxrpc_security_lookup(u8);
1450 void rxrpc_exit_security(void);
1451 int rxrpc_init_client_call_security(struct rxrpc_call *);
1452 int rxrpc_init_client_conn_security(struct rxrpc_connection *);
1453 const struct rxrpc_security *rxrpc_get_incoming_security(struct rxrpc_sock *,
1454 struct sk_buff *);
1455 struct key *rxrpc_look_up_server_security(struct rxrpc_connection *,
1456 struct sk_buff *, u32, u32);
1457
1458 /*
1459 * sendmsg.c
1460 */
1461 bool rxrpc_propose_abort(struct rxrpc_call *call, s32 abort_code, int error,
1462 enum rxrpc_abort_reason why);
1463 int rxrpc_do_sendmsg(struct rxrpc_sock *, struct msghdr *, size_t);
1464
1465 /*
1466 * server_key.c
1467 */
1468 extern struct key_type key_type_rxrpc_s;
1469
1470 int rxrpc_server_keyring(struct rxrpc_sock *, sockptr_t, int);
1471
1472 /*
1473 * skbuff.c
1474 */
1475 void rxrpc_kernel_data_consumed(struct rxrpc_call *, struct sk_buff *);
1476 void rxrpc_new_skb(struct sk_buff *, enum rxrpc_skb_trace);
1477 void rxrpc_see_skb(struct sk_buff *, enum rxrpc_skb_trace);
1478 void rxrpc_eaten_skb(struct sk_buff *, enum rxrpc_skb_trace);
1479 void rxrpc_get_skb(struct sk_buff *, enum rxrpc_skb_trace);
1480 void rxrpc_free_skb(struct sk_buff *, enum rxrpc_skb_trace);
1481 void rxrpc_purge_queue(struct sk_buff_head *);
1482
1483 /*
1484 * stats.c
1485 */
1486 int rxrpc_stats_show(struct seq_file *seq, void *v);
1487 int rxrpc_stats_clear(struct file *file, char *buf, size_t size);
1488
1489 #define rxrpc_inc_stat(rxnet, s) atomic_inc(&(rxnet)->s)
1490 #define rxrpc_dec_stat(rxnet, s) atomic_dec(&(rxnet)->s)
1491
1492 /*
1493 * sysctl.c
1494 */
1495 #ifdef CONFIG_SYSCTL
1496 extern int __init rxrpc_sysctl_init(void);
1497 extern void rxrpc_sysctl_exit(void);
1498 #else
rxrpc_sysctl_init(void)1499 static inline int __init rxrpc_sysctl_init(void) { return 0; }
rxrpc_sysctl_exit(void)1500 static inline void rxrpc_sysctl_exit(void) {}
1501 #endif
1502
1503 /*
1504 * txbuf.c
1505 */
1506 extern atomic_t rxrpc_nr_txbuf;
1507 struct rxrpc_txbuf *rxrpc_alloc_data_txbuf(struct rxrpc_call *call, size_t data_size,
1508 size_t data_align, gfp_t gfp);
1509 void rxrpc_see_txbuf(struct rxrpc_txbuf *txb, enum rxrpc_txbuf_trace what);
1510 void rxrpc_put_txbuf(struct rxrpc_txbuf *txb, enum rxrpc_txbuf_trace what);
1511
1512 /*
1513 * utils.c
1514 */
1515 int rxrpc_extract_addr_from_skb(struct sockaddr_rxrpc *, struct sk_buff *);
1516
before(u32 seq1,u32 seq2)1517 static inline bool before(u32 seq1, u32 seq2)
1518 {
1519 return (s32)(seq1 - seq2) < 0;
1520 }
before_eq(u32 seq1,u32 seq2)1521 static inline bool before_eq(u32 seq1, u32 seq2)
1522 {
1523 return (s32)(seq1 - seq2) <= 0;
1524 }
after(u32 seq1,u32 seq2)1525 static inline bool after(u32 seq1, u32 seq2)
1526 {
1527 return (s32)(seq1 - seq2) > 0;
1528 }
after_eq(u32 seq1,u32 seq2)1529 static inline bool after_eq(u32 seq1, u32 seq2)
1530 {
1531 return (s32)(seq1 - seq2) >= 0;
1532 }
1533
earliest(u32 seq1,u32 seq2)1534 static inline u32 earliest(u32 seq1, u32 seq2)
1535 {
1536 return before(seq1, seq2) ? seq1 : seq2;
1537 }
1538
latest(u32 seq1,u32 seq2)1539 static inline u32 latest(u32 seq1, u32 seq2)
1540 {
1541 return after(seq1, seq2) ? seq1 : seq2;
1542 }
1543
rxrpc_seq_in_txq(const struct rxrpc_txqueue * tq,rxrpc_seq_t seq)1544 static inline bool rxrpc_seq_in_txq(const struct rxrpc_txqueue *tq, rxrpc_seq_t seq)
1545 {
1546 return (seq & (RXRPC_NR_TXQUEUE - 1)) == tq->qbase;
1547 }
1548
rxrpc_queue_rx_call_packet(struct rxrpc_call * call,struct sk_buff * skb)1549 static inline void rxrpc_queue_rx_call_packet(struct rxrpc_call *call, struct sk_buff *skb)
1550 {
1551 rxrpc_get_skb(skb, rxrpc_skb_get_call_rx);
1552 __skb_queue_tail(&call->rx_queue, skb);
1553 rxrpc_poke_call(call, rxrpc_call_poke_rx_packet);
1554 }
1555
1556 /*
1557 * Calculate how much space there is for transmitting more DATA packets.
1558 */
rxrpc_tx_window_space(const struct rxrpc_call * call)1559 static inline unsigned int rxrpc_tx_window_space(const struct rxrpc_call *call)
1560 {
1561 int winsize = umin(call->tx_winsize, call->cong_cwnd + call->cong_extra);
1562 int transmitted = call->tx_top - call->tx_bottom;
1563
1564 return max(winsize - transmitted, 0);
1565 }
1566
rxrpc_left_out(const struct rxrpc_call * call)1567 static inline unsigned int rxrpc_left_out(const struct rxrpc_call *call)
1568 {
1569 return call->acks_nr_sacks + call->tx_nr_lost;
1570 }
1571
1572 /*
1573 * Calculate the number of transmitted DATA packets assumed to be in flight
1574 * [approx RFC6675].
1575 */
rxrpc_tx_in_flight(const struct rxrpc_call * call)1576 static inline unsigned int rxrpc_tx_in_flight(const struct rxrpc_call *call)
1577 {
1578 return call->tx_nr_sent - rxrpc_left_out(call) + call->tx_nr_resent;
1579 }
1580
1581 /*
1582 * debug tracing
1583 */
1584 extern unsigned int rxrpc_debug;
1585
1586 #define dbgprintk(FMT,...) \
1587 printk("[%-6.6s] "FMT"\n", current->comm ,##__VA_ARGS__)
1588
1589 #define kenter(FMT,...) dbgprintk("==> %s("FMT")",__func__ ,##__VA_ARGS__)
1590 #define kleave(FMT,...) dbgprintk("<== %s()"FMT"",__func__ ,##__VA_ARGS__)
1591 #define kdebug(FMT,...) dbgprintk(" "FMT ,##__VA_ARGS__)
1592
1593
1594 #if defined(__KDEBUG)
1595 #define _enter(FMT,...) kenter(FMT,##__VA_ARGS__)
1596 #define _leave(FMT,...) kleave(FMT,##__VA_ARGS__)
1597 #define _debug(FMT,...) kdebug(FMT,##__VA_ARGS__)
1598
1599 #elif defined(CONFIG_AF_RXRPC_DEBUG)
1600 #define RXRPC_DEBUG_KENTER 0x01
1601 #define RXRPC_DEBUG_KLEAVE 0x02
1602 #define RXRPC_DEBUG_KDEBUG 0x04
1603
1604 #define _enter(FMT,...) \
1605 do { \
1606 if (unlikely(rxrpc_debug & RXRPC_DEBUG_KENTER)) \
1607 kenter(FMT,##__VA_ARGS__); \
1608 } while (0)
1609
1610 #define _leave(FMT,...) \
1611 do { \
1612 if (unlikely(rxrpc_debug & RXRPC_DEBUG_KLEAVE)) \
1613 kleave(FMT,##__VA_ARGS__); \
1614 } while (0)
1615
1616 #define _debug(FMT,...) \
1617 do { \
1618 if (unlikely(rxrpc_debug & RXRPC_DEBUG_KDEBUG)) \
1619 kdebug(FMT,##__VA_ARGS__); \
1620 } while (0)
1621
1622 #else
1623 #define _enter(FMT,...) no_printk("==> %s("FMT")",__func__ ,##__VA_ARGS__)
1624 #define _leave(FMT,...) no_printk("<== %s()"FMT"",__func__ ,##__VA_ARGS__)
1625 #define _debug(FMT,...) no_printk(" "FMT ,##__VA_ARGS__)
1626 #endif
1627
1628 /*
1629 * debug assertion checking
1630 */
1631 #if 1 // defined(__KDEBUGALL)
1632
1633 #define ASSERT(X) \
1634 do { \
1635 if (unlikely(!(X))) { \
1636 pr_err("Assertion failed\n"); \
1637 BUG(); \
1638 } \
1639 } while (0)
1640
1641 #define ASSERTCMP(X, OP, Y) \
1642 do { \
1643 __typeof__(X) _x = (X); \
1644 __typeof__(Y) _y = (__typeof__(X))(Y); \
1645 if (unlikely(!(_x OP _y))) { \
1646 pr_err("Assertion failed - %lu(0x%lx) %s %lu(0x%lx) is false\n", \
1647 (unsigned long)_x, (unsigned long)_x, #OP, \
1648 (unsigned long)_y, (unsigned long)_y); \
1649 BUG(); \
1650 } \
1651 } while (0)
1652
1653 #define ASSERTIF(C, X) \
1654 do { \
1655 if (unlikely((C) && !(X))) { \
1656 pr_err("Assertion failed\n"); \
1657 BUG(); \
1658 } \
1659 } while (0)
1660
1661 #define ASSERTIFCMP(C, X, OP, Y) \
1662 do { \
1663 __typeof__(X) _x = (X); \
1664 __typeof__(Y) _y = (__typeof__(X))(Y); \
1665 if (unlikely((C) && !(_x OP _y))) { \
1666 pr_err("Assertion failed - %lu(0x%lx) %s %lu(0x%lx) is false\n", \
1667 (unsigned long)_x, (unsigned long)_x, #OP, \
1668 (unsigned long)_y, (unsigned long)_y); \
1669 BUG(); \
1670 } \
1671 } while (0)
1672
1673 #else
1674
1675 #define ASSERT(X) \
1676 do { \
1677 } while (0)
1678
1679 #define ASSERTCMP(X, OP, Y) \
1680 do { \
1681 } while (0)
1682
1683 #define ASSERTIF(C, X) \
1684 do { \
1685 } while (0)
1686
1687 #define ASSERTIFCMP(C, X, OP, Y) \
1688 do { \
1689 } while (0)
1690
1691 #endif /* __KDEBUGALL */
1692