Loading...
Note: File does not exist in v3.15.
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/tcp.h>
12#include <net/netns/generic.h>
13#include <net/mptcp.h>
14#include <net/genetlink.h>
15#include <uapi/linux/mptcp.h>
16
17#include "protocol.h"
18
19/* forward declaration */
20static struct genl_family mptcp_genl_family;
21
22static int pm_nl_pernet_id;
23
24struct mptcp_pm_addr_entry {
25 struct list_head list;
26 unsigned int flags;
27 int ifindex;
28 struct mptcp_addr_info addr;
29 struct rcu_head rcu;
30};
31
32struct pm_nl_pernet {
33 /* protects pernet updates */
34 spinlock_t lock;
35 struct list_head local_addr_list;
36 unsigned int addrs;
37 unsigned int add_addr_signal_max;
38 unsigned int add_addr_accept_max;
39 unsigned int local_addr_max;
40 unsigned int subflows_max;
41 unsigned int next_id;
42};
43
44#define MPTCP_PM_ADDR_MAX 8
45
46static bool addresses_equal(const struct mptcp_addr_info *a,
47 struct mptcp_addr_info *b, bool use_port)
48{
49 bool addr_equals = false;
50
51 if (a->family != b->family)
52 return false;
53
54 if (a->family == AF_INET)
55 addr_equals = a->addr.s_addr == b->addr.s_addr;
56#if IS_ENABLED(CONFIG_MPTCP_IPV6)
57 else
58 addr_equals = !ipv6_addr_cmp(&a->addr6, &b->addr6);
59#endif
60
61 if (!addr_equals)
62 return false;
63 if (!use_port)
64 return true;
65
66 return a->port == b->port;
67}
68
69static bool address_zero(const struct mptcp_addr_info *addr)
70{
71 struct mptcp_addr_info zero;
72
73 memset(&zero, 0, sizeof(zero));
74 zero.family = addr->family;
75
76 return addresses_equal(addr, &zero, false);
77}
78
79static void local_address(const struct sock_common *skc,
80 struct mptcp_addr_info *addr)
81{
82 addr->port = 0;
83 addr->family = skc->skc_family;
84 if (addr->family == AF_INET)
85 addr->addr.s_addr = skc->skc_rcv_saddr;
86#if IS_ENABLED(CONFIG_MPTCP_IPV6)
87 else if (addr->family == AF_INET6)
88 addr->addr6 = skc->skc_v6_rcv_saddr;
89#endif
90}
91
92static void remote_address(const struct sock_common *skc,
93 struct mptcp_addr_info *addr)
94{
95 addr->family = skc->skc_family;
96 addr->port = skc->skc_dport;
97 if (addr->family == AF_INET)
98 addr->addr.s_addr = skc->skc_daddr;
99#if IS_ENABLED(CONFIG_MPTCP_IPV6)
100 else if (addr->family == AF_INET6)
101 addr->addr6 = skc->skc_v6_daddr;
102#endif
103}
104
105static bool lookup_subflow_by_saddr(const struct list_head *list,
106 struct mptcp_addr_info *saddr)
107{
108 struct mptcp_subflow_context *subflow;
109 struct mptcp_addr_info cur;
110 struct sock_common *skc;
111
112 list_for_each_entry(subflow, list, node) {
113 skc = (struct sock_common *)mptcp_subflow_tcp_sock(subflow);
114
115 local_address(skc, &cur);
116 if (addresses_equal(&cur, saddr, false))
117 return true;
118 }
119
120 return false;
121}
122
123static struct mptcp_pm_addr_entry *
124select_local_address(const struct pm_nl_pernet *pernet,
125 struct mptcp_sock *msk)
126{
127 struct mptcp_pm_addr_entry *entry, *ret = NULL;
128
129 rcu_read_lock();
130 spin_lock_bh(&msk->join_list_lock);
131 list_for_each_entry_rcu(entry, &pernet->local_addr_list, list) {
132 if (!(entry->flags & MPTCP_PM_ADDR_FLAG_SUBFLOW))
133 continue;
134
135 /* avoid any address already in use by subflows and
136 * pending join
137 */
138 if (entry->addr.family == ((struct sock *)msk)->sk_family &&
139 !lookup_subflow_by_saddr(&msk->conn_list, &entry->addr) &&
140 !lookup_subflow_by_saddr(&msk->join_list, &entry->addr)) {
141 ret = entry;
142 break;
143 }
144 }
145 spin_unlock_bh(&msk->join_list_lock);
146 rcu_read_unlock();
147 return ret;
148}
149
150static struct mptcp_pm_addr_entry *
151select_signal_address(struct pm_nl_pernet *pernet, unsigned int pos)
152{
153 struct mptcp_pm_addr_entry *entry, *ret = NULL;
154 int i = 0;
155
156 rcu_read_lock();
157 /* do not keep any additional per socket state, just signal
158 * the address list in order.
159 * Note: removal from the local address list during the msk life-cycle
160 * can lead to additional addresses not being announced.
161 */
162 list_for_each_entry_rcu(entry, &pernet->local_addr_list, list) {
163 if (!(entry->flags & MPTCP_PM_ADDR_FLAG_SIGNAL))
164 continue;
165 if (i++ == pos) {
166 ret = entry;
167 break;
168 }
169 }
170 rcu_read_unlock();
171 return ret;
172}
173
174static void check_work_pending(struct mptcp_sock *msk)
175{
176 if (msk->pm.add_addr_signaled == msk->pm.add_addr_signal_max &&
177 (msk->pm.local_addr_used == msk->pm.local_addr_max ||
178 msk->pm.subflows == msk->pm.subflows_max))
179 WRITE_ONCE(msk->pm.work_pending, false);
180}
181
182static void mptcp_pm_create_subflow_or_signal_addr(struct mptcp_sock *msk)
183{
184 struct mptcp_addr_info remote = { 0 };
185 struct sock *sk = (struct sock *)msk;
186 struct mptcp_pm_addr_entry *local;
187 struct pm_nl_pernet *pernet;
188
189 pernet = net_generic(sock_net((struct sock *)msk), pm_nl_pernet_id);
190
191 pr_debug("local %d:%d signal %d:%d subflows %d:%d\n",
192 msk->pm.local_addr_used, msk->pm.local_addr_max,
193 msk->pm.add_addr_signaled, msk->pm.add_addr_signal_max,
194 msk->pm.subflows, msk->pm.subflows_max);
195
196 /* check first for announce */
197 if (msk->pm.add_addr_signaled < msk->pm.add_addr_signal_max) {
198 local = select_signal_address(pernet,
199 msk->pm.add_addr_signaled);
200
201 if (local) {
202 msk->pm.add_addr_signaled++;
203 mptcp_pm_announce_addr(msk, &local->addr);
204 } else {
205 /* pick failed, avoid fourther attempts later */
206 msk->pm.local_addr_used = msk->pm.add_addr_signal_max;
207 }
208
209 check_work_pending(msk);
210 }
211
212 /* check if should create a new subflow */
213 if (msk->pm.local_addr_used < msk->pm.local_addr_max &&
214 msk->pm.subflows < msk->pm.subflows_max) {
215 remote_address((struct sock_common *)sk, &remote);
216
217 local = select_local_address(pernet, msk);
218 if (local) {
219 msk->pm.local_addr_used++;
220 msk->pm.subflows++;
221 check_work_pending(msk);
222 spin_unlock_bh(&msk->pm.lock);
223 __mptcp_subflow_connect(sk, local->ifindex,
224 &local->addr, &remote);
225 spin_lock_bh(&msk->pm.lock);
226 return;
227 }
228
229 /* lookup failed, avoid fourther attempts later */
230 msk->pm.local_addr_used = msk->pm.local_addr_max;
231 check_work_pending(msk);
232 }
233}
234
235void mptcp_pm_nl_fully_established(struct mptcp_sock *msk)
236{
237 mptcp_pm_create_subflow_or_signal_addr(msk);
238}
239
240void mptcp_pm_nl_subflow_established(struct mptcp_sock *msk)
241{
242 mptcp_pm_create_subflow_or_signal_addr(msk);
243}
244
245void mptcp_pm_nl_add_addr_received(struct mptcp_sock *msk)
246{
247 struct sock *sk = (struct sock *)msk;
248 struct mptcp_addr_info remote;
249 struct mptcp_addr_info local;
250
251 pr_debug("accepted %d:%d remote family %d",
252 msk->pm.add_addr_accepted, msk->pm.add_addr_accept_max,
253 msk->pm.remote.family);
254 msk->pm.add_addr_accepted++;
255 msk->pm.subflows++;
256 if (msk->pm.add_addr_accepted >= msk->pm.add_addr_accept_max ||
257 msk->pm.subflows >= msk->pm.subflows_max)
258 WRITE_ONCE(msk->pm.accept_addr, false);
259
260 /* connect to the specified remote address, using whatever
261 * local address the routing configuration will pick.
262 */
263 remote = msk->pm.remote;
264 if (!remote.port)
265 remote.port = sk->sk_dport;
266 memset(&local, 0, sizeof(local));
267 local.family = remote.family;
268
269 spin_unlock_bh(&msk->pm.lock);
270 __mptcp_subflow_connect((struct sock *)msk, 0, &local, &remote);
271 spin_lock_bh(&msk->pm.lock);
272}
273
274static bool address_use_port(struct mptcp_pm_addr_entry *entry)
275{
276 return (entry->flags &
277 (MPTCP_PM_ADDR_FLAG_SIGNAL | MPTCP_PM_ADDR_FLAG_SUBFLOW)) ==
278 MPTCP_PM_ADDR_FLAG_SIGNAL;
279}
280
281static int mptcp_pm_nl_append_new_local_addr(struct pm_nl_pernet *pernet,
282 struct mptcp_pm_addr_entry *entry)
283{
284 struct mptcp_pm_addr_entry *cur;
285 int ret = -EINVAL;
286
287 spin_lock_bh(&pernet->lock);
288 /* to keep the code simple, don't do IDR-like allocation for address ID,
289 * just bail when we exceed limits
290 */
291 if (pernet->next_id > 255)
292 goto out;
293 if (pernet->addrs >= MPTCP_PM_ADDR_MAX)
294 goto out;
295
296 /* do not insert duplicate address, differentiate on port only
297 * singled addresses
298 */
299 list_for_each_entry(cur, &pernet->local_addr_list, list) {
300 if (addresses_equal(&cur->addr, &entry->addr,
301 address_use_port(entry) &&
302 address_use_port(cur)))
303 goto out;
304 }
305
306 if (entry->flags & MPTCP_PM_ADDR_FLAG_SIGNAL)
307 pernet->add_addr_signal_max++;
308 if (entry->flags & MPTCP_PM_ADDR_FLAG_SUBFLOW)
309 pernet->local_addr_max++;
310
311 entry->addr.id = pernet->next_id++;
312 pernet->addrs++;
313 list_add_tail_rcu(&entry->list, &pernet->local_addr_list);
314 ret = entry->addr.id;
315
316out:
317 spin_unlock_bh(&pernet->lock);
318 return ret;
319}
320
321int mptcp_pm_nl_get_local_id(struct mptcp_sock *msk, struct sock_common *skc)
322{
323 struct mptcp_pm_addr_entry *entry;
324 struct mptcp_addr_info skc_local;
325 struct mptcp_addr_info msk_local;
326 struct pm_nl_pernet *pernet;
327 int ret = -1;
328
329 if (WARN_ON_ONCE(!msk))
330 return -1;
331
332 /* The 0 ID mapping is defined by the first subflow, copied into the msk
333 * addr
334 */
335 local_address((struct sock_common *)msk, &msk_local);
336 local_address((struct sock_common *)skc, &skc_local);
337 if (addresses_equal(&msk_local, &skc_local, false))
338 return 0;
339
340 if (address_zero(&skc_local))
341 return 0;
342
343 pernet = net_generic(sock_net((struct sock *)msk), pm_nl_pernet_id);
344
345 rcu_read_lock();
346 list_for_each_entry_rcu(entry, &pernet->local_addr_list, list) {
347 if (addresses_equal(&entry->addr, &skc_local, false)) {
348 ret = entry->addr.id;
349 break;
350 }
351 }
352 rcu_read_unlock();
353 if (ret >= 0)
354 return ret;
355
356 /* address not found, add to local list */
357 entry = kmalloc(sizeof(*entry), GFP_ATOMIC);
358 if (!entry)
359 return -ENOMEM;
360
361 entry->flags = 0;
362 entry->addr = skc_local;
363 ret = mptcp_pm_nl_append_new_local_addr(pernet, entry);
364 if (ret < 0)
365 kfree(entry);
366
367 return ret;
368}
369
370void mptcp_pm_nl_data_init(struct mptcp_sock *msk)
371{
372 struct mptcp_pm_data *pm = &msk->pm;
373 struct pm_nl_pernet *pernet;
374 bool subflows;
375
376 pernet = net_generic(sock_net((struct sock *)msk), pm_nl_pernet_id);
377
378 pm->add_addr_signal_max = READ_ONCE(pernet->add_addr_signal_max);
379 pm->add_addr_accept_max = READ_ONCE(pernet->add_addr_accept_max);
380 pm->local_addr_max = READ_ONCE(pernet->local_addr_max);
381 pm->subflows_max = READ_ONCE(pernet->subflows_max);
382 subflows = !!pm->subflows_max;
383 WRITE_ONCE(pm->work_pending, (!!pm->local_addr_max && subflows) ||
384 !!pm->add_addr_signal_max);
385 WRITE_ONCE(pm->accept_addr, !!pm->add_addr_accept_max && subflows);
386 WRITE_ONCE(pm->accept_subflow, subflows);
387}
388
389#define MPTCP_PM_CMD_GRP_OFFSET 0
390
391static const struct genl_multicast_group mptcp_pm_mcgrps[] = {
392 [MPTCP_PM_CMD_GRP_OFFSET] = { .name = MPTCP_PM_CMD_GRP_NAME, },
393};
394
395static const struct nla_policy
396mptcp_pm_addr_policy[MPTCP_PM_ADDR_ATTR_MAX + 1] = {
397 [MPTCP_PM_ADDR_ATTR_FAMILY] = { .type = NLA_U16, },
398 [MPTCP_PM_ADDR_ATTR_ID] = { .type = NLA_U8, },
399 [MPTCP_PM_ADDR_ATTR_ADDR4] = { .type = NLA_U32, },
400 [MPTCP_PM_ADDR_ATTR_ADDR6] = { .type = NLA_EXACT_LEN,
401 .len = sizeof(struct in6_addr), },
402 [MPTCP_PM_ADDR_ATTR_PORT] = { .type = NLA_U16 },
403 [MPTCP_PM_ADDR_ATTR_FLAGS] = { .type = NLA_U32 },
404 [MPTCP_PM_ADDR_ATTR_IF_IDX] = { .type = NLA_S32 },
405};
406
407static const struct nla_policy mptcp_pm_policy[MPTCP_PM_ATTR_MAX + 1] = {
408 [MPTCP_PM_ATTR_ADDR] =
409 NLA_POLICY_NESTED(mptcp_pm_addr_policy),
410 [MPTCP_PM_ATTR_RCV_ADD_ADDRS] = { .type = NLA_U32, },
411 [MPTCP_PM_ATTR_SUBFLOWS] = { .type = NLA_U32, },
412};
413
414static int mptcp_pm_family_to_addr(int family)
415{
416#if IS_ENABLED(CONFIG_MPTCP_IPV6)
417 if (family == AF_INET6)
418 return MPTCP_PM_ADDR_ATTR_ADDR6;
419#endif
420 return MPTCP_PM_ADDR_ATTR_ADDR4;
421}
422
423static int mptcp_pm_parse_addr(struct nlattr *attr, struct genl_info *info,
424 bool require_family,
425 struct mptcp_pm_addr_entry *entry)
426{
427 struct nlattr *tb[MPTCP_PM_ADDR_ATTR_MAX + 1];
428 int err, addr_addr;
429
430 if (!attr) {
431 GENL_SET_ERR_MSG(info, "missing address info");
432 return -EINVAL;
433 }
434
435 /* no validation needed - was already done via nested policy */
436 err = nla_parse_nested_deprecated(tb, MPTCP_PM_ADDR_ATTR_MAX, attr,
437 mptcp_pm_addr_policy, info->extack);
438 if (err)
439 return err;
440
441 memset(entry, 0, sizeof(*entry));
442 if (!tb[MPTCP_PM_ADDR_ATTR_FAMILY]) {
443 if (!require_family)
444 goto skip_family;
445
446 NL_SET_ERR_MSG_ATTR(info->extack, attr,
447 "missing family");
448 return -EINVAL;
449 }
450
451 entry->addr.family = nla_get_u16(tb[MPTCP_PM_ADDR_ATTR_FAMILY]);
452 if (entry->addr.family != AF_INET
453#if IS_ENABLED(CONFIG_MPTCP_IPV6)
454 && entry->addr.family != AF_INET6
455#endif
456 ) {
457 NL_SET_ERR_MSG_ATTR(info->extack, attr,
458 "unknown address family");
459 return -EINVAL;
460 }
461 addr_addr = mptcp_pm_family_to_addr(entry->addr.family);
462 if (!tb[addr_addr]) {
463 NL_SET_ERR_MSG_ATTR(info->extack, attr,
464 "missing address data");
465 return -EINVAL;
466 }
467
468#if IS_ENABLED(CONFIG_MPTCP_IPV6)
469 if (entry->addr.family == AF_INET6)
470 entry->addr.addr6 = nla_get_in6_addr(tb[addr_addr]);
471 else
472#endif
473 entry->addr.addr.s_addr = nla_get_in_addr(tb[addr_addr]);
474
475skip_family:
476 if (tb[MPTCP_PM_ADDR_ATTR_IF_IDX])
477 entry->ifindex = nla_get_s32(tb[MPTCP_PM_ADDR_ATTR_IF_IDX]);
478
479 if (tb[MPTCP_PM_ADDR_ATTR_ID])
480 entry->addr.id = nla_get_u8(tb[MPTCP_PM_ADDR_ATTR_ID]);
481
482 if (tb[MPTCP_PM_ADDR_ATTR_FLAGS])
483 entry->flags = nla_get_u32(tb[MPTCP_PM_ADDR_ATTR_FLAGS]);
484
485 return 0;
486}
487
488static struct pm_nl_pernet *genl_info_pm_nl(struct genl_info *info)
489{
490 return net_generic(genl_info_net(info), pm_nl_pernet_id);
491}
492
493static int mptcp_nl_cmd_add_addr(struct sk_buff *skb, struct genl_info *info)
494{
495 struct nlattr *attr = info->attrs[MPTCP_PM_ATTR_ADDR];
496 struct pm_nl_pernet *pernet = genl_info_pm_nl(info);
497 struct mptcp_pm_addr_entry addr, *entry;
498 int ret;
499
500 ret = mptcp_pm_parse_addr(attr, info, true, &addr);
501 if (ret < 0)
502 return ret;
503
504 entry = kmalloc(sizeof(*entry), GFP_KERNEL);
505 if (!entry) {
506 GENL_SET_ERR_MSG(info, "can't allocate addr");
507 return -ENOMEM;
508 }
509
510 *entry = addr;
511 ret = mptcp_pm_nl_append_new_local_addr(pernet, entry);
512 if (ret < 0) {
513 GENL_SET_ERR_MSG(info, "too many addresses or duplicate one");
514 kfree(entry);
515 return ret;
516 }
517
518 return 0;
519}
520
521static struct mptcp_pm_addr_entry *
522__lookup_addr_by_id(struct pm_nl_pernet *pernet, unsigned int id)
523{
524 struct mptcp_pm_addr_entry *entry;
525
526 list_for_each_entry(entry, &pernet->local_addr_list, list) {
527 if (entry->addr.id == id)
528 return entry;
529 }
530 return NULL;
531}
532
533static int mptcp_nl_cmd_del_addr(struct sk_buff *skb, struct genl_info *info)
534{
535 struct nlattr *attr = info->attrs[MPTCP_PM_ATTR_ADDR];
536 struct pm_nl_pernet *pernet = genl_info_pm_nl(info);
537 struct mptcp_pm_addr_entry addr, *entry;
538 int ret;
539
540 ret = mptcp_pm_parse_addr(attr, info, false, &addr);
541 if (ret < 0)
542 return ret;
543
544 spin_lock_bh(&pernet->lock);
545 entry = __lookup_addr_by_id(pernet, addr.addr.id);
546 if (!entry) {
547 GENL_SET_ERR_MSG(info, "address not found");
548 ret = -EINVAL;
549 goto out;
550 }
551 if (entry->flags & MPTCP_PM_ADDR_FLAG_SIGNAL)
552 pernet->add_addr_signal_max--;
553 if (entry->flags & MPTCP_PM_ADDR_FLAG_SUBFLOW)
554 pernet->local_addr_max--;
555
556 pernet->addrs--;
557 list_del_rcu(&entry->list);
558 kfree_rcu(entry, rcu);
559out:
560 spin_unlock_bh(&pernet->lock);
561 return ret;
562}
563
564static void __flush_addrs(struct pm_nl_pernet *pernet)
565{
566 while (!list_empty(&pernet->local_addr_list)) {
567 struct mptcp_pm_addr_entry *cur;
568
569 cur = list_entry(pernet->local_addr_list.next,
570 struct mptcp_pm_addr_entry, list);
571 list_del_rcu(&cur->list);
572 kfree_rcu(cur, rcu);
573 }
574}
575
576static void __reset_counters(struct pm_nl_pernet *pernet)
577{
578 pernet->add_addr_signal_max = 0;
579 pernet->add_addr_accept_max = 0;
580 pernet->local_addr_max = 0;
581 pernet->addrs = 0;
582}
583
584static int mptcp_nl_cmd_flush_addrs(struct sk_buff *skb, struct genl_info *info)
585{
586 struct pm_nl_pernet *pernet = genl_info_pm_nl(info);
587
588 spin_lock_bh(&pernet->lock);
589 __flush_addrs(pernet);
590 __reset_counters(pernet);
591 spin_unlock_bh(&pernet->lock);
592 return 0;
593}
594
595static int mptcp_nl_fill_addr(struct sk_buff *skb,
596 struct mptcp_pm_addr_entry *entry)
597{
598 struct mptcp_addr_info *addr = &entry->addr;
599 struct nlattr *attr;
600
601 attr = nla_nest_start(skb, MPTCP_PM_ATTR_ADDR);
602 if (!attr)
603 return -EMSGSIZE;
604
605 if (nla_put_u16(skb, MPTCP_PM_ADDR_ATTR_FAMILY, addr->family))
606 goto nla_put_failure;
607 if (nla_put_u8(skb, MPTCP_PM_ADDR_ATTR_ID, addr->id))
608 goto nla_put_failure;
609 if (nla_put_u32(skb, MPTCP_PM_ADDR_ATTR_FLAGS, entry->flags))
610 goto nla_put_failure;
611 if (entry->ifindex &&
612 nla_put_s32(skb, MPTCP_PM_ADDR_ATTR_IF_IDX, entry->ifindex))
613 goto nla_put_failure;
614
615 if (addr->family == AF_INET &&
616 nla_put_in_addr(skb, MPTCP_PM_ADDR_ATTR_ADDR4,
617 addr->addr.s_addr))
618 goto nla_put_failure;
619#if IS_ENABLED(CONFIG_MPTCP_IPV6)
620 else if (addr->family == AF_INET6 &&
621 nla_put_in6_addr(skb, MPTCP_PM_ADDR_ATTR_ADDR6, &addr->addr6))
622 goto nla_put_failure;
623#endif
624 nla_nest_end(skb, attr);
625 return 0;
626
627nla_put_failure:
628 nla_nest_cancel(skb, attr);
629 return -EMSGSIZE;
630}
631
632static int mptcp_nl_cmd_get_addr(struct sk_buff *skb, struct genl_info *info)
633{
634 struct nlattr *attr = info->attrs[MPTCP_PM_ATTR_ADDR];
635 struct pm_nl_pernet *pernet = genl_info_pm_nl(info);
636 struct mptcp_pm_addr_entry addr, *entry;
637 struct sk_buff *msg;
638 void *reply;
639 int ret;
640
641 ret = mptcp_pm_parse_addr(attr, info, false, &addr);
642 if (ret < 0)
643 return ret;
644
645 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
646 if (!msg)
647 return -ENOMEM;
648
649 reply = genlmsg_put_reply(msg, info, &mptcp_genl_family, 0,
650 info->genlhdr->cmd);
651 if (!reply) {
652 GENL_SET_ERR_MSG(info, "not enough space in Netlink message");
653 ret = -EMSGSIZE;
654 goto fail;
655 }
656
657 spin_lock_bh(&pernet->lock);
658 entry = __lookup_addr_by_id(pernet, addr.addr.id);
659 if (!entry) {
660 GENL_SET_ERR_MSG(info, "address not found");
661 ret = -EINVAL;
662 goto unlock_fail;
663 }
664
665 ret = mptcp_nl_fill_addr(msg, entry);
666 if (ret)
667 goto unlock_fail;
668
669 genlmsg_end(msg, reply);
670 ret = genlmsg_reply(msg, info);
671 spin_unlock_bh(&pernet->lock);
672 return ret;
673
674unlock_fail:
675 spin_unlock_bh(&pernet->lock);
676
677fail:
678 nlmsg_free(msg);
679 return ret;
680}
681
682static int mptcp_nl_cmd_dump_addrs(struct sk_buff *msg,
683 struct netlink_callback *cb)
684{
685 struct net *net = sock_net(msg->sk);
686 struct mptcp_pm_addr_entry *entry;
687 struct pm_nl_pernet *pernet;
688 int id = cb->args[0];
689 void *hdr;
690
691 pernet = net_generic(net, pm_nl_pernet_id);
692
693 spin_lock_bh(&pernet->lock);
694 list_for_each_entry(entry, &pernet->local_addr_list, list) {
695 if (entry->addr.id <= id)
696 continue;
697
698 hdr = genlmsg_put(msg, NETLINK_CB(cb->skb).portid,
699 cb->nlh->nlmsg_seq, &mptcp_genl_family,
700 NLM_F_MULTI, MPTCP_PM_CMD_GET_ADDR);
701 if (!hdr)
702 break;
703
704 if (mptcp_nl_fill_addr(msg, entry) < 0) {
705 genlmsg_cancel(msg, hdr);
706 break;
707 }
708
709 id = entry->addr.id;
710 genlmsg_end(msg, hdr);
711 }
712 spin_unlock_bh(&pernet->lock);
713
714 cb->args[0] = id;
715 return msg->len;
716}
717
718static int parse_limit(struct genl_info *info, int id, unsigned int *limit)
719{
720 struct nlattr *attr = info->attrs[id];
721
722 if (!attr)
723 return 0;
724
725 *limit = nla_get_u32(attr);
726 if (*limit > MPTCP_PM_ADDR_MAX) {
727 GENL_SET_ERR_MSG(info, "limit greater than maximum");
728 return -EINVAL;
729 }
730 return 0;
731}
732
733static int
734mptcp_nl_cmd_set_limits(struct sk_buff *skb, struct genl_info *info)
735{
736 struct pm_nl_pernet *pernet = genl_info_pm_nl(info);
737 unsigned int rcv_addrs, subflows;
738 int ret;
739
740 spin_lock_bh(&pernet->lock);
741 rcv_addrs = pernet->add_addr_accept_max;
742 ret = parse_limit(info, MPTCP_PM_ATTR_RCV_ADD_ADDRS, &rcv_addrs);
743 if (ret)
744 goto unlock;
745
746 subflows = pernet->subflows_max;
747 ret = parse_limit(info, MPTCP_PM_ATTR_SUBFLOWS, &subflows);
748 if (ret)
749 goto unlock;
750
751 WRITE_ONCE(pernet->add_addr_accept_max, rcv_addrs);
752 WRITE_ONCE(pernet->subflows_max, subflows);
753
754unlock:
755 spin_unlock_bh(&pernet->lock);
756 return ret;
757}
758
759static int
760mptcp_nl_cmd_get_limits(struct sk_buff *skb, struct genl_info *info)
761{
762 struct pm_nl_pernet *pernet = genl_info_pm_nl(info);
763 struct sk_buff *msg;
764 void *reply;
765
766 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
767 if (!msg)
768 return -ENOMEM;
769
770 reply = genlmsg_put_reply(msg, info, &mptcp_genl_family, 0,
771 MPTCP_PM_CMD_GET_LIMITS);
772 if (!reply)
773 goto fail;
774
775 if (nla_put_u32(msg, MPTCP_PM_ATTR_RCV_ADD_ADDRS,
776 READ_ONCE(pernet->add_addr_accept_max)))
777 goto fail;
778
779 if (nla_put_u32(msg, MPTCP_PM_ATTR_SUBFLOWS,
780 READ_ONCE(pernet->subflows_max)))
781 goto fail;
782
783 genlmsg_end(msg, reply);
784 return genlmsg_reply(msg, info);
785
786fail:
787 GENL_SET_ERR_MSG(info, "not enough space in Netlink message");
788 nlmsg_free(msg);
789 return -EMSGSIZE;
790}
791
792static struct genl_ops mptcp_pm_ops[] = {
793 {
794 .cmd = MPTCP_PM_CMD_ADD_ADDR,
795 .doit = mptcp_nl_cmd_add_addr,
796 .flags = GENL_ADMIN_PERM,
797 },
798 {
799 .cmd = MPTCP_PM_CMD_DEL_ADDR,
800 .doit = mptcp_nl_cmd_del_addr,
801 .flags = GENL_ADMIN_PERM,
802 },
803 {
804 .cmd = MPTCP_PM_CMD_FLUSH_ADDRS,
805 .doit = mptcp_nl_cmd_flush_addrs,
806 .flags = GENL_ADMIN_PERM,
807 },
808 {
809 .cmd = MPTCP_PM_CMD_GET_ADDR,
810 .doit = mptcp_nl_cmd_get_addr,
811 .dumpit = mptcp_nl_cmd_dump_addrs,
812 },
813 {
814 .cmd = MPTCP_PM_CMD_SET_LIMITS,
815 .doit = mptcp_nl_cmd_set_limits,
816 .flags = GENL_ADMIN_PERM,
817 },
818 {
819 .cmd = MPTCP_PM_CMD_GET_LIMITS,
820 .doit = mptcp_nl_cmd_get_limits,
821 },
822};
823
824static struct genl_family mptcp_genl_family __ro_after_init = {
825 .name = MPTCP_PM_NAME,
826 .version = MPTCP_PM_VER,
827 .maxattr = MPTCP_PM_ATTR_MAX,
828 .policy = mptcp_pm_policy,
829 .netnsok = true,
830 .module = THIS_MODULE,
831 .ops = mptcp_pm_ops,
832 .n_ops = ARRAY_SIZE(mptcp_pm_ops),
833 .mcgrps = mptcp_pm_mcgrps,
834 .n_mcgrps = ARRAY_SIZE(mptcp_pm_mcgrps),
835};
836
837static int __net_init pm_nl_init_net(struct net *net)
838{
839 struct pm_nl_pernet *pernet = net_generic(net, pm_nl_pernet_id);
840
841 INIT_LIST_HEAD_RCU(&pernet->local_addr_list);
842 __reset_counters(pernet);
843 pernet->next_id = 1;
844 spin_lock_init(&pernet->lock);
845 return 0;
846}
847
848static void __net_exit pm_nl_exit_net(struct list_head *net_list)
849{
850 struct net *net;
851
852 list_for_each_entry(net, net_list, exit_list) {
853 /* net is removed from namespace list, can't race with
854 * other modifiers
855 */
856 __flush_addrs(net_generic(net, pm_nl_pernet_id));
857 }
858}
859
860static struct pernet_operations mptcp_pm_pernet_ops = {
861 .init = pm_nl_init_net,
862 .exit_batch = pm_nl_exit_net,
863 .id = &pm_nl_pernet_id,
864 .size = sizeof(struct pm_nl_pernet),
865};
866
867void __init mptcp_pm_nl_init(void)
868{
869 if (register_pernet_subsys(&mptcp_pm_pernet_ops) < 0)
870 panic("Failed to register MPTCP PM pernet subsystem.\n");
871
872 if (genl_register_family(&mptcp_genl_family))
873 panic("Failed to register MPTCP PM netlink family\n");
874}