Loading...
Note: File does not exist in v4.6.
1// SPDX-License-Identifier: GPL-2.0
2/* Multipath TCP
3 *
4 * Copyright (c) 2020, Red Hat, Inc.
5 */
6
7#define pr_fmt(fmt) "MPTCP: " fmt
8
9#include <linux/inet.h>
10#include <linux/kernel.h>
11#include <net/inet_common.h>
12#include <net/netns/generic.h>
13#include <net/mptcp.h>
14
15#include "protocol.h"
16#include "mib.h"
17#include "mptcp_pm_gen.h"
18
19static int pm_nl_pernet_id;
20
21struct mptcp_pm_add_entry {
22 struct list_head list;
23 struct mptcp_addr_info addr;
24 u8 retrans_times;
25 struct timer_list add_timer;
26 struct mptcp_sock *sock;
27};
28
29struct pm_nl_pernet {
30 /* protects pernet updates */
31 spinlock_t lock;
32 struct list_head local_addr_list;
33 unsigned int addrs;
34 unsigned int stale_loss_cnt;
35 unsigned int add_addr_signal_max;
36 unsigned int add_addr_accept_max;
37 unsigned int local_addr_max;
38 unsigned int subflows_max;
39 unsigned int next_id;
40 DECLARE_BITMAP(id_bitmap, MPTCP_PM_MAX_ADDR_ID + 1);
41};
42
43#define MPTCP_PM_ADDR_MAX 8
44#define ADD_ADDR_RETRANS_MAX 3
45
46static struct pm_nl_pernet *pm_nl_get_pernet(const struct net *net)
47{
48 return net_generic(net, pm_nl_pernet_id);
49}
50
51static struct pm_nl_pernet *
52pm_nl_get_pernet_from_msk(const struct mptcp_sock *msk)
53{
54 return pm_nl_get_pernet(sock_net((struct sock *)msk));
55}
56
57bool mptcp_addresses_equal(const struct mptcp_addr_info *a,
58 const struct mptcp_addr_info *b, bool use_port)
59{
60 bool addr_equals = false;
61
62 if (a->family == b->family) {
63 if (a->family == AF_INET)
64 addr_equals = a->addr.s_addr == b->addr.s_addr;
65#if IS_ENABLED(CONFIG_MPTCP_IPV6)
66 else
67 addr_equals = !ipv6_addr_cmp(&a->addr6, &b->addr6);
68 } else if (a->family == AF_INET) {
69 if (ipv6_addr_v4mapped(&b->addr6))
70 addr_equals = a->addr.s_addr == b->addr6.s6_addr32[3];
71 } else if (b->family == AF_INET) {
72 if (ipv6_addr_v4mapped(&a->addr6))
73 addr_equals = a->addr6.s6_addr32[3] == b->addr.s_addr;
74#endif
75 }
76
77 if (!addr_equals)
78 return false;
79 if (!use_port)
80 return true;
81
82 return a->port == b->port;
83}
84
85void mptcp_local_address(const struct sock_common *skc, struct mptcp_addr_info *addr)
86{
87 addr->family = skc->skc_family;
88 addr->port = htons(skc->skc_num);
89 if (addr->family == AF_INET)
90 addr->addr.s_addr = skc->skc_rcv_saddr;
91#if IS_ENABLED(CONFIG_MPTCP_IPV6)
92 else if (addr->family == AF_INET6)
93 addr->addr6 = skc->skc_v6_rcv_saddr;
94#endif
95}
96
97static void remote_address(const struct sock_common *skc,
98 struct mptcp_addr_info *addr)
99{
100 addr->family = skc->skc_family;
101 addr->port = skc->skc_dport;
102 if (addr->family == AF_INET)
103 addr->addr.s_addr = skc->skc_daddr;
104#if IS_ENABLED(CONFIG_MPTCP_IPV6)
105 else if (addr->family == AF_INET6)
106 addr->addr6 = skc->skc_v6_daddr;
107#endif
108}
109
110static bool lookup_subflow_by_saddr(const struct list_head *list,
111 const struct mptcp_addr_info *saddr)
112{
113 struct mptcp_subflow_context *subflow;
114 struct mptcp_addr_info cur;
115 struct sock_common *skc;
116
117 list_for_each_entry(subflow, list, node) {
118 skc = (struct sock_common *)mptcp_subflow_tcp_sock(subflow);
119
120 mptcp_local_address(skc, &cur);
121 if (mptcp_addresses_equal(&cur, saddr, saddr->port))
122 return true;
123 }
124
125 return false;
126}
127
128static bool lookup_subflow_by_daddr(const struct list_head *list,
129 const struct mptcp_addr_info *daddr)
130{
131 struct mptcp_subflow_context *subflow;
132 struct mptcp_addr_info cur;
133
134 list_for_each_entry(subflow, list, node) {
135 struct sock *ssk = mptcp_subflow_tcp_sock(subflow);
136
137 if (!((1 << inet_sk_state_load(ssk)) &
138 (TCPF_ESTABLISHED | TCPF_SYN_SENT | TCPF_SYN_RECV)))
139 continue;
140
141 remote_address((struct sock_common *)ssk, &cur);
142 if (mptcp_addresses_equal(&cur, daddr, daddr->port))
143 return true;
144 }
145
146 return false;
147}
148
149static bool
150select_local_address(const struct pm_nl_pernet *pernet,
151 const struct mptcp_sock *msk,
152 struct mptcp_pm_local *new_local)
153{
154 struct mptcp_pm_addr_entry *entry;
155 bool found = false;
156
157 msk_owned_by_me(msk);
158
159 rcu_read_lock();
160 list_for_each_entry_rcu(entry, &pernet->local_addr_list, list) {
161 if (!(entry->flags & MPTCP_PM_ADDR_FLAG_SUBFLOW))
162 continue;
163
164 if (!test_bit(entry->addr.id, msk->pm.id_avail_bitmap))
165 continue;
166
167 new_local->addr = entry->addr;
168 new_local->flags = entry->flags;
169 new_local->ifindex = entry->ifindex;
170 found = true;
171 break;
172 }
173 rcu_read_unlock();
174
175 return found;
176}
177
178static bool
179select_signal_address(struct pm_nl_pernet *pernet, const struct mptcp_sock *msk,
180 struct mptcp_pm_local *new_local)
181{
182 struct mptcp_pm_addr_entry *entry;
183 bool found = false;
184
185 rcu_read_lock();
186 /* do not keep any additional per socket state, just signal
187 * the address list in order.
188 * Note: removal from the local address list during the msk life-cycle
189 * can lead to additional addresses not being announced.
190 */
191 list_for_each_entry_rcu(entry, &pernet->local_addr_list, list) {
192 if (!test_bit(entry->addr.id, msk->pm.id_avail_bitmap))
193 continue;
194
195 if (!(entry->flags & MPTCP_PM_ADDR_FLAG_SIGNAL))
196 continue;
197
198 new_local->addr = entry->addr;
199 new_local->flags = entry->flags;
200 new_local->ifindex = entry->ifindex;
201 found = true;
202 break;
203 }
204 rcu_read_unlock();
205
206 return found;
207}
208
209unsigned int mptcp_pm_get_add_addr_signal_max(const struct mptcp_sock *msk)
210{
211 const struct pm_nl_pernet *pernet = pm_nl_get_pernet_from_msk(msk);
212
213 return READ_ONCE(pernet->add_addr_signal_max);
214}
215EXPORT_SYMBOL_GPL(mptcp_pm_get_add_addr_signal_max);
216
217unsigned int mptcp_pm_get_add_addr_accept_max(const struct mptcp_sock *msk)
218{
219 struct pm_nl_pernet *pernet = pm_nl_get_pernet_from_msk(msk);
220
221 return READ_ONCE(pernet->add_addr_accept_max);
222}
223EXPORT_SYMBOL_GPL(mptcp_pm_get_add_addr_accept_max);
224
225unsigned int mptcp_pm_get_subflows_max(const struct mptcp_sock *msk)
226{
227 struct pm_nl_pernet *pernet = pm_nl_get_pernet_from_msk(msk);
228
229 return READ_ONCE(pernet->subflows_max);
230}
231EXPORT_SYMBOL_GPL(mptcp_pm_get_subflows_max);
232
233unsigned int mptcp_pm_get_local_addr_max(const struct mptcp_sock *msk)
234{
235 struct pm_nl_pernet *pernet = pm_nl_get_pernet_from_msk(msk);
236
237 return READ_ONCE(pernet->local_addr_max);
238}
239EXPORT_SYMBOL_GPL(mptcp_pm_get_local_addr_max);
240
241bool mptcp_pm_nl_check_work_pending(struct mptcp_sock *msk)
242{
243 struct pm_nl_pernet *pernet = pm_nl_get_pernet_from_msk(msk);
244
245 if (msk->pm.subflows == mptcp_pm_get_subflows_max(msk) ||
246 (find_next_and_bit(pernet->id_bitmap, msk->pm.id_avail_bitmap,
247 MPTCP_PM_MAX_ADDR_ID + 1, 0) == MPTCP_PM_MAX_ADDR_ID + 1)) {
248 WRITE_ONCE(msk->pm.work_pending, false);
249 return false;
250 }
251 return true;
252}
253
254struct mptcp_pm_add_entry *
255mptcp_lookup_anno_list_by_saddr(const struct mptcp_sock *msk,
256 const struct mptcp_addr_info *addr)
257{
258 struct mptcp_pm_add_entry *entry;
259
260 lockdep_assert_held(&msk->pm.lock);
261
262 list_for_each_entry(entry, &msk->pm.anno_list, list) {
263 if (mptcp_addresses_equal(&entry->addr, addr, true))
264 return entry;
265 }
266
267 return NULL;
268}
269
270bool mptcp_pm_sport_in_anno_list(struct mptcp_sock *msk, const struct sock *sk)
271{
272 struct mptcp_pm_add_entry *entry;
273 struct mptcp_addr_info saddr;
274 bool ret = false;
275
276 mptcp_local_address((struct sock_common *)sk, &saddr);
277
278 spin_lock_bh(&msk->pm.lock);
279 list_for_each_entry(entry, &msk->pm.anno_list, list) {
280 if (mptcp_addresses_equal(&entry->addr, &saddr, true)) {
281 ret = true;
282 goto out;
283 }
284 }
285
286out:
287 spin_unlock_bh(&msk->pm.lock);
288 return ret;
289}
290
291static void mptcp_pm_add_timer(struct timer_list *timer)
292{
293 struct mptcp_pm_add_entry *entry = from_timer(entry, timer, add_timer);
294 struct mptcp_sock *msk = entry->sock;
295 struct sock *sk = (struct sock *)msk;
296
297 pr_debug("msk=%p\n", msk);
298
299 if (!msk)
300 return;
301
302 if (inet_sk_state_load(sk) == TCP_CLOSE)
303 return;
304
305 if (!entry->addr.id)
306 return;
307
308 if (mptcp_pm_should_add_signal_addr(msk)) {
309 sk_reset_timer(sk, timer, jiffies + TCP_RTO_MAX / 8);
310 goto out;
311 }
312
313 spin_lock_bh(&msk->pm.lock);
314
315 if (!mptcp_pm_should_add_signal_addr(msk)) {
316 pr_debug("retransmit ADD_ADDR id=%d\n", entry->addr.id);
317 mptcp_pm_announce_addr(msk, &entry->addr, false);
318 mptcp_pm_add_addr_send_ack(msk);
319 entry->retrans_times++;
320 }
321
322 if (entry->retrans_times < ADD_ADDR_RETRANS_MAX)
323 sk_reset_timer(sk, timer,
324 jiffies + mptcp_get_add_addr_timeout(sock_net(sk)));
325
326 spin_unlock_bh(&msk->pm.lock);
327
328 if (entry->retrans_times == ADD_ADDR_RETRANS_MAX)
329 mptcp_pm_subflow_established(msk);
330
331out:
332 __sock_put(sk);
333}
334
335struct mptcp_pm_add_entry *
336mptcp_pm_del_add_timer(struct mptcp_sock *msk,
337 const struct mptcp_addr_info *addr, bool check_id)
338{
339 struct mptcp_pm_add_entry *entry;
340 struct sock *sk = (struct sock *)msk;
341 struct timer_list *add_timer = NULL;
342
343 spin_lock_bh(&msk->pm.lock);
344 entry = mptcp_lookup_anno_list_by_saddr(msk, addr);
345 if (entry && (!check_id || entry->addr.id == addr->id)) {
346 entry->retrans_times = ADD_ADDR_RETRANS_MAX;
347 add_timer = &entry->add_timer;
348 }
349 if (!check_id && entry)
350 list_del(&entry->list);
351 spin_unlock_bh(&msk->pm.lock);
352
353 /* no lock, because sk_stop_timer_sync() is calling del_timer_sync() */
354 if (add_timer)
355 sk_stop_timer_sync(sk, add_timer);
356
357 return entry;
358}
359
360bool mptcp_pm_alloc_anno_list(struct mptcp_sock *msk,
361 const struct mptcp_addr_info *addr)
362{
363 struct mptcp_pm_add_entry *add_entry = NULL;
364 struct sock *sk = (struct sock *)msk;
365 struct net *net = sock_net(sk);
366
367 lockdep_assert_held(&msk->pm.lock);
368
369 add_entry = mptcp_lookup_anno_list_by_saddr(msk, addr);
370
371 if (add_entry) {
372 if (WARN_ON_ONCE(mptcp_pm_is_kernel(msk)))
373 return false;
374
375 sk_reset_timer(sk, &add_entry->add_timer,
376 jiffies + mptcp_get_add_addr_timeout(net));
377 return true;
378 }
379
380 add_entry = kmalloc(sizeof(*add_entry), GFP_ATOMIC);
381 if (!add_entry)
382 return false;
383
384 list_add(&add_entry->list, &msk->pm.anno_list);
385
386 add_entry->addr = *addr;
387 add_entry->sock = msk;
388 add_entry->retrans_times = 0;
389
390 timer_setup(&add_entry->add_timer, mptcp_pm_add_timer, 0);
391 sk_reset_timer(sk, &add_entry->add_timer,
392 jiffies + mptcp_get_add_addr_timeout(net));
393
394 return true;
395}
396
397void mptcp_pm_free_anno_list(struct mptcp_sock *msk)
398{
399 struct mptcp_pm_add_entry *entry, *tmp;
400 struct sock *sk = (struct sock *)msk;
401 LIST_HEAD(free_list);
402
403 pr_debug("msk=%p\n", msk);
404
405 spin_lock_bh(&msk->pm.lock);
406 list_splice_init(&msk->pm.anno_list, &free_list);
407 spin_unlock_bh(&msk->pm.lock);
408
409 list_for_each_entry_safe(entry, tmp, &free_list, list) {
410 sk_stop_timer_sync(sk, &entry->add_timer);
411 kfree(entry);
412 }
413}
414
415/* Fill all the remote addresses into the array addrs[],
416 * and return the array size.
417 */
418static unsigned int fill_remote_addresses_vec(struct mptcp_sock *msk,
419 struct mptcp_addr_info *local,
420 bool fullmesh,
421 struct mptcp_addr_info *addrs)
422{
423 bool deny_id0 = READ_ONCE(msk->pm.remote_deny_join_id0);
424 struct sock *sk = (struct sock *)msk, *ssk;
425 struct mptcp_subflow_context *subflow;
426 struct mptcp_addr_info remote = { 0 };
427 unsigned int subflows_max;
428 int i = 0;
429
430 subflows_max = mptcp_pm_get_subflows_max(msk);
431 remote_address((struct sock_common *)sk, &remote);
432
433 /* Non-fullmesh endpoint, fill in the single entry
434 * corresponding to the primary MPC subflow remote address
435 */
436 if (!fullmesh) {
437 if (deny_id0)
438 return 0;
439
440 if (!mptcp_pm_addr_families_match(sk, local, &remote))
441 return 0;
442
443 msk->pm.subflows++;
444 addrs[i++] = remote;
445 } else {
446 DECLARE_BITMAP(unavail_id, MPTCP_PM_MAX_ADDR_ID + 1);
447
448 /* Forbid creation of new subflows matching existing
449 * ones, possibly already created by incoming ADD_ADDR
450 */
451 bitmap_zero(unavail_id, MPTCP_PM_MAX_ADDR_ID + 1);
452 mptcp_for_each_subflow(msk, subflow)
453 if (READ_ONCE(subflow->local_id) == local->id)
454 __set_bit(subflow->remote_id, unavail_id);
455
456 mptcp_for_each_subflow(msk, subflow) {
457 ssk = mptcp_subflow_tcp_sock(subflow);
458 remote_address((struct sock_common *)ssk, &addrs[i]);
459 addrs[i].id = READ_ONCE(subflow->remote_id);
460 if (deny_id0 && !addrs[i].id)
461 continue;
462
463 if (test_bit(addrs[i].id, unavail_id))
464 continue;
465
466 if (!mptcp_pm_addr_families_match(sk, local, &addrs[i]))
467 continue;
468
469 if (msk->pm.subflows < subflows_max) {
470 /* forbid creating multiple address towards
471 * this id
472 */
473 __set_bit(addrs[i].id, unavail_id);
474 msk->pm.subflows++;
475 i++;
476 }
477 }
478 }
479
480 return i;
481}
482
483static void __mptcp_pm_send_ack(struct mptcp_sock *msk, struct mptcp_subflow_context *subflow,
484 bool prio, bool backup)
485{
486 struct sock *ssk = mptcp_subflow_tcp_sock(subflow);
487 bool slow;
488
489 pr_debug("send ack for %s\n",
490 prio ? "mp_prio" : (mptcp_pm_should_add_signal(msk) ? "add_addr" : "rm_addr"));
491
492 slow = lock_sock_fast(ssk);
493 if (prio) {
494 subflow->send_mp_prio = 1;
495 subflow->request_bkup = backup;
496 }
497
498 __mptcp_subflow_send_ack(ssk);
499 unlock_sock_fast(ssk, slow);
500}
501
502static void mptcp_pm_send_ack(struct mptcp_sock *msk, struct mptcp_subflow_context *subflow,
503 bool prio, bool backup)
504{
505 spin_unlock_bh(&msk->pm.lock);
506 __mptcp_pm_send_ack(msk, subflow, prio, backup);
507 spin_lock_bh(&msk->pm.lock);
508}
509
510static struct mptcp_pm_addr_entry *
511__lookup_addr_by_id(struct pm_nl_pernet *pernet, unsigned int id)
512{
513 struct mptcp_pm_addr_entry *entry;
514
515 list_for_each_entry_rcu(entry, &pernet->local_addr_list, list,
516 lockdep_is_held(&pernet->lock)) {
517 if (entry->addr.id == id)
518 return entry;
519 }
520 return NULL;
521}
522
523static struct mptcp_pm_addr_entry *
524__lookup_addr(struct pm_nl_pernet *pernet, const struct mptcp_addr_info *info)
525{
526 struct mptcp_pm_addr_entry *entry;
527
528 list_for_each_entry_rcu(entry, &pernet->local_addr_list, list,
529 lockdep_is_held(&pernet->lock)) {
530 if (mptcp_addresses_equal(&entry->addr, info, entry->addr.port))
531 return entry;
532 }
533 return NULL;
534}
535
536static void mptcp_pm_create_subflow_or_signal_addr(struct mptcp_sock *msk)
537{
538 struct sock *sk = (struct sock *)msk;
539 unsigned int add_addr_signal_max;
540 bool signal_and_subflow = false;
541 unsigned int local_addr_max;
542 struct pm_nl_pernet *pernet;
543 struct mptcp_pm_local local;
544 unsigned int subflows_max;
545
546 pernet = pm_nl_get_pernet(sock_net(sk));
547
548 add_addr_signal_max = mptcp_pm_get_add_addr_signal_max(msk);
549 local_addr_max = mptcp_pm_get_local_addr_max(msk);
550 subflows_max = mptcp_pm_get_subflows_max(msk);
551
552 /* do lazy endpoint usage accounting for the MPC subflows */
553 if (unlikely(!(msk->pm.status & BIT(MPTCP_PM_MPC_ENDPOINT_ACCOUNTED))) && msk->first) {
554 struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(msk->first);
555 struct mptcp_pm_addr_entry *entry;
556 struct mptcp_addr_info mpc_addr;
557 bool backup = false;
558
559 mptcp_local_address((struct sock_common *)msk->first, &mpc_addr);
560 rcu_read_lock();
561 entry = __lookup_addr(pernet, &mpc_addr);
562 if (entry) {
563 __clear_bit(entry->addr.id, msk->pm.id_avail_bitmap);
564 msk->mpc_endpoint_id = entry->addr.id;
565 backup = !!(entry->flags & MPTCP_PM_ADDR_FLAG_BACKUP);
566 }
567 rcu_read_unlock();
568
569 if (backup)
570 mptcp_pm_send_ack(msk, subflow, true, backup);
571
572 msk->pm.status |= BIT(MPTCP_PM_MPC_ENDPOINT_ACCOUNTED);
573 }
574
575 pr_debug("local %d:%d signal %d:%d subflows %d:%d\n",
576 msk->pm.local_addr_used, local_addr_max,
577 msk->pm.add_addr_signaled, add_addr_signal_max,
578 msk->pm.subflows, subflows_max);
579
580 /* check first for announce */
581 if (msk->pm.add_addr_signaled < add_addr_signal_max) {
582 /* due to racing events on both ends we can reach here while
583 * previous add address is still running: if we invoke now
584 * mptcp_pm_announce_addr(), that will fail and the
585 * corresponding id will be marked as used.
586 * Instead let the PM machinery reschedule us when the
587 * current address announce will be completed.
588 */
589 if (msk->pm.addr_signal & BIT(MPTCP_ADD_ADDR_SIGNAL))
590 return;
591
592 if (!select_signal_address(pernet, msk, &local))
593 goto subflow;
594
595 /* If the alloc fails, we are on memory pressure, not worth
596 * continuing, and trying to create subflows.
597 */
598 if (!mptcp_pm_alloc_anno_list(msk, &local.addr))
599 return;
600
601 __clear_bit(local.addr.id, msk->pm.id_avail_bitmap);
602 msk->pm.add_addr_signaled++;
603
604 /* Special case for ID0: set the correct ID */
605 if (local.addr.id == msk->mpc_endpoint_id)
606 local.addr.id = 0;
607
608 mptcp_pm_announce_addr(msk, &local.addr, false);
609 mptcp_pm_nl_addr_send_ack(msk);
610
611 if (local.flags & MPTCP_PM_ADDR_FLAG_SUBFLOW)
612 signal_and_subflow = true;
613 }
614
615subflow:
616 /* check if should create a new subflow */
617 while (msk->pm.local_addr_used < local_addr_max &&
618 msk->pm.subflows < subflows_max) {
619 struct mptcp_addr_info addrs[MPTCP_PM_ADDR_MAX];
620 bool fullmesh;
621 int i, nr;
622
623 if (signal_and_subflow)
624 signal_and_subflow = false;
625 else if (!select_local_address(pernet, msk, &local))
626 break;
627
628 fullmesh = !!(local.flags & MPTCP_PM_ADDR_FLAG_FULLMESH);
629
630 __clear_bit(local.addr.id, msk->pm.id_avail_bitmap);
631
632 /* Special case for ID0: set the correct ID */
633 if (local.addr.id == msk->mpc_endpoint_id)
634 local.addr.id = 0;
635 else /* local_addr_used is not decr for ID 0 */
636 msk->pm.local_addr_used++;
637
638 nr = fill_remote_addresses_vec(msk, &local.addr, fullmesh, addrs);
639 if (nr == 0)
640 continue;
641
642 spin_unlock_bh(&msk->pm.lock);
643 for (i = 0; i < nr; i++)
644 __mptcp_subflow_connect(sk, &local, &addrs[i]);
645 spin_lock_bh(&msk->pm.lock);
646 }
647 mptcp_pm_nl_check_work_pending(msk);
648}
649
650static void mptcp_pm_nl_fully_established(struct mptcp_sock *msk)
651{
652 mptcp_pm_create_subflow_or_signal_addr(msk);
653}
654
655static void mptcp_pm_nl_subflow_established(struct mptcp_sock *msk)
656{
657 mptcp_pm_create_subflow_or_signal_addr(msk);
658}
659
660/* Fill all the local addresses into the array addrs[],
661 * and return the array size.
662 */
663static unsigned int fill_local_addresses_vec(struct mptcp_sock *msk,
664 struct mptcp_addr_info *remote,
665 struct mptcp_pm_local *locals)
666{
667 struct sock *sk = (struct sock *)msk;
668 struct mptcp_pm_addr_entry *entry;
669 struct mptcp_addr_info mpc_addr;
670 struct pm_nl_pernet *pernet;
671 unsigned int subflows_max;
672 int i = 0;
673
674 pernet = pm_nl_get_pernet_from_msk(msk);
675 subflows_max = mptcp_pm_get_subflows_max(msk);
676
677 mptcp_local_address((struct sock_common *)msk, &mpc_addr);
678
679 rcu_read_lock();
680 list_for_each_entry_rcu(entry, &pernet->local_addr_list, list) {
681 if (!(entry->flags & MPTCP_PM_ADDR_FLAG_FULLMESH))
682 continue;
683
684 if (!mptcp_pm_addr_families_match(sk, &entry->addr, remote))
685 continue;
686
687 if (msk->pm.subflows < subflows_max) {
688 locals[i].addr = entry->addr;
689 locals[i].flags = entry->flags;
690 locals[i].ifindex = entry->ifindex;
691
692 /* Special case for ID0: set the correct ID */
693 if (mptcp_addresses_equal(&locals[i].addr, &mpc_addr, locals[i].addr.port))
694 locals[i].addr.id = 0;
695
696 msk->pm.subflows++;
697 i++;
698 }
699 }
700 rcu_read_unlock();
701
702 /* If the array is empty, fill in the single
703 * 'IPADDRANY' local address
704 */
705 if (!i) {
706 memset(&locals[i], 0, sizeof(locals[i]));
707 locals[i].addr.family =
708#if IS_ENABLED(CONFIG_MPTCP_IPV6)
709 remote->family == AF_INET6 &&
710 ipv6_addr_v4mapped(&remote->addr6) ? AF_INET :
711#endif
712 remote->family;
713
714 if (!mptcp_pm_addr_families_match(sk, &locals[i].addr, remote))
715 return 0;
716
717 msk->pm.subflows++;
718 i++;
719 }
720
721 return i;
722}
723
724static void mptcp_pm_nl_add_addr_received(struct mptcp_sock *msk)
725{
726 struct mptcp_pm_local locals[MPTCP_PM_ADDR_MAX];
727 struct sock *sk = (struct sock *)msk;
728 unsigned int add_addr_accept_max;
729 struct mptcp_addr_info remote;
730 unsigned int subflows_max;
731 bool sf_created = false;
732 int i, nr;
733
734 add_addr_accept_max = mptcp_pm_get_add_addr_accept_max(msk);
735 subflows_max = mptcp_pm_get_subflows_max(msk);
736
737 pr_debug("accepted %d:%d remote family %d\n",
738 msk->pm.add_addr_accepted, add_addr_accept_max,
739 msk->pm.remote.family);
740
741 remote = msk->pm.remote;
742 mptcp_pm_announce_addr(msk, &remote, true);
743 mptcp_pm_nl_addr_send_ack(msk);
744
745 if (lookup_subflow_by_daddr(&msk->conn_list, &remote))
746 return;
747
748 /* pick id 0 port, if none is provided the remote address */
749 if (!remote.port)
750 remote.port = sk->sk_dport;
751
752 /* connect to the specified remote address, using whatever
753 * local address the routing configuration will pick.
754 */
755 nr = fill_local_addresses_vec(msk, &remote, locals);
756 if (nr == 0)
757 return;
758
759 spin_unlock_bh(&msk->pm.lock);
760 for (i = 0; i < nr; i++)
761 if (__mptcp_subflow_connect(sk, &locals[i], &remote) == 0)
762 sf_created = true;
763 spin_lock_bh(&msk->pm.lock);
764
765 if (sf_created) {
766 /* add_addr_accepted is not decr for ID 0 */
767 if (remote.id)
768 msk->pm.add_addr_accepted++;
769 if (msk->pm.add_addr_accepted >= add_addr_accept_max ||
770 msk->pm.subflows >= subflows_max)
771 WRITE_ONCE(msk->pm.accept_addr, false);
772 }
773}
774
775bool mptcp_pm_nl_is_init_remote_addr(struct mptcp_sock *msk,
776 const struct mptcp_addr_info *remote)
777{
778 struct mptcp_addr_info mpc_remote;
779
780 remote_address((struct sock_common *)msk, &mpc_remote);
781 return mptcp_addresses_equal(&mpc_remote, remote, remote->port);
782}
783
784void mptcp_pm_nl_addr_send_ack(struct mptcp_sock *msk)
785{
786 struct mptcp_subflow_context *subflow, *alt = NULL;
787
788 msk_owned_by_me(msk);
789 lockdep_assert_held(&msk->pm.lock);
790
791 if (!mptcp_pm_should_add_signal(msk) &&
792 !mptcp_pm_should_rm_signal(msk))
793 return;
794
795 mptcp_for_each_subflow(msk, subflow) {
796 if (__mptcp_subflow_active(subflow)) {
797 if (!subflow->stale) {
798 mptcp_pm_send_ack(msk, subflow, false, false);
799 return;
800 }
801
802 if (!alt)
803 alt = subflow;
804 }
805 }
806
807 if (alt)
808 mptcp_pm_send_ack(msk, alt, false, false);
809}
810
811int mptcp_pm_nl_mp_prio_send_ack(struct mptcp_sock *msk,
812 struct mptcp_addr_info *addr,
813 struct mptcp_addr_info *rem,
814 u8 bkup)
815{
816 struct mptcp_subflow_context *subflow;
817
818 pr_debug("bkup=%d\n", bkup);
819
820 mptcp_for_each_subflow(msk, subflow) {
821 struct sock *ssk = mptcp_subflow_tcp_sock(subflow);
822 struct mptcp_addr_info local, remote;
823
824 mptcp_local_address((struct sock_common *)ssk, &local);
825 if (!mptcp_addresses_equal(&local, addr, addr->port))
826 continue;
827
828 if (rem && rem->family != AF_UNSPEC) {
829 remote_address((struct sock_common *)ssk, &remote);
830 if (!mptcp_addresses_equal(&remote, rem, rem->port))
831 continue;
832 }
833
834 __mptcp_pm_send_ack(msk, subflow, true, bkup);
835 return 0;
836 }
837
838 return -EINVAL;
839}
840
841static void mptcp_pm_nl_rm_addr_or_subflow(struct mptcp_sock *msk,
842 const struct mptcp_rm_list *rm_list,
843 enum linux_mptcp_mib_field rm_type)
844{
845 struct mptcp_subflow_context *subflow, *tmp;
846 struct sock *sk = (struct sock *)msk;
847 u8 i;
848
849 pr_debug("%s rm_list_nr %d\n",
850 rm_type == MPTCP_MIB_RMADDR ? "address" : "subflow", rm_list->nr);
851
852 msk_owned_by_me(msk);
853
854 if (sk->sk_state == TCP_LISTEN)
855 return;
856
857 if (!rm_list->nr)
858 return;
859
860 if (list_empty(&msk->conn_list))
861 return;
862
863 for (i = 0; i < rm_list->nr; i++) {
864 u8 rm_id = rm_list->ids[i];
865 bool removed = false;
866
867 mptcp_for_each_subflow_safe(msk, subflow, tmp) {
868 struct sock *ssk = mptcp_subflow_tcp_sock(subflow);
869 u8 remote_id = READ_ONCE(subflow->remote_id);
870 int how = RCV_SHUTDOWN | SEND_SHUTDOWN;
871 u8 id = subflow_get_local_id(subflow);
872
873 if ((1 << inet_sk_state_load(ssk)) &
874 (TCPF_FIN_WAIT1 | TCPF_FIN_WAIT2 | TCPF_CLOSING | TCPF_CLOSE))
875 continue;
876 if (rm_type == MPTCP_MIB_RMADDR && remote_id != rm_id)
877 continue;
878 if (rm_type == MPTCP_MIB_RMSUBFLOW && id != rm_id)
879 continue;
880
881 pr_debug(" -> %s rm_list_ids[%d]=%u local_id=%u remote_id=%u mpc_id=%u\n",
882 rm_type == MPTCP_MIB_RMADDR ? "address" : "subflow",
883 i, rm_id, id, remote_id, msk->mpc_endpoint_id);
884 spin_unlock_bh(&msk->pm.lock);
885 mptcp_subflow_shutdown(sk, ssk, how);
886 removed |= subflow->request_join;
887
888 /* the following takes care of updating the subflows counter */
889 mptcp_close_ssk(sk, ssk, subflow);
890 spin_lock_bh(&msk->pm.lock);
891
892 if (rm_type == MPTCP_MIB_RMSUBFLOW)
893 __MPTCP_INC_STATS(sock_net(sk), rm_type);
894 }
895
896 if (rm_type == MPTCP_MIB_RMADDR)
897 __MPTCP_INC_STATS(sock_net(sk), rm_type);
898
899 if (!removed)
900 continue;
901
902 if (!mptcp_pm_is_kernel(msk))
903 continue;
904
905 if (rm_type == MPTCP_MIB_RMADDR && rm_id &&
906 !WARN_ON_ONCE(msk->pm.add_addr_accepted == 0)) {
907 /* Note: if the subflow has been closed before, this
908 * add_addr_accepted counter will not be decremented.
909 */
910 if (--msk->pm.add_addr_accepted < mptcp_pm_get_add_addr_accept_max(msk))
911 WRITE_ONCE(msk->pm.accept_addr, true);
912 }
913 }
914}
915
916static void mptcp_pm_nl_rm_addr_received(struct mptcp_sock *msk)
917{
918 mptcp_pm_nl_rm_addr_or_subflow(msk, &msk->pm.rm_list_rx, MPTCP_MIB_RMADDR);
919}
920
921static void mptcp_pm_nl_rm_subflow_received(struct mptcp_sock *msk,
922 const struct mptcp_rm_list *rm_list)
923{
924 mptcp_pm_nl_rm_addr_or_subflow(msk, rm_list, MPTCP_MIB_RMSUBFLOW);
925}
926
927void mptcp_pm_nl_work(struct mptcp_sock *msk)
928{
929 struct mptcp_pm_data *pm = &msk->pm;
930
931 msk_owned_by_me(msk);
932
933 if (!(pm->status & MPTCP_PM_WORK_MASK))
934 return;
935
936 spin_lock_bh(&msk->pm.lock);
937
938 pr_debug("msk=%p status=%x\n", msk, pm->status);
939 if (pm->status & BIT(MPTCP_PM_ADD_ADDR_RECEIVED)) {
940 pm->status &= ~BIT(MPTCP_PM_ADD_ADDR_RECEIVED);
941 mptcp_pm_nl_add_addr_received(msk);
942 }
943 if (pm->status & BIT(MPTCP_PM_ADD_ADDR_SEND_ACK)) {
944 pm->status &= ~BIT(MPTCP_PM_ADD_ADDR_SEND_ACK);
945 mptcp_pm_nl_addr_send_ack(msk);
946 }
947 if (pm->status & BIT(MPTCP_PM_RM_ADDR_RECEIVED)) {
948 pm->status &= ~BIT(MPTCP_PM_RM_ADDR_RECEIVED);
949 mptcp_pm_nl_rm_addr_received(msk);
950 }
951 if (pm->status & BIT(MPTCP_PM_ESTABLISHED)) {
952 pm->status &= ~BIT(MPTCP_PM_ESTABLISHED);
953 mptcp_pm_nl_fully_established(msk);
954 }
955 if (pm->status & BIT(MPTCP_PM_SUBFLOW_ESTABLISHED)) {
956 pm->status &= ~BIT(MPTCP_PM_SUBFLOW_ESTABLISHED);
957 mptcp_pm_nl_subflow_established(msk);
958 }
959
960 spin_unlock_bh(&msk->pm.lock);
961}
962
963static bool address_use_port(struct mptcp_pm_addr_entry *entry)
964{
965 return (entry->flags &
966 (MPTCP_PM_ADDR_FLAG_SIGNAL | MPTCP_PM_ADDR_FLAG_SUBFLOW)) ==
967 MPTCP_PM_ADDR_FLAG_SIGNAL;
968}
969
970/* caller must ensure the RCU grace period is already elapsed */
971static void __mptcp_pm_release_addr_entry(struct mptcp_pm_addr_entry *entry)
972{
973 if (entry->lsk)
974 sock_release(entry->lsk);
975 kfree(entry);
976}
977
978static int mptcp_pm_nl_append_new_local_addr(struct pm_nl_pernet *pernet,
979 struct mptcp_pm_addr_entry *entry,
980 bool needs_id, bool replace)
981{
982 struct mptcp_pm_addr_entry *cur, *del_entry = NULL;
983 unsigned int addr_max;
984 int ret = -EINVAL;
985
986 spin_lock_bh(&pernet->lock);
987 /* to keep the code simple, don't do IDR-like allocation for address ID,
988 * just bail when we exceed limits
989 */
990 if (pernet->next_id == MPTCP_PM_MAX_ADDR_ID)
991 pernet->next_id = 1;
992 if (pernet->addrs >= MPTCP_PM_ADDR_MAX) {
993 ret = -ERANGE;
994 goto out;
995 }
996 if (test_bit(entry->addr.id, pernet->id_bitmap)) {
997 ret = -EBUSY;
998 goto out;
999 }
1000
1001 /* do not insert duplicate address, differentiate on port only
1002 * singled addresses
1003 */
1004 if (!address_use_port(entry))
1005 entry->addr.port = 0;
1006 list_for_each_entry(cur, &pernet->local_addr_list, list) {
1007 if (mptcp_addresses_equal(&cur->addr, &entry->addr,
1008 cur->addr.port || entry->addr.port)) {
1009 /* allow replacing the exiting endpoint only if such
1010 * endpoint is an implicit one and the user-space
1011 * did not provide an endpoint id
1012 */
1013 if (!(cur->flags & MPTCP_PM_ADDR_FLAG_IMPLICIT)) {
1014 ret = -EEXIST;
1015 goto out;
1016 }
1017 if (entry->addr.id)
1018 goto out;
1019
1020 /* allow callers that only need to look up the local
1021 * addr's id to skip replacement. This allows them to
1022 * avoid calling synchronize_rcu in the packet recv
1023 * path.
1024 */
1025 if (!replace) {
1026 kfree(entry);
1027 ret = cur->addr.id;
1028 goto out;
1029 }
1030
1031 pernet->addrs--;
1032 entry->addr.id = cur->addr.id;
1033 list_del_rcu(&cur->list);
1034 del_entry = cur;
1035 break;
1036 }
1037 }
1038
1039 if (!entry->addr.id && needs_id) {
1040find_next:
1041 entry->addr.id = find_next_zero_bit(pernet->id_bitmap,
1042 MPTCP_PM_MAX_ADDR_ID + 1,
1043 pernet->next_id);
1044 if (!entry->addr.id && pernet->next_id != 1) {
1045 pernet->next_id = 1;
1046 goto find_next;
1047 }
1048 }
1049
1050 if (!entry->addr.id && needs_id)
1051 goto out;
1052
1053 __set_bit(entry->addr.id, pernet->id_bitmap);
1054 if (entry->addr.id > pernet->next_id)
1055 pernet->next_id = entry->addr.id;
1056
1057 if (entry->flags & MPTCP_PM_ADDR_FLAG_SIGNAL) {
1058 addr_max = pernet->add_addr_signal_max;
1059 WRITE_ONCE(pernet->add_addr_signal_max, addr_max + 1);
1060 }
1061 if (entry->flags & MPTCP_PM_ADDR_FLAG_SUBFLOW) {
1062 addr_max = pernet->local_addr_max;
1063 WRITE_ONCE(pernet->local_addr_max, addr_max + 1);
1064 }
1065
1066 pernet->addrs++;
1067 if (!entry->addr.port)
1068 list_add_tail_rcu(&entry->list, &pernet->local_addr_list);
1069 else
1070 list_add_rcu(&entry->list, &pernet->local_addr_list);
1071 ret = entry->addr.id;
1072
1073out:
1074 spin_unlock_bh(&pernet->lock);
1075
1076 /* just replaced an existing entry, free it */
1077 if (del_entry) {
1078 synchronize_rcu();
1079 __mptcp_pm_release_addr_entry(del_entry);
1080 }
1081 return ret;
1082}
1083
1084static struct lock_class_key mptcp_slock_keys[2];
1085static struct lock_class_key mptcp_keys[2];
1086
1087static int mptcp_pm_nl_create_listen_socket(struct sock *sk,
1088 struct mptcp_pm_addr_entry *entry)
1089{
1090 bool is_ipv6 = sk->sk_family == AF_INET6;
1091 int addrlen = sizeof(struct sockaddr_in);
1092 struct sockaddr_storage addr;
1093 struct sock *newsk, *ssk;
1094 int backlog = 1024;
1095 int err;
1096
1097 err = sock_create_kern(sock_net(sk), entry->addr.family,
1098 SOCK_STREAM, IPPROTO_MPTCP, &entry->lsk);
1099 if (err)
1100 return err;
1101
1102 newsk = entry->lsk->sk;
1103 if (!newsk)
1104 return -EINVAL;
1105
1106 /* The subflow socket lock is acquired in a nested to the msk one
1107 * in several places, even by the TCP stack, and this msk is a kernel
1108 * socket: lockdep complains. Instead of propagating the _nested
1109 * modifiers in several places, re-init the lock class for the msk
1110 * socket to an mptcp specific one.
1111 */
1112 sock_lock_init_class_and_name(newsk,
1113 is_ipv6 ? "mlock-AF_INET6" : "mlock-AF_INET",
1114 &mptcp_slock_keys[is_ipv6],
1115 is_ipv6 ? "msk_lock-AF_INET6" : "msk_lock-AF_INET",
1116 &mptcp_keys[is_ipv6]);
1117
1118 lock_sock(newsk);
1119 ssk = __mptcp_nmpc_sk(mptcp_sk(newsk));
1120 release_sock(newsk);
1121 if (IS_ERR(ssk))
1122 return PTR_ERR(ssk);
1123
1124 mptcp_info2sockaddr(&entry->addr, &addr, entry->addr.family);
1125#if IS_ENABLED(CONFIG_MPTCP_IPV6)
1126 if (entry->addr.family == AF_INET6)
1127 addrlen = sizeof(struct sockaddr_in6);
1128#endif
1129 if (ssk->sk_family == AF_INET)
1130 err = inet_bind_sk(ssk, (struct sockaddr *)&addr, addrlen);
1131#if IS_ENABLED(CONFIG_MPTCP_IPV6)
1132 else if (ssk->sk_family == AF_INET6)
1133 err = inet6_bind_sk(ssk, (struct sockaddr *)&addr, addrlen);
1134#endif
1135 if (err)
1136 return err;
1137
1138 /* We don't use mptcp_set_state() here because it needs to be called
1139 * under the msk socket lock. For the moment, that will not bring
1140 * anything more than only calling inet_sk_state_store(), because the
1141 * old status is known (TCP_CLOSE).
1142 */
1143 inet_sk_state_store(newsk, TCP_LISTEN);
1144 lock_sock(ssk);
1145 WRITE_ONCE(mptcp_subflow_ctx(ssk)->pm_listener, true);
1146 err = __inet_listen_sk(ssk, backlog);
1147 if (!err)
1148 mptcp_event_pm_listener(ssk, MPTCP_EVENT_LISTENER_CREATED);
1149 release_sock(ssk);
1150 return err;
1151}
1152
1153int mptcp_pm_nl_get_local_id(struct mptcp_sock *msk, struct mptcp_addr_info *skc)
1154{
1155 struct mptcp_pm_addr_entry *entry;
1156 struct pm_nl_pernet *pernet;
1157 int ret;
1158
1159 pernet = pm_nl_get_pernet_from_msk(msk);
1160
1161 rcu_read_lock();
1162 entry = __lookup_addr(pernet, skc);
1163 ret = entry ? entry->addr.id : -1;
1164 rcu_read_unlock();
1165 if (ret >= 0)
1166 return ret;
1167
1168 /* address not found, add to local list */
1169 entry = kmalloc(sizeof(*entry), GFP_ATOMIC);
1170 if (!entry)
1171 return -ENOMEM;
1172
1173 entry->addr = *skc;
1174 entry->addr.id = 0;
1175 entry->addr.port = 0;
1176 entry->ifindex = 0;
1177 entry->flags = MPTCP_PM_ADDR_FLAG_IMPLICIT;
1178 entry->lsk = NULL;
1179 ret = mptcp_pm_nl_append_new_local_addr(pernet, entry, true, false);
1180 if (ret < 0)
1181 kfree(entry);
1182
1183 return ret;
1184}
1185
1186bool mptcp_pm_nl_is_backup(struct mptcp_sock *msk, struct mptcp_addr_info *skc)
1187{
1188 struct pm_nl_pernet *pernet = pm_nl_get_pernet_from_msk(msk);
1189 struct mptcp_pm_addr_entry *entry;
1190 bool backup;
1191
1192 rcu_read_lock();
1193 entry = __lookup_addr(pernet, skc);
1194 backup = entry && !!(entry->flags & MPTCP_PM_ADDR_FLAG_BACKUP);
1195 rcu_read_unlock();
1196
1197 return backup;
1198}
1199
1200#define MPTCP_PM_CMD_GRP_OFFSET 0
1201#define MPTCP_PM_EV_GRP_OFFSET 1
1202
1203static const struct genl_multicast_group mptcp_pm_mcgrps[] = {
1204 [MPTCP_PM_CMD_GRP_OFFSET] = { .name = MPTCP_PM_CMD_GRP_NAME, },
1205 [MPTCP_PM_EV_GRP_OFFSET] = { .name = MPTCP_PM_EV_GRP_NAME,
1206 .flags = GENL_MCAST_CAP_NET_ADMIN,
1207 },
1208};
1209
1210void mptcp_pm_nl_subflow_chk_stale(const struct mptcp_sock *msk, struct sock *ssk)
1211{
1212 struct mptcp_subflow_context *iter, *subflow = mptcp_subflow_ctx(ssk);
1213 struct sock *sk = (struct sock *)msk;
1214 unsigned int active_max_loss_cnt;
1215 struct net *net = sock_net(sk);
1216 unsigned int stale_loss_cnt;
1217 bool slow;
1218
1219 stale_loss_cnt = mptcp_stale_loss_cnt(net);
1220 if (subflow->stale || !stale_loss_cnt || subflow->stale_count <= stale_loss_cnt)
1221 return;
1222
1223 /* look for another available subflow not in loss state */
1224 active_max_loss_cnt = max_t(int, stale_loss_cnt - 1, 1);
1225 mptcp_for_each_subflow(msk, iter) {
1226 if (iter != subflow && mptcp_subflow_active(iter) &&
1227 iter->stale_count < active_max_loss_cnt) {
1228 /* we have some alternatives, try to mark this subflow as idle ...*/
1229 slow = lock_sock_fast(ssk);
1230 if (!tcp_rtx_and_write_queues_empty(ssk)) {
1231 subflow->stale = 1;
1232 __mptcp_retransmit_pending_data(sk);
1233 MPTCP_INC_STATS(net, MPTCP_MIB_SUBFLOWSTALE);
1234 }
1235 unlock_sock_fast(ssk, slow);
1236
1237 /* always try to push the pending data regardless of re-injections:
1238 * we can possibly use backup subflows now, and subflow selection
1239 * is cheap under the msk socket lock
1240 */
1241 __mptcp_push_pending(sk, 0);
1242 return;
1243 }
1244 }
1245}
1246
1247static int mptcp_pm_family_to_addr(int family)
1248{
1249#if IS_ENABLED(CONFIG_MPTCP_IPV6)
1250 if (family == AF_INET6)
1251 return MPTCP_PM_ADDR_ATTR_ADDR6;
1252#endif
1253 return MPTCP_PM_ADDR_ATTR_ADDR4;
1254}
1255
1256static int mptcp_pm_parse_pm_addr_attr(struct nlattr *tb[],
1257 const struct nlattr *attr,
1258 struct genl_info *info,
1259 struct mptcp_addr_info *addr,
1260 bool require_family)
1261{
1262 int err, addr_addr;
1263
1264 if (!attr) {
1265 GENL_SET_ERR_MSG(info, "missing address info");
1266 return -EINVAL;
1267 }
1268
1269 /* no validation needed - was already done via nested policy */
1270 err = nla_parse_nested_deprecated(tb, MPTCP_PM_ADDR_ATTR_MAX, attr,
1271 mptcp_pm_address_nl_policy, info->extack);
1272 if (err)
1273 return err;
1274
1275 if (tb[MPTCP_PM_ADDR_ATTR_ID])
1276 addr->id = nla_get_u8(tb[MPTCP_PM_ADDR_ATTR_ID]);
1277
1278 if (!tb[MPTCP_PM_ADDR_ATTR_FAMILY]) {
1279 if (!require_family)
1280 return 0;
1281
1282 NL_SET_ERR_MSG_ATTR(info->extack, attr,
1283 "missing family");
1284 return -EINVAL;
1285 }
1286
1287 addr->family = nla_get_u16(tb[MPTCP_PM_ADDR_ATTR_FAMILY]);
1288 if (addr->family != AF_INET
1289#if IS_ENABLED(CONFIG_MPTCP_IPV6)
1290 && addr->family != AF_INET6
1291#endif
1292 ) {
1293 NL_SET_ERR_MSG_ATTR(info->extack, attr,
1294 "unknown address family");
1295 return -EINVAL;
1296 }
1297 addr_addr = mptcp_pm_family_to_addr(addr->family);
1298 if (!tb[addr_addr]) {
1299 NL_SET_ERR_MSG_ATTR(info->extack, attr,
1300 "missing address data");
1301 return -EINVAL;
1302 }
1303
1304#if IS_ENABLED(CONFIG_MPTCP_IPV6)
1305 if (addr->family == AF_INET6)
1306 addr->addr6 = nla_get_in6_addr(tb[addr_addr]);
1307 else
1308#endif
1309 addr->addr.s_addr = nla_get_in_addr(tb[addr_addr]);
1310
1311 if (tb[MPTCP_PM_ADDR_ATTR_PORT])
1312 addr->port = htons(nla_get_u16(tb[MPTCP_PM_ADDR_ATTR_PORT]));
1313
1314 return 0;
1315}
1316
1317int mptcp_pm_parse_addr(struct nlattr *attr, struct genl_info *info,
1318 struct mptcp_addr_info *addr)
1319{
1320 struct nlattr *tb[MPTCP_PM_ADDR_ATTR_MAX + 1];
1321
1322 memset(addr, 0, sizeof(*addr));
1323
1324 return mptcp_pm_parse_pm_addr_attr(tb, attr, info, addr, true);
1325}
1326
1327int mptcp_pm_parse_entry(struct nlattr *attr, struct genl_info *info,
1328 bool require_family,
1329 struct mptcp_pm_addr_entry *entry)
1330{
1331 struct nlattr *tb[MPTCP_PM_ADDR_ATTR_MAX + 1];
1332 int err;
1333
1334 memset(entry, 0, sizeof(*entry));
1335
1336 err = mptcp_pm_parse_pm_addr_attr(tb, attr, info, &entry->addr, require_family);
1337 if (err)
1338 return err;
1339
1340 if (tb[MPTCP_PM_ADDR_ATTR_IF_IDX]) {
1341 u32 val = nla_get_s32(tb[MPTCP_PM_ADDR_ATTR_IF_IDX]);
1342
1343 entry->ifindex = val;
1344 }
1345
1346 if (tb[MPTCP_PM_ADDR_ATTR_FLAGS])
1347 entry->flags = nla_get_u32(tb[MPTCP_PM_ADDR_ATTR_FLAGS]);
1348
1349 if (tb[MPTCP_PM_ADDR_ATTR_PORT])
1350 entry->addr.port = htons(nla_get_u16(tb[MPTCP_PM_ADDR_ATTR_PORT]));
1351
1352 return 0;
1353}
1354
1355static struct pm_nl_pernet *genl_info_pm_nl(struct genl_info *info)
1356{
1357 return pm_nl_get_pernet(genl_info_net(info));
1358}
1359
1360static int mptcp_nl_add_subflow_or_signal_addr(struct net *net,
1361 struct mptcp_addr_info *addr)
1362{
1363 struct mptcp_sock *msk;
1364 long s_slot = 0, s_num = 0;
1365
1366 while ((msk = mptcp_token_iter_next(net, &s_slot, &s_num)) != NULL) {
1367 struct sock *sk = (struct sock *)msk;
1368 struct mptcp_addr_info mpc_addr;
1369
1370 if (!READ_ONCE(msk->fully_established) ||
1371 mptcp_pm_is_userspace(msk))
1372 goto next;
1373
1374 /* if the endp linked to the init sf is re-added with a != ID */
1375 mptcp_local_address((struct sock_common *)msk, &mpc_addr);
1376
1377 lock_sock(sk);
1378 spin_lock_bh(&msk->pm.lock);
1379 if (mptcp_addresses_equal(addr, &mpc_addr, addr->port))
1380 msk->mpc_endpoint_id = addr->id;
1381 mptcp_pm_create_subflow_or_signal_addr(msk);
1382 spin_unlock_bh(&msk->pm.lock);
1383 release_sock(sk);
1384
1385next:
1386 sock_put(sk);
1387 cond_resched();
1388 }
1389
1390 return 0;
1391}
1392
1393static bool mptcp_pm_has_addr_attr_id(const struct nlattr *attr,
1394 struct genl_info *info)
1395{
1396 struct nlattr *tb[MPTCP_PM_ADDR_ATTR_MAX + 1];
1397
1398 if (!nla_parse_nested_deprecated(tb, MPTCP_PM_ADDR_ATTR_MAX, attr,
1399 mptcp_pm_address_nl_policy, info->extack) &&
1400 tb[MPTCP_PM_ADDR_ATTR_ID])
1401 return true;
1402 return false;
1403}
1404
1405int mptcp_pm_nl_add_addr_doit(struct sk_buff *skb, struct genl_info *info)
1406{
1407 struct nlattr *attr = info->attrs[MPTCP_PM_ENDPOINT_ADDR];
1408 struct pm_nl_pernet *pernet = genl_info_pm_nl(info);
1409 struct mptcp_pm_addr_entry addr, *entry;
1410 int ret;
1411
1412 ret = mptcp_pm_parse_entry(attr, info, true, &addr);
1413 if (ret < 0)
1414 return ret;
1415
1416 if (addr.addr.port && !address_use_port(&addr)) {
1417 GENL_SET_ERR_MSG(info, "flags must have signal and not subflow when using port");
1418 return -EINVAL;
1419 }
1420
1421 if (addr.flags & MPTCP_PM_ADDR_FLAG_SIGNAL &&
1422 addr.flags & MPTCP_PM_ADDR_FLAG_FULLMESH) {
1423 GENL_SET_ERR_MSG(info, "flags mustn't have both signal and fullmesh");
1424 return -EINVAL;
1425 }
1426
1427 if (addr.flags & MPTCP_PM_ADDR_FLAG_IMPLICIT) {
1428 GENL_SET_ERR_MSG(info, "can't create IMPLICIT endpoint");
1429 return -EINVAL;
1430 }
1431
1432 entry = kzalloc(sizeof(*entry), GFP_KERNEL_ACCOUNT);
1433 if (!entry) {
1434 GENL_SET_ERR_MSG(info, "can't allocate addr");
1435 return -ENOMEM;
1436 }
1437
1438 *entry = addr;
1439 if (entry->addr.port) {
1440 ret = mptcp_pm_nl_create_listen_socket(skb->sk, entry);
1441 if (ret) {
1442 GENL_SET_ERR_MSG_FMT(info, "create listen socket error: %d", ret);
1443 goto out_free;
1444 }
1445 }
1446 ret = mptcp_pm_nl_append_new_local_addr(pernet, entry,
1447 !mptcp_pm_has_addr_attr_id(attr, info),
1448 true);
1449 if (ret < 0) {
1450 GENL_SET_ERR_MSG_FMT(info, "too many addresses or duplicate one: %d", ret);
1451 goto out_free;
1452 }
1453
1454 mptcp_nl_add_subflow_or_signal_addr(sock_net(skb->sk), &entry->addr);
1455 return 0;
1456
1457out_free:
1458 __mptcp_pm_release_addr_entry(entry);
1459 return ret;
1460}
1461
1462static bool remove_anno_list_by_saddr(struct mptcp_sock *msk,
1463 const struct mptcp_addr_info *addr)
1464{
1465 struct mptcp_pm_add_entry *entry;
1466
1467 entry = mptcp_pm_del_add_timer(msk, addr, false);
1468 if (entry) {
1469 kfree(entry);
1470 return true;
1471 }
1472
1473 return false;
1474}
1475
1476static u8 mptcp_endp_get_local_id(struct mptcp_sock *msk,
1477 const struct mptcp_addr_info *addr)
1478{
1479 return msk->mpc_endpoint_id == addr->id ? 0 : addr->id;
1480}
1481
1482static bool mptcp_pm_remove_anno_addr(struct mptcp_sock *msk,
1483 const struct mptcp_addr_info *addr,
1484 bool force)
1485{
1486 struct mptcp_rm_list list = { .nr = 0 };
1487 bool ret;
1488
1489 list.ids[list.nr++] = mptcp_endp_get_local_id(msk, addr);
1490
1491 ret = remove_anno_list_by_saddr(msk, addr);
1492 if (ret || force) {
1493 spin_lock_bh(&msk->pm.lock);
1494 if (ret) {
1495 __set_bit(addr->id, msk->pm.id_avail_bitmap);
1496 msk->pm.add_addr_signaled--;
1497 }
1498 mptcp_pm_remove_addr(msk, &list);
1499 spin_unlock_bh(&msk->pm.lock);
1500 }
1501 return ret;
1502}
1503
1504static void __mark_subflow_endp_available(struct mptcp_sock *msk, u8 id)
1505{
1506 /* If it was marked as used, and not ID 0, decrement local_addr_used */
1507 if (!__test_and_set_bit(id ? : msk->mpc_endpoint_id, msk->pm.id_avail_bitmap) &&
1508 id && !WARN_ON_ONCE(msk->pm.local_addr_used == 0))
1509 msk->pm.local_addr_used--;
1510}
1511
1512static int mptcp_nl_remove_subflow_and_signal_addr(struct net *net,
1513 const struct mptcp_pm_addr_entry *entry)
1514{
1515 const struct mptcp_addr_info *addr = &entry->addr;
1516 struct mptcp_rm_list list = { .nr = 1 };
1517 long s_slot = 0, s_num = 0;
1518 struct mptcp_sock *msk;
1519
1520 pr_debug("remove_id=%d\n", addr->id);
1521
1522 while ((msk = mptcp_token_iter_next(net, &s_slot, &s_num)) != NULL) {
1523 struct sock *sk = (struct sock *)msk;
1524 bool remove_subflow;
1525
1526 if (mptcp_pm_is_userspace(msk))
1527 goto next;
1528
1529 lock_sock(sk);
1530 remove_subflow = lookup_subflow_by_saddr(&msk->conn_list, addr);
1531 mptcp_pm_remove_anno_addr(msk, addr, remove_subflow &&
1532 !(entry->flags & MPTCP_PM_ADDR_FLAG_IMPLICIT));
1533
1534 list.ids[0] = mptcp_endp_get_local_id(msk, addr);
1535 if (remove_subflow) {
1536 spin_lock_bh(&msk->pm.lock);
1537 mptcp_pm_nl_rm_subflow_received(msk, &list);
1538 spin_unlock_bh(&msk->pm.lock);
1539 }
1540
1541 if (entry->flags & MPTCP_PM_ADDR_FLAG_SUBFLOW) {
1542 spin_lock_bh(&msk->pm.lock);
1543 __mark_subflow_endp_available(msk, list.ids[0]);
1544 spin_unlock_bh(&msk->pm.lock);
1545 }
1546
1547 if (msk->mpc_endpoint_id == entry->addr.id)
1548 msk->mpc_endpoint_id = 0;
1549 release_sock(sk);
1550
1551next:
1552 sock_put(sk);
1553 cond_resched();
1554 }
1555
1556 return 0;
1557}
1558
1559static int mptcp_nl_remove_id_zero_address(struct net *net,
1560 struct mptcp_addr_info *addr)
1561{
1562 struct mptcp_rm_list list = { .nr = 0 };
1563 long s_slot = 0, s_num = 0;
1564 struct mptcp_sock *msk;
1565
1566 list.ids[list.nr++] = 0;
1567
1568 while ((msk = mptcp_token_iter_next(net, &s_slot, &s_num)) != NULL) {
1569 struct sock *sk = (struct sock *)msk;
1570 struct mptcp_addr_info msk_local;
1571
1572 if (list_empty(&msk->conn_list) || mptcp_pm_is_userspace(msk))
1573 goto next;
1574
1575 mptcp_local_address((struct sock_common *)msk, &msk_local);
1576 if (!mptcp_addresses_equal(&msk_local, addr, addr->port))
1577 goto next;
1578
1579 lock_sock(sk);
1580 spin_lock_bh(&msk->pm.lock);
1581 mptcp_pm_remove_addr(msk, &list);
1582 mptcp_pm_nl_rm_subflow_received(msk, &list);
1583 __mark_subflow_endp_available(msk, 0);
1584 spin_unlock_bh(&msk->pm.lock);
1585 release_sock(sk);
1586
1587next:
1588 sock_put(sk);
1589 cond_resched();
1590 }
1591
1592 return 0;
1593}
1594
1595int mptcp_pm_nl_del_addr_doit(struct sk_buff *skb, struct genl_info *info)
1596{
1597 struct nlattr *attr = info->attrs[MPTCP_PM_ENDPOINT_ADDR];
1598 struct pm_nl_pernet *pernet = genl_info_pm_nl(info);
1599 struct mptcp_pm_addr_entry addr, *entry;
1600 unsigned int addr_max;
1601 int ret;
1602
1603 ret = mptcp_pm_parse_entry(attr, info, false, &addr);
1604 if (ret < 0)
1605 return ret;
1606
1607 /* the zero id address is special: the first address used by the msk
1608 * always gets such an id, so different subflows can have different zero
1609 * id addresses. Additionally zero id is not accounted for in id_bitmap.
1610 * Let's use an 'mptcp_rm_list' instead of the common remove code.
1611 */
1612 if (addr.addr.id == 0)
1613 return mptcp_nl_remove_id_zero_address(sock_net(skb->sk), &addr.addr);
1614
1615 spin_lock_bh(&pernet->lock);
1616 entry = __lookup_addr_by_id(pernet, addr.addr.id);
1617 if (!entry) {
1618 GENL_SET_ERR_MSG(info, "address not found");
1619 spin_unlock_bh(&pernet->lock);
1620 return -EINVAL;
1621 }
1622 if (entry->flags & MPTCP_PM_ADDR_FLAG_SIGNAL) {
1623 addr_max = pernet->add_addr_signal_max;
1624 WRITE_ONCE(pernet->add_addr_signal_max, addr_max - 1);
1625 }
1626 if (entry->flags & MPTCP_PM_ADDR_FLAG_SUBFLOW) {
1627 addr_max = pernet->local_addr_max;
1628 WRITE_ONCE(pernet->local_addr_max, addr_max - 1);
1629 }
1630
1631 pernet->addrs--;
1632 list_del_rcu(&entry->list);
1633 __clear_bit(entry->addr.id, pernet->id_bitmap);
1634 spin_unlock_bh(&pernet->lock);
1635
1636 mptcp_nl_remove_subflow_and_signal_addr(sock_net(skb->sk), entry);
1637 synchronize_rcu();
1638 __mptcp_pm_release_addr_entry(entry);
1639
1640 return ret;
1641}
1642
1643/* Called from the userspace PM only */
1644void mptcp_pm_remove_addrs(struct mptcp_sock *msk, struct list_head *rm_list)
1645{
1646 struct mptcp_rm_list alist = { .nr = 0 };
1647 struct mptcp_pm_addr_entry *entry;
1648 int anno_nr = 0;
1649
1650 list_for_each_entry(entry, rm_list, list) {
1651 if (alist.nr >= MPTCP_RM_IDS_MAX)
1652 break;
1653
1654 /* only delete if either announced or matching a subflow */
1655 if (remove_anno_list_by_saddr(msk, &entry->addr))
1656 anno_nr++;
1657 else if (!lookup_subflow_by_saddr(&msk->conn_list,
1658 &entry->addr))
1659 continue;
1660
1661 alist.ids[alist.nr++] = entry->addr.id;
1662 }
1663
1664 if (alist.nr) {
1665 spin_lock_bh(&msk->pm.lock);
1666 msk->pm.add_addr_signaled -= anno_nr;
1667 mptcp_pm_remove_addr(msk, &alist);
1668 spin_unlock_bh(&msk->pm.lock);
1669 }
1670}
1671
1672/* Called from the in-kernel PM only */
1673static void mptcp_pm_flush_addrs_and_subflows(struct mptcp_sock *msk,
1674 struct list_head *rm_list)
1675{
1676 struct mptcp_rm_list alist = { .nr = 0 }, slist = { .nr = 0 };
1677 struct mptcp_pm_addr_entry *entry;
1678
1679 list_for_each_entry(entry, rm_list, list) {
1680 if (slist.nr < MPTCP_RM_IDS_MAX &&
1681 lookup_subflow_by_saddr(&msk->conn_list, &entry->addr))
1682 slist.ids[slist.nr++] = mptcp_endp_get_local_id(msk, &entry->addr);
1683
1684 if (alist.nr < MPTCP_RM_IDS_MAX &&
1685 remove_anno_list_by_saddr(msk, &entry->addr))
1686 alist.ids[alist.nr++] = mptcp_endp_get_local_id(msk, &entry->addr);
1687 }
1688
1689 spin_lock_bh(&msk->pm.lock);
1690 if (alist.nr) {
1691 msk->pm.add_addr_signaled -= alist.nr;
1692 mptcp_pm_remove_addr(msk, &alist);
1693 }
1694 if (slist.nr)
1695 mptcp_pm_nl_rm_subflow_received(msk, &slist);
1696 /* Reset counters: maybe some subflows have been removed before */
1697 bitmap_fill(msk->pm.id_avail_bitmap, MPTCP_PM_MAX_ADDR_ID + 1);
1698 msk->pm.local_addr_used = 0;
1699 spin_unlock_bh(&msk->pm.lock);
1700}
1701
1702static void mptcp_nl_flush_addrs_list(struct net *net,
1703 struct list_head *rm_list)
1704{
1705 long s_slot = 0, s_num = 0;
1706 struct mptcp_sock *msk;
1707
1708 if (list_empty(rm_list))
1709 return;
1710
1711 while ((msk = mptcp_token_iter_next(net, &s_slot, &s_num)) != NULL) {
1712 struct sock *sk = (struct sock *)msk;
1713
1714 if (!mptcp_pm_is_userspace(msk)) {
1715 lock_sock(sk);
1716 mptcp_pm_flush_addrs_and_subflows(msk, rm_list);
1717 release_sock(sk);
1718 }
1719
1720 sock_put(sk);
1721 cond_resched();
1722 }
1723}
1724
1725/* caller must ensure the RCU grace period is already elapsed */
1726static void __flush_addrs(struct list_head *list)
1727{
1728 while (!list_empty(list)) {
1729 struct mptcp_pm_addr_entry *cur;
1730
1731 cur = list_entry(list->next,
1732 struct mptcp_pm_addr_entry, list);
1733 list_del_rcu(&cur->list);
1734 __mptcp_pm_release_addr_entry(cur);
1735 }
1736}
1737
1738static void __reset_counters(struct pm_nl_pernet *pernet)
1739{
1740 WRITE_ONCE(pernet->add_addr_signal_max, 0);
1741 WRITE_ONCE(pernet->add_addr_accept_max, 0);
1742 WRITE_ONCE(pernet->local_addr_max, 0);
1743 pernet->addrs = 0;
1744}
1745
1746int mptcp_pm_nl_flush_addrs_doit(struct sk_buff *skb, struct genl_info *info)
1747{
1748 struct pm_nl_pernet *pernet = genl_info_pm_nl(info);
1749 LIST_HEAD(free_list);
1750
1751 spin_lock_bh(&pernet->lock);
1752 list_splice_init(&pernet->local_addr_list, &free_list);
1753 __reset_counters(pernet);
1754 pernet->next_id = 1;
1755 bitmap_zero(pernet->id_bitmap, MPTCP_PM_MAX_ADDR_ID + 1);
1756 spin_unlock_bh(&pernet->lock);
1757 mptcp_nl_flush_addrs_list(sock_net(skb->sk), &free_list);
1758 synchronize_rcu();
1759 __flush_addrs(&free_list);
1760 return 0;
1761}
1762
1763int mptcp_nl_fill_addr(struct sk_buff *skb,
1764 struct mptcp_pm_addr_entry *entry)
1765{
1766 struct mptcp_addr_info *addr = &entry->addr;
1767 struct nlattr *attr;
1768
1769 attr = nla_nest_start(skb, MPTCP_PM_ATTR_ADDR);
1770 if (!attr)
1771 return -EMSGSIZE;
1772
1773 if (nla_put_u16(skb, MPTCP_PM_ADDR_ATTR_FAMILY, addr->family))
1774 goto nla_put_failure;
1775 if (nla_put_u16(skb, MPTCP_PM_ADDR_ATTR_PORT, ntohs(addr->port)))
1776 goto nla_put_failure;
1777 if (nla_put_u8(skb, MPTCP_PM_ADDR_ATTR_ID, addr->id))
1778 goto nla_put_failure;
1779 if (nla_put_u32(skb, MPTCP_PM_ADDR_ATTR_FLAGS, entry->flags))
1780 goto nla_put_failure;
1781 if (entry->ifindex &&
1782 nla_put_s32(skb, MPTCP_PM_ADDR_ATTR_IF_IDX, entry->ifindex))
1783 goto nla_put_failure;
1784
1785 if (addr->family == AF_INET &&
1786 nla_put_in_addr(skb, MPTCP_PM_ADDR_ATTR_ADDR4,
1787 addr->addr.s_addr))
1788 goto nla_put_failure;
1789#if IS_ENABLED(CONFIG_MPTCP_IPV6)
1790 else if (addr->family == AF_INET6 &&
1791 nla_put_in6_addr(skb, MPTCP_PM_ADDR_ATTR_ADDR6, &addr->addr6))
1792 goto nla_put_failure;
1793#endif
1794 nla_nest_end(skb, attr);
1795 return 0;
1796
1797nla_put_failure:
1798 nla_nest_cancel(skb, attr);
1799 return -EMSGSIZE;
1800}
1801
1802int mptcp_pm_nl_get_addr(struct sk_buff *skb, struct genl_info *info)
1803{
1804 struct nlattr *attr = info->attrs[MPTCP_PM_ENDPOINT_ADDR];
1805 struct pm_nl_pernet *pernet = genl_info_pm_nl(info);
1806 struct mptcp_pm_addr_entry addr, *entry;
1807 struct sk_buff *msg;
1808 void *reply;
1809 int ret;
1810
1811 ret = mptcp_pm_parse_entry(attr, info, false, &addr);
1812 if (ret < 0)
1813 return ret;
1814
1815 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1816 if (!msg)
1817 return -ENOMEM;
1818
1819 reply = genlmsg_put_reply(msg, info, &mptcp_genl_family, 0,
1820 info->genlhdr->cmd);
1821 if (!reply) {
1822 GENL_SET_ERR_MSG(info, "not enough space in Netlink message");
1823 ret = -EMSGSIZE;
1824 goto fail;
1825 }
1826
1827 rcu_read_lock();
1828 entry = __lookup_addr_by_id(pernet, addr.addr.id);
1829 if (!entry) {
1830 GENL_SET_ERR_MSG(info, "address not found");
1831 ret = -EINVAL;
1832 goto unlock_fail;
1833 }
1834
1835 ret = mptcp_nl_fill_addr(msg, entry);
1836 if (ret)
1837 goto unlock_fail;
1838
1839 genlmsg_end(msg, reply);
1840 ret = genlmsg_reply(msg, info);
1841 rcu_read_unlock();
1842 return ret;
1843
1844unlock_fail:
1845 rcu_read_unlock();
1846
1847fail:
1848 nlmsg_free(msg);
1849 return ret;
1850}
1851
1852int mptcp_pm_nl_get_addr_doit(struct sk_buff *skb, struct genl_info *info)
1853{
1854 return mptcp_pm_get_addr(skb, info);
1855}
1856
1857int mptcp_pm_nl_dump_addr(struct sk_buff *msg,
1858 struct netlink_callback *cb)
1859{
1860 struct net *net = sock_net(msg->sk);
1861 struct mptcp_pm_addr_entry *entry;
1862 struct pm_nl_pernet *pernet;
1863 int id = cb->args[0];
1864 void *hdr;
1865 int i;
1866
1867 pernet = pm_nl_get_pernet(net);
1868
1869 rcu_read_lock();
1870 for (i = id; i < MPTCP_PM_MAX_ADDR_ID + 1; i++) {
1871 if (test_bit(i, pernet->id_bitmap)) {
1872 entry = __lookup_addr_by_id(pernet, i);
1873 if (!entry)
1874 break;
1875
1876 if (entry->addr.id <= id)
1877 continue;
1878
1879 hdr = genlmsg_put(msg, NETLINK_CB(cb->skb).portid,
1880 cb->nlh->nlmsg_seq, &mptcp_genl_family,
1881 NLM_F_MULTI, MPTCP_PM_CMD_GET_ADDR);
1882 if (!hdr)
1883 break;
1884
1885 if (mptcp_nl_fill_addr(msg, entry) < 0) {
1886 genlmsg_cancel(msg, hdr);
1887 break;
1888 }
1889
1890 id = entry->addr.id;
1891 genlmsg_end(msg, hdr);
1892 }
1893 }
1894 rcu_read_unlock();
1895
1896 cb->args[0] = id;
1897 return msg->len;
1898}
1899
1900int mptcp_pm_nl_get_addr_dumpit(struct sk_buff *msg,
1901 struct netlink_callback *cb)
1902{
1903 return mptcp_pm_dump_addr(msg, cb);
1904}
1905
1906static int parse_limit(struct genl_info *info, int id, unsigned int *limit)
1907{
1908 struct nlattr *attr = info->attrs[id];
1909
1910 if (!attr)
1911 return 0;
1912
1913 *limit = nla_get_u32(attr);
1914 if (*limit > MPTCP_PM_ADDR_MAX) {
1915 GENL_SET_ERR_MSG(info, "limit greater than maximum");
1916 return -EINVAL;
1917 }
1918 return 0;
1919}
1920
1921int mptcp_pm_nl_set_limits_doit(struct sk_buff *skb, struct genl_info *info)
1922{
1923 struct pm_nl_pernet *pernet = genl_info_pm_nl(info);
1924 unsigned int rcv_addrs, subflows;
1925 int ret;
1926
1927 spin_lock_bh(&pernet->lock);
1928 rcv_addrs = pernet->add_addr_accept_max;
1929 ret = parse_limit(info, MPTCP_PM_ATTR_RCV_ADD_ADDRS, &rcv_addrs);
1930 if (ret)
1931 goto unlock;
1932
1933 subflows = pernet->subflows_max;
1934 ret = parse_limit(info, MPTCP_PM_ATTR_SUBFLOWS, &subflows);
1935 if (ret)
1936 goto unlock;
1937
1938 WRITE_ONCE(pernet->add_addr_accept_max, rcv_addrs);
1939 WRITE_ONCE(pernet->subflows_max, subflows);
1940
1941unlock:
1942 spin_unlock_bh(&pernet->lock);
1943 return ret;
1944}
1945
1946int mptcp_pm_nl_get_limits_doit(struct sk_buff *skb, struct genl_info *info)
1947{
1948 struct pm_nl_pernet *pernet = genl_info_pm_nl(info);
1949 struct sk_buff *msg;
1950 void *reply;
1951
1952 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1953 if (!msg)
1954 return -ENOMEM;
1955
1956 reply = genlmsg_put_reply(msg, info, &mptcp_genl_family, 0,
1957 MPTCP_PM_CMD_GET_LIMITS);
1958 if (!reply)
1959 goto fail;
1960
1961 if (nla_put_u32(msg, MPTCP_PM_ATTR_RCV_ADD_ADDRS,
1962 READ_ONCE(pernet->add_addr_accept_max)))
1963 goto fail;
1964
1965 if (nla_put_u32(msg, MPTCP_PM_ATTR_SUBFLOWS,
1966 READ_ONCE(pernet->subflows_max)))
1967 goto fail;
1968
1969 genlmsg_end(msg, reply);
1970 return genlmsg_reply(msg, info);
1971
1972fail:
1973 GENL_SET_ERR_MSG(info, "not enough space in Netlink message");
1974 nlmsg_free(msg);
1975 return -EMSGSIZE;
1976}
1977
1978static void mptcp_pm_nl_fullmesh(struct mptcp_sock *msk,
1979 struct mptcp_addr_info *addr)
1980{
1981 struct mptcp_rm_list list = { .nr = 0 };
1982
1983 list.ids[list.nr++] = mptcp_endp_get_local_id(msk, addr);
1984
1985 spin_lock_bh(&msk->pm.lock);
1986 mptcp_pm_nl_rm_subflow_received(msk, &list);
1987 __mark_subflow_endp_available(msk, list.ids[0]);
1988 mptcp_pm_create_subflow_or_signal_addr(msk);
1989 spin_unlock_bh(&msk->pm.lock);
1990}
1991
1992static int mptcp_nl_set_flags(struct net *net,
1993 struct mptcp_addr_info *addr,
1994 u8 bkup, u8 changed)
1995{
1996 long s_slot = 0, s_num = 0;
1997 struct mptcp_sock *msk;
1998 int ret = -EINVAL;
1999
2000 while ((msk = mptcp_token_iter_next(net, &s_slot, &s_num)) != NULL) {
2001 struct sock *sk = (struct sock *)msk;
2002
2003 if (list_empty(&msk->conn_list) || mptcp_pm_is_userspace(msk))
2004 goto next;
2005
2006 lock_sock(sk);
2007 if (changed & MPTCP_PM_ADDR_FLAG_BACKUP)
2008 ret = mptcp_pm_nl_mp_prio_send_ack(msk, addr, NULL, bkup);
2009 if (changed & MPTCP_PM_ADDR_FLAG_FULLMESH)
2010 mptcp_pm_nl_fullmesh(msk, addr);
2011 release_sock(sk);
2012
2013next:
2014 sock_put(sk);
2015 cond_resched();
2016 }
2017
2018 return ret;
2019}
2020
2021int mptcp_pm_nl_set_flags(struct sk_buff *skb, struct genl_info *info)
2022{
2023 struct mptcp_pm_addr_entry addr = { .addr = { .family = AF_UNSPEC }, };
2024 struct nlattr *attr = info->attrs[MPTCP_PM_ATTR_ADDR];
2025 u8 changed, mask = MPTCP_PM_ADDR_FLAG_BACKUP |
2026 MPTCP_PM_ADDR_FLAG_FULLMESH;
2027 struct net *net = sock_net(skb->sk);
2028 struct mptcp_pm_addr_entry *entry;
2029 struct pm_nl_pernet *pernet;
2030 u8 lookup_by_id = 0;
2031 u8 bkup = 0;
2032 int ret;
2033
2034 pernet = pm_nl_get_pernet(net);
2035
2036 ret = mptcp_pm_parse_entry(attr, info, false, &addr);
2037 if (ret < 0)
2038 return ret;
2039
2040 if (addr.addr.family == AF_UNSPEC) {
2041 lookup_by_id = 1;
2042 if (!addr.addr.id) {
2043 GENL_SET_ERR_MSG(info, "missing required inputs");
2044 return -EOPNOTSUPP;
2045 }
2046 }
2047
2048 if (addr.flags & MPTCP_PM_ADDR_FLAG_BACKUP)
2049 bkup = 1;
2050
2051 spin_lock_bh(&pernet->lock);
2052 entry = lookup_by_id ? __lookup_addr_by_id(pernet, addr.addr.id) :
2053 __lookup_addr(pernet, &addr.addr);
2054 if (!entry) {
2055 spin_unlock_bh(&pernet->lock);
2056 GENL_SET_ERR_MSG(info, "address not found");
2057 return -EINVAL;
2058 }
2059 if ((addr.flags & MPTCP_PM_ADDR_FLAG_FULLMESH) &&
2060 (entry->flags & (MPTCP_PM_ADDR_FLAG_SIGNAL |
2061 MPTCP_PM_ADDR_FLAG_IMPLICIT))) {
2062 spin_unlock_bh(&pernet->lock);
2063 GENL_SET_ERR_MSG(info, "invalid addr flags");
2064 return -EINVAL;
2065 }
2066
2067 changed = (addr.flags ^ entry->flags) & mask;
2068 entry->flags = (entry->flags & ~mask) | (addr.flags & mask);
2069 addr = *entry;
2070 spin_unlock_bh(&pernet->lock);
2071
2072 mptcp_nl_set_flags(net, &addr.addr, bkup, changed);
2073 return 0;
2074}
2075
2076int mptcp_pm_nl_set_flags_doit(struct sk_buff *skb, struct genl_info *info)
2077{
2078 return mptcp_pm_set_flags(skb, info);
2079}
2080
2081static void mptcp_nl_mcast_send(struct net *net, struct sk_buff *nlskb, gfp_t gfp)
2082{
2083 genlmsg_multicast_netns(&mptcp_genl_family, net,
2084 nlskb, 0, MPTCP_PM_EV_GRP_OFFSET, gfp);
2085}
2086
2087bool mptcp_userspace_pm_active(const struct mptcp_sock *msk)
2088{
2089 return genl_has_listeners(&mptcp_genl_family,
2090 sock_net((const struct sock *)msk),
2091 MPTCP_PM_EV_GRP_OFFSET);
2092}
2093
2094static int mptcp_event_add_subflow(struct sk_buff *skb, const struct sock *ssk)
2095{
2096 const struct inet_sock *issk = inet_sk(ssk);
2097 const struct mptcp_subflow_context *sf;
2098
2099 if (nla_put_u16(skb, MPTCP_ATTR_FAMILY, ssk->sk_family))
2100 return -EMSGSIZE;
2101
2102 switch (ssk->sk_family) {
2103 case AF_INET:
2104 if (nla_put_in_addr(skb, MPTCP_ATTR_SADDR4, issk->inet_saddr))
2105 return -EMSGSIZE;
2106 if (nla_put_in_addr(skb, MPTCP_ATTR_DADDR4, issk->inet_daddr))
2107 return -EMSGSIZE;
2108 break;
2109#if IS_ENABLED(CONFIG_MPTCP_IPV6)
2110 case AF_INET6: {
2111 const struct ipv6_pinfo *np = inet6_sk(ssk);
2112
2113 if (nla_put_in6_addr(skb, MPTCP_ATTR_SADDR6, &np->saddr))
2114 return -EMSGSIZE;
2115 if (nla_put_in6_addr(skb, MPTCP_ATTR_DADDR6, &ssk->sk_v6_daddr))
2116 return -EMSGSIZE;
2117 break;
2118 }
2119#endif
2120 default:
2121 WARN_ON_ONCE(1);
2122 return -EMSGSIZE;
2123 }
2124
2125 if (nla_put_be16(skb, MPTCP_ATTR_SPORT, issk->inet_sport))
2126 return -EMSGSIZE;
2127 if (nla_put_be16(skb, MPTCP_ATTR_DPORT, issk->inet_dport))
2128 return -EMSGSIZE;
2129
2130 sf = mptcp_subflow_ctx(ssk);
2131 if (WARN_ON_ONCE(!sf))
2132 return -EINVAL;
2133
2134 if (nla_put_u8(skb, MPTCP_ATTR_LOC_ID, subflow_get_local_id(sf)))
2135 return -EMSGSIZE;
2136
2137 if (nla_put_u8(skb, MPTCP_ATTR_REM_ID, sf->remote_id))
2138 return -EMSGSIZE;
2139
2140 return 0;
2141}
2142
2143static int mptcp_event_put_token_and_ssk(struct sk_buff *skb,
2144 const struct mptcp_sock *msk,
2145 const struct sock *ssk)
2146{
2147 const struct sock *sk = (const struct sock *)msk;
2148 const struct mptcp_subflow_context *sf;
2149 u8 sk_err;
2150
2151 if (nla_put_u32(skb, MPTCP_ATTR_TOKEN, READ_ONCE(msk->token)))
2152 return -EMSGSIZE;
2153
2154 if (mptcp_event_add_subflow(skb, ssk))
2155 return -EMSGSIZE;
2156
2157 sf = mptcp_subflow_ctx(ssk);
2158 if (WARN_ON_ONCE(!sf))
2159 return -EINVAL;
2160
2161 if (nla_put_u8(skb, MPTCP_ATTR_BACKUP, sf->backup))
2162 return -EMSGSIZE;
2163
2164 if (ssk->sk_bound_dev_if &&
2165 nla_put_s32(skb, MPTCP_ATTR_IF_IDX, ssk->sk_bound_dev_if))
2166 return -EMSGSIZE;
2167
2168 sk_err = READ_ONCE(ssk->sk_err);
2169 if (sk_err && sk->sk_state == TCP_ESTABLISHED &&
2170 nla_put_u8(skb, MPTCP_ATTR_ERROR, sk_err))
2171 return -EMSGSIZE;
2172
2173 return 0;
2174}
2175
2176static int mptcp_event_sub_established(struct sk_buff *skb,
2177 const struct mptcp_sock *msk,
2178 const struct sock *ssk)
2179{
2180 return mptcp_event_put_token_and_ssk(skb, msk, ssk);
2181}
2182
2183static int mptcp_event_sub_closed(struct sk_buff *skb,
2184 const struct mptcp_sock *msk,
2185 const struct sock *ssk)
2186{
2187 const struct mptcp_subflow_context *sf;
2188
2189 if (mptcp_event_put_token_and_ssk(skb, msk, ssk))
2190 return -EMSGSIZE;
2191
2192 sf = mptcp_subflow_ctx(ssk);
2193 if (!sf->reset_seen)
2194 return 0;
2195
2196 if (nla_put_u32(skb, MPTCP_ATTR_RESET_REASON, sf->reset_reason))
2197 return -EMSGSIZE;
2198
2199 if (nla_put_u32(skb, MPTCP_ATTR_RESET_FLAGS, sf->reset_transient))
2200 return -EMSGSIZE;
2201
2202 return 0;
2203}
2204
2205static int mptcp_event_created(struct sk_buff *skb,
2206 const struct mptcp_sock *msk,
2207 const struct sock *ssk)
2208{
2209 int err = nla_put_u32(skb, MPTCP_ATTR_TOKEN, READ_ONCE(msk->token));
2210
2211 if (err)
2212 return err;
2213
2214 if (nla_put_u8(skb, MPTCP_ATTR_SERVER_SIDE, READ_ONCE(msk->pm.server_side)))
2215 return -EMSGSIZE;
2216
2217 return mptcp_event_add_subflow(skb, ssk);
2218}
2219
2220void mptcp_event_addr_removed(const struct mptcp_sock *msk, uint8_t id)
2221{
2222 struct net *net = sock_net((const struct sock *)msk);
2223 struct nlmsghdr *nlh;
2224 struct sk_buff *skb;
2225
2226 if (!genl_has_listeners(&mptcp_genl_family, net, MPTCP_PM_EV_GRP_OFFSET))
2227 return;
2228
2229 skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
2230 if (!skb)
2231 return;
2232
2233 nlh = genlmsg_put(skb, 0, 0, &mptcp_genl_family, 0, MPTCP_EVENT_REMOVED);
2234 if (!nlh)
2235 goto nla_put_failure;
2236
2237 if (nla_put_u32(skb, MPTCP_ATTR_TOKEN, READ_ONCE(msk->token)))
2238 goto nla_put_failure;
2239
2240 if (nla_put_u8(skb, MPTCP_ATTR_REM_ID, id))
2241 goto nla_put_failure;
2242
2243 genlmsg_end(skb, nlh);
2244 mptcp_nl_mcast_send(net, skb, GFP_ATOMIC);
2245 return;
2246
2247nla_put_failure:
2248 nlmsg_free(skb);
2249}
2250
2251void mptcp_event_addr_announced(const struct sock *ssk,
2252 const struct mptcp_addr_info *info)
2253{
2254 struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(ssk);
2255 struct mptcp_sock *msk = mptcp_sk(subflow->conn);
2256 struct net *net = sock_net(ssk);
2257 struct nlmsghdr *nlh;
2258 struct sk_buff *skb;
2259
2260 if (!genl_has_listeners(&mptcp_genl_family, net, MPTCP_PM_EV_GRP_OFFSET))
2261 return;
2262
2263 skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
2264 if (!skb)
2265 return;
2266
2267 nlh = genlmsg_put(skb, 0, 0, &mptcp_genl_family, 0,
2268 MPTCP_EVENT_ANNOUNCED);
2269 if (!nlh)
2270 goto nla_put_failure;
2271
2272 if (nla_put_u32(skb, MPTCP_ATTR_TOKEN, READ_ONCE(msk->token)))
2273 goto nla_put_failure;
2274
2275 if (nla_put_u8(skb, MPTCP_ATTR_REM_ID, info->id))
2276 goto nla_put_failure;
2277
2278 if (nla_put_be16(skb, MPTCP_ATTR_DPORT,
2279 info->port == 0 ?
2280 inet_sk(ssk)->inet_dport :
2281 info->port))
2282 goto nla_put_failure;
2283
2284 switch (info->family) {
2285 case AF_INET:
2286 if (nla_put_in_addr(skb, MPTCP_ATTR_DADDR4, info->addr.s_addr))
2287 goto nla_put_failure;
2288 break;
2289#if IS_ENABLED(CONFIG_MPTCP_IPV6)
2290 case AF_INET6:
2291 if (nla_put_in6_addr(skb, MPTCP_ATTR_DADDR6, &info->addr6))
2292 goto nla_put_failure;
2293 break;
2294#endif
2295 default:
2296 WARN_ON_ONCE(1);
2297 goto nla_put_failure;
2298 }
2299
2300 genlmsg_end(skb, nlh);
2301 mptcp_nl_mcast_send(net, skb, GFP_ATOMIC);
2302 return;
2303
2304nla_put_failure:
2305 nlmsg_free(skb);
2306}
2307
2308void mptcp_event_pm_listener(const struct sock *ssk,
2309 enum mptcp_event_type event)
2310{
2311 const struct inet_sock *issk = inet_sk(ssk);
2312 struct net *net = sock_net(ssk);
2313 struct nlmsghdr *nlh;
2314 struct sk_buff *skb;
2315
2316 if (!genl_has_listeners(&mptcp_genl_family, net, MPTCP_PM_EV_GRP_OFFSET))
2317 return;
2318
2319 skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
2320 if (!skb)
2321 return;
2322
2323 nlh = genlmsg_put(skb, 0, 0, &mptcp_genl_family, 0, event);
2324 if (!nlh)
2325 goto nla_put_failure;
2326
2327 if (nla_put_u16(skb, MPTCP_ATTR_FAMILY, ssk->sk_family))
2328 goto nla_put_failure;
2329
2330 if (nla_put_be16(skb, MPTCP_ATTR_SPORT, issk->inet_sport))
2331 goto nla_put_failure;
2332
2333 switch (ssk->sk_family) {
2334 case AF_INET:
2335 if (nla_put_in_addr(skb, MPTCP_ATTR_SADDR4, issk->inet_saddr))
2336 goto nla_put_failure;
2337 break;
2338#if IS_ENABLED(CONFIG_MPTCP_IPV6)
2339 case AF_INET6: {
2340 const struct ipv6_pinfo *np = inet6_sk(ssk);
2341
2342 if (nla_put_in6_addr(skb, MPTCP_ATTR_SADDR6, &np->saddr))
2343 goto nla_put_failure;
2344 break;
2345 }
2346#endif
2347 default:
2348 WARN_ON_ONCE(1);
2349 goto nla_put_failure;
2350 }
2351
2352 genlmsg_end(skb, nlh);
2353 mptcp_nl_mcast_send(net, skb, GFP_KERNEL);
2354 return;
2355
2356nla_put_failure:
2357 nlmsg_free(skb);
2358}
2359
2360void mptcp_event(enum mptcp_event_type type, const struct mptcp_sock *msk,
2361 const struct sock *ssk, gfp_t gfp)
2362{
2363 struct net *net = sock_net((const struct sock *)msk);
2364 struct nlmsghdr *nlh;
2365 struct sk_buff *skb;
2366
2367 if (!genl_has_listeners(&mptcp_genl_family, net, MPTCP_PM_EV_GRP_OFFSET))
2368 return;
2369
2370 skb = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
2371 if (!skb)
2372 return;
2373
2374 nlh = genlmsg_put(skb, 0, 0, &mptcp_genl_family, 0, type);
2375 if (!nlh)
2376 goto nla_put_failure;
2377
2378 switch (type) {
2379 case MPTCP_EVENT_UNSPEC:
2380 WARN_ON_ONCE(1);
2381 break;
2382 case MPTCP_EVENT_CREATED:
2383 case MPTCP_EVENT_ESTABLISHED:
2384 if (mptcp_event_created(skb, msk, ssk) < 0)
2385 goto nla_put_failure;
2386 break;
2387 case MPTCP_EVENT_CLOSED:
2388 if (nla_put_u32(skb, MPTCP_ATTR_TOKEN, READ_ONCE(msk->token)) < 0)
2389 goto nla_put_failure;
2390 break;
2391 case MPTCP_EVENT_ANNOUNCED:
2392 case MPTCP_EVENT_REMOVED:
2393 /* call mptcp_event_addr_announced()/removed instead */
2394 WARN_ON_ONCE(1);
2395 break;
2396 case MPTCP_EVENT_SUB_ESTABLISHED:
2397 case MPTCP_EVENT_SUB_PRIORITY:
2398 if (mptcp_event_sub_established(skb, msk, ssk) < 0)
2399 goto nla_put_failure;
2400 break;
2401 case MPTCP_EVENT_SUB_CLOSED:
2402 if (mptcp_event_sub_closed(skb, msk, ssk) < 0)
2403 goto nla_put_failure;
2404 break;
2405 case MPTCP_EVENT_LISTENER_CREATED:
2406 case MPTCP_EVENT_LISTENER_CLOSED:
2407 break;
2408 }
2409
2410 genlmsg_end(skb, nlh);
2411 mptcp_nl_mcast_send(net, skb, gfp);
2412 return;
2413
2414nla_put_failure:
2415 nlmsg_free(skb);
2416}
2417
2418struct genl_family mptcp_genl_family __ro_after_init = {
2419 .name = MPTCP_PM_NAME,
2420 .version = MPTCP_PM_VER,
2421 .netnsok = true,
2422 .module = THIS_MODULE,
2423 .ops = mptcp_pm_nl_ops,
2424 .n_ops = ARRAY_SIZE(mptcp_pm_nl_ops),
2425 .resv_start_op = MPTCP_PM_CMD_SUBFLOW_DESTROY + 1,
2426 .mcgrps = mptcp_pm_mcgrps,
2427 .n_mcgrps = ARRAY_SIZE(mptcp_pm_mcgrps),
2428};
2429
2430static int __net_init pm_nl_init_net(struct net *net)
2431{
2432 struct pm_nl_pernet *pernet = pm_nl_get_pernet(net);
2433
2434 INIT_LIST_HEAD_RCU(&pernet->local_addr_list);
2435
2436 /* Cit. 2 subflows ought to be enough for anybody. */
2437 pernet->subflows_max = 2;
2438 pernet->next_id = 1;
2439 pernet->stale_loss_cnt = 4;
2440 spin_lock_init(&pernet->lock);
2441
2442 /* No need to initialize other pernet fields, the struct is zeroed at
2443 * allocation time.
2444 */
2445
2446 return 0;
2447}
2448
2449static void __net_exit pm_nl_exit_net(struct list_head *net_list)
2450{
2451 struct net *net;
2452
2453 list_for_each_entry(net, net_list, exit_list) {
2454 struct pm_nl_pernet *pernet = pm_nl_get_pernet(net);
2455
2456 /* net is removed from namespace list, can't race with
2457 * other modifiers, also netns core already waited for a
2458 * RCU grace period.
2459 */
2460 __flush_addrs(&pernet->local_addr_list);
2461 }
2462}
2463
2464static struct pernet_operations mptcp_pm_pernet_ops = {
2465 .init = pm_nl_init_net,
2466 .exit_batch = pm_nl_exit_net,
2467 .id = &pm_nl_pernet_id,
2468 .size = sizeof(struct pm_nl_pernet),
2469};
2470
2471void __init mptcp_pm_nl_init(void)
2472{
2473 if (register_pernet_subsys(&mptcp_pm_pernet_ops) < 0)
2474 panic("Failed to register MPTCP PM pernet subsystem.\n");
2475
2476 if (genl_register_family(&mptcp_genl_family))
2477 panic("Failed to register MPTCP PM netlink family\n");
2478}