drivers/net/vxlan/vxlan_mdb.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2
   3 #include <linux/if_bridge.h>
   4 #include <linux/in.h>
   5 #include <linux/list.h>
   6 #include <linux/netdevice.h>
   7 #include <linux/netlink.h>
   8 #include <linux/rhashtable.h>
   9 #include <linux/rhashtable-types.h>
  10 #include <linux/rtnetlink.h>
  11 #include <linux/skbuff.h>
  12 #include <linux/types.h>
  13 #include <net/netlink.h>
  14 #include <net/vxlan.h>
  15
  16 #include "vxlan_private.h"
  17
  18 struct vxlan_mdb_entry_key {
  19         union vxlan_addr src;
  20         union vxlan_addr dst;
  21         __be32 vni;
  22 };
  23
  24 struct vxlan_mdb_entry {
  25         struct rhash_head rhnode;
  26         struct list_head remotes;
  27         struct vxlan_mdb_entry_key key;
  28         struct hlist_node mdb_node;
  29         struct rcu_head rcu;
  30 };
  31
  32 #define VXLAN_MDB_REMOTE_F_BLOCKED      BIT(0)
  33
  34 struct vxlan_mdb_remote {
  35         struct list_head list;
  36         struct vxlan_rdst __rcu *rd;
  37         u8 flags;
  38         u8 filter_mode;
  39         u8 rt_protocol;
  40         struct hlist_head src_list;
  41         struct rcu_head rcu;
  42 };
  43
  44 #define VXLAN_SGRP_F_DELETE     BIT(0)
  45
  46 struct vxlan_mdb_src_entry {
  47         struct hlist_node node;
  48         union vxlan_addr addr;
  49         u8 flags;
  50 };
  51
  52 struct vxlan_mdb_dump_ctx {
  53         long reserved;
  54         long entry_idx;
  55         long remote_idx;
  56 };
  57
  58 struct vxlan_mdb_config_src_entry {
  59         union vxlan_addr addr;
  60         struct list_head node;
  61 };
  62
  63 struct vxlan_mdb_config {
  64         struct vxlan_dev *vxlan;
  65         struct vxlan_mdb_entry_key group;
  66         struct list_head src_list;
  67         union vxlan_addr remote_ip;
  68         u32 remote_ifindex;
  69         __be32 remote_vni;
  70         __be16 remote_port;
  71         u16 nlflags;
  72         u8 flags;
  73         u8 filter_mode;
  74         u8 rt_protocol;
  75 };
  76
  77 static const struct rhashtable_params vxlan_mdb_rht_params = {
  78         .head_offset = offsetof(struct vxlan_mdb_entry, rhnode),
  79         .key_offset = offsetof(struct vxlan_mdb_entry, key),
  80         .key_len = sizeof(struct vxlan_mdb_entry_key),
  81         .automatic_shrinking = true,
  82 };
  83
  84 static int __vxlan_mdb_add(const struct vxlan_mdb_config *cfg,
  85                            struct netlink_ext_ack *extack);
  86 static int __vxlan_mdb_del(const struct vxlan_mdb_config *cfg,
  87                            struct netlink_ext_ack *extack);
  88
  89 static void vxlan_br_mdb_entry_fill(const struct vxlan_dev *vxlan,
  90                                     const struct vxlan_mdb_entry *mdb_entry,
  91                                     const struct vxlan_mdb_remote *remote,
  92                                     struct br_mdb_entry *e)
  93 {
  94         const union vxlan_addr *dst = &mdb_entry->key.dst;
  95
  96         memset(e, 0, sizeof(*e));
  97         e->ifindex = vxlan->dev->ifindex;
  98         e->state = MDB_PERMANENT;
  99
 100         if (remote->flags & VXLAN_MDB_REMOTE_F_BLOCKED)
 101                 e->flags |= MDB_FLAGS_BLOCKED;
 102
 103         switch (dst->sa.sa_family) {
 104         case AF_INET:
 105                 e->addr.u.ip4 = dst->sin.sin_addr.s_addr;
 106                 e->addr.proto = htons(ETH_P_IP);
 107                 break;
 108 #if IS_ENABLED(CONFIG_IPV6)
 109         case AF_INET6:
 110                 e->addr.u.ip6 = dst->sin6.sin6_addr;
 111                 e->addr.proto = htons(ETH_P_IPV6);
 112                 break;
 113 #endif
 114         }
 115 }
 116
 117 static int vxlan_mdb_entry_info_fill_srcs(struct sk_buff *skb,
 118                                           const struct vxlan_mdb_remote *remote)
 119 {
 120         struct vxlan_mdb_src_entry *ent;
 121         struct nlattr *nest;
 122
 123         if (hlist_empty(&remote->src_list))
 124                 return 0;
 125
 126         nest = nla_nest_start(skb, MDBA_MDB_EATTR_SRC_LIST);
 127         if (!nest)
 128                 return -EMSGSIZE;
 129
 130         hlist_for_each_entry(ent, &remote->src_list, node) {
 131                 struct nlattr *nest_ent;
 132
 133                 nest_ent = nla_nest_start(skb, MDBA_MDB_SRCLIST_ENTRY);
 134                 if (!nest_ent)
 135                         goto out_cancel_err;
 136
 137                 if (vxlan_nla_put_addr(skb, MDBA_MDB_SRCATTR_ADDRESS,
 138                                        &ent->addr) ||
 139                     nla_put_u32(skb, MDBA_MDB_SRCATTR_TIMER, 0))
 140                         goto out_cancel_err;
 141
 142                 nla_nest_end(skb, nest_ent);
 143         }
 144
 145         nla_nest_end(skb, nest);
 146
 147         return 0;
 148
 149 out_cancel_err:
 150         nla_nest_cancel(skb, nest);
 151         return -EMSGSIZE;
 152 }
 153
 154 static int vxlan_mdb_entry_info_fill(const struct vxlan_dev *vxlan,
 155                                      struct sk_buff *skb,
 156                                      const struct vxlan_mdb_entry *mdb_entry,
 157                                      const struct vxlan_mdb_remote *remote)
 158 {
 159         struct vxlan_rdst *rd = rtnl_dereference(remote->rd);
 160         struct br_mdb_entry e;
 161         struct nlattr *nest;
 162
 163         nest = nla_nest_start_noflag(skb, MDBA_MDB_ENTRY_INFO);
 164         if (!nest)
 165                 return -EMSGSIZE;
 166
 167         vxlan_br_mdb_entry_fill(vxlan, mdb_entry, remote, &e);
 168
 169         if (nla_put_nohdr(skb, sizeof(e), &e) ||
 170             nla_put_u32(skb, MDBA_MDB_EATTR_TIMER, 0))
 171                 goto nest_err;
 172
 173         if (!vxlan_addr_any(&mdb_entry->key.src) &&
 174             vxlan_nla_put_addr(skb, MDBA_MDB_EATTR_SOURCE, &mdb_entry->key.src))
 175                 goto nest_err;
 176
 177         if (nla_put_u8(skb, MDBA_MDB_EATTR_RTPROT, remote->rt_protocol) ||
 178             nla_put_u8(skb, MDBA_MDB_EATTR_GROUP_MODE, remote->filter_mode) ||
 179             vxlan_mdb_entry_info_fill_srcs(skb, remote) ||
 180             vxlan_nla_put_addr(skb, MDBA_MDB_EATTR_DST, &rd->remote_ip))
 181                 goto nest_err;
 182
 183         if (rd->remote_port && rd->remote_port != vxlan->cfg.dst_port &&
 184             nla_put_u16(skb, MDBA_MDB_EATTR_DST_PORT,
 185                         be16_to_cpu(rd->remote_port)))
 186                 goto nest_err;
 187
 188         if (rd->remote_vni != vxlan->default_dst.remote_vni &&
 189             nla_put_u32(skb, MDBA_MDB_EATTR_VNI, be32_to_cpu(rd->remote_vni)))
 190                 goto nest_err;
 191
 192         if (rd->remote_ifindex &&
 193             nla_put_u32(skb, MDBA_MDB_EATTR_IFINDEX, rd->remote_ifindex))
 194                 goto nest_err;
 195
 196         if ((vxlan->cfg.flags & VXLAN_F_COLLECT_METADATA) &&
 197             mdb_entry->key.vni && nla_put_u32(skb, MDBA_MDB_EATTR_SRC_VNI,
 198                                               be32_to_cpu(mdb_entry->key.vni)))
 199                 goto nest_err;
 200
 201         nla_nest_end(skb, nest);
 202
 203         return 0;
 204
 205 nest_err:
 206         nla_nest_cancel(skb, nest);
 207         return -EMSGSIZE;
 208 }
 209
 210 static int vxlan_mdb_entry_fill(const struct vxlan_dev *vxlan,
 211                                 struct sk_buff *skb,
 212                                 struct vxlan_mdb_dump_ctx *ctx,
 213                                 const struct vxlan_mdb_entry *mdb_entry)
 214 {
 215         int remote_idx = 0, s_remote_idx = ctx->remote_idx;
 216         struct vxlan_mdb_remote *remote;
 217         struct nlattr *nest;
 218         int err = 0;
 219
 220         nest = nla_nest_start_noflag(skb, MDBA_MDB_ENTRY);
 221         if (!nest)
 222                 return -EMSGSIZE;
 223
 224         list_for_each_entry(remote, &mdb_entry->remotes, list) {
 225                 if (remote_idx < s_remote_idx)
 226                         goto skip;
 227
 228                 err = vxlan_mdb_entry_info_fill(vxlan, skb, mdb_entry, remote);
 229                 if (err)
 230                         break;
 231 skip:
 232                 remote_idx++;
 233         }
 234
 235         ctx->remote_idx = err ? remote_idx : 0;
 236         nla_nest_end(skb, nest);
 237         return err;
 238 }
 239
 240 static int vxlan_mdb_fill(const struct vxlan_dev *vxlan, struct sk_buff *skb,
 241                           struct vxlan_mdb_dump_ctx *ctx)
 242 {
 243         int entry_idx = 0, s_entry_idx = ctx->entry_idx;
 244         struct vxlan_mdb_entry *mdb_entry;
 245         struct nlattr *nest;
 246         int err = 0;
 247
 248         nest = nla_nest_start_noflag(skb, MDBA_MDB);
 249         if (!nest)
 250                 return -EMSGSIZE;
 251
 252         hlist_for_each_entry(mdb_entry, &vxlan->mdb_list, mdb_node) {
 253                 if (entry_idx < s_entry_idx)
 254                         goto skip;
 255
 256                 err = vxlan_mdb_entry_fill(vxlan, skb, ctx, mdb_entry);
 257                 if (err)
 258                         break;
 259 skip:
 260                 entry_idx++;
 261         }
 262
 263         ctx->entry_idx = err ? entry_idx : 0;
 264         nla_nest_end(skb, nest);
 265         return err;
 266 }
 267
 268 int vxlan_mdb_dump(struct net_device *dev, struct sk_buff *skb,
 269                    struct netlink_callback *cb)
 270 {
 271         struct vxlan_mdb_dump_ctx *ctx = (void *)cb->ctx;
 272         struct vxlan_dev *vxlan = netdev_priv(dev);
 273         struct br_port_msg *bpm;
 274         struct nlmsghdr *nlh;
 275         int err;
 276
 277         ASSERT_RTNL();
 278
 279         NL_ASSERT_DUMP_CTX_FITS(struct vxlan_mdb_dump_ctx);
 280
 281         nlh = nlmsg_put(skb, NETLINK_CB(cb->skb).portid,
 282                         cb->nlh->nlmsg_seq, RTM_NEWMDB, sizeof(*bpm),
 283                         NLM_F_MULTI);
 284         if (!nlh)
 285                 return -EMSGSIZE;
 286
 287         bpm = nlmsg_data(nlh);
 288         memset(bpm, 0, sizeof(*bpm));
 289         bpm->family = AF_BRIDGE;
 290         bpm->ifindex = dev->ifindex;
 291
 292         err = vxlan_mdb_fill(vxlan, skb, ctx);
 293
 294         nlmsg_end(skb, nlh);
 295
 296         cb->seq = vxlan->mdb_seq;
 297         nl_dump_check_consistent(cb, nlh);
 298
 299         return err;
 300 }
 301
 302 static const struct nla_policy
 303 vxlan_mdbe_src_list_entry_pol[MDBE_SRCATTR_MAX + 1] = {
 304         [MDBE_SRCATTR_ADDRESS] = NLA_POLICY_RANGE(NLA_BINARY,
 305                                                   sizeof(struct in_addr),
 306                                                   sizeof(struct in6_addr)),
 307 };
 308
 309 static const struct nla_policy
 310 vxlan_mdbe_src_list_pol[MDBE_SRC_LIST_MAX + 1] = {
 311         [MDBE_SRC_LIST_ENTRY] = NLA_POLICY_NESTED(vxlan_mdbe_src_list_entry_pol),
 312 };
 313
 314 static struct netlink_range_validation vni_range = {
 315         .max = VXLAN_N_VID - 1,
 316 };
 317
 318 static const struct nla_policy vxlan_mdbe_attrs_pol[MDBE_ATTR_MAX + 1] = {
 319         [MDBE_ATTR_SOURCE] = NLA_POLICY_RANGE(NLA_BINARY,
 320                                               sizeof(struct in_addr),
 321                                               sizeof(struct in6_addr)),
 322         [MDBE_ATTR_GROUP_MODE] = NLA_POLICY_RANGE(NLA_U8, MCAST_EXCLUDE,
 323                                                   MCAST_INCLUDE),
 324         [MDBE_ATTR_SRC_LIST] = NLA_POLICY_NESTED(vxlan_mdbe_src_list_pol),
 325         [MDBE_ATTR_RTPROT] = NLA_POLICY_MIN(NLA_U8, RTPROT_STATIC),
 326         [MDBE_ATTR_DST] = NLA_POLICY_RANGE(NLA_BINARY,
 327                                            sizeof(struct in_addr),
 328                                            sizeof(struct in6_addr)),
 329         [MDBE_ATTR_DST_PORT] = { .type = NLA_U16 },
 330         [MDBE_ATTR_VNI] = NLA_POLICY_FULL_RANGE(NLA_U32, &vni_range),
 331         [MDBE_ATTR_IFINDEX] = NLA_POLICY_MIN(NLA_S32, 1),
 332         [MDBE_ATTR_SRC_VNI] = NLA_POLICY_FULL_RANGE(NLA_U32, &vni_range),
 333 };
 334
 335 static bool vxlan_mdb_is_valid_source(const struct nlattr *attr, __be16 proto,
 336                                       struct netlink_ext_ack *extack)
 337 {
 338         switch (proto) {
 339         case htons(ETH_P_IP):
 340                 if (nla_len(attr) != sizeof(struct in_addr)) {
 341                         NL_SET_ERR_MSG_MOD(extack, "IPv4 invalid source address length");
 342                         return false;
 343                 }
 344                 if (ipv4_is_multicast(nla_get_in_addr(attr))) {
 345                         NL_SET_ERR_MSG_MOD(extack, "IPv4 multicast source address is not allowed");
 346                         return false;
 347                 }
 348                 break;
 349 #if IS_ENABLED(CONFIG_IPV6)
 350         case htons(ETH_P_IPV6): {
 351                 struct in6_addr src;
 352
 353                 if (nla_len(attr) != sizeof(struct in6_addr)) {
 354                         NL_SET_ERR_MSG_MOD(extack, "IPv6 invalid source address length");
 355                         return false;
 356                 }
 357                 src = nla_get_in6_addr(attr);
 358                 if (ipv6_addr_is_multicast(&src)) {
 359                         NL_SET_ERR_MSG_MOD(extack, "IPv6 multicast source address is not allowed");
 360                         return false;
 361                 }
 362                 break;
 363         }
 364 #endif
 365         default:
 366                 NL_SET_ERR_MSG_MOD(extack, "Invalid protocol used with source address");
 367                 return false;
 368         }
 369
 370         return true;
 371 }
 372
 373 static void vxlan_mdb_config_group_set(struct vxlan_mdb_config *cfg,
 374                                        const struct br_mdb_entry *entry,
 375                                        const struct nlattr *source_attr)
 376 {
 377         struct vxlan_mdb_entry_key *group = &cfg->group;
 378
 379         switch (entry->addr.proto) {
 380         case htons(ETH_P_IP):
 381                 group->dst.sa.sa_family = AF_INET;
 382                 group->dst.sin.sin_addr.s_addr = entry->addr.u.ip4;
 383                 break;
 384 #if IS_ENABLED(CONFIG_IPV6)
 385         case htons(ETH_P_IPV6):
 386                 group->dst.sa.sa_family = AF_INET6;
 387                 group->dst.sin6.sin6_addr = entry->addr.u.ip6;
 388                 break;
 389 #endif
 390         }
 391
 392         if (source_attr)
 393                 vxlan_nla_get_addr(&group->src, source_attr);
 394 }
 395
 396 static bool vxlan_mdb_is_star_g(const struct vxlan_mdb_entry_key *group)
 397 {
 398         return !vxlan_addr_any(&group->dst) && vxlan_addr_any(&group->src);
 399 }
 400
 401 static bool vxlan_mdb_is_sg(const struct vxlan_mdb_entry_key *group)
 402 {
 403         return !vxlan_addr_any(&group->dst) && !vxlan_addr_any(&group->src);
 404 }
 405
 406 static int vxlan_mdb_config_src_entry_init(struct vxlan_mdb_config *cfg,
 407                                            __be16 proto,
 408                                            const struct nlattr *src_entry,
 409                                            struct netlink_ext_ack *extack)
 410 {
 411         struct nlattr *tb[MDBE_SRCATTR_MAX + 1];
 412         struct vxlan_mdb_config_src_entry *src;
 413         int err;
 414
 415         err = nla_parse_nested(tb, MDBE_SRCATTR_MAX, src_entry,
 416                                vxlan_mdbe_src_list_entry_pol, extack);
 417         if (err)
 418                 return err;
 419
 420         if (NL_REQ_ATTR_CHECK(extack, src_entry, tb, MDBE_SRCATTR_ADDRESS))
 421                 return -EINVAL;
 422
 423         if (!vxlan_mdb_is_valid_source(tb[MDBE_SRCATTR_ADDRESS], proto,
 424                                        extack))
 425                 return -EINVAL;
 426
 427         src = kzalloc(sizeof(*src), GFP_KERNEL);
 428         if (!src)
 429                 return -ENOMEM;
 430
 431         err = vxlan_nla_get_addr(&src->addr, tb[MDBE_SRCATTR_ADDRESS]);
 432         if (err)
 433                 goto err_free_src;
 434
 435         list_add_tail(&src->node, &cfg->src_list);
 436
 437         return 0;
 438
 439 err_free_src:
 440         kfree(src);
 441         return err;
 442 }
 443
 444 static void
 445 vxlan_mdb_config_src_entry_fini(struct vxlan_mdb_config_src_entry *src)
 446 {
 447         list_del(&src->node);
 448         kfree(src);
 449 }
 450
 451 static int vxlan_mdb_config_src_list_init(struct vxlan_mdb_config *cfg,
 452                                           __be16 proto,
 453                                           const struct nlattr *src_list,
 454                                           struct netlink_ext_ack *extack)
 455 {
 456         struct vxlan_mdb_config_src_entry *src, *tmp;
 457         struct nlattr *src_entry;
 458         int rem, err;
 459
 460         nla_for_each_nested(src_entry, src_list, rem) {
 461                 err = vxlan_mdb_config_src_entry_init(cfg, proto, src_entry,
 462                                                       extack);
 463                 if (err)
 464                         goto err_src_entry_init;
 465         }
 466
 467         return 0;
 468
 469 err_src_entry_init:
 470         list_for_each_entry_safe_reverse(src, tmp, &cfg->src_list, node)
 471                 vxlan_mdb_config_src_entry_fini(src);
 472         return err;
 473 }
 474
 475 static void vxlan_mdb_config_src_list_fini(struct vxlan_mdb_config *cfg)
 476 {
 477         struct vxlan_mdb_config_src_entry *src, *tmp;
 478
 479         list_for_each_entry_safe_reverse(src, tmp, &cfg->src_list, node)
 480                 vxlan_mdb_config_src_entry_fini(src);
 481 }
 482
 483 static int vxlan_mdb_config_attrs_init(struct vxlan_mdb_config *cfg,
 484                                        const struct br_mdb_entry *entry,
 485                                        const struct nlattr *set_attrs,
 486                                        struct netlink_ext_ack *extack)
 487 {
 488         struct nlattr *mdbe_attrs[MDBE_ATTR_MAX + 1];
 489         int err;
 490
 491         err = nla_parse_nested(mdbe_attrs, MDBE_ATTR_MAX, set_attrs,
 492                                vxlan_mdbe_attrs_pol, extack);
 493         if (err)
 494                 return err;
 495
 496         if (NL_REQ_ATTR_CHECK(extack, set_attrs, mdbe_attrs, MDBE_ATTR_DST)) {
 497                 NL_SET_ERR_MSG_MOD(extack, "Missing remote destination IP address");
 498                 return -EINVAL;
 499         }
 500
 501         if (mdbe_attrs[MDBE_ATTR_SOURCE] &&
 502             !vxlan_mdb_is_valid_source(mdbe_attrs[MDBE_ATTR_SOURCE],
 503                                        entry->addr.proto, extack))
 504                 return -EINVAL;
 505
 506         vxlan_mdb_config_group_set(cfg, entry, mdbe_attrs[MDBE_ATTR_SOURCE]);
 507
 508         /* rtnetlink code only validates that IPv4 group address is
 509          * multicast.
 510          */
 511         if (!vxlan_addr_is_multicast(&cfg->group.dst) &&
 512             !vxlan_addr_any(&cfg->group.dst)) {
 513                 NL_SET_ERR_MSG_MOD(extack, "Group address is not multicast");
 514                 return -EINVAL;
 515         }
 516
 517         if (vxlan_addr_any(&cfg->group.dst) &&
 518             mdbe_attrs[MDBE_ATTR_SOURCE]) {
 519                 NL_SET_ERR_MSG_MOD(extack, "Source cannot be specified for the all-zeros entry");
 520                 return -EINVAL;
 521         }
 522
 523         if (vxlan_mdb_is_sg(&cfg->group))
 524                 cfg->filter_mode = MCAST_INCLUDE;
 525
 526         if (mdbe_attrs[MDBE_ATTR_GROUP_MODE]) {
 527                 if (!vxlan_mdb_is_star_g(&cfg->group)) {
 528                         NL_SET_ERR_MSG_MOD(extack, "Filter mode can only be set for (*, G) entries");
 529                         return -EINVAL;
 530                 }
 531                 cfg->filter_mode = nla_get_u8(mdbe_attrs[MDBE_ATTR_GROUP_MODE]);
 532         }
 533
 534         if (mdbe_attrs[MDBE_ATTR_SRC_LIST]) {
 535                 if (!vxlan_mdb_is_star_g(&cfg->group)) {
 536                         NL_SET_ERR_MSG_MOD(extack, "Source list can only be set for (*, G) entries");
 537                         return -EINVAL;
 538                 }
 539                 if (!mdbe_attrs[MDBE_ATTR_GROUP_MODE]) {
 540                         NL_SET_ERR_MSG_MOD(extack, "Source list cannot be set without filter mode");
 541                         return -EINVAL;
 542                 }
 543                 err = vxlan_mdb_config_src_list_init(cfg, entry->addr.proto,
 544                                                      mdbe_attrs[MDBE_ATTR_SRC_LIST],
 545                                                      extack);
 546                 if (err)
 547                         return err;
 548         }
 549
 550         if (vxlan_mdb_is_star_g(&cfg->group) && list_empty(&cfg->src_list) &&
 551             cfg->filter_mode == MCAST_INCLUDE) {
 552                 NL_SET_ERR_MSG_MOD(extack, "Cannot add (*, G) INCLUDE with an empty source list");
 553                 return -EINVAL;
 554         }
 555
 556         if (mdbe_attrs[MDBE_ATTR_RTPROT])
 557                 cfg->rt_protocol = nla_get_u8(mdbe_attrs[MDBE_ATTR_RTPROT]);
 558
 559         err = vxlan_nla_get_addr(&cfg->remote_ip, mdbe_attrs[MDBE_ATTR_DST]);
 560         if (err) {
 561                 NL_SET_ERR_MSG_MOD(extack, "Invalid remote destination address");
 562                 goto err_src_list_fini;
 563         }
 564
 565         if (mdbe_attrs[MDBE_ATTR_DST_PORT])
 566                 cfg->remote_port =
 567                         cpu_to_be16(nla_get_u16(mdbe_attrs[MDBE_ATTR_DST_PORT]));
 568
 569         if (mdbe_attrs[MDBE_ATTR_VNI])
 570                 cfg->remote_vni =
 571                         cpu_to_be32(nla_get_u32(mdbe_attrs[MDBE_ATTR_VNI]));
 572
 573         if (mdbe_attrs[MDBE_ATTR_IFINDEX]) {
 574                 cfg->remote_ifindex =
 575                         nla_get_s32(mdbe_attrs[MDBE_ATTR_IFINDEX]);
 576                 if (!__dev_get_by_index(cfg->vxlan->net, cfg->remote_ifindex)) {
 577                         NL_SET_ERR_MSG_MOD(extack, "Outgoing interface not found");
 578                         err = -EINVAL;
 579                         goto err_src_list_fini;
 580                 }
 581         }
 582
 583         if (mdbe_attrs[MDBE_ATTR_SRC_VNI])
 584                 cfg->group.vni =
 585                         cpu_to_be32(nla_get_u32(mdbe_attrs[MDBE_ATTR_SRC_VNI]));
 586
 587         return 0;
 588
 589 err_src_list_fini:
 590         vxlan_mdb_config_src_list_fini(cfg);
 591         return err;
 592 }
 593
 594 static int vxlan_mdb_config_init(struct vxlan_mdb_config *cfg,
 595                                  struct net_device *dev, struct nlattr *tb[],
 596                                  u16 nlmsg_flags,
 597                                  struct netlink_ext_ack *extack)
 598 {
 599         struct br_mdb_entry *entry = nla_data(tb[MDBA_SET_ENTRY]);
 600         struct vxlan_dev *vxlan = netdev_priv(dev);
 601
 602         memset(cfg, 0, sizeof(*cfg));
 603         cfg->vxlan = vxlan;
 604         cfg->group.vni = vxlan->default_dst.remote_vni;
 605         INIT_LIST_HEAD(&cfg->src_list);
 606         cfg->nlflags = nlmsg_flags;
 607         cfg->filter_mode = MCAST_EXCLUDE;
 608         cfg->rt_protocol = RTPROT_STATIC;
 609         cfg->remote_vni = vxlan->default_dst.remote_vni;
 610         cfg->remote_port = vxlan->cfg.dst_port;
 611
 612         if (entry->ifindex != dev->ifindex) {
 613                 NL_SET_ERR_MSG_MOD(extack, "Port net device must be the VXLAN net device");
 614                 return -EINVAL;
 615         }
 616
 617         /* State is not part of the entry key and can be ignored on deletion
 618          * requests.
 619          */
 620         if ((nlmsg_flags & (NLM_F_CREATE | NLM_F_REPLACE)) &&
 621             entry->state != MDB_PERMANENT) {
 622                 NL_SET_ERR_MSG_MOD(extack, "MDB entry must be permanent");
 623                 return -EINVAL;
 624         }
 625
 626         if (entry->flags) {
 627                 NL_SET_ERR_MSG_MOD(extack, "Invalid MDB entry flags");
 628                 return -EINVAL;
 629         }
 630
 631         if (entry->vid) {
 632                 NL_SET_ERR_MSG_MOD(extack, "VID must not be specified");
 633                 return -EINVAL;
 634         }
 635
 636         if (entry->addr.proto != htons(ETH_P_IP) &&
 637             entry->addr.proto != htons(ETH_P_IPV6)) {
 638                 NL_SET_ERR_MSG_MOD(extack, "Group address must be an IPv4 / IPv6 address");
 639                 return -EINVAL;
 640         }
 641
 642         if (NL_REQ_ATTR_CHECK(extack, NULL, tb, MDBA_SET_ENTRY_ATTRS)) {
 643                 NL_SET_ERR_MSG_MOD(extack, "Missing MDBA_SET_ENTRY_ATTRS attribute");
 644                 return -EINVAL;
 645         }
 646
 647         return vxlan_mdb_config_attrs_init(cfg, entry, tb[MDBA_SET_ENTRY_ATTRS],
 648                                            extack);
 649 }
 650
 651 static void vxlan_mdb_config_fini(struct vxlan_mdb_config *cfg)
 652 {
 653         vxlan_mdb_config_src_list_fini(cfg);
 654 }
 655
 656 static struct vxlan_mdb_entry *
 657 vxlan_mdb_entry_lookup(struct vxlan_dev *vxlan,
 658                        const struct vxlan_mdb_entry_key *group)
 659 {
 660         return rhashtable_lookup_fast(&vxlan->mdb_tbl, group,
 661                                       vxlan_mdb_rht_params);
 662 }
 663
 664 static struct vxlan_mdb_remote *
 665 vxlan_mdb_remote_lookup(const struct vxlan_mdb_entry *mdb_entry,
 666                         const union vxlan_addr *addr)
 667 {
 668         struct vxlan_mdb_remote *remote;
 669
 670         list_for_each_entry(remote, &mdb_entry->remotes, list) {
 671                 struct vxlan_rdst *rd = rtnl_dereference(remote->rd);
 672
 673                 if (vxlan_addr_equal(addr, &rd->remote_ip))
 674                         return remote;
 675         }
 676
 677         return NULL;
 678 }
 679
 680 static void vxlan_mdb_rdst_free(struct rcu_head *head)
 681 {
 682         struct vxlan_rdst *rd = container_of(head, struct vxlan_rdst, rcu);
 683
 684         dst_cache_destroy(&rd->dst_cache);
 685         kfree(rd);
 686 }
 687
 688 static int vxlan_mdb_remote_rdst_init(const struct vxlan_mdb_config *cfg,
 689                                       struct vxlan_mdb_remote *remote)
 690 {
 691         struct vxlan_rdst *rd;
 692         int err;
 693
 694         rd = kzalloc(sizeof(*rd), GFP_KERNEL);
 695         if (!rd)
 696                 return -ENOMEM;
 697
 698         err = dst_cache_init(&rd->dst_cache, GFP_KERNEL);
 699         if (err)
 700                 goto err_free_rdst;
 701
 702         rd->remote_ip = cfg->remote_ip;
 703         rd->remote_port = cfg->remote_port;
 704         rd->remote_vni = cfg->remote_vni;
 705         rd->remote_ifindex = cfg->remote_ifindex;
 706         rcu_assign_pointer(remote->rd, rd);
 707
 708         return 0;
 709
 710 err_free_rdst:
 711         kfree(rd);
 712         return err;
 713 }
 714
 715 static void vxlan_mdb_remote_rdst_fini(struct vxlan_rdst *rd)
 716 {
 717         call_rcu(&rd->rcu, vxlan_mdb_rdst_free);
 718 }
 719
 720 static int vxlan_mdb_remote_init(const struct vxlan_mdb_config *cfg,
 721                                  struct vxlan_mdb_remote *remote)
 722 {
 723         int err;
 724
 725         err = vxlan_mdb_remote_rdst_init(cfg, remote);
 726         if (err)
 727                 return err;
 728
 729         remote->flags = cfg->flags;
 730         remote->filter_mode = cfg->filter_mode;
 731         remote->rt_protocol = cfg->rt_protocol;
 732         INIT_HLIST_HEAD(&remote->src_list);
 733
 734         return 0;
 735 }
 736
 737 static void vxlan_mdb_remote_fini(struct vxlan_dev *vxlan,
 738                                   struct vxlan_mdb_remote *remote)
 739 {
 740         WARN_ON_ONCE(!hlist_empty(&remote->src_list));
 741         vxlan_mdb_remote_rdst_fini(rtnl_dereference(remote->rd));
 742 }
 743
 744 static struct vxlan_mdb_src_entry *
 745 vxlan_mdb_remote_src_entry_lookup(const struct vxlan_mdb_remote *remote,
 746                                   const union vxlan_addr *addr)
 747 {
 748         struct vxlan_mdb_src_entry *ent;
 749
 750         hlist_for_each_entry(ent, &remote->src_list, node) {
 751                 if (vxlan_addr_equal(&ent->addr, addr))
 752                         return ent;
 753         }
 754
 755         return NULL;
 756 }
 757
 758 static struct vxlan_mdb_src_entry *
 759 vxlan_mdb_remote_src_entry_add(struct vxlan_mdb_remote *remote,
 760                                const union vxlan_addr *addr)
 761 {
 762         struct vxlan_mdb_src_entry *ent;
 763
 764         ent = kzalloc(sizeof(*ent), GFP_KERNEL);
 765         if (!ent)
 766                 return NULL;
 767
 768         ent->addr = *addr;
 769         hlist_add_head(&ent->node, &remote->src_list);
 770
 771         return ent;
 772 }
 773
 774 static void
 775 vxlan_mdb_remote_src_entry_del(struct vxlan_mdb_src_entry *ent)
 776 {
 777         hlist_del(&ent->node);
 778         kfree(ent);
 779 }
 780
 781 static int
 782 vxlan_mdb_remote_src_fwd_add(const struct vxlan_mdb_config *cfg,
 783                              const union vxlan_addr *addr,
 784                              struct netlink_ext_ack *extack)
 785 {
 786         struct vxlan_mdb_config sg_cfg;
 787
 788         memset(&sg_cfg, 0, sizeof(sg_cfg));
 789         sg_cfg.vxlan = cfg->vxlan;
 790         sg_cfg.group.src = *addr;
 791         sg_cfg.group.dst = cfg->group.dst;
 792         sg_cfg.group.vni = cfg->group.vni;
 793         INIT_LIST_HEAD(&sg_cfg.src_list);
 794         sg_cfg.remote_ip = cfg->remote_ip;
 795         sg_cfg.remote_ifindex = cfg->remote_ifindex;
 796         sg_cfg.remote_vni = cfg->remote_vni;
 797         sg_cfg.remote_port = cfg->remote_port;
 798         sg_cfg.nlflags = cfg->nlflags;
 799         sg_cfg.filter_mode = MCAST_INCLUDE;
 800         if (cfg->filter_mode == MCAST_EXCLUDE)
 801                 sg_cfg.flags = VXLAN_MDB_REMOTE_F_BLOCKED;
 802         sg_cfg.rt_protocol = cfg->rt_protocol;
 803
 804         return __vxlan_mdb_add(&sg_cfg, extack);
 805 }
 806
 807 static void
 808 vxlan_mdb_remote_src_fwd_del(struct vxlan_dev *vxlan,
 809                              const struct vxlan_mdb_entry_key *group,
 810                              const struct vxlan_mdb_remote *remote,
 811                              const union vxlan_addr *addr)
 812 {
 813         struct vxlan_rdst *rd = rtnl_dereference(remote->rd);
 814         struct vxlan_mdb_config sg_cfg;
 815
 816         memset(&sg_cfg, 0, sizeof(sg_cfg));
 817         sg_cfg.vxlan = vxlan;
 818         sg_cfg.group.src = *addr;
 819         sg_cfg.group.dst = group->dst;
 820         sg_cfg.group.vni = group->vni;
 821         INIT_LIST_HEAD(&sg_cfg.src_list);
 822         sg_cfg.remote_ip = rd->remote_ip;
 823
 824         __vxlan_mdb_del(&sg_cfg, NULL);
 825 }
 826
 827 static int
 828 vxlan_mdb_remote_src_add(const struct vxlan_mdb_config *cfg,
 829                          struct vxlan_mdb_remote *remote,
 830                          const struct vxlan_mdb_config_src_entry *src,
 831                          struct netlink_ext_ack *extack)
 832 {
 833         struct vxlan_mdb_src_entry *ent;
 834         int err;
 835
 836         ent = vxlan_mdb_remote_src_entry_lookup(remote, &src->addr);
 837         if (!ent) {
 838                 ent = vxlan_mdb_remote_src_entry_add(remote, &src->addr);
 839                 if (!ent)
 840                         return -ENOMEM;
 841         } else if (!(cfg->nlflags & NLM_F_REPLACE)) {
 842                 NL_SET_ERR_MSG_MOD(extack, "Source entry already exists");
 843                 return -EEXIST;
 844         }
 845
 846         err = vxlan_mdb_remote_src_fwd_add(cfg, &ent->addr, extack);
 847         if (err)
 848                 goto err_src_del;
 849
 850         /* Clear flags in case source entry was marked for deletion as part of
 851          * replace flow.
 852          */
 853         ent->flags = 0;
 854
 855         return 0;
 856
 857 err_src_del:
 858         vxlan_mdb_remote_src_entry_del(ent);
 859         return err;
 860 }
 861
 862 static void vxlan_mdb_remote_src_del(struct vxlan_dev *vxlan,
 863                                      const struct vxlan_mdb_entry_key *group,
 864                                      const struct vxlan_mdb_remote *remote,
 865                                      struct vxlan_mdb_src_entry *ent)
 866 {
 867         vxlan_mdb_remote_src_fwd_del(vxlan, group, remote, &ent->addr);
 868         vxlan_mdb_remote_src_entry_del(ent);
 869 }
 870
 871 static int vxlan_mdb_remote_srcs_add(const struct vxlan_mdb_config *cfg,
 872                                      struct vxlan_mdb_remote *remote,
 873                                      struct netlink_ext_ack *extack)
 874 {
 875         struct vxlan_mdb_config_src_entry *src;
 876         struct vxlan_mdb_src_entry *ent;
 877         struct hlist_node *tmp;
 878         int err;
 879
 880         list_for_each_entry(src, &cfg->src_list, node) {
 881                 err = vxlan_mdb_remote_src_add(cfg, remote, src, extack);
 882                 if (err)
 883                         goto err_src_del;
 884         }
 885
 886         return 0;
 887
 888 err_src_del:
 889         hlist_for_each_entry_safe(ent, tmp, &remote->src_list, node)
 890                 vxlan_mdb_remote_src_del(cfg->vxlan, &cfg->group, remote, ent);
 891         return err;
 892 }
 893
 894 static void vxlan_mdb_remote_srcs_del(struct vxlan_dev *vxlan,
 895                                       const struct vxlan_mdb_entry_key *group,
 896                                       struct vxlan_mdb_remote *remote)
 897 {
 898         struct vxlan_mdb_src_entry *ent;
 899         struct hlist_node *tmp;
 900
 901         hlist_for_each_entry_safe(ent, tmp, &remote->src_list, node)
 902                 vxlan_mdb_remote_src_del(vxlan, group, remote, ent);
 903 }
 904
 905 static size_t
 906 vxlan_mdb_nlmsg_src_list_size(const struct vxlan_mdb_entry_key *group,
 907                               const struct vxlan_mdb_remote *remote)
 908 {
 909         struct vxlan_mdb_src_entry *ent;
 910         size_t nlmsg_size;
 911
 912         if (hlist_empty(&remote->src_list))
 913                 return 0;
 914
 915         /* MDBA_MDB_EATTR_SRC_LIST */
 916         nlmsg_size = nla_total_size(0);
 917
 918         hlist_for_each_entry(ent, &remote->src_list, node) {
 919                               /* MDBA_MDB_SRCLIST_ENTRY */
 920                 nlmsg_size += nla_total_size(0) +
 921                               /* MDBA_MDB_SRCATTR_ADDRESS */
 922                               nla_total_size(vxlan_addr_size(&group->dst)) +
 923                               /* MDBA_MDB_SRCATTR_TIMER */
 924                               nla_total_size(sizeof(u8));
 925         }
 926
 927         return nlmsg_size;
 928 }
 929
 930 static size_t vxlan_mdb_nlmsg_size(const struct vxlan_dev *vxlan,
 931                                    const struct vxlan_mdb_entry *mdb_entry,
 932                                    const struct vxlan_mdb_remote *remote)
 933 {
 934         const struct vxlan_mdb_entry_key *group = &mdb_entry->key;
 935         struct vxlan_rdst *rd = rtnl_dereference(remote->rd);
 936         size_t nlmsg_size;
 937
 938         nlmsg_size = NLMSG_ALIGN(sizeof(struct br_port_msg)) +
 939                      /* MDBA_MDB */
 940                      nla_total_size(0) +
 941                      /* MDBA_MDB_ENTRY */
 942                      nla_total_size(0) +
 943                      /* MDBA_MDB_ENTRY_INFO */
 944                      nla_total_size(sizeof(struct br_mdb_entry)) +
 945                      /* MDBA_MDB_EATTR_TIMER */
 946                      nla_total_size(sizeof(u32));
 947         /* MDBA_MDB_EATTR_SOURCE */
 948         if (vxlan_mdb_is_sg(group))
 949                 nlmsg_size += nla_total_size(vxlan_addr_size(&group->dst));
 950         /* MDBA_MDB_EATTR_RTPROT */
 951         nlmsg_size += nla_total_size(sizeof(u8));
 952         /* MDBA_MDB_EATTR_SRC_LIST */
 953         nlmsg_size += vxlan_mdb_nlmsg_src_list_size(group, remote);
 954         /* MDBA_MDB_EATTR_GROUP_MODE */
 955         nlmsg_size += nla_total_size(sizeof(u8));
 956         /* MDBA_MDB_EATTR_DST */
 957         nlmsg_size += nla_total_size(vxlan_addr_size(&rd->remote_ip));
 958         /* MDBA_MDB_EATTR_DST_PORT */
 959         if (rd->remote_port && rd->remote_port != vxlan->cfg.dst_port)
 960                 nlmsg_size += nla_total_size(sizeof(u16));
 961         /* MDBA_MDB_EATTR_VNI */
 962         if (rd->remote_vni != vxlan->default_dst.remote_vni)
 963                 nlmsg_size += nla_total_size(sizeof(u32));
 964         /* MDBA_MDB_EATTR_IFINDEX */
 965         if (rd->remote_ifindex)
 966                 nlmsg_size += nla_total_size(sizeof(u32));
 967         /* MDBA_MDB_EATTR_SRC_VNI */
 968         if ((vxlan->cfg.flags & VXLAN_F_COLLECT_METADATA) && group->vni)
 969                 nlmsg_size += nla_total_size(sizeof(u32));
 970
 971         return nlmsg_size;
 972 }
 973
 974 static int vxlan_mdb_nlmsg_fill(const struct vxlan_dev *vxlan,
 975                                 struct sk_buff *skb,
 976                                 const struct vxlan_mdb_entry *mdb_entry,
 977                                 const struct vxlan_mdb_remote *remote,
 978                                 int type)
 979 {
 980         struct nlattr *mdb_nest, *mdb_entry_nest;
 981         struct br_port_msg *bpm;
 982         struct nlmsghdr *nlh;
 983
 984         nlh = nlmsg_put(skb, 0, 0, type, sizeof(*bpm), 0);
 985         if (!nlh)
 986                 return -EMSGSIZE;
 987
 988         bpm = nlmsg_data(nlh);
 989         memset(bpm, 0, sizeof(*bpm));
 990         bpm->family  = AF_BRIDGE;
 991         bpm->ifindex = vxlan->dev->ifindex;
 992
 993         mdb_nest = nla_nest_start_noflag(skb, MDBA_MDB);
 994         if (!mdb_nest)
 995                 goto cancel;
 996         mdb_entry_nest = nla_nest_start_noflag(skb, MDBA_MDB_ENTRY);
 997         if (!mdb_entry_nest)
 998                 goto cancel;
 999
1000         if (vxlan_mdb_entry_info_fill(vxlan, skb, mdb_entry, remote))
1001                 goto cancel;
1002
1003         nla_nest_end(skb, mdb_entry_nest);
1004         nla_nest_end(skb, mdb_nest);
1005         nlmsg_end(skb, nlh);
1006
1007         return 0;
1008
1009 cancel:
1010         nlmsg_cancel(skb, nlh);
1011         return -EMSGSIZE;
1012 }
1013
1014 static void vxlan_mdb_remote_notify(const struct vxlan_dev *vxlan,
1015                                     const struct vxlan_mdb_entry *mdb_entry,
1016                                     const struct vxlan_mdb_remote *remote,
1017                                     int type)
1018 {
1019         struct net *net = dev_net(vxlan->dev);
1020         struct sk_buff *skb;
1021         int err = -ENOBUFS;
1022
1023         skb = nlmsg_new(vxlan_mdb_nlmsg_size(vxlan, mdb_entry, remote),
1024                         GFP_KERNEL);
1025         if (!skb)
1026                 goto errout;
1027
1028         err = vxlan_mdb_nlmsg_fill(vxlan, skb, mdb_entry, remote, type);
1029         if (err) {
1030                 kfree_skb(skb);
1031                 goto errout;
1032         }
1033
1034         rtnl_notify(skb, net, 0, RTNLGRP_MDB, NULL, GFP_KERNEL);
1035         return;
1036 errout:
1037         rtnl_set_sk_err(net, RTNLGRP_MDB, err);
1038 }
1039
1040 static int
1041 vxlan_mdb_remote_srcs_replace(const struct vxlan_mdb_config *cfg,
1042                               const struct vxlan_mdb_entry *mdb_entry,
1043                               struct vxlan_mdb_remote *remote,
1044                               struct netlink_ext_ack *extack)
1045 {
1046         struct vxlan_dev *vxlan = cfg->vxlan;
1047         struct vxlan_mdb_src_entry *ent;
1048         struct hlist_node *tmp;
1049         int err;
1050
1051         hlist_for_each_entry(ent, &remote->src_list, node)
1052                 ent->flags |= VXLAN_SGRP_F_DELETE;
1053
1054         err = vxlan_mdb_remote_srcs_add(cfg, remote, extack);
1055         if (err)
1056                 goto err_clear_delete;
1057
1058         hlist_for_each_entry_safe(ent, tmp, &remote->src_list, node) {
1059                 if (ent->flags & VXLAN_SGRP_F_DELETE)
1060                         vxlan_mdb_remote_src_del(vxlan, &mdb_entry->key, remote,
1061                                                  ent);
1062         }
1063
1064         return 0;
1065
1066 err_clear_delete:
1067         hlist_for_each_entry(ent, &remote->src_list, node)
1068                 ent->flags &= ~VXLAN_SGRP_F_DELETE;
1069         return err;
1070 }
1071
1072 static int vxlan_mdb_remote_replace(const struct vxlan_mdb_config *cfg,
1073                                     const struct vxlan_mdb_entry *mdb_entry,
1074                                     struct vxlan_mdb_remote *remote,
1075                                     struct netlink_ext_ack *extack)
1076 {
1077         struct vxlan_rdst *new_rd, *old_rd = rtnl_dereference(remote->rd);
1078         struct vxlan_dev *vxlan = cfg->vxlan;
1079         int err;
1080
1081         err = vxlan_mdb_remote_rdst_init(cfg, remote);
1082         if (err)
1083                 return err;
1084         new_rd = rtnl_dereference(remote->rd);
1085
1086         err = vxlan_mdb_remote_srcs_replace(cfg, mdb_entry, remote, extack);
1087         if (err)
1088                 goto err_rdst_reset;
1089
1090         WRITE_ONCE(remote->flags, cfg->flags);
1091         WRITE_ONCE(remote->filter_mode, cfg->filter_mode);
1092         remote->rt_protocol = cfg->rt_protocol;
1093         vxlan_mdb_remote_notify(vxlan, mdb_entry, remote, RTM_NEWMDB);
1094
1095         vxlan_mdb_remote_rdst_fini(old_rd);
1096
1097         return 0;
1098
1099 err_rdst_reset:
1100         rcu_assign_pointer(remote->rd, old_rd);
1101         vxlan_mdb_remote_rdst_fini(new_rd);
1102         return err;
1103 }
1104
1105 static int vxlan_mdb_remote_add(const struct vxlan_mdb_config *cfg,
1106                                 struct vxlan_mdb_entry *mdb_entry,
1107                                 struct netlink_ext_ack *extack)
1108 {
1109         struct vxlan_mdb_remote *remote;
1110         int err;
1111
1112         remote = vxlan_mdb_remote_lookup(mdb_entry, &cfg->remote_ip);
1113         if (remote) {
1114                 if (!(cfg->nlflags & NLM_F_REPLACE)) {
1115                         NL_SET_ERR_MSG_MOD(extack, "Replace not specified and MDB remote entry already exists");
1116                         return -EEXIST;
1117                 }
1118                 return vxlan_mdb_remote_replace(cfg, mdb_entry, remote, extack);
1119         }
1120
1121         if (!(cfg->nlflags & NLM_F_CREATE)) {
1122                 NL_SET_ERR_MSG_MOD(extack, "Create not specified and entry does not exist");
1123                 return -ENOENT;
1124         }
1125
1126         remote = kzalloc(sizeof(*remote), GFP_KERNEL);
1127         if (!remote)
1128                 return -ENOMEM;
1129
1130         err = vxlan_mdb_remote_init(cfg, remote);
1131         if (err) {
1132                 NL_SET_ERR_MSG_MOD(extack, "Failed to initialize remote MDB entry");
1133                 goto err_free_remote;
1134         }
1135
1136         err = vxlan_mdb_remote_srcs_add(cfg, remote, extack);
1137         if (err)
1138                 goto err_remote_fini;
1139
1140         list_add_rcu(&remote->list, &mdb_entry->remotes);
1141         vxlan_mdb_remote_notify(cfg->vxlan, mdb_entry, remote, RTM_NEWMDB);
1142
1143         return 0;
1144
1145 err_remote_fini:
1146         vxlan_mdb_remote_fini(cfg->vxlan, remote);
1147 err_free_remote:
1148         kfree(remote);
1149         return err;
1150 }
1151
1152 static void vxlan_mdb_remote_del(struct vxlan_dev *vxlan,
1153                                  struct vxlan_mdb_entry *mdb_entry,
1154                                  struct vxlan_mdb_remote *remote)
1155 {
1156         vxlan_mdb_remote_notify(vxlan, mdb_entry, remote, RTM_DELMDB);
1157         list_del_rcu(&remote->list);
1158         vxlan_mdb_remote_srcs_del(vxlan, &mdb_entry->key, remote);
1159         vxlan_mdb_remote_fini(vxlan, remote);
1160         kfree_rcu(remote, rcu);
1161 }
1162
1163 static struct vxlan_mdb_entry *
1164 vxlan_mdb_entry_get(struct vxlan_dev *vxlan,
1165                     const struct vxlan_mdb_entry_key *group)
1166 {
1167         struct vxlan_mdb_entry *mdb_entry;
1168         int err;
1169
1170         mdb_entry = vxlan_mdb_entry_lookup(vxlan, group);
1171         if (mdb_entry)
1172                 return mdb_entry;
1173
1174         mdb_entry = kzalloc(sizeof(*mdb_entry), GFP_KERNEL);
1175         if (!mdb_entry)
1176                 return ERR_PTR(-ENOMEM);
1177
1178         INIT_LIST_HEAD(&mdb_entry->remotes);
1179         memcpy(&mdb_entry->key, group, sizeof(mdb_entry->key));
1180         hlist_add_head(&mdb_entry->mdb_node, &vxlan->mdb_list);
1181
1182         err = rhashtable_lookup_insert_fast(&vxlan->mdb_tbl,
1183                                             &mdb_entry->rhnode,
1184                                             vxlan_mdb_rht_params);
1185         if (err)
1186                 goto err_free_entry;
1187
1188         if (hlist_is_singular_node(&mdb_entry->mdb_node, &vxlan->mdb_list))
1189                 vxlan->cfg.flags |= VXLAN_F_MDB;
1190
1191         return mdb_entry;
1192
1193 err_free_entry:
1194         hlist_del(&mdb_entry->mdb_node);
1195         kfree(mdb_entry);
1196         return ERR_PTR(err);
1197 }
1198
1199 static void vxlan_mdb_entry_put(struct vxlan_dev *vxlan,
1200                                 struct vxlan_mdb_entry *mdb_entry)
1201 {
1202         if (!list_empty(&mdb_entry->remotes))
1203                 return;
1204
1205         if (hlist_is_singular_node(&mdb_entry->mdb_node, &vxlan->mdb_list))
1206                 vxlan->cfg.flags &= ~VXLAN_F_MDB;
1207
1208         rhashtable_remove_fast(&vxlan->mdb_tbl, &mdb_entry->rhnode,
1209                                vxlan_mdb_rht_params);
1210         hlist_del(&mdb_entry->mdb_node);
1211         kfree_rcu(mdb_entry, rcu);
1212 }
1213
1214 static int __vxlan_mdb_add(const struct vxlan_mdb_config *cfg,
1215                            struct netlink_ext_ack *extack)
1216 {
1217         struct vxlan_dev *vxlan = cfg->vxlan;
1218         struct vxlan_mdb_entry *mdb_entry;
1219         int err;
1220
1221         mdb_entry = vxlan_mdb_entry_get(vxlan, &cfg->group);
1222         if (IS_ERR(mdb_entry))
1223                 return PTR_ERR(mdb_entry);
1224
1225         err = vxlan_mdb_remote_add(cfg, mdb_entry, extack);
1226         if (err)
1227                 goto err_entry_put;
1228
1229         vxlan->mdb_seq++;
1230
1231         return 0;
1232
1233 err_entry_put:
1234         vxlan_mdb_entry_put(vxlan, mdb_entry);
1235         return err;
1236 }
1237
1238 static int __vxlan_mdb_del(const struct vxlan_mdb_config *cfg,
1239                            struct netlink_ext_ack *extack)
1240 {
1241         struct vxlan_dev *vxlan = cfg->vxlan;
1242         struct vxlan_mdb_entry *mdb_entry;
1243         struct vxlan_mdb_remote *remote;
1244
1245         mdb_entry = vxlan_mdb_entry_lookup(vxlan, &cfg->group);
1246         if (!mdb_entry) {
1247                 NL_SET_ERR_MSG_MOD(extack, "Did not find MDB entry");
1248                 return -ENOENT;
1249         }
1250
1251         remote = vxlan_mdb_remote_lookup(mdb_entry, &cfg->remote_ip);
1252         if (!remote) {
1253                 NL_SET_ERR_MSG_MOD(extack, "Did not find MDB remote entry");
1254                 return -ENOENT;
1255         }
1256
1257         vxlan_mdb_remote_del(vxlan, mdb_entry, remote);
1258         vxlan_mdb_entry_put(vxlan, mdb_entry);
1259
1260         vxlan->mdb_seq++;
1261
1262         return 0;
1263 }
1264
1265 int vxlan_mdb_add(struct net_device *dev, struct nlattr *tb[], u16 nlmsg_flags,
1266                   struct netlink_ext_ack *extack)
1267 {
1268         struct vxlan_mdb_config cfg;
1269         int err;
1270
1271         ASSERT_RTNL();
1272
1273         err = vxlan_mdb_config_init(&cfg, dev, tb, nlmsg_flags, extack);
1274         if (err)
1275                 return err;
1276
1277         err = __vxlan_mdb_add(&cfg, extack);
1278
1279         vxlan_mdb_config_fini(&cfg);
1280         return err;
1281 }
1282
1283 int vxlan_mdb_del(struct net_device *dev, struct nlattr *tb[],
1284                   struct netlink_ext_ack *extack)
1285 {
1286         struct vxlan_mdb_config cfg;
1287         int err;
1288
1289         ASSERT_RTNL();
1290
1291         err = vxlan_mdb_config_init(&cfg, dev, tb, 0, extack);
1292         if (err)
1293                 return err;
1294
1295         err = __vxlan_mdb_del(&cfg, extack);
1296
1297         vxlan_mdb_config_fini(&cfg);
1298         return err;
1299 }
1300
1301 struct vxlan_mdb_entry *vxlan_mdb_entry_skb_get(struct vxlan_dev *vxlan,
1302                                                 struct sk_buff *skb,
1303                                                 __be32 src_vni)
1304 {
1305         struct vxlan_mdb_entry *mdb_entry;
1306         struct vxlan_mdb_entry_key group;
1307
1308         if (!is_multicast_ether_addr(eth_hdr(skb)->h_dest) ||
1309             is_broadcast_ether_addr(eth_hdr(skb)->h_dest))
1310                 return NULL;
1311
1312         /* When not in collect metadata mode, 'src_vni' is zero, but MDB
1313          * entries are stored with the VNI of the VXLAN device.
1314          */
1315         if (!(vxlan->cfg.flags & VXLAN_F_COLLECT_METADATA))
1316                 src_vni = vxlan->default_dst.remote_vni;
1317
1318         memset(&group, 0, sizeof(group));
1319         group.vni = src_vni;
1320
1321         switch (skb->protocol) {
1322         case htons(ETH_P_IP):
1323                 if (!pskb_may_pull(skb, sizeof(struct iphdr)))
1324                         return NULL;
1325                 group.dst.sa.sa_family = AF_INET;
1326                 group.dst.sin.sin_addr.s_addr = ip_hdr(skb)->daddr;
1327                 group.src.sa.sa_family = AF_INET;
1328                 group.src.sin.sin_addr.s_addr = ip_hdr(skb)->saddr;
1329                 break;
1330 #if IS_ENABLED(CONFIG_IPV6)
1331         case htons(ETH_P_IPV6):
1332                 if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))
1333                         return NULL;
1334                 group.dst.sa.sa_family = AF_INET6;
1335                 group.dst.sin6.sin6_addr = ipv6_hdr(skb)->daddr;
1336                 group.src.sa.sa_family = AF_INET6;
1337                 group.src.sin6.sin6_addr = ipv6_hdr(skb)->saddr;
1338                 break;
1339 #endif
1340         default:
1341                 return NULL;
1342         }
1343
1344         mdb_entry = vxlan_mdb_entry_lookup(vxlan, &group);
1345         if (mdb_entry)
1346                 return mdb_entry;
1347
1348         memset(&group.src, 0, sizeof(group.src));
1349         mdb_entry = vxlan_mdb_entry_lookup(vxlan, &group);
1350         if (mdb_entry)
1351                 return mdb_entry;
1352
1353         /* No (S, G) or (*, G) found. Look up the all-zeros entry, but only if
1354          * the destination IP address is not link-local multicast since we want
1355          * to transmit such traffic together with broadcast and unknown unicast
1356          * traffic.
1357          */
1358         switch (skb->protocol) {
1359         case htons(ETH_P_IP):
1360                 if (ipv4_is_local_multicast(group.dst.sin.sin_addr.s_addr))
1361                         return NULL;
1362                 group.dst.sin.sin_addr.s_addr = 0;
1363                 break;
1364 #if IS_ENABLED(CONFIG_IPV6)
1365         case htons(ETH_P_IPV6):
1366                 if (ipv6_addr_type(&group.dst.sin6.sin6_addr) &
1367                     IPV6_ADDR_LINKLOCAL)
1368                         return NULL;
1369                 memset(&group.dst.sin6.sin6_addr, 0,
1370                        sizeof(group.dst.sin6.sin6_addr));
1371                 break;
1372 #endif
1373         default:
1374                 return NULL;
1375         }
1376
1377         return vxlan_mdb_entry_lookup(vxlan, &group);
1378 }
1379
1380 netdev_tx_t vxlan_mdb_xmit(struct vxlan_dev *vxlan,
1381                            const struct vxlan_mdb_entry *mdb_entry,
1382                            struct sk_buff *skb)
1383 {
1384         struct vxlan_mdb_remote *remote, *fremote = NULL;
1385         __be32 src_vni = mdb_entry->key.vni;
1386
1387         list_for_each_entry_rcu(remote, &mdb_entry->remotes, list) {
1388                 struct sk_buff *skb1;
1389
1390                 if ((vxlan_mdb_is_star_g(&mdb_entry->key) &&
1391                      READ_ONCE(remote->filter_mode) == MCAST_INCLUDE) ||
1392                     (READ_ONCE(remote->flags) & VXLAN_MDB_REMOTE_F_BLOCKED))
1393                         continue;
1394
1395                 if (!fremote) {
1396                         fremote = remote;
1397                         continue;
1398                 }
1399
1400                 skb1 = skb_clone(skb, GFP_ATOMIC);
1401                 if (skb1)
1402                         vxlan_xmit_one(skb1, vxlan->dev, src_vni,
1403                                        rcu_dereference(remote->rd), false);
1404         }
1405
1406         if (fremote)
1407                 vxlan_xmit_one(skb, vxlan->dev, src_vni,
1408                                rcu_dereference(fremote->rd), false);
1409         else
1410                 kfree_skb(skb);
1411
1412         return NETDEV_TX_OK;
1413 }
1414
1415 static void vxlan_mdb_check_empty(void *ptr, void *arg)
1416 {
1417         WARN_ON_ONCE(1);
1418 }
1419
1420 static void vxlan_mdb_remotes_flush(struct vxlan_dev *vxlan,
1421                                     struct vxlan_mdb_entry *mdb_entry)
1422 {
1423         struct vxlan_mdb_remote *remote, *tmp;
1424
1425         list_for_each_entry_safe(remote, tmp, &mdb_entry->remotes, list)
1426                 vxlan_mdb_remote_del(vxlan, mdb_entry, remote);
1427 }
1428
1429 static void vxlan_mdb_entries_flush(struct vxlan_dev *vxlan)
1430 {
1431         struct vxlan_mdb_entry *mdb_entry;
1432         struct hlist_node *tmp;
1433
1434         /* The removal of an entry cannot trigger the removal of another entry
1435          * since entries are always added to the head of the list.
1436          */
1437         hlist_for_each_entry_safe(mdb_entry, tmp, &vxlan->mdb_list, mdb_node) {
1438                 vxlan_mdb_remotes_flush(vxlan, mdb_entry);
1439                 vxlan_mdb_entry_put(vxlan, mdb_entry);
1440         }
1441 }
1442
1443 int vxlan_mdb_init(struct vxlan_dev *vxlan)
1444 {
1445         int err;
1446
1447         err = rhashtable_init(&vxlan->mdb_tbl, &vxlan_mdb_rht_params);
1448         if (err)
1449                 return err;
1450
1451         INIT_HLIST_HEAD(&vxlan->mdb_list);
1452
1453         return 0;
1454 }
1455
1456 void vxlan_mdb_fini(struct vxlan_dev *vxlan)
1457 {
1458         vxlan_mdb_entries_flush(vxlan);
1459         WARN_ON_ONCE(vxlan->cfg.flags & VXLAN_F_MDB);
1460         rhashtable_free_and_destroy(&vxlan->mdb_tbl, vxlan_mdb_check_empty,
1461                                     NULL);
1462 }