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