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 #include "mib.h"
  19
  20 /* forward declaration */
  21 static struct genl_family mptcp_genl_family;
  22
  23 static int pm_nl_pernet_id;
  24
  25 struct mptcp_pm_addr_entry {
  26         struct list_head        list;
  27         struct mptcp_addr_info  addr;
  28         struct rcu_head         rcu;
  29         struct socket           *lsk;
  30 };
  31
  32 struct mptcp_pm_add_entry {
  33         struct list_head        list;
  34         struct mptcp_addr_info  addr;
  35         struct timer_list       add_timer;
  36         struct mptcp_sock       *sock;
  37         u8                      retrans_times;
  38 };
  39
  40 #define MAX_ADDR_ID             255
  41 #define BITMAP_SZ DIV_ROUND_UP(MAX_ADDR_ID + 1, BITS_PER_LONG)
  42
  43 struct pm_nl_pernet {
  44         /* protects pernet updates */
  45         spinlock_t              lock;
  46         struct list_head        local_addr_list;
  47         unsigned int            addrs;
  48         unsigned int            add_addr_signal_max;
  49         unsigned int            add_addr_accept_max;
  50         unsigned int            local_addr_max;
  51         unsigned int            subflows_max;
  52         unsigned int            next_id;
  53         unsigned long           id_bitmap[BITMAP_SZ];
  54 };
  55
  56 #define MPTCP_PM_ADDR_MAX       8
  57 #define ADD_ADDR_RETRANS_MAX    3
  58
  59 static bool addresses_equal(const struct mptcp_addr_info *a,
  60                             struct mptcp_addr_info *b, bool use_port)
  61 {
  62         bool addr_equals = false;
  63
  64         if (a->family == b->family) {
  65                 if (a->family == AF_INET)
  66                         addr_equals = a->addr.s_addr == b->addr.s_addr;
  67 #if IS_ENABLED(CONFIG_MPTCP_IPV6)
  68                 else
  69                         addr_equals = !ipv6_addr_cmp(&a->addr6, &b->addr6);
  70         } else if (a->family == AF_INET) {
  71                 if (ipv6_addr_v4mapped(&b->addr6))
  72                         addr_equals = a->addr.s_addr == b->addr6.s6_addr32[3];
  73         } else if (b->family == AF_INET) {
  74                 if (ipv6_addr_v4mapped(&a->addr6))
  75                         addr_equals = a->addr6.s6_addr32[3] == b->addr.s_addr;
  76 #endif
  77         }
  78
  79         if (!addr_equals)
  80                 return false;
  81         if (!use_port)
  82                 return true;
  83
  84         return a->port == b->port;
  85 }
  86
  87 static bool address_zero(const struct mptcp_addr_info *addr)
  88 {
  89         struct mptcp_addr_info zero;
  90
  91         memset(&zero, 0, sizeof(zero));
  92         zero.family = addr->family;
  93
  94         return addresses_equal(addr, &zero, true);
  95 }
  96
  97 static void local_address(const struct sock_common *skc,
  98                           struct mptcp_addr_info *addr)
  99 {
 100         addr->family = skc->skc_family;
 101         addr->port = htons(skc->skc_num);
 102         if (addr->family == AF_INET)
 103                 addr->addr.s_addr = skc->skc_rcv_saddr;
 104 #if IS_ENABLED(CONFIG_MPTCP_IPV6)
 105         else if (addr->family == AF_INET6)
 106                 addr->addr6 = skc->skc_v6_rcv_saddr;
 107 #endif
 108 }
 109
 110 static void remote_address(const struct sock_common *skc,
 111                            struct mptcp_addr_info *addr)
 112 {
 113         addr->family = skc->skc_family;
 114         addr->port = skc->skc_dport;
 115         if (addr->family == AF_INET)
 116                 addr->addr.s_addr = skc->skc_daddr;
 117 #if IS_ENABLED(CONFIG_MPTCP_IPV6)
 118         else if (addr->family == AF_INET6)
 119                 addr->addr6 = skc->skc_v6_daddr;
 120 #endif
 121 }
 122
 123 static bool lookup_subflow_by_saddr(const struct list_head *list,
 124                                     struct mptcp_addr_info *saddr)
 125 {
 126         struct mptcp_subflow_context *subflow;
 127         struct mptcp_addr_info cur;
 128         struct sock_common *skc;
 129
 130         list_for_each_entry(subflow, list, node) {
 131                 skc = (struct sock_common *)mptcp_subflow_tcp_sock(subflow);
 132
 133                 local_address(skc, &cur);
 134                 if (addresses_equal(&cur, saddr, saddr->port))
 135                         return true;
 136         }
 137
 138         return false;
 139 }
 140
 141 static bool lookup_subflow_by_daddr(const struct list_head *list,
 142                                     struct mptcp_addr_info *daddr)
 143 {
 144         struct mptcp_subflow_context *subflow;
 145         struct mptcp_addr_info cur;
 146         struct sock_common *skc;
 147
 148         list_for_each_entry(subflow, list, node) {
 149                 skc = (struct sock_common *)mptcp_subflow_tcp_sock(subflow);
 150
 151                 remote_address(skc, &cur);
 152                 if (addresses_equal(&cur, daddr, daddr->port))
 153                         return true;
 154         }
 155
 156         return false;
 157 }
 158
 159 static struct mptcp_pm_addr_entry *
 160 select_local_address(const struct pm_nl_pernet *pernet,
 161                      struct mptcp_sock *msk)
 162 {
 163         struct mptcp_pm_addr_entry *entry, *ret = NULL;
 164         struct sock *sk = (struct sock *)msk;
 165
 166         msk_owned_by_me(msk);
 167
 168         rcu_read_lock();
 169         __mptcp_flush_join_list(msk);
 170         list_for_each_entry_rcu(entry, &pernet->local_addr_list, list) {
 171                 if (!(entry->addr.flags & MPTCP_PM_ADDR_FLAG_SUBFLOW))
 172                         continue;
 173
 174                 if (entry->addr.family != sk->sk_family) {
 175 #if IS_ENABLED(CONFIG_MPTCP_IPV6)
 176                         if ((entry->addr.family == AF_INET &&
 177                              !ipv6_addr_v4mapped(&sk->sk_v6_daddr)) ||
 178                             (sk->sk_family == AF_INET &&
 179                              !ipv6_addr_v4mapped(&entry->addr.addr6)))
 180 #endif
 181                                 continue;
 182                 }
 183
 184                 /* avoid any address already in use by subflows and
 185                  * pending join
 186                  */
 187                 if (!lookup_subflow_by_saddr(&msk->conn_list, &entry->addr)) {
 188                         ret = entry;
 189                         break;
 190                 }
 191         }
 192         rcu_read_unlock();
 193         return ret;
 194 }
 195
 196 static struct mptcp_pm_addr_entry *
 197 select_signal_address(struct pm_nl_pernet *pernet, unsigned int pos)
 198 {
 199         struct mptcp_pm_addr_entry *entry, *ret = NULL;
 200         int i = 0;
 201
 202         rcu_read_lock();
 203         /* do not keep any additional per socket state, just signal
 204          * the address list in order.
 205          * Note: removal from the local address list during the msk life-cycle
 206          * can lead to additional addresses not being announced.
 207          */
 208         list_for_each_entry_rcu(entry, &pernet->local_addr_list, list) {
 209                 if (!(entry->addr.flags & MPTCP_PM_ADDR_FLAG_SIGNAL))
 210                         continue;
 211                 if (i++ == pos) {
 212                         ret = entry;
 213                         break;
 214                 }
 215         }
 216         rcu_read_unlock();
 217         return ret;
 218 }
 219
 220 unsigned int mptcp_pm_get_add_addr_signal_max(struct mptcp_sock *msk)
 221 {
 222         struct pm_nl_pernet *pernet;
 223
 224         pernet = net_generic(sock_net((struct sock *)msk), pm_nl_pernet_id);
 225         return READ_ONCE(pernet->add_addr_signal_max);
 226 }
 227 EXPORT_SYMBOL_GPL(mptcp_pm_get_add_addr_signal_max);
 228
 229 unsigned int mptcp_pm_get_add_addr_accept_max(struct mptcp_sock *msk)
 230 {
 231         struct pm_nl_pernet *pernet;
 232
 233         pernet = net_generic(sock_net((struct sock *)msk), pm_nl_pernet_id);
 234         return READ_ONCE(pernet->add_addr_accept_max);
 235 }
 236 EXPORT_SYMBOL_GPL(mptcp_pm_get_add_addr_accept_max);
 237
 238 unsigned int mptcp_pm_get_subflows_max(struct mptcp_sock *msk)
 239 {
 240         struct pm_nl_pernet *pernet;
 241
 242         pernet = net_generic(sock_net((struct sock *)msk), pm_nl_pernet_id);
 243         return READ_ONCE(pernet->subflows_max);
 244 }
 245 EXPORT_SYMBOL_GPL(mptcp_pm_get_subflows_max);
 246
 247 unsigned int mptcp_pm_get_local_addr_max(struct mptcp_sock *msk)
 248 {
 249         struct pm_nl_pernet *pernet;
 250
 251         pernet = net_generic(sock_net((struct sock *)msk), pm_nl_pernet_id);
 252         return READ_ONCE(pernet->local_addr_max);
 253 }
 254 EXPORT_SYMBOL_GPL(mptcp_pm_get_local_addr_max);
 255
 256 static void check_work_pending(struct mptcp_sock *msk)
 257 {
 258         if (msk->pm.add_addr_signaled == mptcp_pm_get_add_addr_signal_max(msk) &&
 259             (msk->pm.local_addr_used == mptcp_pm_get_local_addr_max(msk) ||
 260              msk->pm.subflows == mptcp_pm_get_subflows_max(msk)))
 261                 WRITE_ONCE(msk->pm.work_pending, false);
 262 }
 263
 264 struct mptcp_pm_add_entry *
 265 mptcp_lookup_anno_list_by_saddr(struct mptcp_sock *msk,
 266                                 struct mptcp_addr_info *addr)
 267 {
 268         struct mptcp_pm_add_entry *entry;
 269
 270         lockdep_assert_held(&msk->pm.lock);
 271
 272         list_for_each_entry(entry, &msk->pm.anno_list, list) {
 273                 if (addresses_equal(&entry->addr, addr, true))
 274                         return entry;
 275         }
 276
 277         return NULL;
 278 }
 279
 280 bool mptcp_pm_sport_in_anno_list(struct mptcp_sock *msk, const struct sock *sk)
 281 {
 282         struct mptcp_pm_add_entry *entry;
 283         struct mptcp_addr_info saddr;
 284         bool ret = false;
 285
 286         local_address((struct sock_common *)sk, &saddr);
 287
 288         spin_lock_bh(&msk->pm.lock);
 289         list_for_each_entry(entry, &msk->pm.anno_list, list) {
 290                 if (addresses_equal(&entry->addr, &saddr, true)) {
 291                         ret = true;
 292                         goto out;
 293                 }
 294         }
 295
 296 out:
 297         spin_unlock_bh(&msk->pm.lock);
 298         return ret;
 299 }
 300
 301 static void mptcp_pm_add_timer(struct timer_list *timer)
 302 {
 303         struct mptcp_pm_add_entry *entry = from_timer(entry, timer, add_timer);
 304         struct mptcp_sock *msk = entry->sock;
 305         struct sock *sk = (struct sock *)msk;
 306
 307         pr_debug("msk=%p", msk);
 308
 309         if (!msk)
 310                 return;
 311
 312         if (inet_sk_state_load(sk) == TCP_CLOSE)
 313                 return;
 314
 315         if (!entry->addr.id)
 316                 return;
 317
 318         if (mptcp_pm_should_add_signal(msk)) {
 319                 sk_reset_timer(sk, timer, jiffies + TCP_RTO_MAX / 8);
 320                 goto out;
 321         }
 322
 323         spin_lock_bh(&msk->pm.lock);
 324
 325         if (!mptcp_pm_should_add_signal(msk)) {
 326                 pr_debug("retransmit ADD_ADDR id=%d", entry->addr.id);
 327                 mptcp_pm_announce_addr(msk, &entry->addr, false);
 328                 mptcp_pm_add_addr_send_ack(msk);
 329                 entry->retrans_times++;
 330         }
 331
 332         if (entry->retrans_times < ADD_ADDR_RETRANS_MAX)
 333                 sk_reset_timer(sk, timer,
 334                                jiffies + mptcp_get_add_addr_timeout(sock_net(sk)));
 335
 336         spin_unlock_bh(&msk->pm.lock);
 337
 338         if (entry->retrans_times == ADD_ADDR_RETRANS_MAX)
 339                 mptcp_pm_subflow_established(msk);
 340
 341 out:
 342         __sock_put(sk);
 343 }
 344
 345 struct mptcp_pm_add_entry *
 346 mptcp_pm_del_add_timer(struct mptcp_sock *msk,
 347                        struct mptcp_addr_info *addr)
 348 {
 349         struct mptcp_pm_add_entry *entry;
 350         struct sock *sk = (struct sock *)msk;
 351
 352         spin_lock_bh(&msk->pm.lock);
 353         entry = mptcp_lookup_anno_list_by_saddr(msk, addr);
 354         if (entry)
 355                 entry->retrans_times = ADD_ADDR_RETRANS_MAX;
 356         spin_unlock_bh(&msk->pm.lock);
 357
 358         if (entry)
 359                 sk_stop_timer_sync(sk, &entry->add_timer);
 360
 361         return entry;
 362 }
 363
 364 static bool mptcp_pm_alloc_anno_list(struct mptcp_sock *msk,
 365                                      struct mptcp_pm_addr_entry *entry)
 366 {
 367         struct mptcp_pm_add_entry *add_entry = NULL;
 368         struct sock *sk = (struct sock *)msk;
 369         struct net *net = sock_net(sk);
 370
 371         lockdep_assert_held(&msk->pm.lock);
 372
 373         if (mptcp_lookup_anno_list_by_saddr(msk, &entry->addr))
 374                 return false;
 375
 376         add_entry = kmalloc(sizeof(*add_entry), GFP_ATOMIC);
 377         if (!add_entry)
 378                 return false;
 379
 380         list_add(&add_entry->list, &msk->pm.anno_list);
 381
 382         add_entry->addr = entry->addr;
 383         add_entry->sock = msk;
 384         add_entry->retrans_times = 0;
 385
 386         timer_setup(&add_entry->add_timer, mptcp_pm_add_timer, 0);
 387         sk_reset_timer(sk, &add_entry->add_timer,
 388                        jiffies + mptcp_get_add_addr_timeout(net));
 389
 390         return true;
 391 }
 392
 393 void mptcp_pm_free_anno_list(struct mptcp_sock *msk)
 394 {
 395         struct mptcp_pm_add_entry *entry, *tmp;
 396         struct sock *sk = (struct sock *)msk;
 397         LIST_HEAD(free_list);
 398
 399         pr_debug("msk=%p", msk);
 400
 401         spin_lock_bh(&msk->pm.lock);
 402         list_splice_init(&msk->pm.anno_list, &free_list);
 403         spin_unlock_bh(&msk->pm.lock);
 404
 405         list_for_each_entry_safe(entry, tmp, &free_list, list) {
 406                 sk_stop_timer_sync(sk, &entry->add_timer);
 407                 kfree(entry);
 408         }
 409 }
 410
 411 static void mptcp_pm_create_subflow_or_signal_addr(struct mptcp_sock *msk)
 412 {
 413         struct sock *sk = (struct sock *)msk;
 414         struct mptcp_pm_addr_entry *local;
 415         unsigned int add_addr_signal_max;
 416         unsigned int local_addr_max;
 417         struct pm_nl_pernet *pernet;
 418         unsigned int subflows_max;
 419
 420         pernet = net_generic(sock_net(sk), pm_nl_pernet_id);
 421
 422         add_addr_signal_max = mptcp_pm_get_add_addr_signal_max(msk);
 423         local_addr_max = mptcp_pm_get_local_addr_max(msk);
 424         subflows_max = mptcp_pm_get_subflows_max(msk);
 425
 426         pr_debug("local %d:%d signal %d:%d subflows %d:%d\n",
 427                  msk->pm.local_addr_used, local_addr_max,
 428                  msk->pm.add_addr_signaled, add_addr_signal_max,
 429                  msk->pm.subflows, subflows_max);
 430
 431         /* check first for announce */
 432         if (msk->pm.add_addr_signaled < add_addr_signal_max) {
 433                 local = select_signal_address(pernet,
 434                                               msk->pm.add_addr_signaled);
 435
 436                 if (local) {
 437                         if (mptcp_pm_alloc_anno_list(msk, local)) {
 438                                 msk->pm.add_addr_signaled++;
 439                                 mptcp_pm_announce_addr(msk, &local->addr, false);
 440                                 mptcp_pm_nl_addr_send_ack(msk);
 441                         }
 442                 } else {
 443                         /* pick failed, avoid fourther attempts later */
 444                         msk->pm.local_addr_used = add_addr_signal_max;
 445                 }
 446
 447                 check_work_pending(msk);
 448         }
 449
 450         /* check if should create a new subflow */
 451         if (msk->pm.local_addr_used < local_addr_max &&
 452             msk->pm.subflows < subflows_max) {
 453                 local = select_local_address(pernet, msk);
 454                 if (local) {
 455                         struct mptcp_addr_info remote = { 0 };
 456
 457                         msk->pm.local_addr_used++;
 458                         msk->pm.subflows++;
 459                         check_work_pending(msk);
 460                         remote_address((struct sock_common *)sk, &remote);
 461                         spin_unlock_bh(&msk->pm.lock);
 462                         __mptcp_subflow_connect(sk, &local->addr, &remote);
 463                         spin_lock_bh(&msk->pm.lock);
 464                         return;
 465                 }
 466
 467                 /* lookup failed, avoid fourther attempts later */
 468                 msk->pm.local_addr_used = local_addr_max;
 469                 check_work_pending(msk);
 470         }
 471 }
 472
 473 static void mptcp_pm_nl_fully_established(struct mptcp_sock *msk)
 474 {
 475         mptcp_pm_create_subflow_or_signal_addr(msk);
 476 }
 477
 478 static void mptcp_pm_nl_subflow_established(struct mptcp_sock *msk)
 479 {
 480         mptcp_pm_create_subflow_or_signal_addr(msk);
 481 }
 482
 483 static void mptcp_pm_nl_add_addr_received(struct mptcp_sock *msk)
 484 {
 485         struct sock *sk = (struct sock *)msk;
 486         unsigned int add_addr_accept_max;
 487         struct mptcp_addr_info remote;
 488         struct mptcp_addr_info local;
 489         unsigned int subflows_max;
 490
 491         add_addr_accept_max = mptcp_pm_get_add_addr_accept_max(msk);
 492         subflows_max = mptcp_pm_get_subflows_max(msk);
 493
 494         pr_debug("accepted %d:%d remote family %d",
 495                  msk->pm.add_addr_accepted, add_addr_accept_max,
 496                  msk->pm.remote.family);
 497
 498         if (lookup_subflow_by_daddr(&msk->conn_list, &msk->pm.remote))
 499                 goto add_addr_echo;
 500
 501         msk->pm.add_addr_accepted++;
 502         msk->pm.subflows++;
 503         if (msk->pm.add_addr_accepted >= add_addr_accept_max ||
 504             msk->pm.subflows >= subflows_max)
 505                 WRITE_ONCE(msk->pm.accept_addr, false);
 506
 507         /* connect to the specified remote address, using whatever
 508          * local address the routing configuration will pick.
 509          */
 510         remote = msk->pm.remote;
 511         if (!remote.port)
 512                 remote.port = sk->sk_dport;
 513         memset(&local, 0, sizeof(local));
 514         local.family = remote.family;
 515
 516         spin_unlock_bh(&msk->pm.lock);
 517         __mptcp_subflow_connect(sk, &local, &remote);
 518         spin_lock_bh(&msk->pm.lock);
 519
 520 add_addr_echo:
 521         mptcp_pm_announce_addr(msk, &msk->pm.remote, true);
 522         mptcp_pm_nl_addr_send_ack(msk);
 523 }
 524
 525 void mptcp_pm_nl_addr_send_ack(struct mptcp_sock *msk)
 526 {
 527         struct mptcp_subflow_context *subflow;
 528
 529         msk_owned_by_me(msk);
 530         lockdep_assert_held(&msk->pm.lock);
 531
 532         if (!mptcp_pm_should_add_signal(msk) &&
 533             !mptcp_pm_should_rm_signal(msk))
 534                 return;
 535
 536         __mptcp_flush_join_list(msk);
 537         subflow = list_first_entry_or_null(&msk->conn_list, typeof(*subflow), node);
 538         if (subflow) {
 539                 struct sock *ssk = mptcp_subflow_tcp_sock(subflow);
 540
 541                 spin_unlock_bh(&msk->pm.lock);
 542                 pr_debug("send ack for %s%s%s",
 543                          mptcp_pm_should_add_signal(msk) ? "add_addr" : "rm_addr",
 544                          mptcp_pm_should_add_signal_ipv6(msk) ? " [ipv6]" : "",
 545                          mptcp_pm_should_add_signal_port(msk) ? " [port]" : "");
 546
 547                 lock_sock(ssk);
 548                 tcp_send_ack(ssk);
 549                 release_sock(ssk);
 550                 spin_lock_bh(&msk->pm.lock);
 551         }
 552 }
 553
 554 int mptcp_pm_nl_mp_prio_send_ack(struct mptcp_sock *msk,
 555                                  struct mptcp_addr_info *addr,
 556                                  u8 bkup)
 557 {
 558         struct mptcp_subflow_context *subflow;
 559
 560         pr_debug("bkup=%d", bkup);
 561
 562         mptcp_for_each_subflow(msk, subflow) {
 563                 struct sock *ssk = mptcp_subflow_tcp_sock(subflow);
 564                 struct sock *sk = (struct sock *)msk;
 565                 struct mptcp_addr_info local;
 566
 567                 local_address((struct sock_common *)ssk, &local);
 568                 if (!addresses_equal(&local, addr, addr->port))
 569                         continue;
 570
 571                 subflow->backup = bkup;
 572                 subflow->send_mp_prio = 1;
 573                 subflow->request_bkup = bkup;
 574                 __MPTCP_INC_STATS(sock_net(sk), MPTCP_MIB_MPPRIOTX);
 575
 576                 spin_unlock_bh(&msk->pm.lock);
 577                 pr_debug("send ack for mp_prio");
 578                 lock_sock(ssk);
 579                 tcp_send_ack(ssk);
 580                 release_sock(ssk);
 581                 spin_lock_bh(&msk->pm.lock);
 582
 583                 return 0;
 584         }
 585
 586         return -EINVAL;
 587 }
 588
 589 static void mptcp_pm_nl_rm_addr_or_subflow(struct mptcp_sock *msk,
 590                                            const struct mptcp_rm_list *rm_list,
 591                                            enum linux_mptcp_mib_field rm_type)
 592 {
 593         struct mptcp_subflow_context *subflow, *tmp;
 594         struct sock *sk = (struct sock *)msk;
 595         u8 i;
 596
 597         pr_debug("%s rm_list_nr %d",
 598                  rm_type == MPTCP_MIB_RMADDR ? "address" : "subflow", rm_list->nr);
 599
 600         msk_owned_by_me(msk);
 601
 602         if (!rm_list->nr)
 603                 return;
 604
 605         if (list_empty(&msk->conn_list))
 606                 return;
 607
 608         for (i = 0; i < rm_list->nr; i++) {
 609                 list_for_each_entry_safe(subflow, tmp, &msk->conn_list, node) {
 610                         struct sock *ssk = mptcp_subflow_tcp_sock(subflow);
 611                         int how = RCV_SHUTDOWN | SEND_SHUTDOWN;
 612                         u8 id = subflow->local_id;
 613
 614                         if (rm_type == MPTCP_MIB_RMADDR)
 615                                 id = subflow->remote_id;
 616
 617                         if (rm_list->ids[i] != id)
 618                                 continue;
 619
 620                         pr_debug(" -> %s rm_list_ids[%d]=%u local_id=%u remote_id=%u",
 621                                  rm_type == MPTCP_MIB_RMADDR ? "address" : "subflow",
 622                                  i, rm_list->ids[i], subflow->local_id, subflow->remote_id);
 623                         spin_unlock_bh(&msk->pm.lock);
 624                         mptcp_subflow_shutdown(sk, ssk, how);
 625                         mptcp_close_ssk(sk, ssk, subflow);
 626                         spin_lock_bh(&msk->pm.lock);
 627
 628                         if (rm_type == MPTCP_MIB_RMADDR) {
 629                                 msk->pm.add_addr_accepted--;
 630                                 WRITE_ONCE(msk->pm.accept_addr, true);
 631                         } else if (rm_type == MPTCP_MIB_RMSUBFLOW) {
 632                                 msk->pm.local_addr_used--;
 633                         }
 634                         msk->pm.subflows--;
 635                         __MPTCP_INC_STATS(sock_net(sk), rm_type);
 636                 }
 637         }
 638 }
 639
 640 static void mptcp_pm_nl_rm_addr_received(struct mptcp_sock *msk)
 641 {
 642         mptcp_pm_nl_rm_addr_or_subflow(msk, &msk->pm.rm_list_rx, MPTCP_MIB_RMADDR);
 643 }
 644
 645 void mptcp_pm_nl_rm_subflow_received(struct mptcp_sock *msk,
 646                                      const struct mptcp_rm_list *rm_list)
 647 {
 648         mptcp_pm_nl_rm_addr_or_subflow(msk, rm_list, MPTCP_MIB_RMSUBFLOW);
 649 }
 650
 651 void mptcp_pm_nl_work(struct mptcp_sock *msk)
 652 {
 653         struct mptcp_pm_data *pm = &msk->pm;
 654
 655         msk_owned_by_me(msk);
 656
 657         spin_lock_bh(&msk->pm.lock);
 658
 659         pr_debug("msk=%p status=%x", msk, pm->status);
 660         if (pm->status & BIT(MPTCP_PM_ADD_ADDR_RECEIVED)) {
 661                 pm->status &= ~BIT(MPTCP_PM_ADD_ADDR_RECEIVED);
 662                 mptcp_pm_nl_add_addr_received(msk);
 663         }
 664         if (pm->status & BIT(MPTCP_PM_ADD_ADDR_SEND_ACK)) {
 665                 pm->status &= ~BIT(MPTCP_PM_ADD_ADDR_SEND_ACK);
 666                 mptcp_pm_nl_addr_send_ack(msk);
 667         }
 668         if (pm->status & BIT(MPTCP_PM_RM_ADDR_RECEIVED)) {
 669                 pm->status &= ~BIT(MPTCP_PM_RM_ADDR_RECEIVED);
 670                 mptcp_pm_nl_rm_addr_received(msk);
 671         }
 672         if (pm->status & BIT(MPTCP_PM_ESTABLISHED)) {
 673                 pm->status &= ~BIT(MPTCP_PM_ESTABLISHED);
 674                 mptcp_pm_nl_fully_established(msk);
 675         }
 676         if (pm->status & BIT(MPTCP_PM_SUBFLOW_ESTABLISHED)) {
 677                 pm->status &= ~BIT(MPTCP_PM_SUBFLOW_ESTABLISHED);
 678                 mptcp_pm_nl_subflow_established(msk);
 679         }
 680
 681         spin_unlock_bh(&msk->pm.lock);
 682 }
 683
 684 static bool address_use_port(struct mptcp_pm_addr_entry *entry)
 685 {
 686         return (entry->addr.flags &
 687                 (MPTCP_PM_ADDR_FLAG_SIGNAL | MPTCP_PM_ADDR_FLAG_SUBFLOW)) ==
 688                 MPTCP_PM_ADDR_FLAG_SIGNAL;
 689 }
 690
 691 static int mptcp_pm_nl_append_new_local_addr(struct pm_nl_pernet *pernet,
 692                                              struct mptcp_pm_addr_entry *entry)
 693 {
 694         struct mptcp_pm_addr_entry *cur;
 695         unsigned int addr_max;
 696         int ret = -EINVAL;
 697
 698         spin_lock_bh(&pernet->lock);
 699         /* to keep the code simple, don't do IDR-like allocation for address ID,
 700          * just bail when we exceed limits
 701          */
 702         if (pernet->next_id == MAX_ADDR_ID)
 703                 pernet->next_id = 1;
 704         if (pernet->addrs >= MPTCP_PM_ADDR_MAX)
 705                 goto out;
 706         if (test_bit(entry->addr.id, pernet->id_bitmap))
 707                 goto out;
 708
 709         /* do not insert duplicate address, differentiate on port only
 710          * singled addresses
 711          */
 712         list_for_each_entry(cur, &pernet->local_addr_list, list) {
 713                 if (addresses_equal(&cur->addr, &entry->addr,
 714                                     address_use_port(entry) &&
 715                                     address_use_port(cur)))
 716                         goto out;
 717         }
 718
 719         if (!entry->addr.id) {
 720 find_next:
 721                 entry->addr.id = find_next_zero_bit(pernet->id_bitmap,
 722                                                     MAX_ADDR_ID + 1,
 723                                                     pernet->next_id);
 724                 if ((!entry->addr.id || entry->addr.id > MAX_ADDR_ID) &&
 725                     pernet->next_id != 1) {
 726                         pernet->next_id = 1;
 727                         goto find_next;
 728                 }
 729         }
 730
 731         if (!entry->addr.id || entry->addr.id > MAX_ADDR_ID)
 732                 goto out;
 733
 734         __set_bit(entry->addr.id, pernet->id_bitmap);
 735         if (entry->addr.id > pernet->next_id)
 736                 pernet->next_id = entry->addr.id;
 737
 738         if (entry->addr.flags & MPTCP_PM_ADDR_FLAG_SIGNAL) {
 739                 addr_max = pernet->add_addr_signal_max;
 740                 WRITE_ONCE(pernet->add_addr_signal_max, addr_max + 1);
 741         }
 742         if (entry->addr.flags & MPTCP_PM_ADDR_FLAG_SUBFLOW) {
 743                 addr_max = pernet->local_addr_max;
 744                 WRITE_ONCE(pernet->local_addr_max, addr_max + 1);
 745         }
 746
 747         pernet->addrs++;
 748         list_add_tail_rcu(&entry->list, &pernet->local_addr_list);
 749         ret = entry->addr.id;
 750
 751 out:
 752         spin_unlock_bh(&pernet->lock);
 753         return ret;
 754 }
 755
 756 static int mptcp_pm_nl_create_listen_socket(struct sock *sk,
 757                                             struct mptcp_pm_addr_entry *entry)
 758 {
 759         struct sockaddr_storage addr;
 760         struct mptcp_sock *msk;
 761         struct socket *ssock;
 762         int backlog = 1024;
 763         int err;
 764
 765         err = sock_create_kern(sock_net(sk), entry->addr.family,
 766                                SOCK_STREAM, IPPROTO_MPTCP, &entry->lsk);
 767         if (err)
 768                 return err;
 769
 770         msk = mptcp_sk(entry->lsk->sk);
 771         if (!msk) {
 772                 err = -EINVAL;
 773                 goto out;
 774         }
 775
 776         ssock = __mptcp_nmpc_socket(msk);
 777         if (!ssock) {
 778                 err = -EINVAL;
 779                 goto out;
 780         }
 781
 782         mptcp_info2sockaddr(&entry->addr, &addr, entry->addr.family);
 783         err = kernel_bind(ssock, (struct sockaddr *)&addr,
 784                           sizeof(struct sockaddr_in));
 785         if (err) {
 786                 pr_warn("kernel_bind error, err=%d", err);
 787                 goto out;
 788         }
 789
 790         err = kernel_listen(ssock, backlog);
 791         if (err) {
 792                 pr_warn("kernel_listen error, err=%d", err);
 793                 goto out;
 794         }
 795
 796         return 0;
 797
 798 out:
 799         sock_release(entry->lsk);
 800         return err;
 801 }
 802
 803 int mptcp_pm_nl_get_local_id(struct mptcp_sock *msk, struct sock_common *skc)
 804 {
 805         struct mptcp_pm_addr_entry *entry;
 806         struct mptcp_addr_info skc_local;
 807         struct mptcp_addr_info msk_local;
 808         struct pm_nl_pernet *pernet;
 809         int ret = -1;
 810
 811         if (WARN_ON_ONCE(!msk))
 812                 return -1;
 813
 814         /* The 0 ID mapping is defined by the first subflow, copied into the msk
 815          * addr
 816          */
 817         local_address((struct sock_common *)msk, &msk_local);
 818         local_address((struct sock_common *)skc, &skc_local);
 819         if (addresses_equal(&msk_local, &skc_local, false))
 820                 return 0;
 821
 822         if (address_zero(&skc_local))
 823                 return 0;
 824
 825         pernet = net_generic(sock_net((struct sock *)msk), pm_nl_pernet_id);
 826
 827         rcu_read_lock();
 828         list_for_each_entry_rcu(entry, &pernet->local_addr_list, list) {
 829                 if (addresses_equal(&entry->addr, &skc_local, entry->addr.port)) {
 830                         ret = entry->addr.id;
 831                         break;
 832                 }
 833         }
 834         rcu_read_unlock();
 835         if (ret >= 0)
 836                 return ret;
 837
 838         /* address not found, add to local list */
 839         entry = kmalloc(sizeof(*entry), GFP_ATOMIC);
 840         if (!entry)
 841                 return -ENOMEM;
 842
 843         entry->addr = skc_local;
 844         entry->addr.ifindex = 0;
 845         entry->addr.flags = 0;
 846         entry->addr.id = 0;
 847         entry->addr.port = 0;
 848         entry->lsk = NULL;
 849         ret = mptcp_pm_nl_append_new_local_addr(pernet, entry);
 850         if (ret < 0)
 851                 kfree(entry);
 852
 853         return ret;
 854 }
 855
 856 void mptcp_pm_nl_data_init(struct mptcp_sock *msk)
 857 {
 858         struct mptcp_pm_data *pm = &msk->pm;
 859         bool subflows;
 860
 861         subflows = !!mptcp_pm_get_subflows_max(msk);
 862         WRITE_ONCE(pm->work_pending, (!!mptcp_pm_get_local_addr_max(msk) && subflows) ||
 863                    !!mptcp_pm_get_add_addr_signal_max(msk));
 864         WRITE_ONCE(pm->accept_addr, !!mptcp_pm_get_add_addr_accept_max(msk) && subflows);
 865         WRITE_ONCE(pm->accept_subflow, subflows);
 866 }
 867
 868 #define MPTCP_PM_CMD_GRP_OFFSET       0
 869 #define MPTCP_PM_EV_GRP_OFFSET        1
 870
 871 static const struct genl_multicast_group mptcp_pm_mcgrps[] = {
 872         [MPTCP_PM_CMD_GRP_OFFSET]       = { .name = MPTCP_PM_CMD_GRP_NAME, },
 873         [MPTCP_PM_EV_GRP_OFFSET]        = { .name = MPTCP_PM_EV_GRP_NAME,
 874                                             .flags = GENL_UNS_ADMIN_PERM,
 875                                           },
 876 };
 877
 878 static const struct nla_policy
 879 mptcp_pm_addr_policy[MPTCP_PM_ADDR_ATTR_MAX + 1] = {
 880         [MPTCP_PM_ADDR_ATTR_FAMILY]     = { .type       = NLA_U16,      },
 881         [MPTCP_PM_ADDR_ATTR_ID]         = { .type       = NLA_U8,       },
 882         [MPTCP_PM_ADDR_ATTR_ADDR4]      = { .type       = NLA_U32,      },
 883         [MPTCP_PM_ADDR_ATTR_ADDR6]      =
 884                 NLA_POLICY_EXACT_LEN(sizeof(struct in6_addr)),
 885         [MPTCP_PM_ADDR_ATTR_PORT]       = { .type       = NLA_U16       },
 886         [MPTCP_PM_ADDR_ATTR_FLAGS]      = { .type       = NLA_U32       },
 887         [MPTCP_PM_ADDR_ATTR_IF_IDX]     = { .type       = NLA_S32       },
 888 };
 889
 890 static const struct nla_policy mptcp_pm_policy[MPTCP_PM_ATTR_MAX + 1] = {
 891         [MPTCP_PM_ATTR_ADDR]            =
 892                                         NLA_POLICY_NESTED(mptcp_pm_addr_policy),
 893         [MPTCP_PM_ATTR_RCV_ADD_ADDRS]   = { .type       = NLA_U32,      },
 894         [MPTCP_PM_ATTR_SUBFLOWS]        = { .type       = NLA_U32,      },
 895 };
 896
 897 static int mptcp_pm_family_to_addr(int family)
 898 {
 899 #if IS_ENABLED(CONFIG_MPTCP_IPV6)
 900         if (family == AF_INET6)
 901                 return MPTCP_PM_ADDR_ATTR_ADDR6;
 902 #endif
 903         return MPTCP_PM_ADDR_ATTR_ADDR4;
 904 }
 905
 906 static int mptcp_pm_parse_addr(struct nlattr *attr, struct genl_info *info,
 907                                bool require_family,
 908                                struct mptcp_pm_addr_entry *entry)
 909 {
 910         struct nlattr *tb[MPTCP_PM_ADDR_ATTR_MAX + 1];
 911         int err, addr_addr;
 912
 913         if (!attr) {
 914                 GENL_SET_ERR_MSG(info, "missing address info");
 915                 return -EINVAL;
 916         }
 917
 918         /* no validation needed - was already done via nested policy */
 919         err = nla_parse_nested_deprecated(tb, MPTCP_PM_ADDR_ATTR_MAX, attr,
 920                                           mptcp_pm_addr_policy, info->extack);
 921         if (err)
 922                 return err;
 923
 924         memset(entry, 0, sizeof(*entry));
 925         if (!tb[MPTCP_PM_ADDR_ATTR_FAMILY]) {
 926                 if (!require_family)
 927                         goto skip_family;
 928
 929                 NL_SET_ERR_MSG_ATTR(info->extack, attr,
 930                                     "missing family");
 931                 return -EINVAL;
 932         }
 933
 934         entry->addr.family = nla_get_u16(tb[MPTCP_PM_ADDR_ATTR_FAMILY]);
 935         if (entry->addr.family != AF_INET
 936 #if IS_ENABLED(CONFIG_MPTCP_IPV6)
 937             && entry->addr.family != AF_INET6
 938 #endif
 939             ) {
 940                 NL_SET_ERR_MSG_ATTR(info->extack, attr,
 941                                     "unknown address family");
 942                 return -EINVAL;
 943         }
 944         addr_addr = mptcp_pm_family_to_addr(entry->addr.family);
 945         if (!tb[addr_addr]) {
 946                 NL_SET_ERR_MSG_ATTR(info->extack, attr,
 947                                     "missing address data");
 948                 return -EINVAL;
 949         }
 950
 951 #if IS_ENABLED(CONFIG_MPTCP_IPV6)
 952         if (entry->addr.family == AF_INET6)
 953                 entry->addr.addr6 = nla_get_in6_addr(tb[addr_addr]);
 954         else
 955 #endif
 956                 entry->addr.addr.s_addr = nla_get_in_addr(tb[addr_addr]);
 957
 958 skip_family:
 959         if (tb[MPTCP_PM_ADDR_ATTR_IF_IDX]) {
 960                 u32 val = nla_get_s32(tb[MPTCP_PM_ADDR_ATTR_IF_IDX]);
 961
 962                 entry->addr.ifindex = val;
 963         }
 964
 965         if (tb[MPTCP_PM_ADDR_ATTR_ID])
 966                 entry->addr.id = nla_get_u8(tb[MPTCP_PM_ADDR_ATTR_ID]);
 967
 968         if (tb[MPTCP_PM_ADDR_ATTR_FLAGS])
 969                 entry->addr.flags = nla_get_u32(tb[MPTCP_PM_ADDR_ATTR_FLAGS]);
 970
 971         if (tb[MPTCP_PM_ADDR_ATTR_PORT])
 972                 entry->addr.port = htons(nla_get_u16(tb[MPTCP_PM_ADDR_ATTR_PORT]));
 973
 974         return 0;
 975 }
 976
 977 static struct pm_nl_pernet *genl_info_pm_nl(struct genl_info *info)
 978 {
 979         return net_generic(genl_info_net(info), pm_nl_pernet_id);
 980 }
 981
 982 static int mptcp_nl_add_subflow_or_signal_addr(struct net *net)
 983 {
 984         struct mptcp_sock *msk;
 985         long s_slot = 0, s_num = 0;
 986
 987         while ((msk = mptcp_token_iter_next(net, &s_slot, &s_num)) != NULL) {
 988                 struct sock *sk = (struct sock *)msk;
 989
 990                 if (!READ_ONCE(msk->fully_established))
 991                         goto next;
 992
 993                 lock_sock(sk);
 994                 spin_lock_bh(&msk->pm.lock);
 995                 mptcp_pm_create_subflow_or_signal_addr(msk);
 996                 spin_unlock_bh(&msk->pm.lock);
 997                 release_sock(sk);
 998
 999 next:
1000                 sock_put(sk);
1001                 cond_resched();
1002         }
1003
1004         return 0;
1005 }
1006
1007 static int mptcp_nl_cmd_add_addr(struct sk_buff *skb, struct genl_info *info)
1008 {
1009         struct nlattr *attr = info->attrs[MPTCP_PM_ATTR_ADDR];
1010         struct pm_nl_pernet *pernet = genl_info_pm_nl(info);
1011         struct mptcp_pm_addr_entry addr, *entry;
1012         int ret;
1013
1014         ret = mptcp_pm_parse_addr(attr, info, true, &addr);
1015         if (ret < 0)
1016                 return ret;
1017
1018         entry = kmalloc(sizeof(*entry), GFP_KERNEL);
1019         if (!entry) {
1020                 GENL_SET_ERR_MSG(info, "can't allocate addr");
1021                 return -ENOMEM;
1022         }
1023
1024         *entry = addr;
1025         if (entry->addr.port) {
1026                 ret = mptcp_pm_nl_create_listen_socket(skb->sk, entry);
1027                 if (ret) {
1028                         GENL_SET_ERR_MSG(info, "create listen socket error");
1029                         kfree(entry);
1030                         return ret;
1031                 }
1032         }
1033         ret = mptcp_pm_nl_append_new_local_addr(pernet, entry);
1034         if (ret < 0) {
1035                 GENL_SET_ERR_MSG(info, "too many addresses or duplicate one");
1036                 if (entry->lsk)
1037                         sock_release(entry->lsk);
1038                 kfree(entry);
1039                 return ret;
1040         }
1041
1042         mptcp_nl_add_subflow_or_signal_addr(sock_net(skb->sk));
1043
1044         return 0;
1045 }
1046
1047 static struct mptcp_pm_addr_entry *
1048 __lookup_addr_by_id(struct pm_nl_pernet *pernet, unsigned int id)
1049 {
1050         struct mptcp_pm_addr_entry *entry;
1051
1052         list_for_each_entry(entry, &pernet->local_addr_list, list) {
1053                 if (entry->addr.id == id)
1054                         return entry;
1055         }
1056         return NULL;
1057 }
1058
1059 static bool remove_anno_list_by_saddr(struct mptcp_sock *msk,
1060                                       struct mptcp_addr_info *addr)
1061 {
1062         struct mptcp_pm_add_entry *entry;
1063
1064         entry = mptcp_pm_del_add_timer(msk, addr);
1065         if (entry) {
1066                 list_del(&entry->list);
1067                 kfree(entry);
1068                 return true;
1069         }
1070
1071         return false;
1072 }
1073
1074 static bool mptcp_pm_remove_anno_addr(struct mptcp_sock *msk,
1075                                       struct mptcp_addr_info *addr,
1076                                       bool force)
1077 {
1078         struct mptcp_rm_list list = { .nr = 0 };
1079         bool ret;
1080
1081         list.ids[list.nr++] = addr->id;
1082
1083         ret = remove_anno_list_by_saddr(msk, addr);
1084         if (ret || force) {
1085                 spin_lock_bh(&msk->pm.lock);
1086                 mptcp_pm_remove_addr(msk, &list);
1087                 spin_unlock_bh(&msk->pm.lock);
1088         }
1089         return ret;
1090 }
1091
1092 static int mptcp_nl_remove_subflow_and_signal_addr(struct net *net,
1093                                                    struct mptcp_addr_info *addr)
1094 {
1095         struct mptcp_sock *msk;
1096         long s_slot = 0, s_num = 0;
1097         struct mptcp_rm_list list = { .nr = 0 };
1098
1099         pr_debug("remove_id=%d", addr->id);
1100
1101         list.ids[list.nr++] = addr->id;
1102
1103         while ((msk = mptcp_token_iter_next(net, &s_slot, &s_num)) != NULL) {
1104                 struct sock *sk = (struct sock *)msk;
1105                 bool remove_subflow;
1106
1107                 if (list_empty(&msk->conn_list)) {
1108                         mptcp_pm_remove_anno_addr(msk, addr, false);
1109                         goto next;
1110                 }
1111
1112                 lock_sock(sk);
1113                 remove_subflow = lookup_subflow_by_saddr(&msk->conn_list, addr);
1114                 mptcp_pm_remove_anno_addr(msk, addr, remove_subflow);
1115                 if (remove_subflow)
1116                         mptcp_pm_remove_subflow(msk, &list);
1117                 release_sock(sk);
1118
1119 next:
1120                 sock_put(sk);
1121                 cond_resched();
1122         }
1123
1124         return 0;
1125 }
1126
1127 struct addr_entry_release_work {
1128         struct rcu_work rwork;
1129         struct mptcp_pm_addr_entry *entry;
1130 };
1131
1132 static void mptcp_pm_release_addr_entry(struct work_struct *work)
1133 {
1134         struct addr_entry_release_work *w;
1135         struct mptcp_pm_addr_entry *entry;
1136
1137         w = container_of(to_rcu_work(work), struct addr_entry_release_work, rwork);
1138         entry = w->entry;
1139         if (entry) {
1140                 if (entry->lsk)
1141                         sock_release(entry->lsk);
1142                 kfree(entry);
1143         }
1144         kfree(w);
1145 }
1146
1147 static void mptcp_pm_free_addr_entry(struct mptcp_pm_addr_entry *entry)
1148 {
1149         struct addr_entry_release_work *w;
1150
1151         w = kmalloc(sizeof(*w), GFP_ATOMIC);
1152         if (w) {
1153                 INIT_RCU_WORK(&w->rwork, mptcp_pm_release_addr_entry);
1154                 w->entry = entry;
1155                 queue_rcu_work(system_wq, &w->rwork);
1156         }
1157 }
1158
1159 static int mptcp_nl_remove_id_zero_address(struct net *net,
1160                                            struct mptcp_addr_info *addr)
1161 {
1162         struct mptcp_rm_list list = { .nr = 0 };
1163         long s_slot = 0, s_num = 0;
1164         struct mptcp_sock *msk;
1165
1166         list.ids[list.nr++] = 0;
1167
1168         while ((msk = mptcp_token_iter_next(net, &s_slot, &s_num)) != NULL) {
1169                 struct sock *sk = (struct sock *)msk;
1170                 struct mptcp_addr_info msk_local;
1171
1172                 if (list_empty(&msk->conn_list))
1173                         goto next;
1174
1175                 local_address((struct sock_common *)msk, &msk_local);
1176                 if (!addresses_equal(&msk_local, addr, addr->port))
1177                         goto next;
1178
1179                 lock_sock(sk);
1180                 spin_lock_bh(&msk->pm.lock);
1181                 mptcp_pm_remove_addr(msk, &list);
1182                 mptcp_pm_nl_rm_subflow_received(msk, &list);
1183                 spin_unlock_bh(&msk->pm.lock);
1184                 release_sock(sk);
1185
1186 next:
1187                 sock_put(sk);
1188                 cond_resched();
1189         }
1190
1191         return 0;
1192 }
1193
1194 static int mptcp_nl_cmd_del_addr(struct sk_buff *skb, struct genl_info *info)
1195 {
1196         struct nlattr *attr = info->attrs[MPTCP_PM_ATTR_ADDR];
1197         struct pm_nl_pernet *pernet = genl_info_pm_nl(info);
1198         struct mptcp_pm_addr_entry addr, *entry;
1199         unsigned int addr_max;
1200         int ret;
1201
1202         ret = mptcp_pm_parse_addr(attr, info, false, &addr);
1203         if (ret < 0)
1204                 return ret;
1205
1206         /* the zero id address is special: the first address used by the msk
1207          * always gets such an id, so different subflows can have different zero
1208          * id addresses. Additionally zero id is not accounted for in id_bitmap.
1209          * Let's use an 'mptcp_rm_list' instead of the common remove code.
1210          */
1211         if (addr.addr.id == 0)
1212                 return mptcp_nl_remove_id_zero_address(sock_net(skb->sk), &addr.addr);
1213
1214         spin_lock_bh(&pernet->lock);
1215         entry = __lookup_addr_by_id(pernet, addr.addr.id);
1216         if (!entry) {
1217                 GENL_SET_ERR_MSG(info, "address not found");
1218                 spin_unlock_bh(&pernet->lock);
1219                 return -EINVAL;
1220         }
1221         if (entry->addr.flags & MPTCP_PM_ADDR_FLAG_SIGNAL) {
1222                 addr_max = pernet->add_addr_signal_max;
1223                 WRITE_ONCE(pernet->add_addr_signal_max, addr_max - 1);
1224         }
1225         if (entry->addr.flags & MPTCP_PM_ADDR_FLAG_SUBFLOW) {
1226                 addr_max = pernet->local_addr_max;
1227                 WRITE_ONCE(pernet->local_addr_max, addr_max - 1);
1228         }
1229
1230         pernet->addrs--;
1231         list_del_rcu(&entry->list);
1232         __clear_bit(entry->addr.id, pernet->id_bitmap);
1233         spin_unlock_bh(&pernet->lock);
1234
1235         mptcp_nl_remove_subflow_and_signal_addr(sock_net(skb->sk), &entry->addr);
1236         mptcp_pm_free_addr_entry(entry);
1237
1238         return ret;
1239 }
1240
1241 static void mptcp_pm_remove_addrs_and_subflows(struct mptcp_sock *msk,
1242                                                struct list_head *rm_list)
1243 {
1244         struct mptcp_rm_list alist = { .nr = 0 }, slist = { .nr = 0 };
1245         struct mptcp_pm_addr_entry *entry;
1246
1247         list_for_each_entry(entry, rm_list, list) {
1248                 if (lookup_subflow_by_saddr(&msk->conn_list, &entry->addr) &&
1249                     alist.nr < MPTCP_RM_IDS_MAX &&
1250                     slist.nr < MPTCP_RM_IDS_MAX) {
1251                         alist.ids[alist.nr++] = entry->addr.id;
1252                         slist.ids[slist.nr++] = entry->addr.id;
1253                 } else if (remove_anno_list_by_saddr(msk, &entry->addr) &&
1254                          alist.nr < MPTCP_RM_IDS_MAX) {
1255                         alist.ids[alist.nr++] = entry->addr.id;
1256                 }
1257         }
1258
1259         if (alist.nr) {
1260                 spin_lock_bh(&msk->pm.lock);
1261                 mptcp_pm_remove_addr(msk, &alist);
1262                 spin_unlock_bh(&msk->pm.lock);
1263         }
1264         if (slist.nr)
1265                 mptcp_pm_remove_subflow(msk, &slist);
1266 }
1267
1268 static void mptcp_nl_remove_addrs_list(struct net *net,
1269                                        struct list_head *rm_list)
1270 {
1271         long s_slot = 0, s_num = 0;
1272         struct mptcp_sock *msk;
1273
1274         if (list_empty(rm_list))
1275                 return;
1276
1277         while ((msk = mptcp_token_iter_next(net, &s_slot, &s_num)) != NULL) {
1278                 struct sock *sk = (struct sock *)msk;
1279
1280                 lock_sock(sk);
1281                 mptcp_pm_remove_addrs_and_subflows(msk, rm_list);
1282                 release_sock(sk);
1283
1284                 sock_put(sk);
1285                 cond_resched();
1286         }
1287 }
1288
1289 static void __flush_addrs(struct list_head *list)
1290 {
1291         while (!list_empty(list)) {
1292                 struct mptcp_pm_addr_entry *cur;
1293
1294                 cur = list_entry(list->next,
1295                                  struct mptcp_pm_addr_entry, list);
1296                 list_del_rcu(&cur->list);
1297                 mptcp_pm_free_addr_entry(cur);
1298         }
1299 }
1300
1301 static void __reset_counters(struct pm_nl_pernet *pernet)
1302 {
1303         WRITE_ONCE(pernet->add_addr_signal_max, 0);
1304         WRITE_ONCE(pernet->add_addr_accept_max, 0);
1305         WRITE_ONCE(pernet->local_addr_max, 0);
1306         pernet->addrs = 0;
1307 }
1308
1309 static int mptcp_nl_cmd_flush_addrs(struct sk_buff *skb, struct genl_info *info)
1310 {
1311         struct pm_nl_pernet *pernet = genl_info_pm_nl(info);
1312         LIST_HEAD(free_list);
1313
1314         spin_lock_bh(&pernet->lock);
1315         list_splice_init(&pernet->local_addr_list, &free_list);
1316         __reset_counters(pernet);
1317         pernet->next_id = 1;
1318         bitmap_zero(pernet->id_bitmap, MAX_ADDR_ID + 1);
1319         spin_unlock_bh(&pernet->lock);
1320         mptcp_nl_remove_addrs_list(sock_net(skb->sk), &free_list);
1321         __flush_addrs(&free_list);
1322         return 0;
1323 }
1324
1325 static int mptcp_nl_fill_addr(struct sk_buff *skb,
1326                               struct mptcp_pm_addr_entry *entry)
1327 {
1328         struct mptcp_addr_info *addr = &entry->addr;
1329         struct nlattr *attr;
1330
1331         attr = nla_nest_start(skb, MPTCP_PM_ATTR_ADDR);
1332         if (!attr)
1333                 return -EMSGSIZE;
1334
1335         if (nla_put_u16(skb, MPTCP_PM_ADDR_ATTR_FAMILY, addr->family))
1336                 goto nla_put_failure;
1337         if (nla_put_u16(skb, MPTCP_PM_ADDR_ATTR_PORT, ntohs(addr->port)))
1338                 goto nla_put_failure;
1339         if (nla_put_u8(skb, MPTCP_PM_ADDR_ATTR_ID, addr->id))
1340                 goto nla_put_failure;
1341         if (nla_put_u32(skb, MPTCP_PM_ADDR_ATTR_FLAGS, entry->addr.flags))
1342                 goto nla_put_failure;
1343         if (entry->addr.ifindex &&
1344             nla_put_s32(skb, MPTCP_PM_ADDR_ATTR_IF_IDX, entry->addr.ifindex))
1345                 goto nla_put_failure;
1346
1347         if (addr->family == AF_INET &&
1348             nla_put_in_addr(skb, MPTCP_PM_ADDR_ATTR_ADDR4,
1349                             addr->addr.s_addr))
1350                 goto nla_put_failure;
1351 #if IS_ENABLED(CONFIG_MPTCP_IPV6)
1352         else if (addr->family == AF_INET6 &&
1353                  nla_put_in6_addr(skb, MPTCP_PM_ADDR_ATTR_ADDR6, &addr->addr6))
1354                 goto nla_put_failure;
1355 #endif
1356         nla_nest_end(skb, attr);
1357         return 0;
1358
1359 nla_put_failure:
1360         nla_nest_cancel(skb, attr);
1361         return -EMSGSIZE;
1362 }
1363
1364 static int mptcp_nl_cmd_get_addr(struct sk_buff *skb, struct genl_info *info)
1365 {
1366         struct nlattr *attr = info->attrs[MPTCP_PM_ATTR_ADDR];
1367         struct pm_nl_pernet *pernet = genl_info_pm_nl(info);
1368         struct mptcp_pm_addr_entry addr, *entry;
1369         struct sk_buff *msg;
1370         void *reply;
1371         int ret;
1372
1373         ret = mptcp_pm_parse_addr(attr, info, false, &addr);
1374         if (ret < 0)
1375                 return ret;
1376
1377         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1378         if (!msg)
1379                 return -ENOMEM;
1380
1381         reply = genlmsg_put_reply(msg, info, &mptcp_genl_family, 0,
1382                                   info->genlhdr->cmd);
1383         if (!reply) {
1384                 GENL_SET_ERR_MSG(info, "not enough space in Netlink message");
1385                 ret = -EMSGSIZE;
1386                 goto fail;
1387         }
1388
1389         spin_lock_bh(&pernet->lock);
1390         entry = __lookup_addr_by_id(pernet, addr.addr.id);
1391         if (!entry) {
1392                 GENL_SET_ERR_MSG(info, "address not found");
1393                 ret = -EINVAL;
1394                 goto unlock_fail;
1395         }
1396
1397         ret = mptcp_nl_fill_addr(msg, entry);
1398         if (ret)
1399                 goto unlock_fail;
1400
1401         genlmsg_end(msg, reply);
1402         ret = genlmsg_reply(msg, info);
1403         spin_unlock_bh(&pernet->lock);
1404         return ret;
1405
1406 unlock_fail:
1407         spin_unlock_bh(&pernet->lock);
1408
1409 fail:
1410         nlmsg_free(msg);
1411         return ret;
1412 }
1413
1414 static int mptcp_nl_cmd_dump_addrs(struct sk_buff *msg,
1415                                    struct netlink_callback *cb)
1416 {
1417         struct net *net = sock_net(msg->sk);
1418         struct mptcp_pm_addr_entry *entry;
1419         struct pm_nl_pernet *pernet;
1420         int id = cb->args[0];
1421         void *hdr;
1422         int i;
1423
1424         pernet = net_generic(net, pm_nl_pernet_id);
1425
1426         spin_lock_bh(&pernet->lock);
1427         for (i = id; i < MAX_ADDR_ID + 1; i++) {
1428                 if (test_bit(i, pernet->id_bitmap)) {
1429                         entry = __lookup_addr_by_id(pernet, i);
1430                         if (!entry)
1431                                 break;
1432
1433                         if (entry->addr.id <= id)
1434                                 continue;
1435
1436                         hdr = genlmsg_put(msg, NETLINK_CB(cb->skb).portid,
1437                                           cb->nlh->nlmsg_seq, &mptcp_genl_family,
1438                                           NLM_F_MULTI, MPTCP_PM_CMD_GET_ADDR);
1439                         if (!hdr)
1440                                 break;
1441
1442                         if (mptcp_nl_fill_addr(msg, entry) < 0) {
1443                                 genlmsg_cancel(msg, hdr);
1444                                 break;
1445                         }
1446
1447                         id = entry->addr.id;
1448                         genlmsg_end(msg, hdr);
1449                 }
1450         }
1451         spin_unlock_bh(&pernet->lock);
1452
1453         cb->args[0] = id;
1454         return msg->len;
1455 }
1456
1457 static int parse_limit(struct genl_info *info, int id, unsigned int *limit)
1458 {
1459         struct nlattr *attr = info->attrs[id];
1460
1461         if (!attr)
1462                 return 0;
1463
1464         *limit = nla_get_u32(attr);
1465         if (*limit > MPTCP_PM_ADDR_MAX) {
1466                 GENL_SET_ERR_MSG(info, "limit greater than maximum");
1467                 return -EINVAL;
1468         }
1469         return 0;
1470 }
1471
1472 static int
1473 mptcp_nl_cmd_set_limits(struct sk_buff *skb, struct genl_info *info)
1474 {
1475         struct pm_nl_pernet *pernet = genl_info_pm_nl(info);
1476         unsigned int rcv_addrs, subflows;
1477         int ret;
1478
1479         spin_lock_bh(&pernet->lock);
1480         rcv_addrs = pernet->add_addr_accept_max;
1481         ret = parse_limit(info, MPTCP_PM_ATTR_RCV_ADD_ADDRS, &rcv_addrs);
1482         if (ret)
1483                 goto unlock;
1484
1485         subflows = pernet->subflows_max;
1486         ret = parse_limit(info, MPTCP_PM_ATTR_SUBFLOWS, &subflows);
1487         if (ret)
1488                 goto unlock;
1489
1490         WRITE_ONCE(pernet->add_addr_accept_max, rcv_addrs);
1491         WRITE_ONCE(pernet->subflows_max, subflows);
1492
1493 unlock:
1494         spin_unlock_bh(&pernet->lock);
1495         return ret;
1496 }
1497
1498 static int
1499 mptcp_nl_cmd_get_limits(struct sk_buff *skb, struct genl_info *info)
1500 {
1501         struct pm_nl_pernet *pernet = genl_info_pm_nl(info);
1502         struct sk_buff *msg;
1503         void *reply;
1504
1505         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1506         if (!msg)
1507                 return -ENOMEM;
1508
1509         reply = genlmsg_put_reply(msg, info, &mptcp_genl_family, 0,
1510                                   MPTCP_PM_CMD_GET_LIMITS);
1511         if (!reply)
1512                 goto fail;
1513
1514         if (nla_put_u32(msg, MPTCP_PM_ATTR_RCV_ADD_ADDRS,
1515                         READ_ONCE(pernet->add_addr_accept_max)))
1516                 goto fail;
1517
1518         if (nla_put_u32(msg, MPTCP_PM_ATTR_SUBFLOWS,
1519                         READ_ONCE(pernet->subflows_max)))
1520                 goto fail;
1521
1522         genlmsg_end(msg, reply);
1523         return genlmsg_reply(msg, info);
1524
1525 fail:
1526         GENL_SET_ERR_MSG(info, "not enough space in Netlink message");
1527         nlmsg_free(msg);
1528         return -EMSGSIZE;
1529 }
1530
1531 static int mptcp_nl_addr_backup(struct net *net,
1532                                 struct mptcp_addr_info *addr,
1533                                 u8 bkup)
1534 {
1535         long s_slot = 0, s_num = 0;
1536         struct mptcp_sock *msk;
1537         int ret = -EINVAL;
1538
1539         while ((msk = mptcp_token_iter_next(net, &s_slot, &s_num)) != NULL) {
1540                 struct sock *sk = (struct sock *)msk;
1541
1542                 if (list_empty(&msk->conn_list))
1543                         goto next;
1544
1545                 lock_sock(sk);
1546                 spin_lock_bh(&msk->pm.lock);
1547                 ret = mptcp_pm_nl_mp_prio_send_ack(msk, addr, bkup);
1548                 spin_unlock_bh(&msk->pm.lock);
1549                 release_sock(sk);
1550
1551 next:
1552                 sock_put(sk);
1553                 cond_resched();
1554         }
1555
1556         return ret;
1557 }
1558
1559 static int mptcp_nl_cmd_set_flags(struct sk_buff *skb, struct genl_info *info)
1560 {
1561         struct nlattr *attr = info->attrs[MPTCP_PM_ATTR_ADDR];
1562         struct pm_nl_pernet *pernet = genl_info_pm_nl(info);
1563         struct mptcp_pm_addr_entry addr, *entry;
1564         struct net *net = sock_net(skb->sk);
1565         u8 bkup = 0;
1566         int ret;
1567
1568         ret = mptcp_pm_parse_addr(attr, info, true, &addr);
1569         if (ret < 0)
1570                 return ret;
1571
1572         if (addr.addr.flags & MPTCP_PM_ADDR_FLAG_BACKUP)
1573                 bkup = 1;
1574
1575         list_for_each_entry(entry, &pernet->local_addr_list, list) {
1576                 if (addresses_equal(&entry->addr, &addr.addr, true)) {
1577                         ret = mptcp_nl_addr_backup(net, &entry->addr, bkup);
1578                         if (ret)
1579                                 return ret;
1580
1581                         if (bkup)
1582                                 entry->addr.flags |= MPTCP_PM_ADDR_FLAG_BACKUP;
1583                         else
1584                                 entry->addr.flags &= ~MPTCP_PM_ADDR_FLAG_BACKUP;
1585                 }
1586         }
1587
1588         return 0;
1589 }
1590
1591 static void mptcp_nl_mcast_send(struct net *net, struct sk_buff *nlskb, gfp_t gfp)
1592 {
1593         genlmsg_multicast_netns(&mptcp_genl_family, net,
1594                                 nlskb, 0, MPTCP_PM_EV_GRP_OFFSET, gfp);
1595 }
1596
1597 static int mptcp_event_add_subflow(struct sk_buff *skb, const struct sock *ssk)
1598 {
1599         const struct inet_sock *issk = inet_sk(ssk);
1600         const struct mptcp_subflow_context *sf;
1601
1602         if (nla_put_u16(skb, MPTCP_ATTR_FAMILY, ssk->sk_family))
1603                 return -EMSGSIZE;
1604
1605         switch (ssk->sk_family) {
1606         case AF_INET:
1607                 if (nla_put_in_addr(skb, MPTCP_ATTR_SADDR4, issk->inet_saddr))
1608                         return -EMSGSIZE;
1609                 if (nla_put_in_addr(skb, MPTCP_ATTR_DADDR4, issk->inet_daddr))
1610                         return -EMSGSIZE;
1611                 break;
1612 #if IS_ENABLED(CONFIG_MPTCP_IPV6)
1613         case AF_INET6: {
1614                 const struct ipv6_pinfo *np = inet6_sk(ssk);
1615
1616                 if (nla_put_in6_addr(skb, MPTCP_ATTR_SADDR6, &np->saddr))
1617                         return -EMSGSIZE;
1618                 if (nla_put_in6_addr(skb, MPTCP_ATTR_DADDR6, &ssk->sk_v6_daddr))
1619                         return -EMSGSIZE;
1620                 break;
1621         }
1622 #endif
1623         default:
1624                 WARN_ON_ONCE(1);
1625                 return -EMSGSIZE;
1626         }
1627
1628         if (nla_put_be16(skb, MPTCP_ATTR_SPORT, issk->inet_sport))
1629                 return -EMSGSIZE;
1630         if (nla_put_be16(skb, MPTCP_ATTR_DPORT, issk->inet_dport))
1631                 return -EMSGSIZE;
1632
1633         sf = mptcp_subflow_ctx(ssk);
1634         if (WARN_ON_ONCE(!sf))
1635                 return -EINVAL;
1636
1637         if (nla_put_u8(skb, MPTCP_ATTR_LOC_ID, sf->local_id))
1638                 return -EMSGSIZE;
1639
1640         if (nla_put_u8(skb, MPTCP_ATTR_REM_ID, sf->remote_id))
1641                 return -EMSGSIZE;
1642
1643         return 0;
1644 }
1645
1646 static int mptcp_event_put_token_and_ssk(struct sk_buff *skb,
1647                                          const struct mptcp_sock *msk,
1648                                          const struct sock *ssk)
1649 {
1650         const struct sock *sk = (const struct sock *)msk;
1651         const struct mptcp_subflow_context *sf;
1652         u8 sk_err;
1653
1654         if (nla_put_u32(skb, MPTCP_ATTR_TOKEN, msk->token))
1655                 return -EMSGSIZE;
1656
1657         if (mptcp_event_add_subflow(skb, ssk))
1658                 return -EMSGSIZE;
1659
1660         sf = mptcp_subflow_ctx(ssk);
1661         if (WARN_ON_ONCE(!sf))
1662                 return -EINVAL;
1663
1664         if (nla_put_u8(skb, MPTCP_ATTR_BACKUP, sf->backup))
1665                 return -EMSGSIZE;
1666
1667         if (ssk->sk_bound_dev_if &&
1668             nla_put_s32(skb, MPTCP_ATTR_IF_IDX, ssk->sk_bound_dev_if))
1669                 return -EMSGSIZE;
1670
1671         sk_err = ssk->sk_err;
1672         if (sk_err && sk->sk_state == TCP_ESTABLISHED &&
1673             nla_put_u8(skb, MPTCP_ATTR_ERROR, sk_err))
1674                 return -EMSGSIZE;
1675
1676         return 0;
1677 }
1678
1679 static int mptcp_event_sub_established(struct sk_buff *skb,
1680                                        const struct mptcp_sock *msk,
1681                                        const struct sock *ssk)
1682 {
1683         return mptcp_event_put_token_and_ssk(skb, msk, ssk);
1684 }
1685
1686 static int mptcp_event_sub_closed(struct sk_buff *skb,
1687                                   const struct mptcp_sock *msk,
1688                                   const struct sock *ssk)
1689 {
1690         const struct mptcp_subflow_context *sf;
1691
1692         if (mptcp_event_put_token_and_ssk(skb, msk, ssk))
1693                 return -EMSGSIZE;
1694
1695         sf = mptcp_subflow_ctx(ssk);
1696         if (!sf->reset_seen)
1697                 return 0;
1698
1699         if (nla_put_u32(skb, MPTCP_ATTR_RESET_REASON, sf->reset_reason))
1700                 return -EMSGSIZE;
1701
1702         if (nla_put_u32(skb, MPTCP_ATTR_RESET_FLAGS, sf->reset_transient))
1703                 return -EMSGSIZE;
1704
1705         return 0;
1706 }
1707
1708 static int mptcp_event_created(struct sk_buff *skb,
1709                                const struct mptcp_sock *msk,
1710                                const struct sock *ssk)
1711 {
1712         int err = nla_put_u32(skb, MPTCP_ATTR_TOKEN, msk->token);
1713
1714         if (err)
1715                 return err;
1716
1717         return mptcp_event_add_subflow(skb, ssk);
1718 }
1719
1720 void mptcp_event_addr_removed(const struct mptcp_sock *msk, uint8_t id)
1721 {
1722         struct net *net = sock_net((const struct sock *)msk);
1723         struct nlmsghdr *nlh;
1724         struct sk_buff *skb;
1725
1726         if (!genl_has_listeners(&mptcp_genl_family, net, MPTCP_PM_EV_GRP_OFFSET))
1727                 return;
1728
1729         skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
1730         if (!skb)
1731                 return;
1732
1733         nlh = genlmsg_put(skb, 0, 0, &mptcp_genl_family, 0, MPTCP_EVENT_REMOVED);
1734         if (!nlh)
1735                 goto nla_put_failure;
1736
1737         if (nla_put_u32(skb, MPTCP_ATTR_TOKEN, msk->token))
1738                 goto nla_put_failure;
1739
1740         if (nla_put_u8(skb, MPTCP_ATTR_REM_ID, id))
1741                 goto nla_put_failure;
1742
1743         genlmsg_end(skb, nlh);
1744         mptcp_nl_mcast_send(net, skb, GFP_ATOMIC);
1745         return;
1746
1747 nla_put_failure:
1748         kfree_skb(skb);
1749 }
1750
1751 void mptcp_event_addr_announced(const struct mptcp_sock *msk,
1752                                 const struct mptcp_addr_info *info)
1753 {
1754         struct net *net = sock_net((const struct sock *)msk);
1755         struct nlmsghdr *nlh;
1756         struct sk_buff *skb;
1757
1758         if (!genl_has_listeners(&mptcp_genl_family, net, MPTCP_PM_EV_GRP_OFFSET))
1759                 return;
1760
1761         skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
1762         if (!skb)
1763                 return;
1764
1765         nlh = genlmsg_put(skb, 0, 0, &mptcp_genl_family, 0,
1766                           MPTCP_EVENT_ANNOUNCED);
1767         if (!nlh)
1768                 goto nla_put_failure;
1769
1770         if (nla_put_u32(skb, MPTCP_ATTR_TOKEN, msk->token))
1771                 goto nla_put_failure;
1772
1773         if (nla_put_u8(skb, MPTCP_ATTR_REM_ID, info->id))
1774                 goto nla_put_failure;
1775
1776         if (nla_put_be16(skb, MPTCP_ATTR_DPORT, info->port))
1777                 goto nla_put_failure;
1778
1779         switch (info->family) {
1780         case AF_INET:
1781                 if (nla_put_in_addr(skb, MPTCP_ATTR_DADDR4, info->addr.s_addr))
1782                         goto nla_put_failure;
1783                 break;
1784 #if IS_ENABLED(CONFIG_MPTCP_IPV6)
1785         case AF_INET6:
1786                 if (nla_put_in6_addr(skb, MPTCP_ATTR_DADDR6, &info->addr6))
1787                         goto nla_put_failure;
1788                 break;
1789 #endif
1790         default:
1791                 WARN_ON_ONCE(1);
1792                 goto nla_put_failure;
1793         }
1794
1795         genlmsg_end(skb, nlh);
1796         mptcp_nl_mcast_send(net, skb, GFP_ATOMIC);
1797         return;
1798
1799 nla_put_failure:
1800         kfree_skb(skb);
1801 }
1802
1803 void mptcp_event(enum mptcp_event_type type, const struct mptcp_sock *msk,
1804                  const struct sock *ssk, gfp_t gfp)
1805 {
1806         struct net *net = sock_net((const struct sock *)msk);
1807         struct nlmsghdr *nlh;
1808         struct sk_buff *skb;
1809
1810         if (!genl_has_listeners(&mptcp_genl_family, net, MPTCP_PM_EV_GRP_OFFSET))
1811                 return;
1812
1813         skb = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
1814         if (!skb)
1815                 return;
1816
1817         nlh = genlmsg_put(skb, 0, 0, &mptcp_genl_family, 0, type);
1818         if (!nlh)
1819                 goto nla_put_failure;
1820
1821         switch (type) {
1822         case MPTCP_EVENT_UNSPEC:
1823                 WARN_ON_ONCE(1);
1824                 break;
1825         case MPTCP_EVENT_CREATED:
1826         case MPTCP_EVENT_ESTABLISHED:
1827                 if (mptcp_event_created(skb, msk, ssk) < 0)
1828                         goto nla_put_failure;
1829                 break;
1830         case MPTCP_EVENT_CLOSED:
1831                 if (nla_put_u32(skb, MPTCP_ATTR_TOKEN, msk->token) < 0)
1832                         goto nla_put_failure;
1833                 break;
1834         case MPTCP_EVENT_ANNOUNCED:
1835         case MPTCP_EVENT_REMOVED:
1836                 /* call mptcp_event_addr_announced()/removed instead */
1837                 WARN_ON_ONCE(1);
1838                 break;
1839         case MPTCP_EVENT_SUB_ESTABLISHED:
1840         case MPTCP_EVENT_SUB_PRIORITY:
1841                 if (mptcp_event_sub_established(skb, msk, ssk) < 0)
1842                         goto nla_put_failure;
1843                 break;
1844         case MPTCP_EVENT_SUB_CLOSED:
1845                 if (mptcp_event_sub_closed(skb, msk, ssk) < 0)
1846                         goto nla_put_failure;
1847                 break;
1848         }
1849
1850         genlmsg_end(skb, nlh);
1851         mptcp_nl_mcast_send(net, skb, gfp);
1852         return;
1853
1854 nla_put_failure:
1855         kfree_skb(skb);
1856 }
1857
1858 static const struct genl_small_ops mptcp_pm_ops[] = {
1859         {
1860                 .cmd    = MPTCP_PM_CMD_ADD_ADDR,
1861                 .doit   = mptcp_nl_cmd_add_addr,
1862                 .flags  = GENL_ADMIN_PERM,
1863         },
1864         {
1865                 .cmd    = MPTCP_PM_CMD_DEL_ADDR,
1866                 .doit   = mptcp_nl_cmd_del_addr,
1867                 .flags  = GENL_ADMIN_PERM,
1868         },
1869         {
1870                 .cmd    = MPTCP_PM_CMD_FLUSH_ADDRS,
1871                 .doit   = mptcp_nl_cmd_flush_addrs,
1872                 .flags  = GENL_ADMIN_PERM,
1873         },
1874         {
1875                 .cmd    = MPTCP_PM_CMD_GET_ADDR,
1876                 .doit   = mptcp_nl_cmd_get_addr,
1877                 .dumpit   = mptcp_nl_cmd_dump_addrs,
1878         },
1879         {
1880                 .cmd    = MPTCP_PM_CMD_SET_LIMITS,
1881                 .doit   = mptcp_nl_cmd_set_limits,
1882                 .flags  = GENL_ADMIN_PERM,
1883         },
1884         {
1885                 .cmd    = MPTCP_PM_CMD_GET_LIMITS,
1886                 .doit   = mptcp_nl_cmd_get_limits,
1887         },
1888         {
1889                 .cmd    = MPTCP_PM_CMD_SET_FLAGS,
1890                 .doit   = mptcp_nl_cmd_set_flags,
1891                 .flags  = GENL_ADMIN_PERM,
1892         },
1893 };
1894
1895 static struct genl_family mptcp_genl_family __ro_after_init = {
1896         .name           = MPTCP_PM_NAME,
1897         .version        = MPTCP_PM_VER,
1898         .maxattr        = MPTCP_PM_ATTR_MAX,
1899         .policy         = mptcp_pm_policy,
1900         .netnsok        = true,
1901         .module         = THIS_MODULE,
1902         .small_ops      = mptcp_pm_ops,
1903         .n_small_ops    = ARRAY_SIZE(mptcp_pm_ops),
1904         .mcgrps         = mptcp_pm_mcgrps,
1905         .n_mcgrps       = ARRAY_SIZE(mptcp_pm_mcgrps),
1906 };
1907
1908 static int __net_init pm_nl_init_net(struct net *net)
1909 {
1910         struct pm_nl_pernet *pernet = net_generic(net, pm_nl_pernet_id);
1911
1912         INIT_LIST_HEAD_RCU(&pernet->local_addr_list);
1913         __reset_counters(pernet);
1914         pernet->next_id = 1;
1915         bitmap_zero(pernet->id_bitmap, MAX_ADDR_ID + 1);
1916         spin_lock_init(&pernet->lock);
1917         return 0;
1918 }
1919
1920 static void __net_exit pm_nl_exit_net(struct list_head *net_list)
1921 {
1922         struct net *net;
1923
1924         list_for_each_entry(net, net_list, exit_list) {
1925                 struct pm_nl_pernet *pernet = net_generic(net, pm_nl_pernet_id);
1926
1927                 /* net is removed from namespace list, can't race with
1928                  * other modifiers
1929                  */
1930                 __flush_addrs(&pernet->local_addr_list);
1931         }
1932 }
1933
1934 static struct pernet_operations mptcp_pm_pernet_ops = {
1935         .init = pm_nl_init_net,
1936         .exit_batch = pm_nl_exit_net,
1937         .id = &pm_nl_pernet_id,
1938         .size = sizeof(struct pm_nl_pernet),
1939 };
1940
1941 void __init mptcp_pm_nl_init(void)
1942 {
1943         if (register_pernet_subsys(&mptcp_pm_pernet_ops) < 0)
1944                 panic("Failed to register MPTCP PM pernet subsystem.\n");
1945
1946         if (genl_register_family(&mptcp_genl_family))
1947                 panic("Failed to register MPTCP PM netlink family\n");
1948 }