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 : 16136 : static struct pm_nl_pernet *pm_nl_get_pernet(const struct net *net)
34 : : {
35 : 30038 : return net_generic(net, pm_nl_pernet_id);
36 : : }
37 : :
38 : : static struct pm_nl_pernet *
39 : 13288 : pm_nl_get_pernet_from_msk(const struct mptcp_sock *msk)
40 : : {
41 : 13288 : return pm_nl_get_pernet(sock_net((struct sock *)msk));
42 : : }
43 : :
44 : 1278 : static struct pm_nl_pernet *genl_info_pm_nl(struct genl_info *info)
45 : : {
46 : 2496 : return pm_nl_get_pernet(genl_info_net(info));
47 : : }
48 : :
49 : 1190 : unsigned int mptcp_pm_get_add_addr_signal_max(const struct mptcp_sock *msk)
50 : : {
51 : 4398 : const struct pm_nl_pernet *pernet = pm_nl_get_pernet_from_msk(msk);
52 : :
53 : 5189 : return READ_ONCE(pernet->add_addr_signal_max);
54 : : }
55 : : EXPORT_SYMBOL_GPL(mptcp_pm_get_add_addr_signal_max);
56 : :
57 : 964 : 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 : 1705 : unsigned int mptcp_pm_get_subflows_max(const struct mptcp_sock *msk)
66 : : {
67 : 1705 : struct pm_nl_pernet *pernet = pm_nl_get_pernet_from_msk(msk);
68 : :
69 : 7585 : return READ_ONCE(pernet->subflows_max);
70 : : }
71 : : EXPORT_SYMBOL_GPL(mptcp_pm_get_subflows_max);
72 : :
73 : 1334 : unsigned int mptcp_pm_get_local_addr_max(const struct mptcp_sock *msk)
74 : : {
75 : 992 : struct pm_nl_pernet *pernet = pm_nl_get_pernet_from_msk(msk);
76 : :
77 : 5491 : return READ_ONCE(pernet->local_addr_max);
78 : : }
79 : : EXPORT_SYMBOL_GPL(mptcp_pm_get_local_addr_max);
80 : :
81 : 296 : static bool lookup_subflow_by_daddr(const struct list_head *list,
82 : : const struct mptcp_addr_info *daddr)
83 : : {
84 : 296 : struct mptcp_subflow_context *subflow;
85 : 296 : struct mptcp_addr_info cur;
86 : :
87 [ + + ]: 787 : list_for_each_entry(subflow, list, node) {
88 : 509 : struct sock *ssk = mptcp_subflow_tcp_sock(subflow);
89 : :
90 [ + + + + ]: 509 : if (!((1 << inet_sk_state_load(ssk)) &
91 : : (TCPF_ESTABLISHED | TCPF_SYN_SENT | TCPF_SYN_RECV)))
92 : 4 : continue;
93 : :
94 : 505 : mptcp_remote_address((struct sock_common *)ssk, &cur);
95 [ + + ]: 505 : if (mptcp_addresses_equal(&cur, daddr, daddr->port))
96 : : return true;
97 : : }
98 : :
99 : : return false;
100 : : }
101 : :
102 : : static bool
103 : 370 : select_local_address(const struct pm_nl_pernet *pernet,
104 : : const struct mptcp_sock *msk,
105 : : struct mptcp_pm_local *new_local)
106 : : {
107 : 370 : struct mptcp_pm_addr_entry *entry;
108 : 370 : bool found = false;
109 : :
110 : 370 : msk_owned_by_me(msk);
111 : :
112 : 370 : rcu_read_lock();
113 [ + + - + : 542 : list_for_each_entry_rcu(entry, &pernet->local_addr_list, list) {
- - - - -
- + + ]
114 [ + + ]: 514 : if (!(entry->flags & MPTCP_PM_ADDR_FLAG_SUBFLOW))
115 : 16 : continue;
116 : :
117 [ - + - - : 996 : if (!test_bit(entry->addr.id, msk->pm.id_avail_bitmap))
- - - - +
+ + + ]
118 : 156 : continue;
119 : :
120 : 342 : new_local->addr = entry->addr;
121 : 342 : new_local->flags = entry->flags;
122 : 342 : new_local->ifindex = entry->ifindex;
123 : 342 : found = true;
124 : 342 : break;
125 : : }
126 : 370 : rcu_read_unlock();
127 : :
128 : 370 : 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 : 350 : 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 [ - + ]: 350 : bool deny_id0 = READ_ONCE(msk->pm.remote_deny_join_id0);
171 : 350 : struct sock *sk = (struct sock *)msk, *ssk;
172 : 350 : struct mptcp_subflow_context *subflow;
173 : 350 : struct mptcp_addr_info remote = { 0 };
174 : 350 : unsigned int subflows_max;
175 : 350 : int i = 0;
176 : :
177 : 350 : subflows_max = mptcp_pm_get_subflows_max(msk);
178 : 350 : 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 [ + + ]: 350 : if (!fullmesh) {
184 [ + + ]: 320 : if (deny_id0)
185 : : return 0;
186 : :
187 [ + + ]: 316 : if (!mptcp_pm_addr_families_match(sk, local, &remote))
188 : : return 0;
189 : :
190 : 310 : msk->pm.subflows++;
191 : 310 : 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 : 340 : 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 : 1602 : __lookup_addr(struct pm_nl_pernet *pernet, const struct mptcp_addr_info *info)
245 : : {
246 : 1602 : struct mptcp_pm_addr_entry *entry;
247 : :
248 [ + + + + : 3143 : list_for_each_entry_rcu(entry, &pernet->local_addr_list, list,
- + - - -
- - - +
+ ]
249 : : lockdep_is_held(&pernet->lock)) {
250 [ + + ]: 2175 : if (mptcp_addresses_equal(&entry->addr, info, entry->addr.port))
251 : : return entry;
252 : : }
253 : : return NULL;
254 : : }
255 : :
256 : 791 : static void mptcp_pm_create_subflow_or_signal_addr(struct mptcp_sock *msk)
257 : : {
258 : 791 : struct sock *sk = (struct sock *)msk;
259 : 791 : unsigned int add_addr_signal_max;
260 : 791 : bool signal_and_subflow = false;
261 : 791 : unsigned int local_addr_max;
262 : 791 : struct pm_nl_pernet *pernet;
263 : 791 : struct mptcp_pm_local local;
264 : 791 : unsigned int subflows_max;
265 : :
266 : 791 : pernet = pm_nl_get_pernet(sock_net(sk));
267 : :
268 : 791 : add_addr_signal_max = mptcp_pm_get_add_addr_signal_max(msk);
269 : 791 : local_addr_max = mptcp_pm_get_local_addr_max(msk);
270 : 791 : subflows_max = mptcp_pm_get_subflows_max(msk);
271 : :
272 : : /* do lazy endpoint usage accounting for the MPC subflows */
273 [ + + + - ]: 791 : if (unlikely(!(msk->pm.status & BIT(MPTCP_PM_MPC_ENDPOINT_ACCOUNTED))) && msk->first) {
274 : 480 : struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(msk->first);
275 : 480 : struct mptcp_pm_addr_entry *entry;
276 : 480 : struct mptcp_addr_info mpc_addr;
277 : 480 : bool backup = false;
278 : :
279 : 480 : mptcp_local_address((struct sock_common *)msk->first, &mpc_addr);
280 : 480 : rcu_read_lock();
281 : 480 : entry = __lookup_addr(pernet, &mpc_addr);
282 [ + + ]: 480 : 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 [ + + ]: 480 : if (backup)
290 : 6 : mptcp_pm_send_ack(msk, subflow, true, backup);
291 : :
292 : 480 : msk->pm.status |= BIT(MPTCP_PM_MPC_ENDPOINT_ACCOUNTED);
293 : : }
294 : :
295 [ - + ]: 791 : 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 [ + + ]: 791 : 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 : 150 : signal_and_subflow = true;
333 : : }
334 : :
335 : 783 : subflow:
336 : : /* check if should create a new subflow */
337 [ + + ]: 1141 : while (msk->pm.local_addr_used < local_addr_max &&
338 [ + + ]: 390 : msk->pm.subflows < subflows_max) {
339 : 378 : struct mptcp_addr_info addrs[MPTCP_PM_ADDR_MAX];
340 : 378 : bool fullmesh;
341 : 378 : int i, nr;
342 : :
343 [ + + ]: 378 : if (signal_and_subflow)
344 : : signal_and_subflow = false;
345 [ + + ]: 370 : else if (!select_local_address(pernet, msk, &local))
346 : : break;
347 : :
348 : 350 : fullmesh = !!(local.flags & MPTCP_PM_ADDR_FLAG_FULLMESH);
349 : :
350 [ - + - - : 350 : __clear_bit(local.addr.id, msk->pm.id_avail_bitmap);
- - - - ]
351 : :
352 : : /* Special case for ID0: set the correct ID */
353 [ + + ]: 350 : 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 : 344 : msk->pm.local_addr_used++;
357 : :
358 : 350 : nr = fill_remote_addresses_vec(msk, &local.addr, fullmesh, addrs);
359 [ + + ]: 350 : if (nr == 0)
360 : 10 : continue;
361 : :
362 : 340 : spin_unlock_bh(&msk->pm.lock);
363 [ + + ]: 1034 : for (i = 0; i < nr; i++)
364 : 354 : __mptcp_subflow_connect(sk, &local, &addrs[i]);
365 : 340 : spin_lock_bh(&msk->pm.lock);
366 : : }
367 : 791 : mptcp_pm_nl_check_work_pending(msk);
368 : : }
369 : :
370 : 102 : static void mptcp_pm_nl_fully_established(struct mptcp_sock *msk)
371 : : {
372 : 436 : mptcp_pm_create_subflow_or_signal_addr(msk);
373 : 436 : }
374 : :
375 : 48 : static void mptcp_pm_nl_subflow_established(struct mptcp_sock *msk)
376 : : {
377 : 277 : mptcp_pm_create_subflow_or_signal_addr(msk);
378 : 277 : }
379 : :
380 : : /* Fill all the local addresses into the array addrs[],
381 : : * and return the array size.
382 : : */
383 : 278 : 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 : 278 : struct sock *sk = (struct sock *)msk;
388 : 278 : struct mptcp_pm_addr_entry *entry;
389 : 278 : struct mptcp_addr_info mpc_addr;
390 : 278 : struct pm_nl_pernet *pernet;
391 : 278 : unsigned int subflows_max;
392 : 278 : int i = 0;
393 : :
394 : 278 : pernet = pm_nl_get_pernet_from_msk(msk);
395 : 278 : subflows_max = mptcp_pm_get_subflows_max(msk);
396 : :
397 : 278 : mptcp_local_address((struct sock_common *)msk, &mpc_addr);
398 : :
399 : 278 : rcu_read_lock();
400 [ + + - + : 792 : list_for_each_entry_rcu(entry, &pernet->local_addr_list, list) {
- - - - -
- + + ]
401 [ + + ]: 514 : if (!(entry->flags & MPTCP_PM_ADDR_FLAG_FULLMESH))
402 : 506 : 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 : 278 : rcu_read_unlock();
421 : :
422 : : /* If the array is empty, fill in the single
423 : : * 'IPADDRANY' local address
424 : : */
425 [ + + ]: 278 : if (!i) {
426 : 274 : memset(&locals[i], 0, sizeof(locals[i]));
427 : 548 : locals[i].addr.family =
428 : : #if IS_ENABLED(CONFIG_MPTCP_IPV6)
429 [ + + + + ]: 274 : remote->family == AF_INET6 &&
430 [ # # ]: 0 : ipv6_addr_v4mapped(&remote->addr6) ? AF_INET :
431 : : #endif
432 : : remote->family;
433 : :
434 [ + + ]: 274 : if (!mptcp_pm_addr_families_match(sk, &locals[i].addr, remote))
435 : : return 0;
436 : :
437 : 252 : msk->pm.subflows++;
438 : 252 : i++;
439 : : }
440 : :
441 : 256 : return i;
442 : : }
443 : :
444 : 296 : static void mptcp_pm_nl_add_addr_received(struct mptcp_sock *msk)
445 : : {
446 : 296 : struct mptcp_pm_local locals[MPTCP_PM_ADDR_MAX];
447 : 296 : struct sock *sk = (struct sock *)msk;
448 : 296 : unsigned int add_addr_accept_max;
449 : 296 : struct mptcp_addr_info remote;
450 : 296 : unsigned int subflows_max;
451 : 296 : bool sf_created = false;
452 : 296 : int i, nr;
453 : :
454 : 296 : add_addr_accept_max = mptcp_pm_get_add_addr_accept_max(msk);
455 : 296 : subflows_max = mptcp_pm_get_subflows_max(msk);
456 : :
457 [ - + ]: 296 : 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 : 296 : remote = msk->pm.remote;
462 : 296 : mptcp_pm_announce_addr(msk, &remote, true);
463 : 296 : mptcp_pm_addr_send_ack(msk);
464 : :
465 [ + + ]: 296 : 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 [ + + ]: 278 : if (!remote.port)
470 : 246 : 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 : 278 : nr = fill_local_addresses_vec(msk, &remote, locals);
476 [ + + ]: 278 : if (nr == 0)
477 : : return;
478 : :
479 : 256 : spin_unlock_bh(&msk->pm.lock);
480 [ + + ]: 770 : for (i = 0; i < nr; i++)
481 [ + + ]: 258 : if (__mptcp_subflow_connect(sk, &locals[i], &remote) == 0)
482 : 232 : sf_created = true;
483 : 256 : spin_lock_bh(&msk->pm.lock);
484 : :
485 [ + + ]: 256 : if (sf_created) {
486 : : /* add_addr_accepted is not decr for ID 0 */
487 [ + + ]: 230 : if (remote.id)
488 : 226 : msk->pm.add_addr_accepted++;
489 [ + + ]: 230 : if (msk->pm.add_addr_accepted >= add_addr_accept_max ||
490 [ - + ]: 110 : msk->pm.subflows >= subflows_max)
491 : 256 : 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 : 1250 : static void __mptcp_pm_release_addr_entry(struct mptcp_pm_addr_entry *entry)
515 : : {
516 [ + + ]: 1250 : if (entry->lsk)
517 : 6 : sock_release(entry->lsk);
518 : 1250 : kfree(entry);
519 : 1250 : }
520 : :
521 : 1266 : 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 : 1266 : struct mptcp_pm_addr_entry *cur, *del_entry = NULL;
526 : 1266 : unsigned int addr_max;
527 : 1266 : int ret = -EINVAL;
528 : :
529 : 1266 : 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 [ + + ]: 1266 : if (pernet->next_id == MPTCP_PM_MAX_ADDR_ID)
534 : 4 : pernet->next_id = 1;
535 [ - + ]: 1266 : if (pernet->addrs >= MPTCP_PM_ADDR_MAX) {
536 : 0 : ret = -ERANGE;
537 : 0 : goto out;
538 : : }
539 [ - + - - : 2532 : 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 [ + + ]: 1266 : if (!address_use_port(entry))
548 : 956 : entry->addr.port = 0;
549 [ + + ]: 5280 : list_for_each_entry(cur, &pernet->local_addr_list, list) {
550 [ + + ]: 4020 : if (mptcp_addresses_equal(&cur->addr, &entry->addr,
551 [ + + - + ]: 4020 : 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 [ + + + - ]: 1262 : if (!entry->addr.id && needs_id) {
583 : 692 : find_next:
584 : 1388 : entry->addr.id = find_next_zero_bit(pernet->id_bitmap,
585 : : MPTCP_PM_MAX_ADDR_ID + 1,
586 : 694 : pernet->next_id);
587 [ + + + - ]: 694 : if (!entry->addr.id && pernet->next_id != 1) {
588 : 2 : pernet->next_id = 1;
589 : 2 : goto find_next;
590 : : }
591 : : }
592 : :
593 [ - + - - ]: 1262 : if (!entry->addr.id && needs_id)
594 : 0 : goto out;
595 : :
596 [ - + - - : 1262 : __set_bit(entry->addr.id, pernet->id_bitmap);
- - - - ]
597 [ + + ]: 1262 : if (entry->addr.id > pernet->next_id)
598 : 776 : pernet->next_id = entry->addr.id;
599 : :
600 [ + + ]: 1262 : 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 [ + + ]: 1262 : if (entry->flags & MPTCP_PM_ADDR_FLAG_SUBFLOW) {
605 : 286 : addr_max = pernet->local_addr_max;
606 : 286 : WRITE_ONCE(pernet->local_addr_max, addr_max + 1);
607 : : }
608 : :
609 : 1262 : pernet->addrs++;
610 [ + + ]: 1262 : if (!entry->addr.port)
611 : 1240 : list_add_tail_rcu(&entry->list, &pernet->local_addr_list);
612 : : else
613 : 22 : list_add_rcu(&entry->list, &pernet->local_addr_list);
614 : 1262 : ret = entry->addr.id;
615 : :
616 : 1266 : out:
617 : 1266 : spin_unlock_bh(&pernet->lock);
618 : :
619 : : /* just replaced an existing entry, free it */
620 [ + + ]: 1266 : if (del_entry) {
621 : 2 : synchronize_rcu();
622 : 2 : __mptcp_pm_release_addr_entry(del_entry);
623 : : }
624 : 1266 : 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 : 364 : static int mptcp_pm_kernel_get_local_id(struct mptcp_sock *msk,
697 : : struct mptcp_pm_addr_entry *skc)
698 : : {
699 : 364 : struct mptcp_pm_addr_entry *entry;
700 : 364 : struct pm_nl_pernet *pernet;
701 : 364 : int ret;
702 : :
703 : 364 : pernet = pm_nl_get_pernet_from_msk(msk);
704 : :
705 : 364 : rcu_read_lock();
706 : 364 : entry = __lookup_addr(pernet, &skc->addr);
707 [ + + ]: 364 : ret = entry ? entry->addr.id : -1;
708 : 252 : rcu_read_unlock();
709 : 364 : if (ret >= 0)
710 : 224 : 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 : 754 : static bool mptcp_pm_kernel_get_priority(struct mptcp_sock *msk,
726 : : struct mptcp_addr_info *skc)
727 : : {
728 : 754 : struct pm_nl_pernet *pernet = pm_nl_get_pernet_from_msk(msk);
729 : 754 : struct mptcp_pm_addr_entry *entry;
730 : 754 : bool backup;
731 : :
732 : 754 : rcu_read_lock();
733 : 754 : entry = __lookup_addr(pernet, skc);
734 [ + + + + ]: 754 : backup = entry && !!(entry->flags & MPTCP_PM_ADDR_FLAG_BACKUP);
735 : 754 : rcu_read_unlock();
736 : :
737 : 754 : return backup;
738 : : }
739 : :
740 : 1122 : static int mptcp_nl_add_subflow_or_signal_addr(struct net *net,
741 : : struct mptcp_addr_info *addr)
742 : : {
743 : 1122 : struct mptcp_sock *msk;
744 : 1122 : long s_slot = 0, s_num = 0;
745 : :
746 [ + + ]: 1186 : while ((msk = mptcp_token_iter_next(net, &s_slot, &s_num)) != NULL) {
747 : 64 : struct sock *sk = (struct sock *)msk;
748 : 64 : struct mptcp_addr_info mpc_addr;
749 : :
750 [ + + + + : 64 : if (!READ_ONCE(msk->fully_established) ||
- + ]
751 [ # # ]: 0 : mptcp_pm_is_userspace(msk))
752 : 0 : goto next;
753 : :
754 : : /* if the endp linked to the init sf is re-added with a != ID */
755 : 64 : mptcp_local_address((struct sock_common *)msk, &mpc_addr);
756 : :
757 : 64 : lock_sock(sk);
758 : 64 : spin_lock_bh(&msk->pm.lock);
759 [ + + ]: 64 : if (mptcp_addresses_equal(addr, &mpc_addr, addr->port))
760 : 10 : msk->mpc_endpoint_id = addr->id;
761 : 64 : mptcp_pm_create_subflow_or_signal_addr(msk);
762 : 64 : spin_unlock_bh(&msk->pm.lock);
763 : 64 : release_sock(sk);
764 : :
765 : 64 : next:
766 : 64 : sock_put(sk);
767 : 64 : cond_resched();
768 : : }
769 : :
770 : 1122 : return 0;
771 : : }
772 : :
773 : 1126 : static bool mptcp_pm_has_addr_attr_id(const struct nlattr *attr,
774 : : struct genl_info *info)
775 : : {
776 : 1126 : struct nlattr *tb[MPTCP_PM_ADDR_ATTR_MAX + 1];
777 : :
778 [ + - ]: 1126 : if (!nla_parse_nested_deprecated(tb, MPTCP_PM_ADDR_ATTR_MAX, attr,
779 : 1126 : mptcp_pm_address_nl_policy, info->extack) &&
780 [ + + ]: 1126 : tb[MPTCP_PM_ADDR_ATTR_ID])
781 : 570 : return true;
782 : : return false;
783 : : }
784 : :
785 : : /* Add an MPTCP endpoint */
786 : 1126 : int mptcp_pm_nl_add_addr_doit(struct sk_buff *skb, struct genl_info *info)
787 : : {
788 : 1126 : struct pm_nl_pernet *pernet = genl_info_pm_nl(info);
789 : 1126 : struct mptcp_pm_addr_entry addr, *entry;
790 : 1126 : struct nlattr *attr;
791 : 1126 : int ret;
792 : :
793 [ + - - - ]: 1126 : if (GENL_REQ_ATTR_CHECK(info, MPTCP_PM_ENDPOINT_ADDR))
794 : 0 : return -EINVAL;
795 : :
796 : 1126 : attr = info->attrs[MPTCP_PM_ENDPOINT_ADDR];
797 : 1126 : ret = mptcp_pm_parse_entry(attr, info, true, &addr);
798 [ + - ]: 1126 : if (ret < 0)
799 : : return ret;
800 : :
801 [ + + - + ]: 1126 : if (addr.addr.port && !address_use_port(&addr)) {
802 [ # # ]: 0 : NL_SET_ERR_MSG_ATTR(info->extack, attr,
803 : : "flags must have signal and not subflow when using port");
804 : 0 : return -EINVAL;
805 : : }
806 : :
807 [ - + ]: 1126 : if (addr.flags & MPTCP_PM_ADDR_FLAG_SIGNAL &&
808 : : addr.flags & MPTCP_PM_ADDR_FLAG_FULLMESH) {
809 [ # # ]: 0 : NL_SET_ERR_MSG_ATTR(info->extack, attr,
810 : : "flags mustn't have both signal and fullmesh");
811 : 0 : return -EINVAL;
812 : : }
813 : :
814 [ - + ]: 1126 : if (addr.flags & MPTCP_PM_ADDR_FLAG_IMPLICIT) {
815 [ # # ]: 0 : NL_SET_ERR_MSG_ATTR(info->extack, attr,
816 : : "can't create IMPLICIT endpoint");
817 : 0 : return -EINVAL;
818 : : }
819 : :
820 : 1126 : entry = kmemdup(&addr, sizeof(addr), GFP_KERNEL_ACCOUNT);
821 [ - + ]: 1126 : if (!entry) {
822 [ # # ]: 0 : GENL_SET_ERR_MSG(info, "can't allocate addr");
823 : 0 : return -ENOMEM;
824 : : }
825 : :
826 [ + + ]: 1126 : if (entry->addr.port) {
827 : 22 : ret = mptcp_pm_nl_create_listen_socket(skb->sk, entry);
828 [ - + ]: 22 : if (ret) {
829 [ # # # # : 0 : GENL_SET_ERR_MSG_FMT(info, "create listen socket error: %d", ret);
# # ]
830 : 0 : goto out_free;
831 : : }
832 : : }
833 : 2318 : ret = mptcp_pm_nl_append_new_local_addr(pernet, entry,
834 : 1126 : !mptcp_pm_has_addr_attr_id(attr, info),
835 : 1126 : true);
836 [ + + ]: 1126 : if (ret < 0) {
837 [ + - - + : 4 : GENL_SET_ERR_MSG_FMT(info, "too many addresses or duplicate one: %d", ret);
- - ]
838 : 4 : goto out_free;
839 : : }
840 : :
841 : 1122 : mptcp_nl_add_subflow_or_signal_addr(sock_net(skb->sk), &entry->addr);
842 : 1122 : return 0;
843 : :
844 : 4 : out_free:
845 : 4 : __mptcp_pm_release_addr_entry(entry);
846 : 4 : return ret;
847 : : }
848 : :
849 : 0 : static u8 mptcp_endp_get_local_id(struct mptcp_sock *msk,
850 : : const struct mptcp_addr_info *addr)
851 : : {
852 [ + - + - ]: 111 : return msk->mpc_endpoint_id == addr->id ? 0 : addr->id;
853 : : }
854 : :
855 : 64 : static bool mptcp_pm_remove_anno_addr(struct mptcp_sock *msk,
856 : : const struct mptcp_addr_info *addr,
857 : : bool force)
858 : : {
859 : 64 : struct mptcp_rm_list list = { .nr = 0 };
860 : 64 : bool ret;
861 : :
862 [ + + ]: 64 : list.ids[list.nr++] = mptcp_endp_get_local_id(msk, addr);
863 : :
864 : 64 : ret = mptcp_remove_anno_list_by_saddr(msk, addr);
865 [ + + ]: 64 : if (ret || force) {
866 : 62 : spin_lock_bh(&msk->pm.lock);
867 [ + + ]: 62 : if (ret) {
868 [ - + - - : 32 : __set_bit(addr->id, msk->pm.id_avail_bitmap);
- - - - ]
869 : 32 : msk->pm.add_addr_signaled--;
870 : : }
871 : 62 : mptcp_pm_remove_addr(msk, &list);
872 : 62 : spin_unlock_bh(&msk->pm.lock);
873 : : }
874 : 64 : return ret;
875 : : }
876 : :
877 : 48 : static void __mark_subflow_endp_available(struct mptcp_sock *msk, u8 id)
878 : : {
879 : : /* If it was marked as used, and not ID 0, decrement local_addr_used */
880 [ + + + + : 72 : if (!__test_and_set_bit(id ? : msk->mpc_endpoint_id, msk->pm.id_avail_bitmap) &&
+ + ]
881 [ - + ]: 38 : id && !WARN_ON_ONCE(msk->pm.local_addr_used == 0))
882 : 38 : msk->pm.local_addr_used--;
883 : 48 : }
884 : :
885 : 562 : static int mptcp_nl_remove_subflow_and_signal_addr(struct net *net,
886 : : const struct mptcp_pm_addr_entry *entry)
887 : : {
888 : 562 : const struct mptcp_addr_info *addr = &entry->addr;
889 : 562 : struct mptcp_rm_list list = { .nr = 1 };
890 : 562 : long s_slot = 0, s_num = 0;
891 : 562 : struct mptcp_sock *msk;
892 : :
893 [ - + ]: 562 : pr_debug("remove_id=%d\n", addr->id);
894 : :
895 [ + + ]: 628 : while ((msk = mptcp_token_iter_next(net, &s_slot, &s_num)) != NULL) {
896 : 66 : struct sock *sk = (struct sock *)msk;
897 : 66 : bool remove_subflow;
898 : :
899 [ + + ]: 66 : if (mptcp_pm_is_userspace(msk))
900 : 2 : goto next;
901 : :
902 : 64 : lock_sock(sk);
903 : 64 : remove_subflow = mptcp_lookup_subflow_by_saddr(&msk->conn_list, addr);
904 [ + + ]: 128 : mptcp_pm_remove_anno_addr(msk, addr, remove_subflow &&
905 [ - + ]: 56 : !(entry->flags & MPTCP_PM_ADDR_FLAG_IMPLICIT));
906 : :
907 [ + + ]: 64 : list.ids[0] = mptcp_endp_get_local_id(msk, addr);
908 [ + + ]: 64 : if (remove_subflow) {
909 : 56 : spin_lock_bh(&msk->pm.lock);
910 : 56 : mptcp_pm_rm_subflow(msk, &list);
911 : 56 : spin_unlock_bh(&msk->pm.lock);
912 : : }
913 : :
914 [ + + ]: 64 : if (entry->flags & MPTCP_PM_ADDR_FLAG_SUBFLOW) {
915 : 30 : spin_lock_bh(&msk->pm.lock);
916 : 30 : __mark_subflow_endp_available(msk, list.ids[0]);
917 : 30 : spin_unlock_bh(&msk->pm.lock);
918 : : }
919 : :
920 [ + + ]: 64 : if (msk->mpc_endpoint_id == entry->addr.id)
921 : 10 : msk->mpc_endpoint_id = 0;
922 : 64 : release_sock(sk);
923 : :
924 : 66 : next:
925 : 66 : sock_put(sk);
926 : 66 : cond_resched();
927 : : }
928 : :
929 : 562 : return 0;
930 : : }
931 : :
932 : 4 : static int mptcp_nl_remove_id_zero_address(struct net *net,
933 : : struct mptcp_addr_info *addr)
934 : : {
935 : 4 : struct mptcp_rm_list list = { .nr = 0 };
936 : 4 : long s_slot = 0, s_num = 0;
937 : 4 : struct mptcp_sock *msk;
938 : :
939 : 4 : list.ids[list.nr++] = 0;
940 : :
941 [ + + ]: 8 : while ((msk = mptcp_token_iter_next(net, &s_slot, &s_num)) != NULL) {
942 : 4 : struct sock *sk = (struct sock *)msk;
943 : 4 : struct mptcp_addr_info msk_local;
944 : :
945 [ + - - + ]: 4 : if (list_empty(&msk->conn_list) || mptcp_pm_is_userspace(msk))
946 : 0 : goto next;
947 : :
948 : 4 : mptcp_local_address((struct sock_common *)msk, &msk_local);
949 [ - + ]: 4 : if (!mptcp_addresses_equal(&msk_local, addr, addr->port))
950 : 0 : goto next;
951 : :
952 : 4 : lock_sock(sk);
953 : 4 : spin_lock_bh(&msk->pm.lock);
954 : 4 : mptcp_pm_remove_addr(msk, &list);
955 : 4 : mptcp_pm_rm_subflow(msk, &list);
956 : 4 : __mark_subflow_endp_available(msk, 0);
957 : 4 : spin_unlock_bh(&msk->pm.lock);
958 : 4 : release_sock(sk);
959 : :
960 : 4 : next:
961 : 4 : sock_put(sk);
962 : 4 : cond_resched();
963 : : }
964 : :
965 : 4 : return 0;
966 : : }
967 : :
968 : : /* Remove an MPTCP endpoint */
969 : 566 : int mptcp_pm_nl_del_addr_doit(struct sk_buff *skb, struct genl_info *info)
970 : : {
971 : 566 : struct pm_nl_pernet *pernet = genl_info_pm_nl(info);
972 : 566 : struct mptcp_pm_addr_entry addr, *entry;
973 : 566 : unsigned int addr_max;
974 : 566 : struct nlattr *attr;
975 : 566 : int ret;
976 : :
977 [ + - - - ]: 566 : if (GENL_REQ_ATTR_CHECK(info, MPTCP_PM_ENDPOINT_ADDR))
978 : 0 : return -EINVAL;
979 : :
980 : 566 : attr = info->attrs[MPTCP_PM_ENDPOINT_ADDR];
981 : 566 : ret = mptcp_pm_parse_entry(attr, info, false, &addr);
982 [ - + ]: 566 : if (ret < 0)
983 : : return ret;
984 : :
985 : : /* the zero id address is special: the first address used by the msk
986 : : * always gets such an id, so different subflows can have different zero
987 : : * id addresses. Additionally zero id is not accounted for in id_bitmap.
988 : : * Let's use an 'mptcp_rm_list' instead of the common remove code.
989 : : */
990 [ + + ]: 566 : if (addr.addr.id == 0)
991 : 4 : return mptcp_nl_remove_id_zero_address(sock_net(skb->sk), &addr.addr);
992 : :
993 : 562 : spin_lock_bh(&pernet->lock);
994 : 562 : entry = __lookup_addr_by_id(pernet, addr.addr.id);
995 [ - + ]: 562 : if (!entry) {
996 [ # # ]: 0 : NL_SET_ERR_MSG_ATTR(info->extack, attr, "address not found");
997 : 0 : spin_unlock_bh(&pernet->lock);
998 : 0 : return -EINVAL;
999 : : }
1000 [ + + ]: 562 : if (entry->flags & MPTCP_PM_ADDR_FLAG_SIGNAL) {
1001 : 36 : addr_max = pernet->add_addr_signal_max;
1002 : 36 : WRITE_ONCE(pernet->add_addr_signal_max, addr_max - 1);
1003 : : }
1004 [ + + ]: 562 : if (entry->flags & MPTCP_PM_ADDR_FLAG_SUBFLOW) {
1005 : 34 : addr_max = pernet->local_addr_max;
1006 : 34 : WRITE_ONCE(pernet->local_addr_max, addr_max - 1);
1007 : : }
1008 : :
1009 : 562 : pernet->addrs--;
1010 [ - + ]: 562 : list_del_rcu(&entry->list);
1011 [ - + - - : 562 : __clear_bit(entry->addr.id, pernet->id_bitmap);
- - - - ]
1012 : 562 : spin_unlock_bh(&pernet->lock);
1013 : :
1014 : 562 : mptcp_nl_remove_subflow_and_signal_addr(sock_net(skb->sk), entry);
1015 : 562 : synchronize_rcu();
1016 : 562 : __mptcp_pm_release_addr_entry(entry);
1017 : :
1018 : 562 : return ret;
1019 : : }
1020 : :
1021 : 18 : static void mptcp_pm_flush_addrs_and_subflows(struct mptcp_sock *msk,
1022 : : struct list_head *rm_list)
1023 : : {
1024 : 18 : struct mptcp_rm_list alist = { .nr = 0 }, slist = { .nr = 0 };
1025 : 18 : struct mptcp_pm_addr_entry *entry;
1026 : :
1027 [ + + ]: 56 : list_for_each_entry(entry, rm_list, list) {
1028 [ + - + + ]: 76 : if (slist.nr < MPTCP_RM_IDS_MAX &&
1029 : 38 : mptcp_lookup_subflow_by_saddr(&msk->conn_list, &entry->addr))
1030 [ + - ]: 44 : slist.ids[slist.nr++] = mptcp_endp_get_local_id(msk, &entry->addr);
1031 : :
1032 [ + - + + ]: 76 : if (alist.nr < MPTCP_RM_IDS_MAX &&
1033 : 38 : mptcp_remove_anno_list_by_saddr(msk, &entry->addr))
1034 [ + - ]: 36 : alist.ids[alist.nr++] = mptcp_endp_get_local_id(msk, &entry->addr);
1035 : : }
1036 : :
1037 : 18 : spin_lock_bh(&msk->pm.lock);
1038 [ + + ]: 18 : if (alist.nr) {
1039 : 10 : msk->pm.add_addr_signaled -= alist.nr;
1040 : 10 : mptcp_pm_remove_addr(msk, &alist);
1041 : : }
1042 [ + + ]: 18 : if (slist.nr)
1043 : 12 : mptcp_pm_rm_subflow(msk, &slist);
1044 : : /* Reset counters: maybe some subflows have been removed before */
1045 : 18 : bitmap_fill(msk->pm.id_avail_bitmap, MPTCP_PM_MAX_ADDR_ID + 1);
1046 : 18 : msk->pm.local_addr_used = 0;
1047 : 18 : spin_unlock_bh(&msk->pm.lock);
1048 : 18 : }
1049 : :
1050 : 190 : static void mptcp_nl_flush_addrs_list(struct net *net,
1051 : : struct list_head *rm_list)
1052 : : {
1053 : 190 : long s_slot = 0, s_num = 0;
1054 : 190 : struct mptcp_sock *msk;
1055 : :
1056 [ + + ]: 190 : if (list_empty(rm_list))
1057 : 166 : return;
1058 : :
1059 [ + + ]: 42 : while ((msk = mptcp_token_iter_next(net, &s_slot, &s_num)) != NULL) {
1060 : 18 : struct sock *sk = (struct sock *)msk;
1061 : :
1062 [ + - ]: 18 : if (!mptcp_pm_is_userspace(msk)) {
1063 : 18 : lock_sock(sk);
1064 : 18 : mptcp_pm_flush_addrs_and_subflows(msk, rm_list);
1065 : 18 : release_sock(sk);
1066 : : }
1067 : :
1068 : 18 : sock_put(sk);
1069 : 18 : cond_resched();
1070 : : }
1071 : : }
1072 : :
1073 : : /* caller must ensure the RCU grace period is already elapsed */
1074 : 1222 : static void __flush_addrs(struct list_head *list)
1075 : : {
1076 [ + + ]: 1904 : while (!list_empty(list)) {
1077 : 682 : struct mptcp_pm_addr_entry *cur;
1078 : :
1079 : 682 : cur = list_entry(list->next,
1080 : : struct mptcp_pm_addr_entry, list);
1081 : 682 : list_del_rcu(&cur->list);
1082 : 682 : __mptcp_pm_release_addr_entry(cur);
1083 : : }
1084 : 1222 : }
1085 : :
1086 : 6 : static void __reset_counters(struct pm_nl_pernet *pernet)
1087 : : {
1088 : 190 : WRITE_ONCE(pernet->add_addr_signal_max, 0);
1089 : 190 : WRITE_ONCE(pernet->add_addr_accept_max, 0);
1090 : 190 : WRITE_ONCE(pernet->local_addr_max, 0);
1091 : 190 : pernet->addrs = 0;
1092 : : }
1093 : :
1094 : 190 : int mptcp_pm_nl_flush_addrs_doit(struct sk_buff *skb, struct genl_info *info)
1095 : : {
1096 : 190 : struct pm_nl_pernet *pernet = genl_info_pm_nl(info);
1097 : 190 : LIST_HEAD(free_list);
1098 : :
1099 : 190 : spin_lock_bh(&pernet->lock);
1100 [ + + ]: 190 : list_splice_init(&pernet->local_addr_list, &free_list);
1101 : 190 : __reset_counters(pernet);
1102 : 190 : pernet->next_id = 1;
1103 : 190 : bitmap_zero(pernet->id_bitmap, MPTCP_PM_MAX_ADDR_ID + 1);
1104 : 190 : spin_unlock_bh(&pernet->lock);
1105 : 190 : mptcp_nl_flush_addrs_list(sock_net(skb->sk), &free_list);
1106 : 190 : synchronize_rcu();
1107 : 190 : __flush_addrs(&free_list);
1108 : 190 : return 0;
1109 : : }
1110 : :
1111 : 22 : int mptcp_pm_nl_get_addr(u8 id, struct mptcp_pm_addr_entry *addr,
1112 : : struct genl_info *info)
1113 : : {
1114 : 22 : struct pm_nl_pernet *pernet = genl_info_pm_nl(info);
1115 : 22 : struct mptcp_pm_addr_entry *entry;
1116 : 22 : int ret = -EINVAL;
1117 : :
1118 : 22 : rcu_read_lock();
1119 : 22 : entry = __lookup_addr_by_id(pernet, id);
1120 [ + + ]: 22 : if (entry) {
1121 : 16 : *addr = *entry;
1122 : 16 : ret = 0;
1123 : : }
1124 : 22 : rcu_read_unlock();
1125 : :
1126 : 22 : return ret;
1127 : : }
1128 : :
1129 : 216 : int mptcp_pm_nl_dump_addr(struct sk_buff *msg,
1130 : : struct netlink_callback *cb)
1131 : : {
1132 : 216 : struct net *net = sock_net(msg->sk);
1133 : 216 : struct mptcp_pm_addr_entry *entry;
1134 : 216 : struct pm_nl_pernet *pernet;
1135 : 216 : int id = cb->args[0];
1136 : 216 : int i;
1137 : :
1138 : 216 : pernet = pm_nl_get_pernet(net);
1139 : :
1140 : 216 : rcu_read_lock();
1141 [ + + ]: 53958 : for (i = id; i < MPTCP_PM_MAX_ADDR_ID + 1; i++) {
1142 [ - + - - : 107268 : if (test_bit(i, pernet->id_bitmap)) {
- - - - +
+ + + ]
1143 : 274 : entry = __lookup_addr_by_id(pernet, i);
1144 [ + - ]: 274 : if (!entry)
1145 : : break;
1146 : :
1147 [ + + ]: 274 : if (entry->addr.id <= id)
1148 : 102 : continue;
1149 : :
1150 [ + - ]: 172 : if (mptcp_pm_genl_fill_addr(msg, cb, entry) < 0)
1151 : : break;
1152 : :
1153 : 172 : id = entry->addr.id;
1154 : : }
1155 : : }
1156 : 216 : rcu_read_unlock();
1157 : :
1158 : 216 : cb->args[0] = id;
1159 : 216 : return msg->len;
1160 : : }
1161 : :
1162 : 1282 : static int parse_limit(struct genl_info *info, int id, unsigned int *limit)
1163 : : {
1164 : 1282 : struct nlattr *attr = info->attrs[id];
1165 : :
1166 [ - + ]: 1282 : if (!attr)
1167 : : return 0;
1168 : :
1169 [ + + ]: 1282 : *limit = nla_get_u32(attr);
1170 [ + + ]: 1282 : if (*limit > MPTCP_PM_ADDR_MAX) {
1171 [ + - - + : 4 : NL_SET_ERR_MSG_ATTR_FMT(info->extack, attr,
- - ]
1172 : : "limit greater than maximum (%u)",
1173 : : MPTCP_PM_ADDR_MAX);
1174 : 4 : return -EINVAL;
1175 : : }
1176 : : return 0;
1177 : : }
1178 : :
1179 : 642 : int mptcp_pm_nl_set_limits_doit(struct sk_buff *skb, struct genl_info *info)
1180 : : {
1181 : 642 : struct pm_nl_pernet *pernet = genl_info_pm_nl(info);
1182 : 642 : unsigned int rcv_addrs, subflows;
1183 : 642 : int ret;
1184 : :
1185 : 642 : spin_lock_bh(&pernet->lock);
1186 : 642 : rcv_addrs = pernet->add_addr_accept_max;
1187 : 642 : ret = parse_limit(info, MPTCP_PM_ATTR_RCV_ADD_ADDRS, &rcv_addrs);
1188 [ + + ]: 642 : if (ret)
1189 : 2 : goto unlock;
1190 : :
1191 : 640 : subflows = pernet->subflows_max;
1192 : 640 : ret = parse_limit(info, MPTCP_PM_ATTR_SUBFLOWS, &subflows);
1193 [ + + ]: 640 : if (ret)
1194 : 2 : goto unlock;
1195 : :
1196 : 638 : WRITE_ONCE(pernet->add_addr_accept_max, rcv_addrs);
1197 : 638 : WRITE_ONCE(pernet->subflows_max, subflows);
1198 : :
1199 : 642 : unlock:
1200 : 642 : spin_unlock_bh(&pernet->lock);
1201 : 642 : return ret;
1202 : : }
1203 : :
1204 : 10 : int mptcp_pm_nl_get_limits_doit(struct sk_buff *skb, struct genl_info *info)
1205 : : {
1206 : 10 : struct pm_nl_pernet *pernet = genl_info_pm_nl(info);
1207 : 10 : struct sk_buff *msg;
1208 : 10 : void *reply;
1209 : :
1210 : 10 : msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1211 [ + - ]: 10 : if (!msg)
1212 : : return -ENOMEM;
1213 : :
1214 : 10 : reply = genlmsg_put_reply(msg, info, &mptcp_genl_family, 0,
1215 : : MPTCP_PM_CMD_GET_LIMITS);
1216 [ - + ]: 10 : if (!reply)
1217 : 0 : goto fail;
1218 : :
1219 [ - + ]: 10 : if (nla_put_u32(msg, MPTCP_PM_ATTR_RCV_ADD_ADDRS,
1220 : 10 : READ_ONCE(pernet->add_addr_accept_max)))
1221 : 0 : goto fail;
1222 : :
1223 [ - + ]: 10 : if (nla_put_u32(msg, MPTCP_PM_ATTR_SUBFLOWS,
1224 : 10 : READ_ONCE(pernet->subflows_max)))
1225 : 0 : goto fail;
1226 : :
1227 : 10 : genlmsg_end(msg, reply);
1228 : 10 : return genlmsg_reply(msg, info);
1229 : :
1230 : 0 : fail:
1231 [ # # ]: 0 : GENL_SET_ERR_MSG(info, "not enough space in Netlink message");
1232 : 0 : nlmsg_free(msg);
1233 : 0 : return -EMSGSIZE;
1234 : : }
1235 : :
1236 : 14 : static void mptcp_pm_nl_fullmesh(struct mptcp_sock *msk,
1237 : : struct mptcp_addr_info *addr)
1238 : : {
1239 : 14 : struct mptcp_rm_list list = { .nr = 0 };
1240 : :
1241 [ + - ]: 14 : list.ids[list.nr++] = mptcp_endp_get_local_id(msk, addr);
1242 : :
1243 : 14 : spin_lock_bh(&msk->pm.lock);
1244 : 14 : mptcp_pm_rm_subflow(msk, &list);
1245 : 14 : __mark_subflow_endp_available(msk, list.ids[0]);
1246 : 14 : mptcp_pm_create_subflow_or_signal_addr(msk);
1247 : 14 : spin_unlock_bh(&msk->pm.lock);
1248 : 14 : }
1249 : :
1250 : 46 : static void mptcp_pm_nl_set_flags_all(struct net *net,
1251 : : struct mptcp_pm_addr_entry *local,
1252 : : u8 changed)
1253 : : {
1254 : 46 : u8 is_subflow = !!(local->flags & MPTCP_PM_ADDR_FLAG_SUBFLOW);
1255 : 46 : u8 bkup = !!(local->flags & MPTCP_PM_ADDR_FLAG_BACKUP);
1256 : 46 : long s_slot = 0, s_num = 0;
1257 : 46 : struct mptcp_sock *msk;
1258 : :
1259 [ - + ]: 46 : if (changed == MPTCP_PM_ADDR_FLAG_FULLMESH && !is_subflow)
1260 : 0 : return;
1261 : :
1262 [ + + ]: 82 : while ((msk = mptcp_token_iter_next(net, &s_slot, &s_num)) != NULL) {
1263 : 36 : struct sock *sk = (struct sock *)msk;
1264 : :
1265 [ + - - + ]: 36 : if (list_empty(&msk->conn_list) || mptcp_pm_is_userspace(msk))
1266 : 0 : goto next;
1267 : :
1268 : 36 : lock_sock(sk);
1269 [ + + ]: 36 : if (changed & MPTCP_PM_ADDR_FLAG_BACKUP)
1270 : 24 : mptcp_pm_mp_prio_send_ack(msk, &local->addr, NULL, bkup);
1271 : : /* Subflows will only be recreated if the SUBFLOW flag is set */
1272 [ + + + + ]: 36 : if (is_subflow && (changed & MPTCP_PM_ADDR_FLAG_FULLMESH))
1273 : 14 : mptcp_pm_nl_fullmesh(msk, &local->addr);
1274 : 36 : release_sock(sk);
1275 : :
1276 : 36 : next:
1277 : 36 : sock_put(sk);
1278 : 36 : cond_resched();
1279 : : }
1280 : : }
1281 : :
1282 : 46 : int mptcp_pm_nl_set_flags(struct mptcp_pm_addr_entry *local,
1283 : : struct genl_info *info)
1284 : : {
1285 : 46 : struct nlattr *attr = info->attrs[MPTCP_PM_ATTR_ADDR];
1286 : 46 : u8 changed, mask = MPTCP_PM_ADDR_FLAG_BACKUP |
1287 : : MPTCP_PM_ADDR_FLAG_FULLMESH;
1288 : 46 : struct net *net = genl_info_net(info);
1289 : 46 : struct mptcp_pm_addr_entry *entry;
1290 : 46 : struct pm_nl_pernet *pernet;
1291 : 46 : u8 lookup_by_id = 0;
1292 : :
1293 : 46 : pernet = pm_nl_get_pernet(net);
1294 : :
1295 [ + + ]: 46 : if (local->addr.family == AF_UNSPEC) {
1296 : 42 : lookup_by_id = 1;
1297 [ - + ]: 42 : if (!local->addr.id) {
1298 [ # # ]: 0 : NL_SET_ERR_MSG_ATTR(info->extack, attr,
1299 : : "missing address ID");
1300 : 0 : return -EOPNOTSUPP;
1301 : : }
1302 : : }
1303 : :
1304 : 46 : spin_lock_bh(&pernet->lock);
1305 [ + + ]: 46 : entry = lookup_by_id ? __lookup_addr_by_id(pernet, local->addr.id) :
1306 : 4 : __lookup_addr(pernet, &local->addr);
1307 [ - + ]: 46 : if (!entry) {
1308 : 0 : spin_unlock_bh(&pernet->lock);
1309 [ # # ]: 0 : NL_SET_ERR_MSG_ATTR(info->extack, attr, "address not found");
1310 : 0 : return -EINVAL;
1311 : : }
1312 [ + + ]: 46 : if ((local->flags & MPTCP_PM_ADDR_FLAG_FULLMESH) &&
1313 [ - + ]: 12 : (entry->flags & (MPTCP_PM_ADDR_FLAG_SIGNAL |
1314 : : MPTCP_PM_ADDR_FLAG_IMPLICIT))) {
1315 : 0 : spin_unlock_bh(&pernet->lock);
1316 [ # # ]: 0 : NL_SET_ERR_MSG_ATTR(info->extack, attr, "invalid addr flags");
1317 : 0 : return -EINVAL;
1318 : : }
1319 : :
1320 : 46 : changed = (local->flags ^ entry->flags) & mask;
1321 : 46 : entry->flags = (entry->flags & ~mask) | (local->flags & mask);
1322 : 46 : *local = *entry;
1323 : 46 : spin_unlock_bh(&pernet->lock);
1324 : :
1325 : 46 : mptcp_pm_nl_set_flags_all(net, local, changed);
1326 : 46 : return 0;
1327 : : }
1328 : :
1329 : 1094 : bool mptcp_pm_nl_check_work_pending(struct mptcp_sock *msk)
1330 : : {
1331 : 1094 : struct pm_nl_pernet *pernet = pm_nl_get_pernet_from_msk(msk);
1332 : :
1333 [ + + + + ]: 1825 : if (msk->pm.subflows == mptcp_pm_get_subflows_max(msk) ||
1334 [ + - ]: 906 : (find_next_and_bit(pernet->id_bitmap, msk->pm.id_avail_bitmap,
1335 : : MPTCP_PM_MAX_ADDR_ID + 1, 0) == MPTCP_PM_MAX_ADDR_ID + 1)) {
1336 : 853 : WRITE_ONCE(msk->pm.work_pending, false);
1337 : 853 : return false;
1338 : : }
1339 : : return true;
1340 : : }
1341 : :
1342 : : /* Called under PM lock */
1343 : 964 : void __mptcp_pm_kernel_worker(struct mptcp_sock *msk)
1344 : : {
1345 : 964 : struct mptcp_pm_data *pm = &msk->pm;
1346 : :
1347 [ + + ]: 964 : if (pm->status & BIT(MPTCP_PM_ADD_ADDR_RECEIVED)) {
1348 : 296 : pm->status &= ~BIT(MPTCP_PM_ADD_ADDR_RECEIVED);
1349 : 296 : mptcp_pm_nl_add_addr_received(msk);
1350 : : }
1351 [ + + ]: 964 : if (pm->status & BIT(MPTCP_PM_ESTABLISHED)) {
1352 : 436 : pm->status &= ~BIT(MPTCP_PM_ESTABLISHED);
1353 : 436 : mptcp_pm_nl_fully_established(msk);
1354 : : }
1355 [ + + ]: 964 : if (pm->status & BIT(MPTCP_PM_SUBFLOW_ESTABLISHED)) {
1356 : 277 : pm->status &= ~BIT(MPTCP_PM_SUBFLOW_ESTABLISHED);
1357 : 277 : mptcp_pm_nl_subflow_established(msk);
1358 : : }
1359 : 964 : }
1360 : :
1361 : 1106 : static int __net_init pm_nl_init_net(struct net *net)
1362 : : {
1363 : 1106 : struct pm_nl_pernet *pernet = pm_nl_get_pernet(net);
1364 : :
1365 : 1106 : INIT_LIST_HEAD_RCU(&pernet->local_addr_list);
1366 : :
1367 : : /* Cit. 2 subflows ought to be enough for anybody. */
1368 : 1106 : pernet->subflows_max = 2;
1369 : 1106 : pernet->next_id = 1;
1370 : 1106 : pernet->stale_loss_cnt = 4;
1371 : 1106 : spin_lock_init(&pernet->lock);
1372 : :
1373 : : /* No need to initialize other pernet fields, the struct is zeroed at
1374 : : * allocation time.
1375 : : */
1376 : :
1377 : 1106 : return 0;
1378 : : }
1379 : :
1380 : 935 : static void __net_exit pm_nl_exit_net(struct list_head *net_list)
1381 : : {
1382 : 935 : struct net *net;
1383 : :
1384 [ + + ]: 1967 : list_for_each_entry(net, net_list, exit_list) {
1385 : 1032 : struct pm_nl_pernet *pernet = pm_nl_get_pernet(net);
1386 : :
1387 : : /* net is removed from namespace list, can't race with
1388 : : * other modifiers, also netns core already waited for a
1389 : : * RCU grace period.
1390 : : */
1391 : 1032 : __flush_addrs(&pernet->local_addr_list);
1392 : : }
1393 : 935 : }
1394 : :
1395 : : static struct pernet_operations mptcp_pm_pernet_ops = {
1396 : : .init = pm_nl_init_net,
1397 : : .exit_batch = pm_nl_exit_net,
1398 : : .id = &pm_nl_pernet_id,
1399 : : .size = sizeof(struct pm_nl_pernet),
1400 : : };
1401 : :
1402 : 3708 : static void mptcp_pm_kernel_init(struct mptcp_sock *msk)
1403 : : {
1404 : 3708 : bool subflows_allowed = !!mptcp_pm_get_subflows_max(msk);
1405 : 3708 : struct mptcp_pm_data *pm = &msk->pm;
1406 : :
1407 : : /* pm->work_pending must be only be set to 'true' when
1408 : : * pm->pm_type is set to MPTCP_PM_TYPE_KERNEL
1409 : : */
1410 [ + + + + : 7114 : WRITE_ONCE(pm->work_pending,
+ + ]
1411 : : (!!mptcp_pm_get_local_addr_max(msk) &&
1412 : : subflows_allowed) ||
1413 : : !!mptcp_pm_get_add_addr_signal_max(msk));
1414 [ + + - + ]: 3708 : WRITE_ONCE(pm->accept_addr,
1415 : : !!mptcp_pm_get_add_addr_accept_max(msk) &&
1416 : : subflows_allowed);
1417 : 3708 : WRITE_ONCE(pm->accept_subflow, subflows_allowed);
1418 : :
1419 : 3708 : bitmap_fill(pm->id_avail_bitmap, MPTCP_PM_MAX_ADDR_ID + 1);
1420 : 3708 : }
1421 : :
1422 : : struct mptcp_pm_ops mptcp_pm_kernel = {
1423 : : .get_local_id = mptcp_pm_kernel_get_local_id,
1424 : : .get_priority = mptcp_pm_kernel_get_priority,
1425 : : .init = mptcp_pm_kernel_init,
1426 : : .name = "kernel",
1427 : : .owner = THIS_MODULE,
1428 : : };
1429 : :
1430 : 4 : void __init mptcp_pm_kernel_register(void)
1431 : : {
1432 [ - + ]: 4 : if (register_pernet_subsys(&mptcp_pm_pernet_ops) < 0)
1433 : 0 : panic("Failed to register MPTCP PM pernet subsystem.\n");
1434 : :
1435 : 4 : mptcp_pm_register(&mptcp_pm_kernel);
1436 : 4 : }
|
