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 #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 */
  20 static struct genl_family mptcp_genl_family;
  21
  22 static int pm_nl_pernet_id;
  23
  24 struct 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
  32 struct 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
  46 static 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
  69 static 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
  79 static 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
  92 static 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
 105 static 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
 123 static struct mptcp_pm_addr_entry *
 124 select_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
 150 static struct mptcp_pm_addr_entry *
 151 select_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
 174 static 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
 182 static 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
 235 void mptcp_pm_nl_fully_established(struct mptcp_sock *msk)
 236 {
 237         mptcp_pm_create_subflow_or_signal_addr(msk);
 238 }
 239
 240 void mptcp_pm_nl_subflow_established(struct mptcp_sock *msk)
 241 {
 242         mptcp_pm_create_subflow_or_signal_addr(msk);
 243 }
 244
 245 void 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
 274 static 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
 281 static 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
 316 out:
 317         spin_unlock_bh(&pernet->lock);
 318         return ret;
 319 }
 320
 321 int 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
 370 void 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
 391 static const struct genl_multicast_group mptcp_pm_mcgrps[] = {
 392         [MPTCP_PM_CMD_GRP_OFFSET]       = { .name = MPTCP_PM_CMD_GRP_NAME, },
 393 };
 394
 395 static const struct nla_policy
 396 mptcp_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
 407 static 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
 414 static 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
 423 static 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
 475 skip_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
 488 static 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
 493 static 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
 521 static 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
 533 static 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);
 559 out:
 560         spin_unlock_bh(&pernet->lock);
 561         return ret;
 562 }
 563
 564 static 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
 576 static 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
 584 static 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
 595 static 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
 627 nla_put_failure:
 628         nla_nest_cancel(skb, attr);
 629         return -EMSGSIZE;
 630 }
 631
 632 static 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
 674 unlock_fail:
 675         spin_unlock_bh(&pernet->lock);
 676
 677 fail:
 678         nlmsg_free(msg);
 679         return ret;
 680 }
 681
 682 static 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
 718 static 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
 733 static int
 734 mptcp_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
 754 unlock:
 755         spin_unlock_bh(&pernet->lock);
 756         return ret;
 757 }
 758
 759 static int
 760 mptcp_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
 786 fail:
 787         GENL_SET_ERR_MSG(info, "not enough space in Netlink message");
 788         nlmsg_free(msg);
 789         return -EMSGSIZE;
 790 }
 791
 792 static 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
 824 static 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
 837 static 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
 848 static 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
 860 static 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
 867 void __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 }