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