1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Vxlan vni filter for collect metadata mode 4 * 5 * Authors: Roopa Prabhu <roopa@nvidia.com> 6 * 7 */ 8 9 #include <linux/kernel.h> 10 #include <linux/slab.h> 11 #include <linux/etherdevice.h> 12 #include <linux/rhashtable.h> 13 #include <net/rtnetlink.h> 14 #include <net/net_namespace.h> 15 #include <net/sock.h> 16 #include <net/vxlan.h> 17 18 #include "vxlan_private.h" 19 20 static inline int vxlan_vni_cmp(struct rhashtable_compare_arg *arg, 21 const void *ptr) 22 { 23 const struct vxlan_vni_node *vnode = ptr; 24 __be32 vni = *(__be32 *)arg->key; 25 26 return vnode->vni != vni; 27 } 28 29 const struct rhashtable_params vxlan_vni_rht_params = { 30 .head_offset = offsetof(struct vxlan_vni_node, vnode), 31 .key_offset = offsetof(struct vxlan_vni_node, vni), 32 .key_len = sizeof(__be32), 33 .nelem_hint = 3, 34 .max_size = VXLAN_N_VID, 35 .obj_cmpfn = vxlan_vni_cmp, 36 .automatic_shrinking = true, 37 }; 38 39 static void vxlan_vs_add_del_vninode(struct vxlan_dev *vxlan, 40 struct vxlan_vni_node *v, 41 bool del) 42 { 43 struct vxlan_net *vn = net_generic(vxlan->net, vxlan_net_id); 44 struct vxlan_dev_node *node; 45 struct vxlan_sock *vs; 46 47 spin_lock(&vn->sock_lock); 48 if (del) { 49 if (!hlist_unhashed(&v->hlist4.hlist)) 50 hlist_del_init_rcu(&v->hlist4.hlist); 51 #if IS_ENABLED(CONFIG_IPV6) 52 if (!hlist_unhashed(&v->hlist6.hlist)) 53 hlist_del_init_rcu(&v->hlist6.hlist); 54 #endif 55 goto out; 56 } 57 58 #if IS_ENABLED(CONFIG_IPV6) 59 vs = rtnl_dereference(vxlan->vn6_sock); 60 if (vs && v) { 61 node = &v->hlist6; 62 hlist_add_head_rcu(&node->hlist, vni_head(vs, v->vni)); 63 } 64 #endif 65 vs = rtnl_dereference(vxlan->vn4_sock); 66 if (vs && v) { 67 node = &v->hlist4; 68 hlist_add_head_rcu(&node->hlist, vni_head(vs, v->vni)); 69 } 70 out: 71 spin_unlock(&vn->sock_lock); 72 } 73 74 void vxlan_vs_add_vnigrp(struct vxlan_dev *vxlan, 75 struct vxlan_sock *vs, 76 bool ipv6) 77 { 78 struct vxlan_net *vn = net_generic(vxlan->net, vxlan_net_id); 79 struct vxlan_vni_group *vg = rtnl_dereference(vxlan->vnigrp); 80 struct vxlan_vni_node *v, *tmp; 81 struct vxlan_dev_node *node; 82 83 if (!vg) 84 return; 85 86 spin_lock(&vn->sock_lock); 87 list_for_each_entry_safe(v, tmp, &vg->vni_list, vlist) { 88 #if IS_ENABLED(CONFIG_IPV6) 89 if (ipv6) 90 node = &v->hlist6; 91 else 92 #endif 93 node = &v->hlist4; 94 node->vxlan = vxlan; 95 hlist_add_head_rcu(&node->hlist, vni_head(vs, v->vni)); 96 } 97 spin_unlock(&vn->sock_lock); 98 } 99 100 void vxlan_vs_del_vnigrp(struct vxlan_dev *vxlan) 101 { 102 struct vxlan_vni_group *vg = rtnl_dereference(vxlan->vnigrp); 103 struct vxlan_net *vn = net_generic(vxlan->net, vxlan_net_id); 104 struct vxlan_vni_node *v, *tmp; 105 106 if (!vg) 107 return; 108 109 spin_lock(&vn->sock_lock); 110 list_for_each_entry_safe(v, tmp, &vg->vni_list, vlist) { 111 hlist_del_init_rcu(&v->hlist4.hlist); 112 #if IS_ENABLED(CONFIG_IPV6) 113 hlist_del_init_rcu(&v->hlist6.hlist); 114 #endif 115 } 116 spin_unlock(&vn->sock_lock); 117 } 118 119 static void vxlan_vnifilter_stats_get(const struct vxlan_vni_node *vninode, 120 struct vxlan_vni_stats *dest) 121 { 122 int i; 123 124 memset(dest, 0, sizeof(*dest)); 125 for_each_possible_cpu(i) { 126 struct vxlan_vni_stats_pcpu *pstats; 127 struct vxlan_vni_stats temp; 128 unsigned int start; 129 130 pstats = per_cpu_ptr(vninode->stats, i); 131 do { 132 start = u64_stats_fetch_begin(&pstats->syncp); 133 memcpy(&temp, &pstats->stats, sizeof(temp)); 134 } while (u64_stats_fetch_retry(&pstats->syncp, start)); 135 136 dest->rx_packets += temp.rx_packets; 137 dest->rx_bytes += temp.rx_bytes; 138 dest->rx_drops += temp.rx_drops; 139 dest->rx_errors += temp.rx_errors; 140 dest->tx_packets += temp.tx_packets; 141 dest->tx_bytes += temp.tx_bytes; 142 dest->tx_drops += temp.tx_drops; 143 dest->tx_errors += temp.tx_errors; 144 } 145 } 146 147 static void vxlan_vnifilter_stats_add(struct vxlan_vni_node *vninode, 148 int type, unsigned int len) 149 { 150 struct vxlan_vni_stats_pcpu *pstats = this_cpu_ptr(vninode->stats); 151 152 u64_stats_update_begin(&pstats->syncp); 153 switch (type) { 154 case VXLAN_VNI_STATS_RX: 155 pstats->stats.rx_bytes += len; 156 pstats->stats.rx_packets++; 157 break; 158 case VXLAN_VNI_STATS_RX_DROPS: 159 pstats->stats.rx_drops++; 160 break; 161 case VXLAN_VNI_STATS_RX_ERRORS: 162 pstats->stats.rx_errors++; 163 break; 164 case VXLAN_VNI_STATS_TX: 165 pstats->stats.tx_bytes += len; 166 pstats->stats.tx_packets++; 167 break; 168 case VXLAN_VNI_STATS_TX_DROPS: 169 pstats->stats.tx_drops++; 170 break; 171 case VXLAN_VNI_STATS_TX_ERRORS: 172 pstats->stats.tx_errors++; 173 break; 174 } 175 u64_stats_update_end(&pstats->syncp); 176 } 177 178 void vxlan_vnifilter_count(struct vxlan_dev *vxlan, __be32 vni, 179 struct vxlan_vni_node *vninode, 180 int type, unsigned int len) 181 { 182 struct vxlan_vni_node *vnode; 183 184 if (!(vxlan->cfg.flags & VXLAN_F_VNIFILTER)) 185 return; 186 187 if (vninode) { 188 vnode = vninode; 189 } else { 190 vnode = vxlan_vnifilter_lookup(vxlan, vni); 191 if (!vnode) 192 return; 193 } 194 195 vxlan_vnifilter_stats_add(vnode, type, len); 196 } 197 198 static u32 vnirange(struct vxlan_vni_node *vbegin, 199 struct vxlan_vni_node *vend) 200 { 201 return (be32_to_cpu(vend->vni) - be32_to_cpu(vbegin->vni)); 202 } 203 204 static size_t vxlan_vnifilter_entry_nlmsg_size(void) 205 { 206 return NLMSG_ALIGN(sizeof(struct tunnel_msg)) 207 + nla_total_size(0) /* VXLAN_VNIFILTER_ENTRY */ 208 + nla_total_size(sizeof(u32)) /* VXLAN_VNIFILTER_ENTRY_START */ 209 + nla_total_size(sizeof(u32)) /* VXLAN_VNIFILTER_ENTRY_END */ 210 + nla_total_size(sizeof(struct in6_addr));/* VXLAN_VNIFILTER_ENTRY_GROUP{6} */ 211 } 212 213 static int __vnifilter_entry_fill_stats(struct sk_buff *skb, 214 const struct vxlan_vni_node *vbegin) 215 { 216 struct vxlan_vni_stats vstats; 217 struct nlattr *vstats_attr; 218 219 vstats_attr = nla_nest_start(skb, VXLAN_VNIFILTER_ENTRY_STATS); 220 if (!vstats_attr) 221 goto out_stats_err; 222 223 vxlan_vnifilter_stats_get(vbegin, &vstats); 224 if (nla_put_u64_64bit(skb, VNIFILTER_ENTRY_STATS_RX_BYTES, 225 vstats.rx_bytes, VNIFILTER_ENTRY_STATS_PAD) || 226 nla_put_u64_64bit(skb, VNIFILTER_ENTRY_STATS_RX_PKTS, 227 vstats.rx_packets, VNIFILTER_ENTRY_STATS_PAD) || 228 nla_put_u64_64bit(skb, VNIFILTER_ENTRY_STATS_RX_DROPS, 229 vstats.rx_drops, VNIFILTER_ENTRY_STATS_PAD) || 230 nla_put_u64_64bit(skb, VNIFILTER_ENTRY_STATS_RX_ERRORS, 231 vstats.rx_errors, VNIFILTER_ENTRY_STATS_PAD) || 232 nla_put_u64_64bit(skb, VNIFILTER_ENTRY_STATS_TX_BYTES, 233 vstats.tx_bytes, VNIFILTER_ENTRY_STATS_PAD) || 234 nla_put_u64_64bit(skb, VNIFILTER_ENTRY_STATS_TX_PKTS, 235 vstats.tx_packets, VNIFILTER_ENTRY_STATS_PAD) || 236 nla_put_u64_64bit(skb, VNIFILTER_ENTRY_STATS_TX_DROPS, 237 vstats.tx_drops, VNIFILTER_ENTRY_STATS_PAD) || 238 nla_put_u64_64bit(skb, VNIFILTER_ENTRY_STATS_TX_ERRORS, 239 vstats.tx_errors, VNIFILTER_ENTRY_STATS_PAD)) 240 goto out_stats_err; 241 242 nla_nest_end(skb, vstats_attr); 243 244 return 0; 245 246 out_stats_err: 247 nla_nest_cancel(skb, vstats_attr); 248 return -EMSGSIZE; 249 } 250 251 static bool vxlan_fill_vni_filter_entry(struct sk_buff *skb, 252 struct vxlan_vni_node *vbegin, 253 struct vxlan_vni_node *vend, 254 bool fill_stats) 255 { 256 struct nlattr *ventry; 257 u32 vs = be32_to_cpu(vbegin->vni); 258 u32 ve = 0; 259 260 if (vbegin != vend) 261 ve = be32_to_cpu(vend->vni); 262 263 ventry = nla_nest_start(skb, VXLAN_VNIFILTER_ENTRY); 264 if (!ventry) 265 return false; 266 267 if (nla_put_u32(skb, VXLAN_VNIFILTER_ENTRY_START, vs)) 268 goto out_err; 269 270 if (ve && nla_put_u32(skb, VXLAN_VNIFILTER_ENTRY_END, ve)) 271 goto out_err; 272 273 if (!vxlan_addr_any(&vbegin->remote_ip)) { 274 if (vbegin->remote_ip.sa.sa_family == AF_INET) { 275 if (nla_put_in_addr(skb, VXLAN_VNIFILTER_ENTRY_GROUP, 276 vbegin->remote_ip.sin.sin_addr.s_addr)) 277 goto out_err; 278 #if IS_ENABLED(CONFIG_IPV6) 279 } else { 280 if (nla_put_in6_addr(skb, VXLAN_VNIFILTER_ENTRY_GROUP6, 281 &vbegin->remote_ip.sin6.sin6_addr)) 282 goto out_err; 283 #endif 284 } 285 } 286 287 if (fill_stats && __vnifilter_entry_fill_stats(skb, vbegin)) 288 goto out_err; 289 290 nla_nest_end(skb, ventry); 291 292 return true; 293 294 out_err: 295 nla_nest_cancel(skb, ventry); 296 297 return false; 298 } 299 300 static void vxlan_vnifilter_notify(const struct vxlan_dev *vxlan, 301 struct vxlan_vni_node *vninode, int cmd) 302 { 303 struct tunnel_msg *tmsg; 304 struct sk_buff *skb; 305 struct nlmsghdr *nlh; 306 struct net *net = dev_net(vxlan->dev); 307 int err = -ENOBUFS; 308 309 skb = nlmsg_new(vxlan_vnifilter_entry_nlmsg_size(), GFP_KERNEL); 310 if (!skb) 311 goto out_err; 312 313 err = -EMSGSIZE; 314 nlh = nlmsg_put(skb, 0, 0, cmd, sizeof(*tmsg), 0); 315 if (!nlh) 316 goto out_err; 317 tmsg = nlmsg_data(nlh); 318 memset(tmsg, 0, sizeof(*tmsg)); 319 tmsg->family = AF_BRIDGE; 320 tmsg->ifindex = vxlan->dev->ifindex; 321 322 if (!vxlan_fill_vni_filter_entry(skb, vninode, vninode, false)) 323 goto out_err; 324 325 nlmsg_end(skb, nlh); 326 rtnl_notify(skb, net, 0, RTNLGRP_TUNNEL, NULL, GFP_KERNEL); 327 328 return; 329 330 out_err: 331 rtnl_set_sk_err(net, RTNLGRP_TUNNEL, err); 332 333 kfree_skb(skb); 334 } 335 336 static int vxlan_vnifilter_dump_dev(const struct net_device *dev, 337 struct sk_buff *skb, 338 struct netlink_callback *cb) 339 { 340 struct vxlan_vni_node *tmp, *v, *vbegin = NULL, *vend = NULL; 341 struct vxlan_dev *vxlan = netdev_priv(dev); 342 struct tunnel_msg *new_tmsg, *tmsg; 343 int idx = 0, s_idx = cb->args[1]; 344 struct vxlan_vni_group *vg; 345 struct nlmsghdr *nlh; 346 bool dump_stats; 347 int err = 0; 348 349 if (!(vxlan->cfg.flags & VXLAN_F_VNIFILTER)) 350 return -EINVAL; 351 352 /* RCU needed because of the vni locking rules (rcu || rtnl) */ 353 vg = rcu_dereference(vxlan->vnigrp); 354 if (!vg || !vg->num_vnis) 355 return 0; 356 357 tmsg = nlmsg_data(cb->nlh); 358 dump_stats = !!(tmsg->flags & TUNNEL_MSG_FLAG_STATS); 359 360 nlh = nlmsg_put(skb, NETLINK_CB(cb->skb).portid, cb->nlh->nlmsg_seq, 361 RTM_NEWTUNNEL, sizeof(*new_tmsg), NLM_F_MULTI); 362 if (!nlh) 363 return -EMSGSIZE; 364 new_tmsg = nlmsg_data(nlh); 365 memset(new_tmsg, 0, sizeof(*new_tmsg)); 366 new_tmsg->family = PF_BRIDGE; 367 new_tmsg->ifindex = dev->ifindex; 368 369 list_for_each_entry_safe(v, tmp, &vg->vni_list, vlist) { 370 if (idx < s_idx) { 371 idx++; 372 continue; 373 } 374 if (!vbegin) { 375 vbegin = v; 376 vend = v; 377 continue; 378 } 379 if (!dump_stats && vnirange(vend, v) == 1 && 380 vxlan_addr_equal(&v->remote_ip, &vend->remote_ip)) { 381 goto update_end; 382 } else { 383 if (!vxlan_fill_vni_filter_entry(skb, vbegin, vend, 384 dump_stats)) { 385 err = -EMSGSIZE; 386 break; 387 } 388 idx += vnirange(vbegin, vend) + 1; 389 vbegin = v; 390 } 391 update_end: 392 vend = v; 393 } 394 395 if (!err && vbegin) { 396 if (!vxlan_fill_vni_filter_entry(skb, vbegin, vend, dump_stats)) 397 err = -EMSGSIZE; 398 } 399 400 cb->args[1] = err ? idx : 0; 401 402 nlmsg_end(skb, nlh); 403 404 return err; 405 } 406 407 static int vxlan_vnifilter_dump(struct sk_buff *skb, struct netlink_callback *cb) 408 { 409 int idx = 0, err = 0, s_idx = cb->args[0]; 410 struct net *net = sock_net(skb->sk); 411 struct tunnel_msg *tmsg; 412 struct net_device *dev; 413 414 tmsg = nlmsg_data(cb->nlh); 415 416 if (tmsg->flags & ~TUNNEL_MSG_VALID_USER_FLAGS) { 417 NL_SET_ERR_MSG(cb->extack, "Invalid tunnelmsg flags in ancillary header"); 418 return -EINVAL; 419 } 420 421 rcu_read_lock(); 422 if (tmsg->ifindex) { 423 dev = dev_get_by_index_rcu(net, tmsg->ifindex); 424 if (!dev) { 425 err = -ENODEV; 426 goto out_err; 427 } 428 if (!netif_is_vxlan(dev)) { 429 NL_SET_ERR_MSG(cb->extack, 430 "The device is not a vxlan device"); 431 err = -EINVAL; 432 goto out_err; 433 } 434 err = vxlan_vnifilter_dump_dev(dev, skb, cb); 435 /* if the dump completed without an error we return 0 here */ 436 if (err != -EMSGSIZE) 437 goto out_err; 438 } else { 439 for_each_netdev_rcu(net, dev) { 440 if (!netif_is_vxlan(dev)) 441 continue; 442 if (idx < s_idx) 443 goto skip; 444 err = vxlan_vnifilter_dump_dev(dev, skb, cb); 445 if (err == -EMSGSIZE) 446 break; 447 skip: 448 idx++; 449 } 450 } 451 cb->args[0] = idx; 452 rcu_read_unlock(); 453 454 return skb->len; 455 456 out_err: 457 rcu_read_unlock(); 458 459 return err; 460 } 461 462 static const struct nla_policy vni_filter_entry_policy[VXLAN_VNIFILTER_ENTRY_MAX + 1] = { 463 [VXLAN_VNIFILTER_ENTRY_START] = { .type = NLA_U32 }, 464 [VXLAN_VNIFILTER_ENTRY_END] = { .type = NLA_U32 }, 465 [VXLAN_VNIFILTER_ENTRY_GROUP] = { .type = NLA_BINARY, 466 .len = sizeof_field(struct iphdr, daddr) }, 467 [VXLAN_VNIFILTER_ENTRY_GROUP6] = { .type = NLA_BINARY, 468 .len = sizeof(struct in6_addr) }, 469 }; 470 471 static const struct nla_policy vni_filter_policy[VXLAN_VNIFILTER_MAX + 1] = { 472 [VXLAN_VNIFILTER_ENTRY] = { .type = NLA_NESTED }, 473 }; 474 475 static int vxlan_update_default_fdb_entry(struct vxlan_dev *vxlan, __be32 vni, 476 union vxlan_addr *old_remote_ip, 477 union vxlan_addr *remote_ip, 478 struct netlink_ext_ack *extack) 479 { 480 struct vxlan_rdst *dst = &vxlan->default_dst; 481 u32 hash_index; 482 int err = 0; 483 484 hash_index = fdb_head_index(vxlan, all_zeros_mac, vni); 485 spin_lock_bh(&vxlan->hash_lock[hash_index]); 486 if (remote_ip && !vxlan_addr_any(remote_ip)) { 487 err = vxlan_fdb_update(vxlan, all_zeros_mac, 488 remote_ip, 489 NUD_REACHABLE | NUD_PERMANENT, 490 NLM_F_APPEND | NLM_F_CREATE, 491 vxlan->cfg.dst_port, 492 vni, 493 vni, 494 dst->remote_ifindex, 495 NTF_SELF, 0, true, extack); 496 if (err) { 497 spin_unlock_bh(&vxlan->hash_lock[hash_index]); 498 return err; 499 } 500 } 501 502 if (old_remote_ip && !vxlan_addr_any(old_remote_ip)) { 503 __vxlan_fdb_delete(vxlan, all_zeros_mac, 504 *old_remote_ip, 505 vxlan->cfg.dst_port, 506 vni, vni, 507 dst->remote_ifindex, 508 true); 509 } 510 spin_unlock_bh(&vxlan->hash_lock[hash_index]); 511 512 return err; 513 } 514 515 static int vxlan_vni_update_group(struct vxlan_dev *vxlan, 516 struct vxlan_vni_node *vninode, 517 union vxlan_addr *group, 518 bool create, bool *changed, 519 struct netlink_ext_ack *extack) 520 { 521 struct vxlan_net *vn = net_generic(vxlan->net, vxlan_net_id); 522 struct vxlan_rdst *dst = &vxlan->default_dst; 523 union vxlan_addr *newrip = NULL, *oldrip = NULL; 524 union vxlan_addr old_remote_ip; 525 int ret = 0; 526 527 memcpy(&old_remote_ip, &vninode->remote_ip, sizeof(old_remote_ip)); 528 529 /* if per vni remote ip is not present use vxlan dev 530 * default dst remote ip for fdb entry 531 */ 532 if (group && !vxlan_addr_any(group)) { 533 newrip = group; 534 } else { 535 if (!vxlan_addr_any(&dst->remote_ip)) 536 newrip = &dst->remote_ip; 537 } 538 539 /* if old rip exists, and no newrip, 540 * explicitly delete old rip 541 */ 542 if (!newrip && !vxlan_addr_any(&old_remote_ip)) 543 oldrip = &old_remote_ip; 544 545 if (!newrip && !oldrip) 546 return 0; 547 548 if (!create && oldrip && newrip && vxlan_addr_equal(oldrip, newrip)) 549 return 0; 550 551 ret = vxlan_update_default_fdb_entry(vxlan, vninode->vni, 552 oldrip, newrip, 553 extack); 554 if (ret) 555 goto out; 556 557 if (group) 558 memcpy(&vninode->remote_ip, group, sizeof(vninode->remote_ip)); 559 560 if (vxlan->dev->flags & IFF_UP) { 561 if (vxlan_addr_multicast(&old_remote_ip) && 562 !vxlan_group_used(vn, vxlan, vninode->vni, 563 &old_remote_ip, 564 vxlan->default_dst.remote_ifindex)) { 565 ret = vxlan_igmp_leave(vxlan, &old_remote_ip, 566 0); 567 if (ret) 568 goto out; 569 } 570 571 if (vxlan_addr_multicast(&vninode->remote_ip)) { 572 ret = vxlan_igmp_join(vxlan, &vninode->remote_ip, 0); 573 if (ret == -EADDRINUSE) 574 ret = 0; 575 if (ret) 576 goto out; 577 } 578 } 579 580 *changed = true; 581 582 return 0; 583 out: 584 return ret; 585 } 586 587 int vxlan_vnilist_update_group(struct vxlan_dev *vxlan, 588 union vxlan_addr *old_remote_ip, 589 union vxlan_addr *new_remote_ip, 590 struct netlink_ext_ack *extack) 591 { 592 struct list_head *headp, *hpos; 593 struct vxlan_vni_group *vg; 594 struct vxlan_vni_node *vent; 595 int ret; 596 597 vg = rtnl_dereference(vxlan->vnigrp); 598 599 headp = &vg->vni_list; 600 list_for_each_prev(hpos, headp) { 601 vent = list_entry(hpos, struct vxlan_vni_node, vlist); 602 if (vxlan_addr_any(&vent->remote_ip)) { 603 ret = vxlan_update_default_fdb_entry(vxlan, vent->vni, 604 old_remote_ip, 605 new_remote_ip, 606 extack); 607 if (ret) 608 return ret; 609 } 610 } 611 612 return 0; 613 } 614 615 static void vxlan_vni_delete_group(struct vxlan_dev *vxlan, 616 struct vxlan_vni_node *vninode) 617 { 618 struct vxlan_net *vn = net_generic(vxlan->net, vxlan_net_id); 619 struct vxlan_rdst *dst = &vxlan->default_dst; 620 621 /* if per vni remote_ip not present, delete the 622 * default dst remote_ip previously added for this vni 623 */ 624 if (!vxlan_addr_any(&vninode->remote_ip) || 625 !vxlan_addr_any(&dst->remote_ip)) 626 __vxlan_fdb_delete(vxlan, all_zeros_mac, 627 (vxlan_addr_any(&vninode->remote_ip) ? 628 dst->remote_ip : vninode->remote_ip), 629 vxlan->cfg.dst_port, 630 vninode->vni, vninode->vni, 631 dst->remote_ifindex, 632 true); 633 634 if (vxlan->dev->flags & IFF_UP) { 635 if (vxlan_addr_multicast(&vninode->remote_ip) && 636 !vxlan_group_used(vn, vxlan, vninode->vni, 637 &vninode->remote_ip, 638 dst->remote_ifindex)) { 639 vxlan_igmp_leave(vxlan, &vninode->remote_ip, 0); 640 } 641 } 642 } 643 644 static int vxlan_vni_update(struct vxlan_dev *vxlan, 645 struct vxlan_vni_group *vg, 646 __be32 vni, union vxlan_addr *group, 647 bool *changed, 648 struct netlink_ext_ack *extack) 649 { 650 struct vxlan_vni_node *vninode; 651 int ret; 652 653 vninode = rhashtable_lookup_fast(&vg->vni_hash, &vni, 654 vxlan_vni_rht_params); 655 if (!vninode) 656 return 0; 657 658 ret = vxlan_vni_update_group(vxlan, vninode, group, false, changed, 659 extack); 660 if (ret) 661 return ret; 662 663 if (changed) 664 vxlan_vnifilter_notify(vxlan, vninode, RTM_NEWTUNNEL); 665 666 return 0; 667 } 668 669 static void __vxlan_vni_add_list(struct vxlan_vni_group *vg, 670 struct vxlan_vni_node *v) 671 { 672 struct list_head *headp, *hpos; 673 struct vxlan_vni_node *vent; 674 675 headp = &vg->vni_list; 676 list_for_each_prev(hpos, headp) { 677 vent = list_entry(hpos, struct vxlan_vni_node, vlist); 678 if (be32_to_cpu(v->vni) < be32_to_cpu(vent->vni)) 679 continue; 680 else 681 break; 682 } 683 list_add_rcu(&v->vlist, hpos); 684 vg->num_vnis++; 685 } 686 687 static void __vxlan_vni_del_list(struct vxlan_vni_group *vg, 688 struct vxlan_vni_node *v) 689 { 690 list_del_rcu(&v->vlist); 691 vg->num_vnis--; 692 } 693 694 static struct vxlan_vni_node *vxlan_vni_alloc(struct vxlan_dev *vxlan, 695 __be32 vni) 696 { 697 struct vxlan_vni_node *vninode; 698 699 vninode = kzalloc(sizeof(*vninode), GFP_KERNEL); 700 if (!vninode) 701 return NULL; 702 vninode->stats = netdev_alloc_pcpu_stats(struct vxlan_vni_stats_pcpu); 703 if (!vninode->stats) { 704 kfree(vninode); 705 return NULL; 706 } 707 vninode->vni = vni; 708 vninode->hlist4.vxlan = vxlan; 709 #if IS_ENABLED(CONFIG_IPV6) 710 vninode->hlist6.vxlan = vxlan; 711 #endif 712 713 return vninode; 714 } 715 716 static void vxlan_vni_free(struct vxlan_vni_node *vninode) 717 { 718 free_percpu(vninode->stats); 719 kfree(vninode); 720 } 721 722 static int vxlan_vni_add(struct vxlan_dev *vxlan, 723 struct vxlan_vni_group *vg, 724 u32 vni, union vxlan_addr *group, 725 struct netlink_ext_ack *extack) 726 { 727 struct vxlan_vni_node *vninode; 728 __be32 v = cpu_to_be32(vni); 729 bool changed = false; 730 int err = 0; 731 732 if (vxlan_vnifilter_lookup(vxlan, v)) 733 return vxlan_vni_update(vxlan, vg, v, group, &changed, extack); 734 735 err = vxlan_vni_in_use(vxlan->net, vxlan, &vxlan->cfg, v); 736 if (err) { 737 NL_SET_ERR_MSG(extack, "VNI in use"); 738 return err; 739 } 740 741 vninode = vxlan_vni_alloc(vxlan, v); 742 if (!vninode) 743 return -ENOMEM; 744 745 err = rhashtable_lookup_insert_fast(&vg->vni_hash, 746 &vninode->vnode, 747 vxlan_vni_rht_params); 748 if (err) { 749 vxlan_vni_free(vninode); 750 return err; 751 } 752 753 __vxlan_vni_add_list(vg, vninode); 754 755 if (vxlan->dev->flags & IFF_UP) 756 vxlan_vs_add_del_vninode(vxlan, vninode, false); 757 758 err = vxlan_vni_update_group(vxlan, vninode, group, true, &changed, 759 extack); 760 761 if (changed) 762 vxlan_vnifilter_notify(vxlan, vninode, RTM_NEWTUNNEL); 763 764 return err; 765 } 766 767 static void vxlan_vni_node_rcu_free(struct rcu_head *rcu) 768 { 769 struct vxlan_vni_node *v; 770 771 v = container_of(rcu, struct vxlan_vni_node, rcu); 772 vxlan_vni_free(v); 773 } 774 775 static int vxlan_vni_del(struct vxlan_dev *vxlan, 776 struct vxlan_vni_group *vg, 777 u32 vni, struct netlink_ext_ack *extack) 778 { 779 struct vxlan_vni_node *vninode; 780 __be32 v = cpu_to_be32(vni); 781 int err = 0; 782 783 vg = rtnl_dereference(vxlan->vnigrp); 784 785 vninode = rhashtable_lookup_fast(&vg->vni_hash, &v, 786 vxlan_vni_rht_params); 787 if (!vninode) { 788 err = -ENOENT; 789 goto out; 790 } 791 792 vxlan_vni_delete_group(vxlan, vninode); 793 794 err = rhashtable_remove_fast(&vg->vni_hash, 795 &vninode->vnode, 796 vxlan_vni_rht_params); 797 if (err) 798 goto out; 799 800 __vxlan_vni_del_list(vg, vninode); 801 802 vxlan_vnifilter_notify(vxlan, vninode, RTM_DELTUNNEL); 803 804 if (vxlan->dev->flags & IFF_UP) 805 vxlan_vs_add_del_vninode(vxlan, vninode, true); 806 807 call_rcu(&vninode->rcu, vxlan_vni_node_rcu_free); 808 809 return 0; 810 out: 811 return err; 812 } 813 814 static int vxlan_vni_add_del(struct vxlan_dev *vxlan, __u32 start_vni, 815 __u32 end_vni, union vxlan_addr *group, 816 int cmd, struct netlink_ext_ack *extack) 817 { 818 struct vxlan_vni_group *vg; 819 int v, err = 0; 820 821 vg = rtnl_dereference(vxlan->vnigrp); 822 823 for (v = start_vni; v <= end_vni; v++) { 824 switch (cmd) { 825 case RTM_NEWTUNNEL: 826 err = vxlan_vni_add(vxlan, vg, v, group, extack); 827 break; 828 case RTM_DELTUNNEL: 829 err = vxlan_vni_del(vxlan, vg, v, extack); 830 break; 831 default: 832 err = -EOPNOTSUPP; 833 break; 834 } 835 if (err) 836 goto out; 837 } 838 839 return 0; 840 out: 841 return err; 842 } 843 844 static int vxlan_process_vni_filter(struct vxlan_dev *vxlan, 845 struct nlattr *nlvnifilter, 846 int cmd, struct netlink_ext_ack *extack) 847 { 848 struct nlattr *vattrs[VXLAN_VNIFILTER_ENTRY_MAX + 1]; 849 u32 vni_start = 0, vni_end = 0; 850 union vxlan_addr group; 851 int err; 852 853 err = nla_parse_nested(vattrs, 854 VXLAN_VNIFILTER_ENTRY_MAX, 855 nlvnifilter, vni_filter_entry_policy, 856 extack); 857 if (err) 858 return err; 859 860 if (vattrs[VXLAN_VNIFILTER_ENTRY_START]) { 861 vni_start = nla_get_u32(vattrs[VXLAN_VNIFILTER_ENTRY_START]); 862 vni_end = vni_start; 863 } 864 865 if (vattrs[VXLAN_VNIFILTER_ENTRY_END]) 866 vni_end = nla_get_u32(vattrs[VXLAN_VNIFILTER_ENTRY_END]); 867 868 if (!vni_start && !vni_end) { 869 NL_SET_ERR_MSG_ATTR(extack, nlvnifilter, 870 "vni start nor end found in vni entry"); 871 return -EINVAL; 872 } 873 874 if (vattrs[VXLAN_VNIFILTER_ENTRY_GROUP]) { 875 group.sin.sin_addr.s_addr = 876 nla_get_in_addr(vattrs[VXLAN_VNIFILTER_ENTRY_GROUP]); 877 group.sa.sa_family = AF_INET; 878 } else if (vattrs[VXLAN_VNIFILTER_ENTRY_GROUP6]) { 879 group.sin6.sin6_addr = 880 nla_get_in6_addr(vattrs[VXLAN_VNIFILTER_ENTRY_GROUP6]); 881 group.sa.sa_family = AF_INET6; 882 } else { 883 memset(&group, 0, sizeof(group)); 884 } 885 886 if (vxlan_addr_multicast(&group) && !vxlan->default_dst.remote_ifindex) { 887 NL_SET_ERR_MSG(extack, 888 "Local interface required for multicast remote group"); 889 890 return -EINVAL; 891 } 892 893 err = vxlan_vni_add_del(vxlan, vni_start, vni_end, &group, cmd, 894 extack); 895 if (err) 896 return err; 897 898 return 0; 899 } 900 901 void vxlan_vnigroup_uninit(struct vxlan_dev *vxlan) 902 { 903 struct vxlan_vni_node *v, *tmp; 904 struct vxlan_vni_group *vg; 905 906 vg = rtnl_dereference(vxlan->vnigrp); 907 list_for_each_entry_safe(v, tmp, &vg->vni_list, vlist) { 908 rhashtable_remove_fast(&vg->vni_hash, &v->vnode, 909 vxlan_vni_rht_params); 910 hlist_del_init_rcu(&v->hlist4.hlist); 911 #if IS_ENABLED(CONFIG_IPV6) 912 hlist_del_init_rcu(&v->hlist6.hlist); 913 #endif 914 __vxlan_vni_del_list(vg, v); 915 vxlan_vnifilter_notify(vxlan, v, RTM_DELTUNNEL); 916 call_rcu(&v->rcu, vxlan_vni_node_rcu_free); 917 } 918 rhashtable_destroy(&vg->vni_hash); 919 kfree(vg); 920 } 921 922 int vxlan_vnigroup_init(struct vxlan_dev *vxlan) 923 { 924 struct vxlan_vni_group *vg; 925 int ret; 926 927 vg = kzalloc(sizeof(*vg), GFP_KERNEL); 928 if (!vg) 929 return -ENOMEM; 930 ret = rhashtable_init(&vg->vni_hash, &vxlan_vni_rht_params); 931 if (ret) { 932 kfree(vg); 933 return ret; 934 } 935 INIT_LIST_HEAD(&vg->vni_list); 936 rcu_assign_pointer(vxlan->vnigrp, vg); 937 938 return 0; 939 } 940 941 static int vxlan_vnifilter_process(struct sk_buff *skb, struct nlmsghdr *nlh, 942 struct netlink_ext_ack *extack) 943 { 944 struct net *net = sock_net(skb->sk); 945 struct tunnel_msg *tmsg; 946 struct vxlan_dev *vxlan; 947 struct net_device *dev; 948 struct nlattr *attr; 949 int err, vnis = 0; 950 int rem; 951 952 /* this should validate the header and check for remaining bytes */ 953 err = nlmsg_parse(nlh, sizeof(*tmsg), NULL, VXLAN_VNIFILTER_MAX, 954 vni_filter_policy, extack); 955 if (err < 0) 956 return err; 957 958 tmsg = nlmsg_data(nlh); 959 dev = __dev_get_by_index(net, tmsg->ifindex); 960 if (!dev) 961 return -ENODEV; 962 963 if (!netif_is_vxlan(dev)) { 964 NL_SET_ERR_MSG_MOD(extack, "The device is not a vxlan device"); 965 return -EINVAL; 966 } 967 968 vxlan = netdev_priv(dev); 969 970 if (!(vxlan->cfg.flags & VXLAN_F_VNIFILTER)) 971 return -EOPNOTSUPP; 972 973 nlmsg_for_each_attr(attr, nlh, sizeof(*tmsg), rem) { 974 switch (nla_type(attr)) { 975 case VXLAN_VNIFILTER_ENTRY: 976 err = vxlan_process_vni_filter(vxlan, attr, 977 nlh->nlmsg_type, extack); 978 break; 979 default: 980 continue; 981 } 982 vnis++; 983 if (err) 984 break; 985 } 986 987 if (!vnis) { 988 NL_SET_ERR_MSG_MOD(extack, "No vnis found to process"); 989 err = -EINVAL; 990 } 991 992 return err; 993 } 994 995 void vxlan_vnifilter_init(void) 996 { 997 rtnl_register_module(THIS_MODULE, PF_BRIDGE, RTM_GETTUNNEL, NULL, 998 vxlan_vnifilter_dump, 0); 999 rtnl_register_module(THIS_MODULE, PF_BRIDGE, RTM_NEWTUNNEL, 1000 vxlan_vnifilter_process, NULL, 0); 1001 rtnl_register_module(THIS_MODULE, PF_BRIDGE, RTM_DELTUNNEL, 1002 vxlan_vnifilter_process, NULL, 0); 1003 } 1004 1005 void vxlan_vnifilter_uninit(void) 1006 { 1007 rtnl_unregister(PF_BRIDGE, RTM_GETTUNNEL); 1008 rtnl_unregister(PF_BRIDGE, RTM_NEWTUNNEL); 1009 rtnl_unregister(PF_BRIDGE, RTM_DELTUNNEL); 1010 } 1011