net/bridge/br_fdb.c

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