Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0
2 : : /* Multipath TCP
3 : : *
4 : : * Copyright (c) 2025, Matthieu Baerts.
5 : : */
6 : :
7 : : #define pr_fmt(fmt) "MPTCP: " fmt
8 : :
9 : : #include <net/netns/generic.h>
10 : :
11 : : #include "protocol.h"
12 : : #include "mib.h"
13 : : #include "mptcp_pm_gen.h"
14 : :
15 : : static int pm_nl_pernet_id;
16 : :
17 : : struct pm_nl_pernet {
18 : : /* protects pernet updates */
19 : : spinlock_t lock;
20 : : struct list_head local_addr_list;
21 : : unsigned int addrs;
22 : : unsigned int stale_loss_cnt;
23 : : unsigned int add_addr_signal_max;
24 : : unsigned int add_addr_accept_max;
25 : : unsigned int local_addr_max;
26 : : unsigned int subflows_max;
27 : : unsigned int next_id;
28 : : DECLARE_BITMAP(id_bitmap, MPTCP_PM_MAX_ADDR_ID + 1);
29 : : };
30 : :
31 : : #define MPTCP_PM_ADDR_MAX 8
32 : :
33 : 15211 : static struct pm_nl_pernet *pm_nl_get_pernet(const struct net *net)
34 : : {
35 : 29108 : return net_generic(net, pm_nl_pernet_id);
36 : : }
37 : :
38 : : static struct pm_nl_pernet *
39 : 12601 : pm_nl_get_pernet_from_msk(const struct mptcp_sock *msk)
40 : : {
41 : 12601 : return pm_nl_get_pernet(sock_net((struct sock *)msk));
42 : : }
43 : :
44 : 1227 : static struct pm_nl_pernet *genl_info_pm_nl(struct genl_info *info)
45 : : {
46 : 2445 : return pm_nl_get_pernet(genl_info_net(info));
47 : : }
48 : :
49 : 4397 : unsigned int mptcp_pm_get_add_addr_signal_max(const struct mptcp_sock *msk)
50 : : {
51 : 4373 : const struct pm_nl_pernet *pernet = pm_nl_get_pernet_from_msk(msk);
52 : :
53 : 5038 : return READ_ONCE(pernet->add_addr_signal_max);
54 : : }
55 : : EXPORT_SYMBOL_GPL(mptcp_pm_get_add_addr_signal_max);
56 : :
57 : 4466 : unsigned int mptcp_pm_get_add_addr_accept_max(const struct mptcp_sock *msk)
58 : : {
59 : 0 : struct pm_nl_pernet *pernet = pm_nl_get_pernet_from_msk(msk);
60 : :
61 : 0 : return READ_ONCE(pernet->add_addr_accept_max);
62 : : }
63 : : EXPORT_SYMBOL_GPL(mptcp_pm_get_add_addr_accept_max);
64 : :
65 : 5205 : unsigned int mptcp_pm_get_subflows_max(const struct mptcp_sock *msk)
66 : : {
67 : 5205 : struct pm_nl_pernet *pernet = pm_nl_get_pernet_from_msk(msk);
68 : :
69 : 7565 : return READ_ONCE(pernet->subflows_max);
70 : : }
71 : : EXPORT_SYMBOL_GPL(mptcp_pm_get_subflows_max);
72 : :
73 : 4573 : unsigned int mptcp_pm_get_local_addr_max(const struct mptcp_sock *msk)
74 : : {
75 : 4549 : struct pm_nl_pernet *pernet = pm_nl_get_pernet_from_msk(msk);
76 : :
77 : 5214 : return READ_ONCE(pernet->local_addr_max);
78 : : }
79 : : EXPORT_SYMBOL_GPL(mptcp_pm_get_local_addr_max);
80 : :
81 : 295 : static bool lookup_subflow_by_daddr(const struct list_head *list,
82 : : const struct mptcp_addr_info *daddr)
83 : : {
84 : 295 : struct mptcp_subflow_context *subflow;
85 : 295 : struct mptcp_addr_info cur;
86 : :
87 [ + + ]: 780 : list_for_each_entry(subflow, list, node) {
88 : 503 : struct sock *ssk = mptcp_subflow_tcp_sock(subflow);
89 : :
90 [ + + + + ]: 503 : if (!((1 << inet_sk_state_load(ssk)) &
91 : : (TCPF_ESTABLISHED | TCPF_SYN_SENT | TCPF_SYN_RECV)))
92 : 4 : continue;
93 : :
94 : 499 : mptcp_remote_address((struct sock_common *)ssk, &cur);
95 [ + + ]: 499 : if (mptcp_addresses_equal(&cur, daddr, daddr->port))
96 : : return true;
97 : : }
98 : :
99 : : return false;
100 : : }
101 : :
102 : : static bool
103 : 262 : select_local_address(const struct pm_nl_pernet *pernet,
104 : : const struct mptcp_sock *msk,
105 : : struct mptcp_pm_local *new_local)
106 : : {
107 : 262 : struct mptcp_pm_addr_entry *entry;
108 : 262 : bool found = false;
109 : :
110 : 262 : msk_owned_by_me(msk);
111 : :
112 : 262 : rcu_read_lock();
113 [ + + - + : 398 : list_for_each_entry_rcu(entry, &pernet->local_addr_list, list) {
- - - - -
- + + ]
114 [ + + ]: 370 : if (!(entry->flags & MPTCP_PM_ADDR_FLAG_SUBFLOW))
115 : 16 : continue;
116 : :
117 [ - + - - : 708 : if (!test_bit(entry->addr.id, msk->pm.id_avail_bitmap))
- - - - +
+ + + ]
118 : 120 : continue;
119 : :
120 : 234 : new_local->addr = entry->addr;
121 : 234 : new_local->flags = entry->flags;
122 : 234 : new_local->ifindex = entry->ifindex;
123 : 234 : found = true;
124 : 234 : break;
125 : : }
126 : 262 : rcu_read_unlock();
127 : :
128 : 262 : return found;
129 : : }
130 : :
131 : : static bool
132 : 310 : select_signal_address(struct pm_nl_pernet *pernet, const struct mptcp_sock *msk,
133 : : struct mptcp_pm_local *new_local)
134 : : {
135 : 310 : struct mptcp_pm_addr_entry *entry;
136 : 310 : bool found = false;
137 : :
138 : 310 : rcu_read_lock();
139 : : /* do not keep any additional per socket state, just signal
140 : : * the address list in order.
141 : : * Note: removal from the local address list during the msk life-cycle
142 : : * can lead to additional addresses not being announced.
143 : : */
144 [ + - - + : 620 : list_for_each_entry_rcu(entry, &pernet->local_addr_list, list) {
- - - - -
- + - ]
145 [ - + - - : 1240 : if (!test_bit(entry->addr.id, msk->pm.id_avail_bitmap))
- - - - +
+ + + ]
146 : 310 : continue;
147 : :
148 [ - + ]: 310 : if (!(entry->flags & MPTCP_PM_ADDR_FLAG_SIGNAL))
149 : 0 : continue;
150 : :
151 : 310 : new_local->addr = entry->addr;
152 : 310 : new_local->flags = entry->flags;
153 : 310 : new_local->ifindex = entry->ifindex;
154 : 310 : found = true;
155 : 310 : break;
156 : : }
157 : 310 : rcu_read_unlock();
158 : :
159 : 310 : return found;
160 : : }
161 : :
162 : : /* Fill all the remote addresses into the array addrs[],
163 : : * and return the array size.
164 : : */
165 : 242 : static unsigned int fill_remote_addresses_vec(struct mptcp_sock *msk,
166 : : struct mptcp_addr_info *local,
167 : : bool fullmesh,
168 : : struct mptcp_addr_info *addrs)
169 : : {
170 [ - + ]: 242 : bool deny_id0 = READ_ONCE(msk->pm.remote_deny_join_id0);
171 : 242 : struct sock *sk = (struct sock *)msk, *ssk;
172 : 242 : struct mptcp_subflow_context *subflow;
173 : 242 : struct mptcp_addr_info remote = { 0 };
174 : 242 : unsigned int subflows_max;
175 : 242 : int i = 0;
176 : :
177 : 242 : subflows_max = mptcp_pm_get_subflows_max(msk);
178 : 242 : mptcp_remote_address((struct sock_common *)sk, &remote);
179 : :
180 : : /* Non-fullmesh endpoint, fill in the single entry
181 : : * corresponding to the primary MPC subflow remote address
182 : : */
183 [ + + ]: 242 : if (!fullmesh) {
184 [ + + ]: 212 : if (deny_id0)
185 : : return 0;
186 : :
187 [ + + ]: 208 : if (!mptcp_pm_addr_families_match(sk, local, &remote))
188 : : return 0;
189 : :
190 : 202 : msk->pm.subflows++;
191 : 202 : addrs[i++] = remote;
192 : : } else {
193 : 30 : DECLARE_BITMAP(unavail_id, MPTCP_PM_MAX_ADDR_ID + 1);
194 : :
195 : : /* Forbid creation of new subflows matching existing
196 : : * ones, possibly already created by incoming ADD_ADDR
197 : : */
198 : 30 : bitmap_zero(unavail_id, MPTCP_PM_MAX_ADDR_ID + 1);
199 [ + + ]: 88 : mptcp_for_each_subflow(msk, subflow)
200 [ - + ]: 58 : if (READ_ONCE(subflow->local_id) == local->id)
201 [ # # # # ]: 0 : __set_bit(subflow->remote_id, unavail_id);
202 : :
203 [ + + ]: 88 : mptcp_for_each_subflow(msk, subflow) {
204 : 58 : ssk = mptcp_subflow_tcp_sock(subflow);
205 : 58 : mptcp_remote_address((struct sock_common *)ssk, &addrs[i]);
206 : 58 : addrs[i].id = READ_ONCE(subflow->remote_id);
207 [ - + - - ]: 58 : if (deny_id0 && !addrs[i].id)
208 : 0 : continue;
209 : :
210 [ - + - - : 116 : if (test_bit(addrs[i].id, unavail_id))
+ + + + ]
211 : 8 : continue;
212 : :
213 [ + + ]: 50 : if (!mptcp_pm_addr_families_match(sk, local, &addrs[i]))
214 : 2 : continue;
215 : :
216 [ + + ]: 48 : if (msk->pm.subflows < subflows_max) {
217 : : /* forbid creating multiple address towards
218 : : * this id
219 : : */
220 [ - + - - ]: 44 : __set_bit(addrs[i].id, unavail_id);
221 : 44 : msk->pm.subflows++;
222 : 44 : i++;
223 : : }
224 : : }
225 : : }
226 : :
227 : 232 : return i;
228 : : }
229 : :
230 : : static struct mptcp_pm_addr_entry *
231 : 450 : __lookup_addr_by_id(struct pm_nl_pernet *pernet, unsigned int id)
232 : : {
233 : 900 : struct mptcp_pm_addr_entry *entry;
234 : :
235 [ + - + + : 4672 : list_for_each_entry_rcu(entry, &pernet->local_addr_list, list,
+ + + - -
- - - +
+ ]
236 : : lockdep_is_held(&pernet->lock)) {
237 [ + + + + : 4666 : if (entry->addr.id == id)
+ + + + ]
238 : : return entry;
239 : : }
240 : : return NULL;
241 : : }
242 : :
243 : : static struct mptcp_pm_addr_entry *
244 : 1460 : __lookup_addr(struct pm_nl_pernet *pernet, const struct mptcp_addr_info *info)
245 : : {
246 : 1460 : struct mptcp_pm_addr_entry *entry;
247 : :
248 [ + + + + : 2775 : list_for_each_entry_rcu(entry, &pernet->local_addr_list, list,
- + - - -
- - - +
+ ]
249 : : lockdep_is_held(&pernet->lock)) {
250 [ + + ]: 1945 : if (mptcp_addresses_equal(&entry->addr, info, entry->addr.port))
251 : : return entry;
252 : : }
253 : : return NULL;
254 : : }
255 : :
256 : 665 : static void mptcp_pm_create_subflow_or_signal_addr(struct mptcp_sock *msk)
257 : : {
258 : 665 : struct sock *sk = (struct sock *)msk;
259 : 665 : unsigned int add_addr_signal_max;
260 : 665 : bool signal_and_subflow = false;
261 : 665 : unsigned int local_addr_max;
262 : 665 : struct pm_nl_pernet *pernet;
263 : 665 : struct mptcp_pm_local local;
264 : 665 : unsigned int subflows_max;
265 : :
266 : 665 : pernet = pm_nl_get_pernet(sock_net(sk));
267 : :
268 : 665 : add_addr_signal_max = mptcp_pm_get_add_addr_signal_max(msk);
269 : 665 : local_addr_max = mptcp_pm_get_local_addr_max(msk);
270 : 665 : subflows_max = mptcp_pm_get_subflows_max(msk);
271 : :
272 : : /* do lazy endpoint usage accounting for the MPC subflows */
273 [ + + + - ]: 665 : if (unlikely(!(msk->pm.status & BIT(MPTCP_PM_MPC_ENDPOINT_ACCOUNTED))) && msk->first) {
274 : 396 : struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(msk->first);
275 : 396 : struct mptcp_pm_addr_entry *entry;
276 : 396 : struct mptcp_addr_info mpc_addr;
277 : 396 : bool backup = false;
278 : :
279 : 396 : mptcp_local_address((struct sock_common *)msk->first, &mpc_addr);
280 : 396 : rcu_read_lock();
281 : 396 : entry = __lookup_addr(pernet, &mpc_addr);
282 [ + + ]: 396 : if (entry) {
283 [ - + - - : 34 : __clear_bit(entry->addr.id, msk->pm.id_avail_bitmap);
- - - - ]
284 : 34 : msk->mpc_endpoint_id = entry->addr.id;
285 : 34 : backup = !!(entry->flags & MPTCP_PM_ADDR_FLAG_BACKUP);
286 : : }
287 : 206 : rcu_read_unlock();
288 : :
289 [ + + ]: 396 : if (backup)
290 : 6 : mptcp_pm_send_ack(msk, subflow, true, backup);
291 : :
292 : 396 : msk->pm.status |= BIT(MPTCP_PM_MPC_ENDPOINT_ACCOUNTED);
293 : : }
294 : :
295 [ - + ]: 665 : pr_debug("local %d:%d signal %d:%d subflows %d:%d\n",
296 : : msk->pm.local_addr_used, local_addr_max,
297 : : msk->pm.add_addr_signaled, add_addr_signal_max,
298 : : msk->pm.subflows, subflows_max);
299 : :
300 : : /* check first for announce */
301 [ + + ]: 665 : if (msk->pm.add_addr_signaled < add_addr_signal_max) {
302 : : /* due to racing events on both ends we can reach here while
303 : : * previous add address is still running: if we invoke now
304 : : * mptcp_pm_announce_addr(), that will fail and the
305 : : * corresponding id will be marked as used.
306 : : * Instead let the PM machinery reschedule us when the
307 : : * current address announce will be completed.
308 : : */
309 [ + - ]: 310 : if (msk->pm.addr_signal & BIT(MPTCP_ADD_ADDR_SIGNAL))
310 : 0 : return;
311 : :
312 [ - + ]: 310 : if (!select_signal_address(pernet, msk, &local))
313 : 0 : goto subflow;
314 : :
315 : : /* If the alloc fails, we are on memory pressure, not worth
316 : : * continuing, and trying to create subflows.
317 : : */
318 [ + - ]: 310 : if (!mptcp_pm_alloc_anno_list(msk, &local.addr))
319 : : return;
320 : :
321 [ - + - - : 310 : __clear_bit(local.addr.id, msk->pm.id_avail_bitmap);
- - - - ]
322 : 310 : msk->pm.add_addr_signaled++;
323 : :
324 : : /* Special case for ID0: set the correct ID */
325 [ + + ]: 310 : if (local.addr.id == msk->mpc_endpoint_id)
326 : 4 : local.addr.id = 0;
327 : :
328 : 310 : mptcp_pm_announce_addr(msk, &local.addr, false);
329 : 310 : mptcp_pm_addr_send_ack(msk);
330 : :
331 [ + + ]: 310 : if (local.flags & MPTCP_PM_ADDR_FLAG_SUBFLOW)
332 : 24 : signal_and_subflow = true;
333 : : }
334 : :
335 : 657 : subflow:
336 : : /* check if should create a new subflow */
337 [ + + ]: 907 : while (msk->pm.local_addr_used < local_addr_max &&
338 [ + + ]: 282 : msk->pm.subflows < subflows_max) {
339 : 270 : struct mptcp_addr_info addrs[MPTCP_PM_ADDR_MAX];
340 : 270 : bool fullmesh;
341 : 270 : int i, nr;
342 : :
343 [ + + ]: 270 : if (signal_and_subflow)
344 : : signal_and_subflow = false;
345 [ + + ]: 262 : else if (!select_local_address(pernet, msk, &local))
346 : : break;
347 : :
348 : 242 : fullmesh = !!(local.flags & MPTCP_PM_ADDR_FLAG_FULLMESH);
349 : :
350 [ - + - - : 242 : __clear_bit(local.addr.id, msk->pm.id_avail_bitmap);
- - - - ]
351 : :
352 : : /* Special case for ID0: set the correct ID */
353 [ + + ]: 242 : if (local.addr.id == msk->mpc_endpoint_id)
354 : 6 : local.addr.id = 0;
355 : : else /* local_addr_used is not decr for ID 0 */
356 : 236 : msk->pm.local_addr_used++;
357 : :
358 : 242 : nr = fill_remote_addresses_vec(msk, &local.addr, fullmesh, addrs);
359 [ + + ]: 242 : if (nr == 0)
360 : 10 : continue;
361 : :
362 : 232 : spin_unlock_bh(&msk->pm.lock);
363 [ + + ]: 710 : for (i = 0; i < nr; i++)
364 : 246 : __mptcp_subflow_connect(sk, &local, &addrs[i]);
365 : 232 : spin_lock_bh(&msk->pm.lock);
366 : : }
367 : 665 : mptcp_pm_nl_check_work_pending(msk);
368 : : }
369 : :
370 : 18 : static void mptcp_pm_nl_fully_established(struct mptcp_sock *msk)
371 : : {
372 : 352 : mptcp_pm_create_subflow_or_signal_addr(msk);
373 : 352 : }
374 : :
375 : 6 : static void mptcp_pm_nl_subflow_established(struct mptcp_sock *msk)
376 : : {
377 : 235 : mptcp_pm_create_subflow_or_signal_addr(msk);
378 : 235 : }
379 : :
380 : : /* Fill all the local addresses into the array addrs[],
381 : : * and return the array size.
382 : : */
383 : 277 : static unsigned int fill_local_addresses_vec(struct mptcp_sock *msk,
384 : : struct mptcp_addr_info *remote,
385 : : struct mptcp_pm_local *locals)
386 : : {
387 : 277 : struct sock *sk = (struct sock *)msk;
388 : 277 : struct mptcp_pm_addr_entry *entry;
389 : 277 : struct mptcp_addr_info mpc_addr;
390 : 277 : struct pm_nl_pernet *pernet;
391 : 277 : unsigned int subflows_max;
392 : 277 : int i = 0;
393 : :
394 : 277 : pernet = pm_nl_get_pernet_from_msk(msk);
395 : 277 : subflows_max = mptcp_pm_get_subflows_max(msk);
396 : :
397 : 277 : mptcp_local_address((struct sock_common *)msk, &mpc_addr);
398 : :
399 : 277 : rcu_read_lock();
400 [ + + - + : 783 : list_for_each_entry_rcu(entry, &pernet->local_addr_list, list) {
- - - - -
- + + ]
401 [ + + ]: 506 : if (!(entry->flags & MPTCP_PM_ADDR_FLAG_FULLMESH))
402 : 498 : continue;
403 : :
404 [ + + ]: 8 : if (!mptcp_pm_addr_families_match(sk, &entry->addr, remote))
405 : 2 : continue;
406 : :
407 [ - + ]: 6 : if (msk->pm.subflows < subflows_max) {
408 : 6 : locals[i].addr = entry->addr;
409 : 6 : locals[i].flags = entry->flags;
410 : 6 : locals[i].ifindex = entry->ifindex;
411 : :
412 : : /* Special case for ID0: set the correct ID */
413 [ + + ]: 6 : if (mptcp_addresses_equal(&locals[i].addr, &mpc_addr, locals[i].addr.port))
414 : 2 : locals[i].addr.id = 0;
415 : :
416 : 6 : msk->pm.subflows++;
417 : 6 : i++;
418 : : }
419 : : }
420 : 277 : rcu_read_unlock();
421 : :
422 : : /* If the array is empty, fill in the single
423 : : * 'IPADDRANY' local address
424 : : */
425 [ + + ]: 277 : if (!i) {
426 : 273 : memset(&locals[i], 0, sizeof(locals[i]));
427 : 546 : locals[i].addr.family =
428 : : #if IS_ENABLED(CONFIG_MPTCP_IPV6)
429 [ + + + + ]: 273 : remote->family == AF_INET6 &&
430 [ # # ]: 0 : ipv6_addr_v4mapped(&remote->addr6) ? AF_INET :
431 : : #endif
432 : : remote->family;
433 : :
434 [ + + ]: 273 : if (!mptcp_pm_addr_families_match(sk, &locals[i].addr, remote))
435 : : return 0;
436 : :
437 : 251 : msk->pm.subflows++;
438 : 251 : i++;
439 : : }
440 : :
441 : 255 : return i;
442 : : }
443 : :
444 : 295 : static void mptcp_pm_nl_add_addr_received(struct mptcp_sock *msk)
445 : : {
446 : 295 : struct mptcp_pm_local locals[MPTCP_PM_ADDR_MAX];
447 : 295 : struct sock *sk = (struct sock *)msk;
448 : 295 : unsigned int add_addr_accept_max;
449 : 295 : struct mptcp_addr_info remote;
450 : 295 : unsigned int subflows_max;
451 : 295 : bool sf_created = false;
452 : 295 : int i, nr;
453 : :
454 : 295 : add_addr_accept_max = mptcp_pm_get_add_addr_accept_max(msk);
455 : 295 : subflows_max = mptcp_pm_get_subflows_max(msk);
456 : :
457 [ - + ]: 295 : pr_debug("accepted %d:%d remote family %d\n",
458 : : msk->pm.add_addr_accepted, add_addr_accept_max,
459 : : msk->pm.remote.family);
460 : :
461 : 295 : remote = msk->pm.remote;
462 : 295 : mptcp_pm_announce_addr(msk, &remote, true);
463 : 295 : mptcp_pm_addr_send_ack(msk);
464 : :
465 [ + + ]: 295 : if (lookup_subflow_by_daddr(&msk->conn_list, &remote))
466 : 40 : return;
467 : :
468 : : /* pick id 0 port, if none is provided the remote address */
469 [ + + ]: 277 : if (!remote.port)
470 : 245 : remote.port = sk->sk_dport;
471 : :
472 : : /* connect to the specified remote address, using whatever
473 : : * local address the routing configuration will pick.
474 : : */
475 : 277 : nr = fill_local_addresses_vec(msk, &remote, locals);
476 [ + + ]: 277 : if (nr == 0)
477 : : return;
478 : :
479 : 255 : spin_unlock_bh(&msk->pm.lock);
480 [ + + ]: 767 : for (i = 0; i < nr; i++)
481 [ + + ]: 257 : if (__mptcp_subflow_connect(sk, &locals[i], &remote) == 0)
482 : 231 : sf_created = true;
483 : 255 : spin_lock_bh(&msk->pm.lock);
484 : :
485 [ + + ]: 255 : if (sf_created) {
486 : : /* add_addr_accepted is not decr for ID 0 */
487 [ + + ]: 229 : if (remote.id)
488 : 225 : msk->pm.add_addr_accepted++;
489 [ + + ]: 229 : if (msk->pm.add_addr_accepted >= add_addr_accept_max ||
490 [ - + ]: 109 : msk->pm.subflows >= subflows_max)
491 : 255 : WRITE_ONCE(msk->pm.accept_addr, false);
492 : : }
493 : : }
494 : :
495 : 46 : void mptcp_pm_nl_rm_addr(struct mptcp_sock *msk, u8 rm_id)
496 : : {
497 [ + + - + ]: 46 : if (rm_id && WARN_ON_ONCE(msk->pm.add_addr_accepted == 0)) {
498 : : /* Note: if the subflow has been closed before, this
499 : : * add_addr_accepted counter will not be decremented.
500 : : */
501 [ # # ]: 0 : if (--msk->pm.add_addr_accepted < mptcp_pm_get_add_addr_accept_max(msk))
502 : 0 : WRITE_ONCE(msk->pm.accept_addr, true);
503 : : }
504 : 46 : }
505 : :
506 : 0 : static bool address_use_port(struct mptcp_pm_addr_entry *entry)
507 : : {
508 : 1222 : return (entry->flags &
509 : : (MPTCP_PM_ADDR_FLAG_SIGNAL | MPTCP_PM_ADDR_FLAG_SUBFLOW)) ==
510 : : MPTCP_PM_ADDR_FLAG_SIGNAL;
511 : : }
512 : :
513 : : /* caller must ensure the RCU grace period is already elapsed */
514 : 1196 : static void __mptcp_pm_release_addr_entry(struct mptcp_pm_addr_entry *entry)
515 : : {
516 [ + + ]: 1196 : if (entry->lsk)
517 : 6 : sock_release(entry->lsk);
518 : 1196 : kfree(entry);
519 : 1196 : }
520 : :
521 : 1212 : static int mptcp_pm_nl_append_new_local_addr(struct pm_nl_pernet *pernet,
522 : : struct mptcp_pm_addr_entry *entry,
523 : : bool needs_id, bool replace)
524 : : {
525 : 1212 : struct mptcp_pm_addr_entry *cur, *del_entry = NULL;
526 : 1212 : unsigned int addr_max;
527 : 1212 : int ret = -EINVAL;
528 : :
529 : 1212 : spin_lock_bh(&pernet->lock);
530 : : /* to keep the code simple, don't do IDR-like allocation for address ID,
531 : : * just bail when we exceed limits
532 : : */
533 [ + + ]: 1212 : if (pernet->next_id == MPTCP_PM_MAX_ADDR_ID)
534 : 4 : pernet->next_id = 1;
535 [ - + ]: 1212 : if (pernet->addrs >= MPTCP_PM_ADDR_MAX) {
536 : 0 : ret = -ERANGE;
537 : 0 : goto out;
538 : : }
539 [ - + - - : 2424 : if (test_bit(entry->addr.id, pernet->id_bitmap)) {
- - - - -
+ - + ]
540 : 0 : ret = -EBUSY;
541 : 0 : goto out;
542 : : }
543 : :
544 : : /* do not insert duplicate address, differentiate on port only
545 : : * singled addresses
546 : : */
547 [ + + ]: 1212 : if (!address_use_port(entry))
548 : 902 : entry->addr.port = 0;
549 [ + + ]: 5208 : list_for_each_entry(cur, &pernet->local_addr_list, list) {
550 [ + + ]: 4002 : if (mptcp_addresses_equal(&cur->addr, &entry->addr,
551 [ + + - + ]: 4002 : cur->addr.port || entry->addr.port)) {
552 : : /* allow replacing the exiting endpoint only if such
553 : : * endpoint is an implicit one and the user-space
554 : : * did not provide an endpoint id
555 : : */
556 [ + + ]: 6 : if (!(cur->flags & MPTCP_PM_ADDR_FLAG_IMPLICIT)) {
557 : 2 : ret = -EEXIST;
558 : 2 : goto out;
559 : : }
560 [ + + ]: 4 : if (entry->addr.id)
561 : 2 : goto out;
562 : :
563 : : /* allow callers that only need to look up the local
564 : : * addr's id to skip replacement. This allows them to
565 : : * avoid calling synchronize_rcu in the packet recv
566 : : * path.
567 : : */
568 [ - + ]: 2 : if (!replace) {
569 : 0 : kfree(entry);
570 : 0 : ret = cur->addr.id;
571 : 0 : goto out;
572 : : }
573 : :
574 : 2 : pernet->addrs--;
575 : 2 : entry->addr.id = cur->addr.id;
576 : 2 : list_del_rcu(&cur->list);
577 : 2 : del_entry = cur;
578 : 2 : break;
579 : : }
580 : : }
581 : :
582 [ + + + - ]: 1208 : if (!entry->addr.id && needs_id) {
583 : 638 : find_next:
584 : 1280 : entry->addr.id = find_next_zero_bit(pernet->id_bitmap,
585 : : MPTCP_PM_MAX_ADDR_ID + 1,
586 : 640 : pernet->next_id);
587 [ + + + - ]: 640 : if (!entry->addr.id && pernet->next_id != 1) {
588 : 2 : pernet->next_id = 1;
589 : 2 : goto find_next;
590 : : }
591 : : }
592 : :
593 [ - + - - ]: 1208 : if (!entry->addr.id && needs_id)
594 : 0 : goto out;
595 : :
596 [ - + - - : 1208 : __set_bit(entry->addr.id, pernet->id_bitmap);
- - - - ]
597 [ + + ]: 1208 : if (entry->addr.id > pernet->next_id)
598 : 764 : pernet->next_id = entry->addr.id;
599 : :
600 [ + + ]: 1208 : if (entry->flags & MPTCP_PM_ADDR_FLAG_SIGNAL) {
601 : 318 : addr_max = pernet->add_addr_signal_max;
602 : 318 : WRITE_ONCE(pernet->add_addr_signal_max, addr_max + 1);
603 : : }
604 [ + + ]: 1208 : if (entry->flags & MPTCP_PM_ADDR_FLAG_SUBFLOW) {
605 : 232 : addr_max = pernet->local_addr_max;
606 : 232 : WRITE_ONCE(pernet->local_addr_max, addr_max + 1);
607 : : }
608 : :
609 : 1208 : pernet->addrs++;
610 [ + + ]: 1208 : if (!entry->addr.port)
611 : 1186 : list_add_tail_rcu(&entry->list, &pernet->local_addr_list);
612 : : else
613 : 22 : list_add_rcu(&entry->list, &pernet->local_addr_list);
614 : 1208 : ret = entry->addr.id;
615 : :
616 : 1212 : out:
617 : 1212 : spin_unlock_bh(&pernet->lock);
618 : :
619 : : /* just replaced an existing entry, free it */
620 [ + + ]: 1212 : if (del_entry) {
621 : 2 : synchronize_rcu();
622 : 2 : __mptcp_pm_release_addr_entry(del_entry);
623 : : }
624 : 1212 : return ret;
625 : : }
626 : :
627 : : static struct lock_class_key mptcp_slock_keys[2];
628 : : static struct lock_class_key mptcp_keys[2];
629 : :
630 : 22 : static int mptcp_pm_nl_create_listen_socket(struct sock *sk,
631 : : struct mptcp_pm_addr_entry *entry)
632 : : {
633 : 22 : bool is_ipv6 = sk->sk_family == AF_INET6;
634 : 22 : int addrlen = sizeof(struct sockaddr_in);
635 : 22 : struct sockaddr_storage addr;
636 : 22 : struct sock *newsk, *ssk;
637 : 22 : int backlog = 1024;
638 : 22 : int err;
639 : :
640 : 22 : err = sock_create_kern(sock_net(sk), entry->addr.family,
641 : : SOCK_STREAM, IPPROTO_MPTCP, &entry->lsk);
642 [ + - ]: 22 : if (err)
643 : : return err;
644 : :
645 : 22 : newsk = entry->lsk->sk;
646 [ + - ]: 22 : if (!newsk)
647 : : return -EINVAL;
648 : :
649 : : /* The subflow socket lock is acquired in a nested to the msk one
650 : : * in several places, even by the TCP stack, and this msk is a kernel
651 : : * socket: lockdep complains. Instead of propagating the _nested
652 : : * modifiers in several places, re-init the lock class for the msk
653 : : * socket to an mptcp specific one.
654 : : */
655 [ + - + - ]: 44 : sock_lock_init_class_and_name(newsk,
656 : : is_ipv6 ? "mlock-AF_INET6" : "mlock-AF_INET",
657 : : &mptcp_slock_keys[is_ipv6],
658 : : is_ipv6 ? "msk_lock-AF_INET6" : "msk_lock-AF_INET",
659 : : &mptcp_keys[is_ipv6]);
660 : :
661 : 22 : lock_sock(newsk);
662 [ - + ]: 22 : ssk = __mptcp_nmpc_sk(mptcp_sk(newsk));
663 : 22 : release_sock(newsk);
664 [ - + ]: 22 : if (IS_ERR(ssk))
665 : 0 : return PTR_ERR(ssk);
666 : :
667 : 22 : mptcp_info2sockaddr(&entry->addr, &addr, entry->addr.family);
668 : : #if IS_ENABLED(CONFIG_MPTCP_IPV6)
669 [ - + ]: 22 : if (entry->addr.family == AF_INET6)
670 : 0 : addrlen = sizeof(struct sockaddr_in6);
671 : : #endif
672 [ + - ]: 22 : if (ssk->sk_family == AF_INET)
673 : 22 : err = inet_bind_sk(ssk, (struct sockaddr *)&addr, addrlen);
674 : : #if IS_ENABLED(CONFIG_MPTCP_IPV6)
675 [ # # ]: 0 : else if (ssk->sk_family == AF_INET6)
676 : 0 : err = inet6_bind_sk(ssk, (struct sockaddr *)&addr, addrlen);
677 : : #endif
678 [ + - ]: 22 : if (err)
679 : : return err;
680 : :
681 : : /* We don't use mptcp_set_state() here because it needs to be called
682 : : * under the msk socket lock. For the moment, that will not bring
683 : : * anything more than only calling inet_sk_state_store(), because the
684 : : * old status is known (TCP_CLOSE).
685 : : */
686 : 22 : inet_sk_state_store(newsk, TCP_LISTEN);
687 : 22 : lock_sock(ssk);
688 : 22 : WRITE_ONCE(mptcp_subflow_ctx(ssk)->pm_listener, true);
689 : 22 : err = __inet_listen_sk(ssk, backlog);
690 [ + - ]: 22 : if (!err)
691 : 22 : mptcp_event_pm_listener(ssk, MPTCP_EVENT_LISTENER_CREATED);
692 : 22 : release_sock(ssk);
693 : 22 : return err;
694 : : }
695 : :
696 : 362 : int mptcp_pm_nl_get_local_id(struct mptcp_sock *msk,
697 : : struct mptcp_pm_addr_entry *skc)
698 : : {
699 : 362 : struct mptcp_pm_addr_entry *entry;
700 : 362 : struct pm_nl_pernet *pernet;
701 : 362 : int ret;
702 : :
703 : 362 : pernet = pm_nl_get_pernet_from_msk(msk);
704 : :
705 : 362 : rcu_read_lock();
706 : 362 : entry = __lookup_addr(pernet, &skc->addr);
707 [ + + ]: 362 : ret = entry ? entry->addr.id : -1;
708 : 250 : rcu_read_unlock();
709 : 362 : if (ret >= 0)
710 : 222 : return ret;
711 : :
712 : : /* address not found, add to local list */
713 : 140 : entry = kmemdup(skc, sizeof(*skc), GFP_ATOMIC);
714 [ + - ]: 140 : if (!entry)
715 : : return -ENOMEM;
716 : :
717 : 140 : entry->addr.port = 0;
718 : 140 : ret = mptcp_pm_nl_append_new_local_addr(pernet, entry, true, false);
719 [ - + ]: 140 : if (ret < 0)
720 : 0 : kfree(entry);
721 : :
722 : : return ret;
723 : : }
724 : :
725 : 698 : bool mptcp_pm_nl_is_backup(struct mptcp_sock *msk, struct mptcp_addr_info *skc)
726 : : {
727 : 698 : struct pm_nl_pernet *pernet = pm_nl_get_pernet_from_msk(msk);
728 : 698 : struct mptcp_pm_addr_entry *entry;
729 : 698 : bool backup;
730 : :
731 : 698 : rcu_read_lock();
732 : 698 : entry = __lookup_addr(pernet, skc);
733 [ + + + + ]: 698 : backup = entry && !!(entry->flags & MPTCP_PM_ADDR_FLAG_BACKUP);
734 : 698 : rcu_read_unlock();
735 : :
736 : 698 : return backup;
737 : : }
738 : :
739 : 1068 : static int mptcp_nl_add_subflow_or_signal_addr(struct net *net,
740 : : struct mptcp_addr_info *addr)
741 : : {
742 : 1068 : struct mptcp_sock *msk;
743 : 1068 : long s_slot = 0, s_num = 0;
744 : :
745 [ + + ]: 1132 : while ((msk = mptcp_token_iter_next(net, &s_slot, &s_num)) != NULL) {
746 : 64 : struct sock *sk = (struct sock *)msk;
747 : 64 : struct mptcp_addr_info mpc_addr;
748 : :
749 [ + + + + : 64 : if (!READ_ONCE(msk->fully_established) ||
- + ]
750 [ # # ]: 0 : mptcp_pm_is_userspace(msk))
751 : 0 : goto next;
752 : :
753 : : /* if the endp linked to the init sf is re-added with a != ID */
754 : 64 : mptcp_local_address((struct sock_common *)msk, &mpc_addr);
755 : :
756 : 64 : lock_sock(sk);
757 : 64 : spin_lock_bh(&msk->pm.lock);
758 [ + + ]: 64 : if (mptcp_addresses_equal(addr, &mpc_addr, addr->port))
759 : 10 : msk->mpc_endpoint_id = addr->id;
760 : 64 : mptcp_pm_create_subflow_or_signal_addr(msk);
761 : 64 : spin_unlock_bh(&msk->pm.lock);
762 : 64 : release_sock(sk);
763 : :
764 : 64 : next:
765 : 64 : sock_put(sk);
766 : 64 : cond_resched();
767 : : }
768 : :
769 : 1068 : return 0;
770 : : }
771 : :
772 : 1072 : static bool mptcp_pm_has_addr_attr_id(const struct nlattr *attr,
773 : : struct genl_info *info)
774 : : {
775 : 1072 : struct nlattr *tb[MPTCP_PM_ADDR_ATTR_MAX + 1];
776 : :
777 [ + - ]: 1072 : if (!nla_parse_nested_deprecated(tb, MPTCP_PM_ADDR_ATTR_MAX, attr,
778 : 1072 : mptcp_pm_address_nl_policy, info->extack) &&
779 [ + + ]: 1072 : tb[MPTCP_PM_ADDR_ATTR_ID])
780 : 570 : return true;
781 : : return false;
782 : : }
783 : :
784 : : /* Add an MPTCP endpoint */
785 : 1072 : int mptcp_pm_nl_add_addr_doit(struct sk_buff *skb, struct genl_info *info)
786 : : {
787 : 1072 : struct pm_nl_pernet *pernet = genl_info_pm_nl(info);
788 : 1072 : struct mptcp_pm_addr_entry addr, *entry;
789 : 1072 : struct nlattr *attr;
790 : 1072 : int ret;
791 : :
792 [ + - - - ]: 1072 : if (GENL_REQ_ATTR_CHECK(info, MPTCP_PM_ENDPOINT_ADDR))
793 : 0 : return -EINVAL;
794 : :
795 : 1072 : attr = info->attrs[MPTCP_PM_ENDPOINT_ADDR];
796 : 1072 : ret = mptcp_pm_parse_entry(attr, info, true, &addr);
797 [ + - ]: 1072 : if (ret < 0)
798 : : return ret;
799 : :
800 [ + + - + ]: 1072 : if (addr.addr.port && !address_use_port(&addr)) {
801 [ # # ]: 0 : NL_SET_ERR_MSG_ATTR(info->extack, attr,
802 : : "flags must have signal and not subflow when using port");
803 : 0 : return -EINVAL;
804 : : }
805 : :
806 [ - + ]: 1072 : if (addr.flags & MPTCP_PM_ADDR_FLAG_SIGNAL &&
807 : : addr.flags & MPTCP_PM_ADDR_FLAG_FULLMESH) {
808 [ # # ]: 0 : NL_SET_ERR_MSG_ATTR(info->extack, attr,
809 : : "flags mustn't have both signal and fullmesh");
810 : 0 : return -EINVAL;
811 : : }
812 : :
813 [ - + ]: 1072 : if (addr.flags & MPTCP_PM_ADDR_FLAG_IMPLICIT) {
814 [ # # ]: 0 : NL_SET_ERR_MSG_ATTR(info->extack, attr,
815 : : "can't create IMPLICIT endpoint");
816 : 0 : return -EINVAL;
817 : : }
818 : :
819 : 1072 : entry = kmemdup(&addr, sizeof(addr), GFP_KERNEL_ACCOUNT);
820 [ - + ]: 1072 : if (!entry) {
821 [ # # ]: 0 : GENL_SET_ERR_MSG(info, "can't allocate addr");
822 : 0 : return -ENOMEM;
823 : : }
824 : :
825 [ + + ]: 1072 : if (entry->addr.port) {
826 : 22 : ret = mptcp_pm_nl_create_listen_socket(skb->sk, entry);
827 [ - + ]: 22 : if (ret) {
828 [ # # # # : 0 : GENL_SET_ERR_MSG_FMT(info, "create listen socket error: %d", ret);
# # ]
829 : 0 : goto out_free;
830 : : }
831 : : }
832 : 2156 : ret = mptcp_pm_nl_append_new_local_addr(pernet, entry,
833 : 1072 : !mptcp_pm_has_addr_attr_id(attr, info),
834 : 1072 : true);
835 [ + + ]: 1072 : if (ret < 0) {
836 [ + - - + : 4 : GENL_SET_ERR_MSG_FMT(info, "too many addresses or duplicate one: %d", ret);
- - ]
837 : 4 : goto out_free;
838 : : }
839 : :
840 : 1068 : mptcp_nl_add_subflow_or_signal_addr(sock_net(skb->sk), &entry->addr);
841 : 1068 : return 0;
842 : :
843 : 4 : out_free:
844 : 4 : __mptcp_pm_release_addr_entry(entry);
845 : 4 : return ret;
846 : : }
847 : :
848 : 0 : static u8 mptcp_endp_get_local_id(struct mptcp_sock *msk,
849 : : const struct mptcp_addr_info *addr)
850 : : {
851 [ + - + - ]: 111 : return msk->mpc_endpoint_id == addr->id ? 0 : addr->id;
852 : : }
853 : :
854 : 64 : static bool mptcp_pm_remove_anno_addr(struct mptcp_sock *msk,
855 : : const struct mptcp_addr_info *addr,
856 : : bool force)
857 : : {
858 : 64 : struct mptcp_rm_list list = { .nr = 0 };
859 : 64 : bool ret;
860 : :
861 [ + + ]: 64 : list.ids[list.nr++] = mptcp_endp_get_local_id(msk, addr);
862 : :
863 : 64 : ret = mptcp_remove_anno_list_by_saddr(msk, addr);
864 [ + + ]: 64 : if (ret || force) {
865 : 62 : spin_lock_bh(&msk->pm.lock);
866 [ + + ]: 62 : if (ret) {
867 [ - + - - : 32 : __set_bit(addr->id, msk->pm.id_avail_bitmap);
- - - - ]
868 : 32 : msk->pm.add_addr_signaled--;
869 : : }
870 : 62 : mptcp_pm_remove_addr(msk, &list);
871 : 62 : spin_unlock_bh(&msk->pm.lock);
872 : : }
873 : 64 : return ret;
874 : : }
875 : :
876 : 48 : static void __mark_subflow_endp_available(struct mptcp_sock *msk, u8 id)
877 : : {
878 : : /* If it was marked as used, and not ID 0, decrement local_addr_used */
879 [ + + + + : 72 : if (!__test_and_set_bit(id ? : msk->mpc_endpoint_id, msk->pm.id_avail_bitmap) &&
+ + ]
880 [ - + ]: 38 : id && !WARN_ON_ONCE(msk->pm.local_addr_used == 0))
881 : 38 : msk->pm.local_addr_used--;
882 : 48 : }
883 : :
884 : 562 : static int mptcp_nl_remove_subflow_and_signal_addr(struct net *net,
885 : : const struct mptcp_pm_addr_entry *entry)
886 : : {
887 : 562 : const struct mptcp_addr_info *addr = &entry->addr;
888 : 562 : struct mptcp_rm_list list = { .nr = 1 };
889 : 562 : long s_slot = 0, s_num = 0;
890 : 562 : struct mptcp_sock *msk;
891 : :
892 [ - + ]: 562 : pr_debug("remove_id=%d\n", addr->id);
893 : :
894 [ + + ]: 628 : while ((msk = mptcp_token_iter_next(net, &s_slot, &s_num)) != NULL) {
895 : 66 : struct sock *sk = (struct sock *)msk;
896 : 66 : bool remove_subflow;
897 : :
898 [ + + ]: 66 : if (mptcp_pm_is_userspace(msk))
899 : 2 : goto next;
900 : :
901 : 64 : lock_sock(sk);
902 : 64 : remove_subflow = mptcp_lookup_subflow_by_saddr(&msk->conn_list, addr);
903 [ + + ]: 128 : mptcp_pm_remove_anno_addr(msk, addr, remove_subflow &&
904 [ - + ]: 56 : !(entry->flags & MPTCP_PM_ADDR_FLAG_IMPLICIT));
905 : :
906 [ + + ]: 64 : list.ids[0] = mptcp_endp_get_local_id(msk, addr);
907 [ + + ]: 64 : if (remove_subflow) {
908 : 56 : spin_lock_bh(&msk->pm.lock);
909 : 56 : mptcp_pm_rm_subflow(msk, &list);
910 : 56 : spin_unlock_bh(&msk->pm.lock);
911 : : }
912 : :
913 [ + + ]: 64 : if (entry->flags & MPTCP_PM_ADDR_FLAG_SUBFLOW) {
914 : 30 : spin_lock_bh(&msk->pm.lock);
915 : 30 : __mark_subflow_endp_available(msk, list.ids[0]);
916 : 30 : spin_unlock_bh(&msk->pm.lock);
917 : : }
918 : :
919 [ + + ]: 64 : if (msk->mpc_endpoint_id == entry->addr.id)
920 : 10 : msk->mpc_endpoint_id = 0;
921 : 64 : release_sock(sk);
922 : :
923 : 66 : next:
924 : 66 : sock_put(sk);
925 : 66 : cond_resched();
926 : : }
927 : :
928 : 562 : return 0;
929 : : }
930 : :
931 : 4 : static int mptcp_nl_remove_id_zero_address(struct net *net,
932 : : struct mptcp_addr_info *addr)
933 : : {
934 : 4 : struct mptcp_rm_list list = { .nr = 0 };
935 : 4 : long s_slot = 0, s_num = 0;
936 : 4 : struct mptcp_sock *msk;
937 : :
938 : 4 : list.ids[list.nr++] = 0;
939 : :
940 [ + + ]: 8 : while ((msk = mptcp_token_iter_next(net, &s_slot, &s_num)) != NULL) {
941 : 4 : struct sock *sk = (struct sock *)msk;
942 : 4 : struct mptcp_addr_info msk_local;
943 : :
944 [ + - - + ]: 4 : if (list_empty(&msk->conn_list) || mptcp_pm_is_userspace(msk))
945 : 0 : goto next;
946 : :
947 : 4 : mptcp_local_address((struct sock_common *)msk, &msk_local);
948 [ - + ]: 4 : if (!mptcp_addresses_equal(&msk_local, addr, addr->port))
949 : 0 : goto next;
950 : :
951 : 4 : lock_sock(sk);
952 : 4 : spin_lock_bh(&msk->pm.lock);
953 : 4 : mptcp_pm_remove_addr(msk, &list);
954 : 4 : mptcp_pm_rm_subflow(msk, &list);
955 : 4 : __mark_subflow_endp_available(msk, 0);
956 : 4 : spin_unlock_bh(&msk->pm.lock);
957 : 4 : release_sock(sk);
958 : :
959 : 4 : next:
960 : 4 : sock_put(sk);
961 : 4 : cond_resched();
962 : : }
963 : :
964 : 4 : return 0;
965 : : }
966 : :
967 : : /* Remove an MPTCP endpoint */
968 : 566 : int mptcp_pm_nl_del_addr_doit(struct sk_buff *skb, struct genl_info *info)
969 : : {
970 : 566 : struct pm_nl_pernet *pernet = genl_info_pm_nl(info);
971 : 566 : struct mptcp_pm_addr_entry addr, *entry;
972 : 566 : unsigned int addr_max;
973 : 566 : struct nlattr *attr;
974 : 566 : int ret;
975 : :
976 [ + - - - ]: 566 : if (GENL_REQ_ATTR_CHECK(info, MPTCP_PM_ENDPOINT_ADDR))
977 : 0 : return -EINVAL;
978 : :
979 : 566 : attr = info->attrs[MPTCP_PM_ENDPOINT_ADDR];
980 : 566 : ret = mptcp_pm_parse_entry(attr, info, false, &addr);
981 [ - + ]: 566 : if (ret < 0)
982 : : return ret;
983 : :
984 : : /* the zero id address is special: the first address used by the msk
985 : : * always gets such an id, so different subflows can have different zero
986 : : * id addresses. Additionally zero id is not accounted for in id_bitmap.
987 : : * Let's use an 'mptcp_rm_list' instead of the common remove code.
988 : : */
989 [ + + ]: 566 : if (addr.addr.id == 0)
990 : 4 : return mptcp_nl_remove_id_zero_address(sock_net(skb->sk), &addr.addr);
991 : :
992 : 562 : spin_lock_bh(&pernet->lock);
993 : 562 : entry = __lookup_addr_by_id(pernet, addr.addr.id);
994 [ - + ]: 562 : if (!entry) {
995 [ # # ]: 0 : NL_SET_ERR_MSG_ATTR(info->extack, attr, "address not found");
996 : 0 : spin_unlock_bh(&pernet->lock);
997 : 0 : return -EINVAL;
998 : : }
999 [ + + ]: 562 : if (entry->flags & MPTCP_PM_ADDR_FLAG_SIGNAL) {
1000 : 36 : addr_max = pernet->add_addr_signal_max;
1001 : 36 : WRITE_ONCE(pernet->add_addr_signal_max, addr_max - 1);
1002 : : }
1003 [ + + ]: 562 : if (entry->flags & MPTCP_PM_ADDR_FLAG_SUBFLOW) {
1004 : 34 : addr_max = pernet->local_addr_max;
1005 : 34 : WRITE_ONCE(pernet->local_addr_max, addr_max - 1);
1006 : : }
1007 : :
1008 : 562 : pernet->addrs--;
1009 [ - + ]: 562 : list_del_rcu(&entry->list);
1010 [ - + - - : 562 : __clear_bit(entry->addr.id, pernet->id_bitmap);
- - - - ]
1011 : 562 : spin_unlock_bh(&pernet->lock);
1012 : :
1013 : 562 : mptcp_nl_remove_subflow_and_signal_addr(sock_net(skb->sk), entry);
1014 : 562 : synchronize_rcu();
1015 : 562 : __mptcp_pm_release_addr_entry(entry);
1016 : :
1017 : 562 : return ret;
1018 : : }
1019 : :
1020 : 18 : static void mptcp_pm_flush_addrs_and_subflows(struct mptcp_sock *msk,
1021 : : struct list_head *rm_list)
1022 : : {
1023 : 18 : struct mptcp_rm_list alist = { .nr = 0 }, slist = { .nr = 0 };
1024 : 18 : struct mptcp_pm_addr_entry *entry;
1025 : :
1026 [ + + ]: 56 : list_for_each_entry(entry, rm_list, list) {
1027 [ + - + + ]: 76 : if (slist.nr < MPTCP_RM_IDS_MAX &&
1028 : 38 : mptcp_lookup_subflow_by_saddr(&msk->conn_list, &entry->addr))
1029 [ + - ]: 44 : slist.ids[slist.nr++] = mptcp_endp_get_local_id(msk, &entry->addr);
1030 : :
1031 [ + - + + ]: 76 : if (alist.nr < MPTCP_RM_IDS_MAX &&
1032 : 38 : mptcp_remove_anno_list_by_saddr(msk, &entry->addr))
1033 [ + - ]: 36 : alist.ids[alist.nr++] = mptcp_endp_get_local_id(msk, &entry->addr);
1034 : : }
1035 : :
1036 : 18 : spin_lock_bh(&msk->pm.lock);
1037 [ + + ]: 18 : if (alist.nr) {
1038 : 10 : msk->pm.add_addr_signaled -= alist.nr;
1039 : 10 : mptcp_pm_remove_addr(msk, &alist);
1040 : : }
1041 [ + + ]: 18 : if (slist.nr)
1042 : 12 : mptcp_pm_rm_subflow(msk, &slist);
1043 : : /* Reset counters: maybe some subflows have been removed before */
1044 : 18 : bitmap_fill(msk->pm.id_avail_bitmap, MPTCP_PM_MAX_ADDR_ID + 1);
1045 : 18 : msk->pm.local_addr_used = 0;
1046 : 18 : spin_unlock_bh(&msk->pm.lock);
1047 : 18 : }
1048 : :
1049 : 190 : static void mptcp_nl_flush_addrs_list(struct net *net,
1050 : : struct list_head *rm_list)
1051 : : {
1052 : 190 : long s_slot = 0, s_num = 0;
1053 : 190 : struct mptcp_sock *msk;
1054 : :
1055 [ + + ]: 190 : if (list_empty(rm_list))
1056 : 166 : return;
1057 : :
1058 [ + + ]: 42 : while ((msk = mptcp_token_iter_next(net, &s_slot, &s_num)) != NULL) {
1059 : 18 : struct sock *sk = (struct sock *)msk;
1060 : :
1061 [ + - ]: 18 : if (!mptcp_pm_is_userspace(msk)) {
1062 : 18 : lock_sock(sk);
1063 : 18 : mptcp_pm_flush_addrs_and_subflows(msk, rm_list);
1064 : 18 : release_sock(sk);
1065 : : }
1066 : :
1067 : 18 : sock_put(sk);
1068 : 18 : cond_resched();
1069 : : }
1070 : : }
1071 : :
1072 : : /* caller must ensure the RCU grace period is already elapsed */
1073 : 1173 : static void __flush_addrs(struct list_head *list)
1074 : : {
1075 [ + + ]: 1801 : while (!list_empty(list)) {
1076 : 628 : struct mptcp_pm_addr_entry *cur;
1077 : :
1078 : 628 : cur = list_entry(list->next,
1079 : : struct mptcp_pm_addr_entry, list);
1080 : 628 : list_del_rcu(&cur->list);
1081 : 628 : __mptcp_pm_release_addr_entry(cur);
1082 : : }
1083 : 1173 : }
1084 : :
1085 : 6 : static void __reset_counters(struct pm_nl_pernet *pernet)
1086 : : {
1087 : 190 : WRITE_ONCE(pernet->add_addr_signal_max, 0);
1088 : 190 : WRITE_ONCE(pernet->add_addr_accept_max, 0);
1089 : 190 : WRITE_ONCE(pernet->local_addr_max, 0);
1090 : 190 : pernet->addrs = 0;
1091 : : }
1092 : :
1093 : 190 : int mptcp_pm_nl_flush_addrs_doit(struct sk_buff *skb, struct genl_info *info)
1094 : : {
1095 : 190 : struct pm_nl_pernet *pernet = genl_info_pm_nl(info);
1096 : 190 : LIST_HEAD(free_list);
1097 : :
1098 : 190 : spin_lock_bh(&pernet->lock);
1099 [ + + ]: 190 : list_splice_init(&pernet->local_addr_list, &free_list);
1100 : 190 : __reset_counters(pernet);
1101 : 190 : pernet->next_id = 1;
1102 : 190 : bitmap_zero(pernet->id_bitmap, MPTCP_PM_MAX_ADDR_ID + 1);
1103 : 190 : spin_unlock_bh(&pernet->lock);
1104 : 190 : mptcp_nl_flush_addrs_list(sock_net(skb->sk), &free_list);
1105 : 190 : synchronize_rcu();
1106 : 190 : __flush_addrs(&free_list);
1107 : 190 : return 0;
1108 : : }
1109 : :
1110 : 22 : int mptcp_pm_nl_get_addr(u8 id, struct mptcp_pm_addr_entry *addr,
1111 : : struct genl_info *info)
1112 : : {
1113 : 22 : struct pm_nl_pernet *pernet = genl_info_pm_nl(info);
1114 : 22 : struct mptcp_pm_addr_entry *entry;
1115 : 22 : int ret = -EINVAL;
1116 : :
1117 : 22 : rcu_read_lock();
1118 : 22 : entry = __lookup_addr_by_id(pernet, id);
1119 [ + + ]: 22 : if (entry) {
1120 : 16 : *addr = *entry;
1121 : 16 : ret = 0;
1122 : : }
1123 : 22 : rcu_read_unlock();
1124 : :
1125 : 22 : return ret;
1126 : : }
1127 : :
1128 : 216 : int mptcp_pm_nl_dump_addr(struct sk_buff *msg,
1129 : : struct netlink_callback *cb)
1130 : : {
1131 : 216 : struct net *net = sock_net(msg->sk);
1132 : 216 : struct mptcp_pm_addr_entry *entry;
1133 : 216 : struct pm_nl_pernet *pernet;
1134 : 216 : int id = cb->args[0];
1135 : 216 : int i;
1136 : :
1137 : 216 : pernet = pm_nl_get_pernet(net);
1138 : :
1139 : 216 : rcu_read_lock();
1140 [ + + ]: 53958 : for (i = id; i < MPTCP_PM_MAX_ADDR_ID + 1; i++) {
1141 [ - + - - : 107268 : if (test_bit(i, pernet->id_bitmap)) {
- - - - +
+ + + ]
1142 : 274 : entry = __lookup_addr_by_id(pernet, i);
1143 [ + - ]: 274 : if (!entry)
1144 : : break;
1145 : :
1146 [ + + ]: 274 : if (entry->addr.id <= id)
1147 : 102 : continue;
1148 : :
1149 [ + - ]: 172 : if (mptcp_pm_genl_fill_addr(msg, cb, entry) < 0)
1150 : : break;
1151 : :
1152 : 172 : id = entry->addr.id;
1153 : : }
1154 : : }
1155 : 216 : rcu_read_unlock();
1156 : :
1157 : 216 : cb->args[0] = id;
1158 : 216 : return msg->len;
1159 : : }
1160 : :
1161 : 1186 : static int parse_limit(struct genl_info *info, int id, unsigned int *limit)
1162 : : {
1163 : 1186 : struct nlattr *attr = info->attrs[id];
1164 : :
1165 [ - + ]: 1186 : if (!attr)
1166 : : return 0;
1167 : :
1168 [ + + ]: 1186 : *limit = nla_get_u32(attr);
1169 [ + + ]: 1186 : if (*limit > MPTCP_PM_ADDR_MAX) {
1170 [ + - - + : 4 : NL_SET_ERR_MSG_ATTR_FMT(info->extack, attr,
- - ]
1171 : : "limit greater than maximum (%u)",
1172 : : MPTCP_PM_ADDR_MAX);
1173 : 4 : return -EINVAL;
1174 : : }
1175 : : return 0;
1176 : : }
1177 : :
1178 : 594 : int mptcp_pm_nl_set_limits_doit(struct sk_buff *skb, struct genl_info *info)
1179 : : {
1180 : 594 : struct pm_nl_pernet *pernet = genl_info_pm_nl(info);
1181 : 594 : unsigned int rcv_addrs, subflows;
1182 : 594 : int ret;
1183 : :
1184 : 594 : spin_lock_bh(&pernet->lock);
1185 : 594 : rcv_addrs = pernet->add_addr_accept_max;
1186 : 594 : ret = parse_limit(info, MPTCP_PM_ATTR_RCV_ADD_ADDRS, &rcv_addrs);
1187 [ + + ]: 594 : if (ret)
1188 : 2 : goto unlock;
1189 : :
1190 : 592 : subflows = pernet->subflows_max;
1191 : 592 : ret = parse_limit(info, MPTCP_PM_ATTR_SUBFLOWS, &subflows);
1192 [ + + ]: 592 : if (ret)
1193 : 2 : goto unlock;
1194 : :
1195 : 590 : WRITE_ONCE(pernet->add_addr_accept_max, rcv_addrs);
1196 : 590 : WRITE_ONCE(pernet->subflows_max, subflows);
1197 : :
1198 : 594 : unlock:
1199 : 594 : spin_unlock_bh(&pernet->lock);
1200 : 594 : return ret;
1201 : : }
1202 : :
1203 : 10 : int mptcp_pm_nl_get_limits_doit(struct sk_buff *skb, struct genl_info *info)
1204 : : {
1205 : 10 : struct pm_nl_pernet *pernet = genl_info_pm_nl(info);
1206 : 10 : struct sk_buff *msg;
1207 : 10 : void *reply;
1208 : :
1209 : 10 : msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1210 [ + - ]: 10 : if (!msg)
1211 : : return -ENOMEM;
1212 : :
1213 : 10 : reply = genlmsg_put_reply(msg, info, &mptcp_genl_family, 0,
1214 : : MPTCP_PM_CMD_GET_LIMITS);
1215 [ - + ]: 10 : if (!reply)
1216 : 0 : goto fail;
1217 : :
1218 [ - + ]: 10 : if (nla_put_u32(msg, MPTCP_PM_ATTR_RCV_ADD_ADDRS,
1219 : 10 : READ_ONCE(pernet->add_addr_accept_max)))
1220 : 0 : goto fail;
1221 : :
1222 [ - + ]: 10 : if (nla_put_u32(msg, MPTCP_PM_ATTR_SUBFLOWS,
1223 : 10 : READ_ONCE(pernet->subflows_max)))
1224 : 0 : goto fail;
1225 : :
1226 : 10 : genlmsg_end(msg, reply);
1227 : 10 : return genlmsg_reply(msg, info);
1228 : :
1229 : 0 : fail:
1230 [ # # ]: 0 : GENL_SET_ERR_MSG(info, "not enough space in Netlink message");
1231 : 0 : nlmsg_free(msg);
1232 : 0 : return -EMSGSIZE;
1233 : : }
1234 : :
1235 : 14 : static void mptcp_pm_nl_fullmesh(struct mptcp_sock *msk,
1236 : : struct mptcp_addr_info *addr)
1237 : : {
1238 : 14 : struct mptcp_rm_list list = { .nr = 0 };
1239 : :
1240 [ + - ]: 14 : list.ids[list.nr++] = mptcp_endp_get_local_id(msk, addr);
1241 : :
1242 : 14 : spin_lock_bh(&msk->pm.lock);
1243 : 14 : mptcp_pm_rm_subflow(msk, &list);
1244 : 14 : __mark_subflow_endp_available(msk, list.ids[0]);
1245 : 14 : mptcp_pm_create_subflow_or_signal_addr(msk);
1246 : 14 : spin_unlock_bh(&msk->pm.lock);
1247 : 14 : }
1248 : :
1249 : 46 : static void mptcp_pm_nl_set_flags_all(struct net *net,
1250 : : struct mptcp_pm_addr_entry *local,
1251 : : u8 changed)
1252 : : {
1253 : 46 : u8 is_subflow = !!(local->flags & MPTCP_PM_ADDR_FLAG_SUBFLOW);
1254 : 46 : u8 bkup = !!(local->flags & MPTCP_PM_ADDR_FLAG_BACKUP);
1255 : 46 : long s_slot = 0, s_num = 0;
1256 : 46 : struct mptcp_sock *msk;
1257 : :
1258 [ - + ]: 46 : if (changed == MPTCP_PM_ADDR_FLAG_FULLMESH && !is_subflow)
1259 : 0 : return;
1260 : :
1261 [ + + ]: 82 : while ((msk = mptcp_token_iter_next(net, &s_slot, &s_num)) != NULL) {
1262 : 36 : struct sock *sk = (struct sock *)msk;
1263 : :
1264 [ + - - + ]: 36 : if (list_empty(&msk->conn_list) || mptcp_pm_is_userspace(msk))
1265 : 0 : goto next;
1266 : :
1267 : 36 : lock_sock(sk);
1268 [ + + ]: 36 : if (changed & MPTCP_PM_ADDR_FLAG_BACKUP)
1269 : 24 : mptcp_pm_mp_prio_send_ack(msk, &local->addr, NULL, bkup);
1270 : : /* Subflows will only be recreated if the SUBFLOW flag is set */
1271 [ + + + + ]: 36 : if (is_subflow && (changed & MPTCP_PM_ADDR_FLAG_FULLMESH))
1272 : 14 : mptcp_pm_nl_fullmesh(msk, &local->addr);
1273 : 36 : release_sock(sk);
1274 : :
1275 : 36 : next:
1276 : 36 : sock_put(sk);
1277 : 36 : cond_resched();
1278 : : }
1279 : : }
1280 : :
1281 : 46 : int mptcp_pm_nl_set_flags(struct mptcp_pm_addr_entry *local,
1282 : : struct genl_info *info)
1283 : : {
1284 : 46 : struct nlattr *attr = info->attrs[MPTCP_PM_ATTR_ADDR];
1285 : 46 : u8 changed, mask = MPTCP_PM_ADDR_FLAG_BACKUP |
1286 : : MPTCP_PM_ADDR_FLAG_FULLMESH;
1287 : 46 : struct net *net = genl_info_net(info);
1288 : 46 : struct mptcp_pm_addr_entry *entry;
1289 : 46 : struct pm_nl_pernet *pernet;
1290 : 46 : u8 lookup_by_id = 0;
1291 : :
1292 : 46 : pernet = pm_nl_get_pernet(net);
1293 : :
1294 [ + + ]: 46 : if (local->addr.family == AF_UNSPEC) {
1295 : 42 : lookup_by_id = 1;
1296 [ - + ]: 42 : if (!local->addr.id) {
1297 [ # # ]: 0 : NL_SET_ERR_MSG_ATTR(info->extack, attr,
1298 : : "missing address ID");
1299 : 0 : return -EOPNOTSUPP;
1300 : : }
1301 : : }
1302 : :
1303 : 46 : spin_lock_bh(&pernet->lock);
1304 [ + + ]: 46 : entry = lookup_by_id ? __lookup_addr_by_id(pernet, local->addr.id) :
1305 : 4 : __lookup_addr(pernet, &local->addr);
1306 [ - + ]: 46 : if (!entry) {
1307 : 0 : spin_unlock_bh(&pernet->lock);
1308 [ # # ]: 0 : NL_SET_ERR_MSG_ATTR(info->extack, attr, "address not found");
1309 : 0 : return -EINVAL;
1310 : : }
1311 [ + + ]: 46 : if ((local->flags & MPTCP_PM_ADDR_FLAG_FULLMESH) &&
1312 [ - + ]: 12 : (entry->flags & (MPTCP_PM_ADDR_FLAG_SIGNAL |
1313 : : MPTCP_PM_ADDR_FLAG_IMPLICIT))) {
1314 : 0 : spin_unlock_bh(&pernet->lock);
1315 [ # # ]: 0 : NL_SET_ERR_MSG_ATTR(info->extack, attr, "invalid addr flags");
1316 : 0 : return -EINVAL;
1317 : : }
1318 : :
1319 : 46 : changed = (local->flags ^ entry->flags) & mask;
1320 : 46 : entry->flags = (entry->flags & ~mask) | (local->flags & mask);
1321 : 46 : *local = *entry;
1322 : 46 : spin_unlock_bh(&pernet->lock);
1323 : :
1324 : 46 : mptcp_pm_nl_set_flags_all(net, local, changed);
1325 : 46 : return 0;
1326 : : }
1327 : :
1328 : 947 : bool mptcp_pm_nl_check_work_pending(struct mptcp_sock *msk)
1329 : : {
1330 : 947 : struct pm_nl_pernet *pernet = pm_nl_get_pernet_from_msk(msk);
1331 : :
1332 [ + + + + ]: 1675 : if (msk->pm.subflows == mptcp_pm_get_subflows_max(msk) ||
1333 [ + - ]: 758 : (find_next_and_bit(pernet->id_bitmap, msk->pm.id_avail_bitmap,
1334 : : MPTCP_PM_MAX_ADDR_ID + 1, 0) == MPTCP_PM_MAX_ADDR_ID + 1)) {
1335 : 706 : WRITE_ONCE(msk->pm.work_pending, false);
1336 : 706 : return false;
1337 : : }
1338 : : return true;
1339 : : }
1340 : :
1341 : : /* Called under PM lock */
1342 : 880 : void __mptcp_pm_kernel_worker(struct mptcp_sock *msk)
1343 : : {
1344 : 880 : struct mptcp_pm_data *pm = &msk->pm;
1345 : :
1346 [ + + ]: 880 : if (pm->status & BIT(MPTCP_PM_ADD_ADDR_RECEIVED)) {
1347 : 295 : pm->status &= ~BIT(MPTCP_PM_ADD_ADDR_RECEIVED);
1348 : 295 : mptcp_pm_nl_add_addr_received(msk);
1349 : : }
1350 [ + + ]: 880 : if (pm->status & BIT(MPTCP_PM_ESTABLISHED)) {
1351 : 352 : pm->status &= ~BIT(MPTCP_PM_ESTABLISHED);
1352 : 352 : mptcp_pm_nl_fully_established(msk);
1353 : : }
1354 [ + + ]: 880 : if (pm->status & BIT(MPTCP_PM_SUBFLOW_ESTABLISHED)) {
1355 : 235 : pm->status &= ~BIT(MPTCP_PM_SUBFLOW_ESTABLISHED);
1356 : 235 : mptcp_pm_nl_subflow_established(msk);
1357 : : }
1358 : 880 : }
1359 : :
1360 : 1064 : static int __net_init pm_nl_init_net(struct net *net)
1361 : : {
1362 : 1064 : struct pm_nl_pernet *pernet = pm_nl_get_pernet(net);
1363 : :
1364 : 1064 : INIT_LIST_HEAD_RCU(&pernet->local_addr_list);
1365 : :
1366 : : /* Cit. 2 subflows ought to be enough for anybody. */
1367 : 1064 : pernet->subflows_max = 2;
1368 : 1064 : pernet->next_id = 1;
1369 : 1064 : pernet->stale_loss_cnt = 4;
1370 : 1064 : spin_lock_init(&pernet->lock);
1371 : :
1372 : : /* No need to initialize other pernet fields, the struct is zeroed at
1373 : : * allocation time.
1374 : : */
1375 : :
1376 : 1064 : return 0;
1377 : : }
1378 : :
1379 : 894 : static void __net_exit pm_nl_exit_net(struct list_head *net_list)
1380 : : {
1381 : 894 : struct net *net;
1382 : :
1383 [ + + ]: 1877 : list_for_each_entry(net, net_list, exit_list) {
1384 : 983 : struct pm_nl_pernet *pernet = pm_nl_get_pernet(net);
1385 : :
1386 : : /* net is removed from namespace list, can't race with
1387 : : * other modifiers, also netns core already waited for a
1388 : : * RCU grace period.
1389 : : */
1390 : 983 : __flush_addrs(&pernet->local_addr_list);
1391 : : }
1392 : 894 : }
1393 : :
1394 : : static struct pernet_operations mptcp_pm_pernet_ops = {
1395 : : .init = pm_nl_init_net,
1396 : : .exit_batch = pm_nl_exit_net,
1397 : : .id = &pm_nl_pernet_id,
1398 : : .size = sizeof(struct pm_nl_pernet),
1399 : : };
1400 : :
1401 : : struct mptcp_pm_ops mptcp_pm_kernel = {
1402 : : .name = "kernel",
1403 : : .owner = THIS_MODULE,
1404 : : };
1405 : :
1406 : 4 : void __init mptcp_pm_kernel_register(void)
1407 : : {
1408 [ - + ]: 4 : if (register_pernet_subsys(&mptcp_pm_pernet_ops) < 0)
1409 : 0 : panic("Failed to register MPTCP PM pernet subsystem.\n");
1410 : :
1411 : 4 : mptcp_pm_register(&mptcp_pm_kernel);
1412 : 4 : }
|
