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