net/mptcp/pm_netlink.c

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