1/* 2 * Forwarding database 3 * Linux ethernet bridge 4 * 5 * Authors: 6 * Lennert Buytenhek <buytenh@gnu.org> 7 * 8 * This program is free software; you can redistribute it and/or 9 * modify it under the terms of the GNU General Public License 10 * as published by the Free Software Foundation; either version 11 * 2 of the License, or (at your option) any later version. 12 */ 13 14#include <linux/kernel.h> 15#include <linux/init.h> 16#include <linux/rculist.h> 17#include <linux/spinlock.h> 18#include <linux/times.h> 19#include <linux/netdevice.h> 20#include <linux/etherdevice.h> 21#include <linux/jhash.h> 22#include <linux/random.h> 23#include <linux/slab.h> 24#include <linux/atomic.h> 25#include <asm/unaligned.h> 26#include <linux/if_vlan.h> 27#include <net/switchdev.h> 28#include "br_private.h" 29 30static struct kmem_cache *br_fdb_cache __read_mostly; 31static struct net_bridge_fdb_entry *fdb_find(struct hlist_head *head, 32 const unsigned char *addr, 33 __u16 vid); 34static int fdb_insert(struct net_bridge *br, struct net_bridge_port *source, 35 const unsigned char *addr, u16 vid); 36static void fdb_notify(struct net_bridge *br, 37 const struct net_bridge_fdb_entry *, int); 38 39static u32 fdb_salt __read_mostly; 40 41int __init br_fdb_init(void) 42{ 43 br_fdb_cache = kmem_cache_create("bridge_fdb_cache", 44 sizeof(struct net_bridge_fdb_entry), 45 0, 46 SLAB_HWCACHE_ALIGN, NULL); 47 if (!br_fdb_cache) 48 return -ENOMEM; 49 50 get_random_bytes(&fdb_salt, sizeof(fdb_salt)); 51 return 0; 52} 53 54void br_fdb_fini(void) 55{ 56 kmem_cache_destroy(br_fdb_cache); 57} 58 59 60/* if topology_changing then use forward_delay (default 15 sec) 61 * otherwise keep longer (default 5 minutes) 62 */ 63static inline unsigned long hold_time(const struct net_bridge *br) 64{ 65 return br->topology_change ? br->forward_delay : br->ageing_time; 66} 67 68static inline int has_expired(const struct net_bridge *br, 69 const struct net_bridge_fdb_entry *fdb) 70{ 71 return !fdb->is_static && 72 time_before_eq(fdb->updated + hold_time(br), jiffies); 73} 74 75static inline int br_mac_hash(const unsigned char *mac, __u16 vid) 76{ 77 /* use 1 byte of OUI and 3 bytes of NIC */ 78 u32 key = get_unaligned((u32 *)(mac + 2)); 79 return jhash_2words(key, vid, fdb_salt) & (BR_HASH_SIZE - 1); 80} 81 82static void fdb_rcu_free(struct rcu_head *head) 83{ 84 struct net_bridge_fdb_entry *ent 85 = container_of(head, struct net_bridge_fdb_entry, rcu); 86 kmem_cache_free(br_fdb_cache, ent); 87} 88 89/* When a static FDB entry is added, the mac address from the entry is 90 * added to the bridge private HW address list and all required ports 91 * are then updated with the new information. 92 * Called under RTNL. 93 */ 94static void fdb_add_hw_addr(struct net_bridge *br, const unsigned char *addr) 95{ 96 int err; 97 struct net_bridge_port *p; 98 99 ASSERT_RTNL(); 100 101 list_for_each_entry(p, &br->port_list, list) { 102 if (!br_promisc_port(p)) { 103 err = dev_uc_add(p->dev, addr); 104 if (err) 105 goto undo; 106 } 107 } 108 109 return; 110undo: 111 list_for_each_entry_continue_reverse(p, &br->port_list, list) { 112 if (!br_promisc_port(p)) 113 dev_uc_del(p->dev, addr); 114 } 115} 116 117/* When a static FDB entry is deleted, the HW address from that entry is 118 * also removed from the bridge private HW address list and updates all 119 * the ports with needed information. 120 * Called under RTNL. 121 */ 122static void fdb_del_hw_addr(struct net_bridge *br, const unsigned char *addr) 123{ 124 struct net_bridge_port *p; 125 126 ASSERT_RTNL(); 127 128 list_for_each_entry(p, &br->port_list, list) { 129 if (!br_promisc_port(p)) 130 dev_uc_del(p->dev, addr); 131 } 132} 133 134static void fdb_del_external_learn(struct net_bridge_fdb_entry *f) 135{ 136 struct switchdev_obj_port_fdb fdb = { 137 .obj = { 138 .id = SWITCHDEV_OBJ_ID_PORT_FDB, 139 .flags = SWITCHDEV_F_DEFER, 140 }, 141 .vid = f->vlan_id, 142 }; 143 144 ether_addr_copy(fdb.addr, f->addr.addr); 145 switchdev_port_obj_del(f->dst->dev, &fdb.obj); 146} 147 148static void fdb_delete(struct net_bridge *br, struct net_bridge_fdb_entry *f) 149{ 150 if (f->is_static) 151 fdb_del_hw_addr(br, f->addr.addr); 152 153 if (f->added_by_external_learn) 154 fdb_del_external_learn(f); 155 156 hlist_del_rcu(&f->hlist); 157 fdb_notify(br, f, RTM_DELNEIGH); 158 call_rcu(&f->rcu, fdb_rcu_free); 159} 160 161/* Delete a local entry if no other port had the same address. */ 162static void fdb_delete_local(struct net_bridge *br, 163 const struct net_bridge_port *p, 164 struct net_bridge_fdb_entry *f) 165{ 166 const unsigned char *addr = f->addr.addr; 167 struct net_bridge_vlan_group *vg; 168 const struct net_bridge_vlan *v; 169 struct net_bridge_port *op; 170 u16 vid = f->vlan_id; 171 172 /* Maybe another port has same hw addr? */ 173 list_for_each_entry(op, &br->port_list, list) { 174 vg = nbp_vlan_group(op); 175 if (op != p && ether_addr_equal(op->dev->dev_addr, addr) && 176 (!vid || br_vlan_find(vg, vid))) { 177 f->dst = op; 178 f->added_by_user = 0; 179 return; 180 } 181 } 182 183 vg = br_vlan_group(br); 184 v = br_vlan_find(vg, vid); 185 /* Maybe bridge device has same hw addr? */ 186 if (p && ether_addr_equal(br->dev->dev_addr, addr) && 187 (!vid || (v && br_vlan_should_use(v)))) { 188 f->dst = NULL; 189 f->added_by_user = 0; 190 return; 191 } 192 193 fdb_delete(br, f); 194} 195 196void br_fdb_find_delete_local(struct net_bridge *br, 197 const struct net_bridge_port *p, 198 const unsigned char *addr, u16 vid) 199{ 200 struct hlist_head *head = &br->hash[br_mac_hash(addr, vid)]; 201 struct net_bridge_fdb_entry *f; 202 203 spin_lock_bh(&br->hash_lock); 204 f = fdb_find(head, addr, vid); 205 if (f && f->is_local && !f->added_by_user && f->dst == p) 206 fdb_delete_local(br, p, f); 207 spin_unlock_bh(&br->hash_lock); 208} 209 210void br_fdb_changeaddr(struct net_bridge_port *p, const unsigned char *newaddr) 211{ 212 struct net_bridge_vlan_group *vg; 213 struct net_bridge *br = p->br; 214 struct net_bridge_vlan *v; 215 int i; 216 217 spin_lock_bh(&br->hash_lock); 218 219 vg = nbp_vlan_group(p); 220 /* Search all chains since old address/hash is unknown */ 221 for (i = 0; i < BR_HASH_SIZE; i++) { 222 struct hlist_node *h; 223 hlist_for_each(h, &br->hash[i]) { 224 struct net_bridge_fdb_entry *f; 225 226 f = hlist_entry(h, struct net_bridge_fdb_entry, hlist); 227 if (f->dst == p && f->is_local && !f->added_by_user) { 228 /* delete old one */ 229 fdb_delete_local(br, p, f); 230 231 /* if this port has no vlan information 232 * configured, we can safely be done at 233 * this point. 234 */ 235 if (!vg || !vg->num_vlans) 236 goto insert; 237 } 238 } 239 } 240 241insert: 242 /* insert new address, may fail if invalid address or dup. */ 243 fdb_insert(br, p, newaddr, 0); 244 245 if (!vg || !vg->num_vlans) 246 goto done; 247 248 /* Now add entries for every VLAN configured on the port. 249 * This function runs under RTNL so the bitmap will not change 250 * from under us. 251 */ 252 list_for_each_entry(v, &vg->vlan_list, vlist) 253 fdb_insert(br, p, newaddr, v->vid); 254 255done: 256 spin_unlock_bh(&br->hash_lock); 257} 258 259void br_fdb_change_mac_address(struct net_bridge *br, const u8 *newaddr) 260{ 261 struct net_bridge_vlan_group *vg; 262 struct net_bridge_fdb_entry *f; 263 struct net_bridge_vlan *v; 264 265 spin_lock_bh(&br->hash_lock); 266 267 /* If old entry was unassociated with any port, then delete it. */ 268 f = __br_fdb_get(br, br->dev->dev_addr, 0); 269 if (f && f->is_local && !f->dst) 270 fdb_delete_local(br, NULL, f); 271 272 fdb_insert(br, NULL, newaddr, 0); 273 vg = br_vlan_group(br); 274 if (!vg || !vg->num_vlans) 275 goto out; 276 /* Now remove and add entries for every VLAN configured on the 277 * bridge. This function runs under RTNL so the bitmap will not 278 * change from under us. 279 */ 280 list_for_each_entry(v, &vg->vlan_list, vlist) { 281 if (!br_vlan_should_use(v)) 282 continue; 283 f = __br_fdb_get(br, br->dev->dev_addr, v->vid); 284 if (f && f->is_local && !f->dst) 285 fdb_delete_local(br, NULL, f); 286 fdb_insert(br, NULL, newaddr, v->vid); 287 } 288out: 289 spin_unlock_bh(&br->hash_lock); 290} 291 292void br_fdb_cleanup(unsigned long _data) 293{ 294 struct net_bridge *br = (struct net_bridge *)_data; 295 unsigned long delay = hold_time(br); 296 unsigned long next_timer = jiffies + br->ageing_time; 297 int i; 298 299 spin_lock(&br->hash_lock); 300 for (i = 0; i < BR_HASH_SIZE; i++) { 301 struct net_bridge_fdb_entry *f; 302 struct hlist_node *n; 303 304 hlist_for_each_entry_safe(f, n, &br->hash[i], hlist) { 305 unsigned long this_timer; 306 if (f->is_static) 307 continue; 308 if (f->added_by_external_learn) 309 continue; 310 this_timer = f->updated + delay; 311 if (time_before_eq(this_timer, jiffies)) 312 fdb_delete(br, f); 313 else if (time_before(this_timer, next_timer)) 314 next_timer = this_timer; 315 } 316 } 317 spin_unlock(&br->hash_lock); 318 319 mod_timer(&br->gc_timer, round_jiffies_up(next_timer)); 320} 321 322/* Completely flush all dynamic entries in forwarding database.*/ 323void br_fdb_flush(struct net_bridge *br) 324{ 325 int i; 326 327 spin_lock_bh(&br->hash_lock); 328 for (i = 0; i < BR_HASH_SIZE; i++) { 329 struct net_bridge_fdb_entry *f; 330 struct hlist_node *n; 331 hlist_for_each_entry_safe(f, n, &br->hash[i], hlist) { 332 if (!f->is_static) 333 fdb_delete(br, f); 334 } 335 } 336 spin_unlock_bh(&br->hash_lock); 337} 338 339/* Flush all entries referring to a specific port. 340 * if do_all is set also flush static entries 341 * if vid is set delete all entries that match the vlan_id 342 */ 343void br_fdb_delete_by_port(struct net_bridge *br, 344 const struct net_bridge_port *p, 345 u16 vid, 346 int do_all) 347{ 348 int i; 349 350 spin_lock_bh(&br->hash_lock); 351 for (i = 0; i < BR_HASH_SIZE; i++) { 352 struct hlist_node *h, *g; 353 354 hlist_for_each_safe(h, g, &br->hash[i]) { 355 struct net_bridge_fdb_entry *f 356 = hlist_entry(h, struct net_bridge_fdb_entry, hlist); 357 if (f->dst != p) 358 continue; 359 360 if (!do_all) 361 if (f->is_static || (vid && f->vlan_id != vid)) 362 continue; 363 364 if (f->is_local) 365 fdb_delete_local(br, p, f); 366 else 367 fdb_delete(br, f); 368 } 369 } 370 spin_unlock_bh(&br->hash_lock); 371} 372 373/* No locking or refcounting, assumes caller has rcu_read_lock */ 374struct net_bridge_fdb_entry *__br_fdb_get(struct net_bridge *br, 375 const unsigned char *addr, 376 __u16 vid) 377{ 378 struct net_bridge_fdb_entry *fdb; 379 380 hlist_for_each_entry_rcu(fdb, 381 &br->hash[br_mac_hash(addr, vid)], hlist) { 382 if (ether_addr_equal(fdb->addr.addr, addr) && 383 fdb->vlan_id == vid) { 384 if (unlikely(has_expired(br, fdb))) 385 break; 386 return fdb; 387 } 388 } 389 390 return NULL; 391} 392 393#if IS_ENABLED(CONFIG_ATM_LANE) 394/* Interface used by ATM LANE hook to test 395 * if an addr is on some other bridge port */ 396int br_fdb_test_addr(struct net_device *dev, unsigned char *addr) 397{ 398 struct net_bridge_fdb_entry *fdb; 399 struct net_bridge_port *port; 400 int ret; 401 402 rcu_read_lock(); 403 port = br_port_get_rcu(dev); 404 if (!port) 405 ret = 0; 406 else { 407 fdb = __br_fdb_get(port->br, addr, 0); 408 ret = fdb && fdb->dst && fdb->dst->dev != dev && 409 fdb->dst->state == BR_STATE_FORWARDING; 410 } 411 rcu_read_unlock(); 412 413 return ret; 414} 415#endif /* CONFIG_ATM_LANE */ 416 417/* 418 * Fill buffer with forwarding table records in 419 * the API format. 420 */ 421int br_fdb_fillbuf(struct net_bridge *br, void *buf, 422 unsigned long maxnum, unsigned long skip) 423{ 424 struct __fdb_entry *fe = buf; 425 int i, num = 0; 426 struct net_bridge_fdb_entry *f; 427 428 memset(buf, 0, maxnum*sizeof(struct __fdb_entry)); 429 430 rcu_read_lock(); 431 for (i = 0; i < BR_HASH_SIZE; i++) { 432 hlist_for_each_entry_rcu(f, &br->hash[i], hlist) { 433 if (num >= maxnum) 434 goto out; 435 436 if (has_expired(br, f)) 437 continue; 438 439 /* ignore pseudo entry for local MAC address */ 440 if (!f->dst) 441 continue; 442 443 if (skip) { 444 --skip; 445 continue; 446 } 447 448 /* convert from internal format to API */ 449 memcpy(fe->mac_addr, f->addr.addr, ETH_ALEN); 450 451 /* due to ABI compat need to split into hi/lo */ 452 fe->port_no = f->dst->port_no; 453 fe->port_hi = f->dst->port_no >> 8; 454 455 fe->is_local = f->is_local; 456 if (!f->is_static) 457 fe->ageing_timer_value = jiffies_delta_to_clock_t(jiffies - f->updated); 458 ++fe; 459 ++num; 460 } 461 } 462 463 out: 464 rcu_read_unlock(); 465 466 return num; 467} 468 469static struct net_bridge_fdb_entry *fdb_find(struct hlist_head *head, 470 const unsigned char *addr, 471 __u16 vid) 472{ 473 struct net_bridge_fdb_entry *fdb; 474 475 hlist_for_each_entry(fdb, head, hlist) { 476 if (ether_addr_equal(fdb->addr.addr, addr) && 477 fdb->vlan_id == vid) 478 return fdb; 479 } 480 return NULL; 481} 482 483static struct net_bridge_fdb_entry *fdb_find_rcu(struct hlist_head *head, 484 const unsigned char *addr, 485 __u16 vid) 486{ 487 struct net_bridge_fdb_entry *fdb; 488 489 hlist_for_each_entry_rcu(fdb, head, hlist) { 490 if (ether_addr_equal(fdb->addr.addr, addr) && 491 fdb->vlan_id == vid) 492 return fdb; 493 } 494 return NULL; 495} 496 497static struct net_bridge_fdb_entry *fdb_create(struct hlist_head *head, 498 struct net_bridge_port *source, 499 const unsigned char *addr, 500 __u16 vid, 501 unsigned char is_local, 502 unsigned char is_static) 503{ 504 struct net_bridge_fdb_entry *fdb; 505 506 fdb = kmem_cache_alloc(br_fdb_cache, GFP_ATOMIC); 507 if (fdb) { 508 memcpy(fdb->addr.addr, addr, ETH_ALEN); 509 fdb->dst = source; 510 fdb->vlan_id = vid; 511 fdb->is_local = is_local; 512 fdb->is_static = is_static; 513 fdb->added_by_user = 0; 514 fdb->added_by_external_learn = 0; 515 fdb->updated = fdb->used = jiffies; 516 hlist_add_head_rcu(&fdb->hlist, head); 517 } 518 return fdb; 519} 520 521static int fdb_insert(struct net_bridge *br, struct net_bridge_port *source, 522 const unsigned char *addr, u16 vid) 523{ 524 struct hlist_head *head = &br->hash[br_mac_hash(addr, vid)]; 525 struct net_bridge_fdb_entry *fdb; 526 527 if (!is_valid_ether_addr(addr)) 528 return -EINVAL; 529 530 fdb = fdb_find(head, addr, vid); 531 if (fdb) { 532 /* it is okay to have multiple ports with same 533 * address, just use the first one. 534 */ 535 if (fdb->is_local) 536 return 0; 537 br_warn(br, "adding interface %s with same address " 538 "as a received packet\n", 539 source ? source->dev->name : br->dev->name); 540 fdb_delete(br, fdb); 541 } 542 543 fdb = fdb_create(head, source, addr, vid, 1, 1); 544 if (!fdb) 545 return -ENOMEM; 546 547 fdb_add_hw_addr(br, addr); 548 fdb_notify(br, fdb, RTM_NEWNEIGH); 549 return 0; 550} 551 552/* Add entry for local address of interface */ 553int br_fdb_insert(struct net_bridge *br, struct net_bridge_port *source, 554 const unsigned char *addr, u16 vid) 555{ 556 int ret; 557 558 spin_lock_bh(&br->hash_lock); 559 ret = fdb_insert(br, source, addr, vid); 560 spin_unlock_bh(&br->hash_lock); 561 return ret; 562} 563 564void br_fdb_update(struct net_bridge *br, struct net_bridge_port *source, 565 const unsigned char *addr, u16 vid, bool added_by_user) 566{ 567 struct hlist_head *head = &br->hash[br_mac_hash(addr, vid)]; 568 struct net_bridge_fdb_entry *fdb; 569 bool fdb_modified = false; 570 571 /* some users want to always flood. */ 572 if (hold_time(br) == 0) 573 return; 574 575 /* ignore packets unless we are using this port */ 576 if (!(source->state == BR_STATE_LEARNING || 577 source->state == BR_STATE_FORWARDING)) 578 return; 579 580 fdb = fdb_find_rcu(head, addr, vid); 581 if (likely(fdb)) { 582 /* attempt to update an entry for a local interface */ 583 if (unlikely(fdb->is_local)) { 584 if (net_ratelimit()) 585 br_warn(br, "received packet on %s with " 586 "own address as source address\n", 587 source->dev->name); 588 } else { 589 /* fastpath: update of existing entry */ 590 if (unlikely(source != fdb->dst)) { 591 fdb->dst = source; 592 fdb_modified = true; 593 } 594 fdb->updated = jiffies; 595 if (unlikely(added_by_user)) 596 fdb->added_by_user = 1; 597 if (unlikely(fdb_modified)) 598 fdb_notify(br, fdb, RTM_NEWNEIGH); 599 } 600 } else { 601 spin_lock(&br->hash_lock); 602 if (likely(!fdb_find(head, addr, vid))) { 603 fdb = fdb_create(head, source, addr, vid, 0, 0); 604 if (fdb) { 605 if (unlikely(added_by_user)) 606 fdb->added_by_user = 1; 607 fdb_notify(br, fdb, RTM_NEWNEIGH); 608 } 609 } 610 /* else we lose race and someone else inserts 611 * it first, don't bother updating 612 */ 613 spin_unlock(&br->hash_lock); 614 } 615} 616 617static int fdb_to_nud(const struct net_bridge *br, 618 const struct net_bridge_fdb_entry *fdb) 619{ 620 if (fdb->is_local) 621 return NUD_PERMANENT; 622 else if (fdb->is_static) 623 return NUD_NOARP; 624 else if (has_expired(br, fdb)) 625 return NUD_STALE; 626 else 627 return NUD_REACHABLE; 628} 629 630static int fdb_fill_info(struct sk_buff *skb, const struct net_bridge *br, 631 const struct net_bridge_fdb_entry *fdb, 632 u32 portid, u32 seq, int type, unsigned int flags) 633{ 634 unsigned long now = jiffies; 635 struct nda_cacheinfo ci; 636 struct nlmsghdr *nlh; 637 struct ndmsg *ndm; 638 639 nlh = nlmsg_put(skb, portid, seq, type, sizeof(*ndm), flags); 640 if (nlh == NULL) 641 return -EMSGSIZE; 642 643 ndm = nlmsg_data(nlh); 644 ndm->ndm_family = AF_BRIDGE; 645 ndm->ndm_pad1 = 0; 646 ndm->ndm_pad2 = 0; 647 ndm->ndm_flags = fdb->added_by_external_learn ? NTF_EXT_LEARNED : 0; 648 ndm->ndm_type = 0; 649 ndm->ndm_ifindex = fdb->dst ? fdb->dst->dev->ifindex : br->dev->ifindex; 650 ndm->ndm_state = fdb_to_nud(br, fdb); 651 652 if (nla_put(skb, NDA_LLADDR, ETH_ALEN, &fdb->addr)) 653 goto nla_put_failure; 654 if (nla_put_u32(skb, NDA_MASTER, br->dev->ifindex)) 655 goto nla_put_failure; 656 ci.ndm_used = jiffies_to_clock_t(now - fdb->used); 657 ci.ndm_confirmed = 0; 658 ci.ndm_updated = jiffies_to_clock_t(now - fdb->updated); 659 ci.ndm_refcnt = 0; 660 if (nla_put(skb, NDA_CACHEINFO, sizeof(ci), &ci)) 661 goto nla_put_failure; 662 663 if (fdb->vlan_id && nla_put(skb, NDA_VLAN, sizeof(u16), &fdb->vlan_id)) 664 goto nla_put_failure; 665 666 nlmsg_end(skb, nlh); 667 return 0; 668 669nla_put_failure: 670 nlmsg_cancel(skb, nlh); 671 return -EMSGSIZE; 672} 673 674static inline size_t fdb_nlmsg_size(void) 675{ 676 return NLMSG_ALIGN(sizeof(struct ndmsg)) 677 + nla_total_size(ETH_ALEN) /* NDA_LLADDR */ 678 + nla_total_size(sizeof(u32)) /* NDA_MASTER */ 679 + nla_total_size(sizeof(u16)) /* NDA_VLAN */ 680 + nla_total_size(sizeof(struct nda_cacheinfo)); 681} 682 683static void fdb_notify(struct net_bridge *br, 684 const struct net_bridge_fdb_entry *fdb, int type) 685{ 686 struct net *net = dev_net(br->dev); 687 struct sk_buff *skb; 688 int err = -ENOBUFS; 689 690 skb = nlmsg_new(fdb_nlmsg_size(), GFP_ATOMIC); 691 if (skb == NULL) 692 goto errout; 693 694 err = fdb_fill_info(skb, br, fdb, 0, 0, type, 0); 695 if (err < 0) { 696 /* -EMSGSIZE implies BUG in fdb_nlmsg_size() */ 697 WARN_ON(err == -EMSGSIZE); 698 kfree_skb(skb); 699 goto errout; 700 } 701 rtnl_notify(skb, net, 0, RTNLGRP_NEIGH, NULL, GFP_ATOMIC); 702 return; 703errout: 704 rtnl_set_sk_err(net, RTNLGRP_NEIGH, err); 705} 706 707/* Dump information about entries, in response to GETNEIGH */ 708int br_fdb_dump(struct sk_buff *skb, 709 struct netlink_callback *cb, 710 struct net_device *dev, 711 struct net_device *filter_dev, 712 int idx) 713{ 714 struct net_bridge *br = netdev_priv(dev); 715 int i; 716 717 if (!(dev->priv_flags & IFF_EBRIDGE)) 718 goto out; 719 720 if (!filter_dev) 721 idx = ndo_dflt_fdb_dump(skb, cb, dev, NULL, idx); 722 723 for (i = 0; i < BR_HASH_SIZE; i++) { 724 struct net_bridge_fdb_entry *f; 725 726 hlist_for_each_entry_rcu(f, &br->hash[i], hlist) { 727 if (idx < cb->args[0]) 728 goto skip; 729 730 if (filter_dev && 731 (!f->dst || f->dst->dev != filter_dev)) { 732 if (filter_dev != dev) 733 goto skip; 734 /* !f->dst is a special case for bridge 735 * It means the MAC belongs to the bridge 736 * Therefore need a little more filtering 737 * we only want to dump the !f->dst case 738 */ 739 if (f->dst) 740 goto skip; 741 } 742 if (!filter_dev && f->dst) 743 goto skip; 744 745 if (fdb_fill_info(skb, br, f, 746 NETLINK_CB(cb->skb).portid, 747 cb->nlh->nlmsg_seq, 748 RTM_NEWNEIGH, 749 NLM_F_MULTI) < 0) 750 break; 751skip: 752 ++idx; 753 } 754 } 755 756out: 757 return idx; 758} 759 760/* Update (create or replace) forwarding database entry */ 761static int fdb_add_entry(struct net_bridge_port *source, const __u8 *addr, 762 __u16 state, __u16 flags, __u16 vid) 763{ 764 struct net_bridge *br = source->br; 765 struct hlist_head *head = &br->hash[br_mac_hash(addr, vid)]; 766 struct net_bridge_fdb_entry *fdb; 767 bool modified = false; 768 769 /* If the port cannot learn allow only local and static entries */ 770 if (!(state & NUD_PERMANENT) && !(state & NUD_NOARP) && 771 !(source->state == BR_STATE_LEARNING || 772 source->state == BR_STATE_FORWARDING)) 773 return -EPERM; 774 775 fdb = fdb_find(head, addr, vid); 776 if (fdb == NULL) { 777 if (!(flags & NLM_F_CREATE)) 778 return -ENOENT; 779 780 fdb = fdb_create(head, source, addr, vid, 0, 0); 781 if (!fdb) 782 return -ENOMEM; 783 784 modified = true; 785 } else { 786 if (flags & NLM_F_EXCL) 787 return -EEXIST; 788 789 if (fdb->dst != source) { 790 fdb->dst = source; 791 modified = true; 792 } 793 } 794 795 if (fdb_to_nud(br, fdb) != state) { 796 if (state & NUD_PERMANENT) { 797 fdb->is_local = 1; 798 if (!fdb->is_static) { 799 fdb->is_static = 1; 800 fdb_add_hw_addr(br, addr); 801 } 802 } else if (state & NUD_NOARP) { 803 fdb->is_local = 0; 804 if (!fdb->is_static) { 805 fdb->is_static = 1; 806 fdb_add_hw_addr(br, addr); 807 } 808 } else { 809 fdb->is_local = 0; 810 if (fdb->is_static) { 811 fdb->is_static = 0; 812 fdb_del_hw_addr(br, addr); 813 } 814 } 815 816 modified = true; 817 } 818 fdb->added_by_user = 1; 819 820 fdb->used = jiffies; 821 if (modified) { 822 fdb->updated = jiffies; 823 fdb_notify(br, fdb, RTM_NEWNEIGH); 824 } 825 826 return 0; 827} 828 829static int __br_fdb_add(struct ndmsg *ndm, struct net_bridge_port *p, 830 const unsigned char *addr, u16 nlh_flags, u16 vid) 831{ 832 int err = 0; 833 834 if (ndm->ndm_flags & NTF_USE) { 835 local_bh_disable(); 836 rcu_read_lock(); 837 br_fdb_update(p->br, p, addr, vid, true); 838 rcu_read_unlock(); 839 local_bh_enable(); 840 } else { 841 spin_lock_bh(&p->br->hash_lock); 842 err = fdb_add_entry(p, addr, ndm->ndm_state, 843 nlh_flags, vid); 844 spin_unlock_bh(&p->br->hash_lock); 845 } 846 847 return err; 848} 849 850/* Add new permanent fdb entry with RTM_NEWNEIGH */ 851int br_fdb_add(struct ndmsg *ndm, struct nlattr *tb[], 852 struct net_device *dev, 853 const unsigned char *addr, u16 vid, u16 nlh_flags) 854{ 855 struct net_bridge_vlan_group *vg; 856 struct net_bridge_port *p = NULL; 857 struct net_bridge_vlan *v; 858 struct net_bridge *br = NULL; 859 int err = 0; 860 861 if (!(ndm->ndm_state & (NUD_PERMANENT|NUD_NOARP|NUD_REACHABLE))) { 862 pr_info("bridge: RTM_NEWNEIGH with invalid state %#x\n", ndm->ndm_state); 863 return -EINVAL; 864 } 865 866 if (is_zero_ether_addr(addr)) { 867 pr_info("bridge: RTM_NEWNEIGH with invalid ether address\n"); 868 return -EINVAL; 869 } 870 871 if (dev->priv_flags & IFF_EBRIDGE) { 872 br = netdev_priv(dev); 873 vg = br_vlan_group(br); 874 } else { 875 p = br_port_get_rtnl(dev); 876 if (!p) { 877 pr_info("bridge: RTM_NEWNEIGH %s not a bridge port\n", 878 dev->name); 879 return -EINVAL; 880 } 881 vg = nbp_vlan_group(p); 882 } 883 884 if (vid) { 885 v = br_vlan_find(vg, vid); 886 if (!v || !br_vlan_should_use(v)) { 887 pr_info("bridge: RTM_NEWNEIGH with unconfigured vlan %d on %s\n", vid, dev->name); 888 return -EINVAL; 889 } 890 891 /* VID was specified, so use it. */ 892 if (dev->priv_flags & IFF_EBRIDGE) 893 err = br_fdb_insert(br, NULL, addr, vid); 894 else 895 err = __br_fdb_add(ndm, p, addr, nlh_flags, vid); 896 } else { 897 if (dev->priv_flags & IFF_EBRIDGE) 898 err = br_fdb_insert(br, NULL, addr, 0); 899 else 900 err = __br_fdb_add(ndm, p, addr, nlh_flags, 0); 901 if (err || !vg || !vg->num_vlans) 902 goto out; 903 904 /* We have vlans configured on this port and user didn't 905 * specify a VLAN. To be nice, add/update entry for every 906 * vlan on this port. 907 */ 908 list_for_each_entry(v, &vg->vlan_list, vlist) { 909 if (!br_vlan_should_use(v)) 910 continue; 911 if (dev->priv_flags & IFF_EBRIDGE) 912 err = br_fdb_insert(br, NULL, addr, v->vid); 913 else 914 err = __br_fdb_add(ndm, p, addr, nlh_flags, 915 v->vid); 916 if (err) 917 goto out; 918 } 919 } 920 921out: 922 return err; 923} 924 925static int fdb_delete_by_addr(struct net_bridge *br, const u8 *addr, 926 u16 vid) 927{ 928 struct hlist_head *head = &br->hash[br_mac_hash(addr, vid)]; 929 struct net_bridge_fdb_entry *fdb; 930 931 fdb = fdb_find(head, addr, vid); 932 if (!fdb) 933 return -ENOENT; 934 935 fdb_delete(br, fdb); 936 return 0; 937} 938 939static int __br_fdb_delete_by_addr(struct net_bridge *br, 940 const unsigned char *addr, u16 vid) 941{ 942 int err; 943 944 spin_lock_bh(&br->hash_lock); 945 err = fdb_delete_by_addr(br, addr, vid); 946 spin_unlock_bh(&br->hash_lock); 947 948 return err; 949} 950 951static int fdb_delete_by_addr_and_port(struct net_bridge_port *p, 952 const u8 *addr, u16 vlan) 953{ 954 struct net_bridge *br = p->br; 955 struct hlist_head *head = &br->hash[br_mac_hash(addr, vlan)]; 956 struct net_bridge_fdb_entry *fdb; 957 958 fdb = fdb_find(head, addr, vlan); 959 if (!fdb || fdb->dst != p) 960 return -ENOENT; 961 962 fdb_delete(br, fdb); 963 return 0; 964} 965 966static int __br_fdb_delete(struct net_bridge_port *p, 967 const unsigned char *addr, u16 vid) 968{ 969 int err; 970 971 spin_lock_bh(&p->br->hash_lock); 972 err = fdb_delete_by_addr_and_port(p, addr, vid); 973 spin_unlock_bh(&p->br->hash_lock); 974 975 return err; 976} 977 978/* Remove neighbor entry with RTM_DELNEIGH */ 979int br_fdb_delete(struct ndmsg *ndm, struct nlattr *tb[], 980 struct net_device *dev, 981 const unsigned char *addr, u16 vid) 982{ 983 struct net_bridge_vlan_group *vg; 984 struct net_bridge_port *p = NULL; 985 struct net_bridge_vlan *v; 986 struct net_bridge *br = NULL; 987 int err; 988 989 if (dev->priv_flags & IFF_EBRIDGE) { 990 br = netdev_priv(dev); 991 vg = br_vlan_group(br); 992 } else { 993 p = br_port_get_rtnl(dev); 994 if (!p) { 995 pr_info("bridge: RTM_DELNEIGH %s not a bridge port\n", 996 dev->name); 997 return -EINVAL; 998 } 999 vg = nbp_vlan_group(p); 1000 } 1001 1002 if (vid) { 1003 v = br_vlan_find(vg, vid); 1004 if (!v) { 1005 pr_info("bridge: RTM_DELNEIGH with unconfigured vlan %d on %s\n", vid, dev->name); 1006 return -EINVAL; 1007 } 1008 1009 if (dev->priv_flags & IFF_EBRIDGE) 1010 err = __br_fdb_delete_by_addr(br, addr, vid); 1011 else 1012 err = __br_fdb_delete(p, addr, vid); 1013 } else { 1014 err = -ENOENT; 1015 if (dev->priv_flags & IFF_EBRIDGE) 1016 err = __br_fdb_delete_by_addr(br, addr, 0); 1017 else 1018 err &= __br_fdb_delete(p, addr, 0); 1019 1020 if (!vg || !vg->num_vlans) 1021 goto out; 1022 1023 list_for_each_entry(v, &vg->vlan_list, vlist) { 1024 if (!br_vlan_should_use(v)) 1025 continue; 1026 if (dev->priv_flags & IFF_EBRIDGE) 1027 err = __br_fdb_delete_by_addr(br, addr, v->vid); 1028 else 1029 err &= __br_fdb_delete(p, addr, v->vid); 1030 } 1031 } 1032out: 1033 return err; 1034} 1035 1036int br_fdb_sync_static(struct net_bridge *br, struct net_bridge_port *p) 1037{ 1038 struct net_bridge_fdb_entry *fdb, *tmp; 1039 int i; 1040 int err; 1041 1042 ASSERT_RTNL(); 1043 1044 for (i = 0; i < BR_HASH_SIZE; i++) { 1045 hlist_for_each_entry(fdb, &br->hash[i], hlist) { 1046 /* We only care for static entries */ 1047 if (!fdb->is_static) 1048 continue; 1049 1050 err = dev_uc_add(p->dev, fdb->addr.addr); 1051 if (err) 1052 goto rollback; 1053 } 1054 } 1055 return 0; 1056 1057rollback: 1058 for (i = 0; i < BR_HASH_SIZE; i++) { 1059 hlist_for_each_entry(tmp, &br->hash[i], hlist) { 1060 /* If we reached the fdb that failed, we can stop */ 1061 if (tmp == fdb) 1062 break; 1063 1064 /* We only care for static entries */ 1065 if (!tmp->is_static) 1066 continue; 1067 1068 dev_uc_del(p->dev, tmp->addr.addr); 1069 } 1070 } 1071 return err; 1072} 1073 1074void br_fdb_unsync_static(struct net_bridge *br, struct net_bridge_port *p) 1075{ 1076 struct net_bridge_fdb_entry *fdb; 1077 int i; 1078 1079 ASSERT_RTNL(); 1080 1081 for (i = 0; i < BR_HASH_SIZE; i++) { 1082 hlist_for_each_entry_rcu(fdb, &br->hash[i], hlist) { 1083 /* We only care for static entries */ 1084 if (!fdb->is_static) 1085 continue; 1086 1087 dev_uc_del(p->dev, fdb->addr.addr); 1088 } 1089 } 1090} 1091 1092int br_fdb_external_learn_add(struct net_bridge *br, struct net_bridge_port *p, 1093 const unsigned char *addr, u16 vid) 1094{ 1095 struct hlist_head *head; 1096 struct net_bridge_fdb_entry *fdb; 1097 int err = 0; 1098 1099 ASSERT_RTNL(); 1100 spin_lock_bh(&br->hash_lock); 1101 1102 head = &br->hash[br_mac_hash(addr, vid)]; 1103 fdb = fdb_find(head, addr, vid); 1104 if (!fdb) { 1105 fdb = fdb_create(head, p, addr, vid, 0, 0); 1106 if (!fdb) { 1107 err = -ENOMEM; 1108 goto err_unlock; 1109 } 1110 fdb->added_by_external_learn = 1; 1111 fdb_notify(br, fdb, RTM_NEWNEIGH); 1112 } else if (fdb->added_by_external_learn) { 1113 /* Refresh entry */ 1114 fdb->updated = fdb->used = jiffies; 1115 } else if (!fdb->added_by_user) { 1116 /* Take over SW learned entry */ 1117 fdb->added_by_external_learn = 1; 1118 fdb->updated = jiffies; 1119 fdb_notify(br, fdb, RTM_NEWNEIGH); 1120 } 1121 1122err_unlock: 1123 spin_unlock_bh(&br->hash_lock); 1124 1125 return err; 1126} 1127 1128int br_fdb_external_learn_del(struct net_bridge *br, struct net_bridge_port *p, 1129 const unsigned char *addr, u16 vid) 1130{ 1131 struct hlist_head *head; 1132 struct net_bridge_fdb_entry *fdb; 1133 int err = 0; 1134 1135 ASSERT_RTNL(); 1136 spin_lock_bh(&br->hash_lock); 1137 1138 head = &br->hash[br_mac_hash(addr, vid)]; 1139 fdb = fdb_find(head, addr, vid); 1140 if (fdb && fdb->added_by_external_learn) 1141 fdb_delete(br, fdb); 1142 else 1143 err = -ENOENT; 1144 1145 spin_unlock_bh(&br->hash_lock); 1146 1147 return err; 1148} 1149