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