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