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 "br_private.h" 27 28 static struct kmem_cache *br_fdb_cache __read_mostly; 29 static int fdb_insert(struct net_bridge *br, struct net_bridge_port *source, 30 const unsigned char *addr); 31 static void fdb_notify(struct net_bridge *br, 32 const struct net_bridge_fdb_entry *, int); 33 34 static u32 fdb_salt __read_mostly; 35 36 int __init br_fdb_init(void) 37 { 38 br_fdb_cache = kmem_cache_create("bridge_fdb_cache", 39 sizeof(struct net_bridge_fdb_entry), 40 0, 41 SLAB_HWCACHE_ALIGN, NULL); 42 if (!br_fdb_cache) 43 return -ENOMEM; 44 45 get_random_bytes(&fdb_salt, sizeof(fdb_salt)); 46 return 0; 47 } 48 49 void br_fdb_fini(void) 50 { 51 kmem_cache_destroy(br_fdb_cache); 52 } 53 54 55 /* if topology_changing then use forward_delay (default 15 sec) 56 * otherwise keep longer (default 5 minutes) 57 */ 58 static inline unsigned long hold_time(const struct net_bridge *br) 59 { 60 return br->topology_change ? br->forward_delay : br->ageing_time; 61 } 62 63 static inline int has_expired(const struct net_bridge *br, 64 const struct net_bridge_fdb_entry *fdb) 65 { 66 return !fdb->is_static && 67 time_before_eq(fdb->updated + hold_time(br), jiffies); 68 } 69 70 static inline int br_mac_hash(const unsigned char *mac) 71 { 72 /* use 1 byte of OUI cnd 3 bytes of NIC */ 73 u32 key = get_unaligned((u32 *)(mac + 2)); 74 return jhash_1word(key, fdb_salt) & (BR_HASH_SIZE - 1); 75 } 76 77 static void fdb_rcu_free(struct rcu_head *head) 78 { 79 struct net_bridge_fdb_entry *ent 80 = container_of(head, struct net_bridge_fdb_entry, rcu); 81 kmem_cache_free(br_fdb_cache, ent); 82 } 83 84 static void fdb_delete(struct net_bridge *br, struct net_bridge_fdb_entry *f) 85 { 86 hlist_del_rcu(&f->hlist); 87 fdb_notify(br, f, RTM_DELNEIGH); 88 call_rcu(&f->rcu, fdb_rcu_free); 89 } 90 91 void br_fdb_changeaddr(struct net_bridge_port *p, const unsigned char *newaddr) 92 { 93 struct net_bridge *br = p->br; 94 int i; 95 96 spin_lock_bh(&br->hash_lock); 97 98 /* Search all chains since old address/hash is unknown */ 99 for (i = 0; i < BR_HASH_SIZE; i++) { 100 struct hlist_node *h; 101 hlist_for_each(h, &br->hash[i]) { 102 struct net_bridge_fdb_entry *f; 103 104 f = hlist_entry(h, struct net_bridge_fdb_entry, hlist); 105 if (f->dst == p && f->is_local) { 106 /* maybe another port has same hw addr? */ 107 struct net_bridge_port *op; 108 list_for_each_entry(op, &br->port_list, list) { 109 if (op != p && 110 ether_addr_equal(op->dev->dev_addr, 111 f->addr.addr)) { 112 f->dst = op; 113 goto insert; 114 } 115 } 116 117 /* delete old one */ 118 fdb_delete(br, f); 119 goto insert; 120 } 121 } 122 } 123 insert: 124 /* insert new address, may fail if invalid address or dup. */ 125 fdb_insert(br, p, newaddr); 126 127 spin_unlock_bh(&br->hash_lock); 128 } 129 130 void br_fdb_change_mac_address(struct net_bridge *br, const u8 *newaddr) 131 { 132 struct net_bridge_fdb_entry *f; 133 134 /* If old entry was unassociated with any port, then delete it. */ 135 f = __br_fdb_get(br, br->dev->dev_addr); 136 if (f && f->is_local && !f->dst) 137 fdb_delete(br, f); 138 139 fdb_insert(br, NULL, newaddr); 140 } 141 142 void br_fdb_cleanup(unsigned long _data) 143 { 144 struct net_bridge *br = (struct net_bridge *)_data; 145 unsigned long delay = hold_time(br); 146 unsigned long next_timer = jiffies + br->ageing_time; 147 int i; 148 149 spin_lock(&br->hash_lock); 150 for (i = 0; i < BR_HASH_SIZE; i++) { 151 struct net_bridge_fdb_entry *f; 152 struct hlist_node *h, *n; 153 154 hlist_for_each_entry_safe(f, h, n, &br->hash[i], hlist) { 155 unsigned long this_timer; 156 if (f->is_static) 157 continue; 158 this_timer = f->updated + delay; 159 if (time_before_eq(this_timer, jiffies)) 160 fdb_delete(br, f); 161 else if (time_before(this_timer, next_timer)) 162 next_timer = this_timer; 163 } 164 } 165 spin_unlock(&br->hash_lock); 166 167 mod_timer(&br->gc_timer, round_jiffies_up(next_timer)); 168 } 169 170 /* Completely flush all dynamic entries in forwarding database.*/ 171 void br_fdb_flush(struct net_bridge *br) 172 { 173 int i; 174 175 spin_lock_bh(&br->hash_lock); 176 for (i = 0; i < BR_HASH_SIZE; i++) { 177 struct net_bridge_fdb_entry *f; 178 struct hlist_node *h, *n; 179 hlist_for_each_entry_safe(f, h, n, &br->hash[i], hlist) { 180 if (!f->is_static) 181 fdb_delete(br, f); 182 } 183 } 184 spin_unlock_bh(&br->hash_lock); 185 } 186 187 /* Flush all entries referring to a specific port. 188 * if do_all is set also flush static entries 189 */ 190 void br_fdb_delete_by_port(struct net_bridge *br, 191 const struct net_bridge_port *p, 192 int do_all) 193 { 194 int i; 195 196 spin_lock_bh(&br->hash_lock); 197 for (i = 0; i < BR_HASH_SIZE; i++) { 198 struct hlist_node *h, *g; 199 200 hlist_for_each_safe(h, g, &br->hash[i]) { 201 struct net_bridge_fdb_entry *f 202 = hlist_entry(h, struct net_bridge_fdb_entry, hlist); 203 if (f->dst != p) 204 continue; 205 206 if (f->is_static && !do_all) 207 continue; 208 /* 209 * if multiple ports all have the same device address 210 * then when one port is deleted, assign 211 * the local entry to other port 212 */ 213 if (f->is_local) { 214 struct net_bridge_port *op; 215 list_for_each_entry(op, &br->port_list, list) { 216 if (op != p && 217 ether_addr_equal(op->dev->dev_addr, 218 f->addr.addr)) { 219 f->dst = op; 220 goto skip_delete; 221 } 222 } 223 } 224 225 fdb_delete(br, f); 226 skip_delete: ; 227 } 228 } 229 spin_unlock_bh(&br->hash_lock); 230 } 231 232 /* No locking or refcounting, assumes caller has rcu_read_lock */ 233 struct net_bridge_fdb_entry *__br_fdb_get(struct net_bridge *br, 234 const unsigned char *addr) 235 { 236 struct hlist_node *h; 237 struct net_bridge_fdb_entry *fdb; 238 239 hlist_for_each_entry_rcu(fdb, h, &br->hash[br_mac_hash(addr)], hlist) { 240 if (ether_addr_equal(fdb->addr.addr, addr)) { 241 if (unlikely(has_expired(br, fdb))) 242 break; 243 return fdb; 244 } 245 } 246 247 return NULL; 248 } 249 250 #if IS_ENABLED(CONFIG_ATM_LANE) 251 /* Interface used by ATM LANE hook to test 252 * if an addr is on some other bridge port */ 253 int br_fdb_test_addr(struct net_device *dev, unsigned char *addr) 254 { 255 struct net_bridge_fdb_entry *fdb; 256 struct net_bridge_port *port; 257 int ret; 258 259 rcu_read_lock(); 260 port = br_port_get_rcu(dev); 261 if (!port) 262 ret = 0; 263 else { 264 fdb = __br_fdb_get(port->br, addr); 265 ret = fdb && fdb->dst && fdb->dst->dev != dev && 266 fdb->dst->state == BR_STATE_FORWARDING; 267 } 268 rcu_read_unlock(); 269 270 return ret; 271 } 272 #endif /* CONFIG_ATM_LANE */ 273 274 /* 275 * Fill buffer with forwarding table records in 276 * the API format. 277 */ 278 int br_fdb_fillbuf(struct net_bridge *br, void *buf, 279 unsigned long maxnum, unsigned long skip) 280 { 281 struct __fdb_entry *fe = buf; 282 int i, num = 0; 283 struct hlist_node *h; 284 struct net_bridge_fdb_entry *f; 285 286 memset(buf, 0, maxnum*sizeof(struct __fdb_entry)); 287 288 rcu_read_lock(); 289 for (i = 0; i < BR_HASH_SIZE; i++) { 290 hlist_for_each_entry_rcu(f, h, &br->hash[i], hlist) { 291 if (num >= maxnum) 292 goto out; 293 294 if (has_expired(br, f)) 295 continue; 296 297 /* ignore pseudo entry for local MAC address */ 298 if (!f->dst) 299 continue; 300 301 if (skip) { 302 --skip; 303 continue; 304 } 305 306 /* convert from internal format to API */ 307 memcpy(fe->mac_addr, f->addr.addr, ETH_ALEN); 308 309 /* due to ABI compat need to split into hi/lo */ 310 fe->port_no = f->dst->port_no; 311 fe->port_hi = f->dst->port_no >> 8; 312 313 fe->is_local = f->is_local; 314 if (!f->is_static) 315 fe->ageing_timer_value = jiffies_delta_to_clock_t(jiffies - f->updated); 316 ++fe; 317 ++num; 318 } 319 } 320 321 out: 322 rcu_read_unlock(); 323 324 return num; 325 } 326 327 static struct net_bridge_fdb_entry *fdb_find(struct hlist_head *head, 328 const unsigned char *addr) 329 { 330 struct hlist_node *h; 331 struct net_bridge_fdb_entry *fdb; 332 333 hlist_for_each_entry(fdb, h, head, hlist) { 334 if (ether_addr_equal(fdb->addr.addr, addr)) 335 return fdb; 336 } 337 return NULL; 338 } 339 340 static struct net_bridge_fdb_entry *fdb_find_rcu(struct hlist_head *head, 341 const unsigned char *addr) 342 { 343 struct hlist_node *h; 344 struct net_bridge_fdb_entry *fdb; 345 346 hlist_for_each_entry_rcu(fdb, h, head, hlist) { 347 if (ether_addr_equal(fdb->addr.addr, addr)) 348 return fdb; 349 } 350 return NULL; 351 } 352 353 static struct net_bridge_fdb_entry *fdb_create(struct hlist_head *head, 354 struct net_bridge_port *source, 355 const unsigned char *addr) 356 { 357 struct net_bridge_fdb_entry *fdb; 358 359 fdb = kmem_cache_alloc(br_fdb_cache, GFP_ATOMIC); 360 if (fdb) { 361 memcpy(fdb->addr.addr, addr, ETH_ALEN); 362 fdb->dst = source; 363 fdb->is_local = 0; 364 fdb->is_static = 0; 365 fdb->updated = fdb->used = jiffies; 366 hlist_add_head_rcu(&fdb->hlist, head); 367 } 368 return fdb; 369 } 370 371 static int fdb_insert(struct net_bridge *br, struct net_bridge_port *source, 372 const unsigned char *addr) 373 { 374 struct hlist_head *head = &br->hash[br_mac_hash(addr)]; 375 struct net_bridge_fdb_entry *fdb; 376 377 if (!is_valid_ether_addr(addr)) 378 return -EINVAL; 379 380 fdb = fdb_find(head, addr); 381 if (fdb) { 382 /* it is okay to have multiple ports with same 383 * address, just use the first one. 384 */ 385 if (fdb->is_local) 386 return 0; 387 br_warn(br, "adding interface %s with same address " 388 "as a received packet\n", 389 source->dev->name); 390 fdb_delete(br, fdb); 391 } 392 393 fdb = fdb_create(head, source, addr); 394 if (!fdb) 395 return -ENOMEM; 396 397 fdb->is_local = fdb->is_static = 1; 398 fdb_notify(br, fdb, RTM_NEWNEIGH); 399 return 0; 400 } 401 402 /* Add entry for local address of interface */ 403 int br_fdb_insert(struct net_bridge *br, struct net_bridge_port *source, 404 const unsigned char *addr) 405 { 406 int ret; 407 408 spin_lock_bh(&br->hash_lock); 409 ret = fdb_insert(br, source, addr); 410 spin_unlock_bh(&br->hash_lock); 411 return ret; 412 } 413 414 void br_fdb_update(struct net_bridge *br, struct net_bridge_port *source, 415 const unsigned char *addr) 416 { 417 struct hlist_head *head = &br->hash[br_mac_hash(addr)]; 418 struct net_bridge_fdb_entry *fdb; 419 420 /* some users want to always flood. */ 421 if (hold_time(br) == 0) 422 return; 423 424 /* ignore packets unless we are using this port */ 425 if (!(source->state == BR_STATE_LEARNING || 426 source->state == BR_STATE_FORWARDING)) 427 return; 428 429 fdb = fdb_find_rcu(head, addr); 430 if (likely(fdb)) { 431 /* attempt to update an entry for a local interface */ 432 if (unlikely(fdb->is_local)) { 433 if (net_ratelimit()) 434 br_warn(br, "received packet on %s with " 435 "own address as source address\n", 436 source->dev->name); 437 } else { 438 /* fastpath: update of existing entry */ 439 fdb->dst = source; 440 fdb->updated = jiffies; 441 } 442 } else { 443 spin_lock(&br->hash_lock); 444 if (likely(!fdb_find(head, addr))) { 445 fdb = fdb_create(head, source, addr); 446 if (fdb) 447 fdb_notify(br, fdb, RTM_NEWNEIGH); 448 } 449 /* else we lose race and someone else inserts 450 * it first, don't bother updating 451 */ 452 spin_unlock(&br->hash_lock); 453 } 454 } 455 456 static int fdb_to_nud(const struct net_bridge_fdb_entry *fdb) 457 { 458 if (fdb->is_local) 459 return NUD_PERMANENT; 460 else if (fdb->is_static) 461 return NUD_NOARP; 462 else if (has_expired(fdb->dst->br, fdb)) 463 return NUD_STALE; 464 else 465 return NUD_REACHABLE; 466 } 467 468 static int fdb_fill_info(struct sk_buff *skb, const struct net_bridge *br, 469 const struct net_bridge_fdb_entry *fdb, 470 u32 portid, u32 seq, int type, unsigned int flags) 471 { 472 unsigned long now = jiffies; 473 struct nda_cacheinfo ci; 474 struct nlmsghdr *nlh; 475 struct ndmsg *ndm; 476 477 nlh = nlmsg_put(skb, portid, seq, type, sizeof(*ndm), flags); 478 if (nlh == NULL) 479 return -EMSGSIZE; 480 481 ndm = nlmsg_data(nlh); 482 ndm->ndm_family = AF_BRIDGE; 483 ndm->ndm_pad1 = 0; 484 ndm->ndm_pad2 = 0; 485 ndm->ndm_flags = 0; 486 ndm->ndm_type = 0; 487 ndm->ndm_ifindex = fdb->dst ? fdb->dst->dev->ifindex : br->dev->ifindex; 488 ndm->ndm_state = fdb_to_nud(fdb); 489 490 if (nla_put(skb, NDA_LLADDR, ETH_ALEN, &fdb->addr)) 491 goto nla_put_failure; 492 ci.ndm_used = jiffies_to_clock_t(now - fdb->used); 493 ci.ndm_confirmed = 0; 494 ci.ndm_updated = jiffies_to_clock_t(now - fdb->updated); 495 ci.ndm_refcnt = 0; 496 if (nla_put(skb, NDA_CACHEINFO, sizeof(ci), &ci)) 497 goto nla_put_failure; 498 return nlmsg_end(skb, nlh); 499 500 nla_put_failure: 501 nlmsg_cancel(skb, nlh); 502 return -EMSGSIZE; 503 } 504 505 static inline size_t fdb_nlmsg_size(void) 506 { 507 return NLMSG_ALIGN(sizeof(struct ndmsg)) 508 + nla_total_size(ETH_ALEN) /* NDA_LLADDR */ 509 + nla_total_size(sizeof(struct nda_cacheinfo)); 510 } 511 512 static void fdb_notify(struct net_bridge *br, 513 const struct net_bridge_fdb_entry *fdb, int type) 514 { 515 struct net *net = dev_net(br->dev); 516 struct sk_buff *skb; 517 int err = -ENOBUFS; 518 519 skb = nlmsg_new(fdb_nlmsg_size(), GFP_ATOMIC); 520 if (skb == NULL) 521 goto errout; 522 523 err = fdb_fill_info(skb, br, fdb, 0, 0, type, 0); 524 if (err < 0) { 525 /* -EMSGSIZE implies BUG in fdb_nlmsg_size() */ 526 WARN_ON(err == -EMSGSIZE); 527 kfree_skb(skb); 528 goto errout; 529 } 530 rtnl_notify(skb, net, 0, RTNLGRP_NEIGH, NULL, GFP_ATOMIC); 531 return; 532 errout: 533 if (err < 0) 534 rtnl_set_sk_err(net, RTNLGRP_NEIGH, err); 535 } 536 537 /* Dump information about entries, in response to GETNEIGH */ 538 int br_fdb_dump(struct sk_buff *skb, 539 struct netlink_callback *cb, 540 struct net_device *dev, 541 int idx) 542 { 543 struct net_bridge *br = netdev_priv(dev); 544 int i; 545 546 if (!(dev->priv_flags & IFF_EBRIDGE)) 547 goto out; 548 549 for (i = 0; i < BR_HASH_SIZE; i++) { 550 struct hlist_node *h; 551 struct net_bridge_fdb_entry *f; 552 553 hlist_for_each_entry_rcu(f, h, &br->hash[i], hlist) { 554 if (idx < cb->args[0]) 555 goto skip; 556 557 if (fdb_fill_info(skb, br, f, 558 NETLINK_CB(cb->skb).portid, 559 cb->nlh->nlmsg_seq, 560 RTM_NEWNEIGH, 561 NLM_F_MULTI) < 0) 562 break; 563 skip: 564 ++idx; 565 } 566 } 567 568 out: 569 return idx; 570 } 571 572 /* Update (create or replace) forwarding database entry */ 573 static int fdb_add_entry(struct net_bridge_port *source, const __u8 *addr, 574 __u16 state, __u16 flags) 575 { 576 struct net_bridge *br = source->br; 577 struct hlist_head *head = &br->hash[br_mac_hash(addr)]; 578 struct net_bridge_fdb_entry *fdb; 579 580 fdb = fdb_find(head, addr); 581 if (fdb == NULL) { 582 if (!(flags & NLM_F_CREATE)) 583 return -ENOENT; 584 585 fdb = fdb_create(head, source, addr); 586 if (!fdb) 587 return -ENOMEM; 588 fdb_notify(br, fdb, RTM_NEWNEIGH); 589 } else { 590 if (flags & NLM_F_EXCL) 591 return -EEXIST; 592 } 593 594 if (fdb_to_nud(fdb) != state) { 595 if (state & NUD_PERMANENT) 596 fdb->is_local = fdb->is_static = 1; 597 else if (state & NUD_NOARP) { 598 fdb->is_local = 0; 599 fdb->is_static = 1; 600 } else 601 fdb->is_local = fdb->is_static = 0; 602 603 fdb->updated = fdb->used = jiffies; 604 fdb_notify(br, fdb, RTM_NEWNEIGH); 605 } 606 607 return 0; 608 } 609 610 /* Add new permanent fdb entry with RTM_NEWNEIGH */ 611 int br_fdb_add(struct ndmsg *ndm, struct nlattr *tb[], 612 struct net_device *dev, 613 const unsigned char *addr, u16 nlh_flags) 614 { 615 struct net_bridge_port *p; 616 int err = 0; 617 618 if (!(ndm->ndm_state & (NUD_PERMANENT|NUD_NOARP|NUD_REACHABLE))) { 619 pr_info("bridge: RTM_NEWNEIGH with invalid state %#x\n", ndm->ndm_state); 620 return -EINVAL; 621 } 622 623 p = br_port_get_rtnl(dev); 624 if (p == NULL) { 625 pr_info("bridge: RTM_NEWNEIGH %s not a bridge port\n", 626 dev->name); 627 return -EINVAL; 628 } 629 630 if (ndm->ndm_flags & NTF_USE) { 631 rcu_read_lock(); 632 br_fdb_update(p->br, p, addr); 633 rcu_read_unlock(); 634 } else { 635 spin_lock_bh(&p->br->hash_lock); 636 err = fdb_add_entry(p, addr, ndm->ndm_state, nlh_flags); 637 spin_unlock_bh(&p->br->hash_lock); 638 } 639 640 return err; 641 } 642 643 static int fdb_delete_by_addr(struct net_bridge_port *p, const u8 *addr) 644 { 645 struct net_bridge *br = p->br; 646 struct hlist_head *head = &br->hash[br_mac_hash(addr)]; 647 struct net_bridge_fdb_entry *fdb; 648 649 fdb = fdb_find(head, addr); 650 if (!fdb) 651 return -ENOENT; 652 653 fdb_delete(p->br, fdb); 654 return 0; 655 } 656 657 /* Remove neighbor entry with RTM_DELNEIGH */ 658 int br_fdb_delete(struct ndmsg *ndm, struct net_device *dev, 659 const unsigned char *addr) 660 { 661 struct net_bridge_port *p; 662 int err; 663 664 p = br_port_get_rtnl(dev); 665 if (p == NULL) { 666 pr_info("bridge: RTM_DELNEIGH %s not a bridge port\n", 667 dev->name); 668 return -EINVAL; 669 } 670 671 spin_lock_bh(&p->br->hash_lock); 672 err = fdb_delete_by_addr(p, addr); 673 spin_unlock_bh(&p->br->hash_lock); 674 675 return err; 676 } 677