1 // SPDX-License-Identifier: GPL-2.0
2 /* Multipath TCP token management
3 * Copyright (c) 2017 - 2019, Intel Corporation.
5 * Note: This code is based on mptcp_ctrl.c from multipath-tcp.org,
8 * Sébastien Barré <sebastien.barre@uclouvain.be>
9 * Christoph Paasch <christoph.paasch@uclouvain.be>
10 * Jaakko Korkeaniemi <jaakko.korkeaniemi@aalto.fi>
11 * Gregory Detal <gregory.detal@uclouvain.be>
12 * Fabien Duchêne <fabien.duchene@uclouvain.be>
13 * Andreas Seelinger <Andreas.Seelinger@rwth-aachen.de>
14 * Lavkesh Lahngir <lavkesh51@gmail.com>
15 * Andreas Ripke <ripke@neclab.eu>
16 * Vlad Dogaru <vlad.dogaru@intel.com>
17 * Octavian Purdila <octavian.purdila@intel.com>
18 * John Ronan <jronan@tssg.org>
19 * Catalin Nicutar <catalin.nicutar@gmail.com>
20 * Brandon Heller <brandonh@stanford.edu>
23 #define pr_fmt(fmt) "MPTCP: " fmt
25 #include <linux/kernel.h>
26 #include <linux/module.h>
27 #include <linux/memblock.h>
29 #include <linux/tcp.h>
31 #include <net/inet_common.h>
32 #include <net/protocol.h>
33 #include <net/mptcp.h>
36 #define TOKEN_MAX_CHAIN_LEN 4
41 struct hlist_nulls_head req_chain
;
42 struct hlist_nulls_head msk_chain
;
45 static struct token_bucket
*token_hash __read_mostly
;
46 static unsigned int token_mask __read_mostly
;
48 static struct token_bucket
*token_bucket(u32 token
)
50 return &token_hash
[token
& token_mask
];
53 /* called with bucket lock held */
54 static struct mptcp_subflow_request_sock
*
55 __token_lookup_req(struct token_bucket
*t
, u32 token
)
57 struct mptcp_subflow_request_sock
*req
;
58 struct hlist_nulls_node
*pos
;
60 hlist_nulls_for_each_entry_rcu(req
, pos
, &t
->req_chain
, token_node
)
61 if (req
->token
== token
)
66 /* called with bucket lock held */
67 static struct mptcp_sock
*
68 __token_lookup_msk(struct token_bucket
*t
, u32 token
)
70 struct hlist_nulls_node
*pos
;
73 sk_nulls_for_each_rcu(sk
, pos
, &t
->msk_chain
)
74 if (mptcp_sk(sk
)->token
== token
)
79 static bool __token_bucket_busy(struct token_bucket
*t
, u32 token
)
81 return !token
|| t
->chain_len
>= TOKEN_MAX_CHAIN_LEN
||
82 __token_lookup_req(t
, token
) || __token_lookup_msk(t
, token
);
85 static void mptcp_crypto_key_gen_sha(u64
*key
, u32
*token
, u64
*idsn
)
87 /* we might consider a faster version that computes the key as a
88 * hash of some information available in the MPTCP socket. Use
89 * random data at the moment, as it's probably the safest option
90 * in case multiple sockets are opened in different namespaces at
93 get_random_bytes(key
, sizeof(u64
));
94 mptcp_crypto_key_sha(*key
, token
, idsn
);
98 * mptcp_token_new_request - create new key/idsn/token for subflow_request
99 * @req: the request socket
101 * This function is called when a new mptcp connection is coming in.
103 * It creates a unique token to identify the new mptcp connection,
104 * a secret local key and the initial data sequence number (idsn).
106 * Returns 0 on success.
108 int mptcp_token_new_request(struct request_sock
*req
)
110 struct mptcp_subflow_request_sock
*subflow_req
= mptcp_subflow_rsk(req
);
111 struct token_bucket
*bucket
;
114 mptcp_crypto_key_sha(subflow_req
->local_key
,
117 pr_debug("req=%p local_key=%llu, token=%u, idsn=%llu\n",
118 req
, subflow_req
->local_key
, subflow_req
->token
,
121 token
= subflow_req
->token
;
122 bucket
= token_bucket(token
);
123 spin_lock_bh(&bucket
->lock
);
124 if (__token_bucket_busy(bucket
, token
)) {
125 spin_unlock_bh(&bucket
->lock
);
129 hlist_nulls_add_head_rcu(&subflow_req
->token_node
, &bucket
->req_chain
);
131 spin_unlock_bh(&bucket
->lock
);
136 * mptcp_token_new_connect - create new key/idsn/token for subflow
137 * @ssk: the socket that will initiate a connection
139 * This function is called when a new outgoing mptcp connection is
142 * It creates a unique token to identify the new mptcp connection,
143 * a secret local key and the initial data sequence number (idsn).
145 * On success, the mptcp connection can be found again using
146 * the computed token at a later time, this is needed to process
149 * returns 0 on success.
151 int mptcp_token_new_connect(struct sock
*ssk
)
153 struct mptcp_subflow_context
*subflow
= mptcp_subflow_ctx(ssk
);
154 struct mptcp_sock
*msk
= mptcp_sk(subflow
->conn
);
155 int retries
= MPTCP_TOKEN_MAX_RETRIES
;
156 struct sock
*sk
= subflow
->conn
;
157 struct token_bucket
*bucket
;
160 mptcp_crypto_key_gen_sha(&subflow
->local_key
, &subflow
->token
,
163 bucket
= token_bucket(subflow
->token
);
164 spin_lock_bh(&bucket
->lock
);
165 if (__token_bucket_busy(bucket
, subflow
->token
)) {
166 spin_unlock_bh(&bucket
->lock
);
172 pr_debug("ssk=%p, local_key=%llu, token=%u, idsn=%llu\n",
173 ssk
, subflow
->local_key
, subflow
->token
, subflow
->idsn
);
175 WRITE_ONCE(msk
->token
, subflow
->token
);
176 __sk_nulls_add_node_rcu((struct sock
*)msk
, &bucket
->msk_chain
);
178 spin_unlock_bh(&bucket
->lock
);
179 sock_prot_inuse_add(sock_net(sk
), sk
->sk_prot
, 1);
184 * mptcp_token_accept - replace a req sk with full sock in token hash
185 * @req: the request socket to be removed
186 * @msk: the just cloned socket linked to the new connection
188 * Called when a SYN packet creates a new logical connection, i.e.
189 * is not a join request.
191 void mptcp_token_accept(struct mptcp_subflow_request_sock
*req
,
192 struct mptcp_sock
*msk
)
194 struct mptcp_subflow_request_sock
*pos
;
195 struct sock
*sk
= (struct sock
*)msk
;
196 struct token_bucket
*bucket
;
198 sock_prot_inuse_add(sock_net(sk
), sk
->sk_prot
, 1);
199 bucket
= token_bucket(req
->token
);
200 spin_lock_bh(&bucket
->lock
);
202 /* pedantic lookup check for the moved token */
203 pos
= __token_lookup_req(bucket
, req
->token
);
204 if (!WARN_ON_ONCE(pos
!= req
))
205 hlist_nulls_del_init_rcu(&req
->token_node
);
206 __sk_nulls_add_node_rcu((struct sock
*)msk
, &bucket
->msk_chain
);
207 spin_unlock_bh(&bucket
->lock
);
210 bool mptcp_token_exists(u32 token
)
212 struct hlist_nulls_node
*pos
;
213 struct token_bucket
*bucket
;
214 struct mptcp_sock
*msk
;
218 bucket
= token_bucket(token
);
221 sk_nulls_for_each_rcu(sk
, pos
, &bucket
->msk_chain
) {
223 if (READ_ONCE(msk
->token
) == token
)
226 if (get_nulls_value(pos
) != (token
& token_mask
))
237 * mptcp_token_get_sock - retrieve mptcp connection sock using its token
238 * @net: restrict to this namespace
239 * @token: token of the mptcp connection to retrieve
241 * This function returns the mptcp connection structure with the given token.
242 * A reference count on the mptcp socket returned is taken.
244 * returns NULL if no connection with the given token value exists.
246 struct mptcp_sock
*mptcp_token_get_sock(struct net
*net
, u32 token
)
248 struct hlist_nulls_node
*pos
;
249 struct token_bucket
*bucket
;
250 struct mptcp_sock
*msk
;
254 bucket
= token_bucket(token
);
257 sk_nulls_for_each_rcu(sk
, pos
, &bucket
->msk_chain
) {
259 if (READ_ONCE(msk
->token
) != token
||
260 !net_eq(sock_net(sk
), net
))
263 if (!refcount_inc_not_zero(&sk
->sk_refcnt
))
266 if (READ_ONCE(msk
->token
) != token
||
267 !net_eq(sock_net(sk
), net
)) {
273 if (get_nulls_value(pos
) != (token
& token_mask
))
283 EXPORT_SYMBOL_GPL(mptcp_token_get_sock
);
286 * mptcp_token_iter_next - iterate over the token container from given pos
287 * @net: namespace to be iterated
288 * @s_slot: start slot number
289 * @s_num: start number inside the given lock
291 * This function returns the first mptcp connection structure found inside the
292 * token container starting from the specified position, or NULL.
294 * On successful iteration, the iterator is moved to the next position and
295 * a reference to the returned socket is acquired.
297 struct mptcp_sock
*mptcp_token_iter_next(const struct net
*net
, long *s_slot
,
300 struct mptcp_sock
*ret
= NULL
;
301 struct hlist_nulls_node
*pos
;
304 for (slot
= *s_slot
; slot
<= token_mask
; *s_num
= 0, slot
++) {
305 struct token_bucket
*bucket
= &token_hash
[slot
];
310 if (hlist_nulls_empty(&bucket
->msk_chain
))
314 sk_nulls_for_each_rcu(sk
, pos
, &bucket
->msk_chain
) {
316 if (!net_eq(sock_net(sk
), net
))
322 if (!refcount_inc_not_zero(&sk
->sk_refcnt
))
325 if (!net_eq(sock_net(sk
), net
)) {
342 EXPORT_SYMBOL_GPL(mptcp_token_iter_next
);
345 * mptcp_token_destroy_request - remove mptcp connection/token
346 * @req: mptcp request socket dropping the token
348 * Remove the token associated to @req.
350 void mptcp_token_destroy_request(struct request_sock
*req
)
352 struct mptcp_subflow_request_sock
*subflow_req
= mptcp_subflow_rsk(req
);
353 struct mptcp_subflow_request_sock
*pos
;
354 struct token_bucket
*bucket
;
356 if (hlist_nulls_unhashed(&subflow_req
->token_node
))
359 bucket
= token_bucket(subflow_req
->token
);
360 spin_lock_bh(&bucket
->lock
);
361 pos
= __token_lookup_req(bucket
, subflow_req
->token
);
362 if (!WARN_ON_ONCE(pos
!= subflow_req
)) {
363 hlist_nulls_del_init_rcu(&pos
->token_node
);
366 spin_unlock_bh(&bucket
->lock
);
370 * mptcp_token_destroy - remove mptcp connection/token
371 * @msk: mptcp connection dropping the token
373 * Remove the token associated to @msk
375 void mptcp_token_destroy(struct mptcp_sock
*msk
)
377 struct sock
*sk
= (struct sock
*)msk
;
378 struct token_bucket
*bucket
;
379 struct mptcp_sock
*pos
;
381 if (sk_unhashed((struct sock
*)msk
))
384 sock_prot_inuse_add(sock_net(sk
), sk
->sk_prot
, -1);
385 bucket
= token_bucket(msk
->token
);
386 spin_lock_bh(&bucket
->lock
);
387 pos
= __token_lookup_msk(bucket
, msk
->token
);
388 if (!WARN_ON_ONCE(pos
!= msk
)) {
389 __sk_nulls_del_node_init_rcu((struct sock
*)pos
);
392 spin_unlock_bh(&bucket
->lock
);
393 WRITE_ONCE(msk
->token
, 0);
396 void __init
mptcp_token_init(void)
400 token_hash
= alloc_large_system_hash("MPTCP token",
401 sizeof(struct token_bucket
),
403 20,/* one slot per 1MB of memory */
409 for (i
= 0; i
< token_mask
+ 1; ++i
) {
410 INIT_HLIST_NULLS_HEAD(&token_hash
[i
].req_chain
, i
);
411 INIT_HLIST_NULLS_HEAD(&token_hash
[i
].msk_chain
, i
);
412 spin_lock_init(&token_hash
[i
].lock
);
416 #if IS_MODULE(CONFIG_MPTCP_KUNIT_TEST)
417 EXPORT_SYMBOL_GPL(mptcp_token_new_request
);
418 EXPORT_SYMBOL_GPL(mptcp_token_new_connect
);
419 EXPORT_SYMBOL_GPL(mptcp_token_accept
);
420 EXPORT_SYMBOL_GPL(mptcp_token_destroy_request
);
421 EXPORT_SYMBOL_GPL(mptcp_token_destroy
);