Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  *  Forwarding database
0004  *  Linux ethernet bridge
0005  *
0006  *  Authors:
0007  *  Lennert Buytenhek       <buytenh@gnu.org>
0008  */
0009 
0010 #include <linux/kernel.h>
0011 #include <linux/init.h>
0012 #include <linux/rculist.h>
0013 #include <linux/spinlock.h>
0014 #include <linux/times.h>
0015 #include <linux/netdevice.h>
0016 #include <linux/etherdevice.h>
0017 #include <linux/jhash.h>
0018 #include <linux/random.h>
0019 #include <linux/slab.h>
0020 #include <linux/atomic.h>
0021 #include <asm/unaligned.h>
0022 #include <linux/if_vlan.h>
0023 #include <net/switchdev.h>
0024 #include <trace/events/bridge.h>
0025 #include "br_private.h"
0026 
0027 static const struct rhashtable_params br_fdb_rht_params = {
0028     .head_offset = offsetof(struct net_bridge_fdb_entry, rhnode),
0029     .key_offset = offsetof(struct net_bridge_fdb_entry, key),
0030     .key_len = sizeof(struct net_bridge_fdb_key),
0031     .automatic_shrinking = true,
0032 };
0033 
0034 static struct kmem_cache *br_fdb_cache __read_mostly;
0035 
0036 int __init br_fdb_init(void)
0037 {
0038     br_fdb_cache = kmem_cache_create("bridge_fdb_cache",
0039                      sizeof(struct net_bridge_fdb_entry),
0040                      0,
0041                      SLAB_HWCACHE_ALIGN, NULL);
0042     if (!br_fdb_cache)
0043         return -ENOMEM;
0044 
0045     return 0;
0046 }
0047 
0048 void br_fdb_fini(void)
0049 {
0050     kmem_cache_destroy(br_fdb_cache);
0051 }
0052 
0053 int br_fdb_hash_init(struct net_bridge *br)
0054 {
0055     return rhashtable_init(&br->fdb_hash_tbl, &br_fdb_rht_params);
0056 }
0057 
0058 void br_fdb_hash_fini(struct net_bridge *br)
0059 {
0060     rhashtable_destroy(&br->fdb_hash_tbl);
0061 }
0062 
0063 /* if topology_changing then use forward_delay (default 15 sec)
0064  * otherwise keep longer (default 5 minutes)
0065  */
0066 static inline unsigned long hold_time(const struct net_bridge *br)
0067 {
0068     return br->topology_change ? br->forward_delay : br->ageing_time;
0069 }
0070 
0071 static inline int has_expired(const struct net_bridge *br,
0072                   const struct net_bridge_fdb_entry *fdb)
0073 {
0074     return !test_bit(BR_FDB_STATIC, &fdb->flags) &&
0075            !test_bit(BR_FDB_ADDED_BY_EXT_LEARN, &fdb->flags) &&
0076            time_before_eq(fdb->updated + hold_time(br), jiffies);
0077 }
0078 
0079 static void fdb_rcu_free(struct rcu_head *head)
0080 {
0081     struct net_bridge_fdb_entry *ent
0082         = container_of(head, struct net_bridge_fdb_entry, rcu);
0083     kmem_cache_free(br_fdb_cache, ent);
0084 }
0085 
0086 static int fdb_to_nud(const struct net_bridge *br,
0087               const struct net_bridge_fdb_entry *fdb)
0088 {
0089     if (test_bit(BR_FDB_LOCAL, &fdb->flags))
0090         return NUD_PERMANENT;
0091     else if (test_bit(BR_FDB_STATIC, &fdb->flags))
0092         return NUD_NOARP;
0093     else if (has_expired(br, fdb))
0094         return NUD_STALE;
0095     else
0096         return NUD_REACHABLE;
0097 }
0098 
0099 static int fdb_fill_info(struct sk_buff *skb, const struct net_bridge *br,
0100              const struct net_bridge_fdb_entry *fdb,
0101              u32 portid, u32 seq, int type, unsigned int flags)
0102 {
0103     const struct net_bridge_port *dst = READ_ONCE(fdb->dst);
0104     unsigned long now = jiffies;
0105     struct nda_cacheinfo ci;
0106     struct nlmsghdr *nlh;
0107     struct ndmsg *ndm;
0108 
0109     nlh = nlmsg_put(skb, portid, seq, type, sizeof(*ndm), flags);
0110     if (nlh == NULL)
0111         return -EMSGSIZE;
0112 
0113     ndm = nlmsg_data(nlh);
0114     ndm->ndm_family  = AF_BRIDGE;
0115     ndm->ndm_pad1    = 0;
0116     ndm->ndm_pad2    = 0;
0117     ndm->ndm_flags   = 0;
0118     ndm->ndm_type    = 0;
0119     ndm->ndm_ifindex = dst ? dst->dev->ifindex : br->dev->ifindex;
0120     ndm->ndm_state   = fdb_to_nud(br, fdb);
0121 
0122     if (test_bit(BR_FDB_OFFLOADED, &fdb->flags))
0123         ndm->ndm_flags |= NTF_OFFLOADED;
0124     if (test_bit(BR_FDB_ADDED_BY_EXT_LEARN, &fdb->flags))
0125         ndm->ndm_flags |= NTF_EXT_LEARNED;
0126     if (test_bit(BR_FDB_STICKY, &fdb->flags))
0127         ndm->ndm_flags |= NTF_STICKY;
0128 
0129     if (nla_put(skb, NDA_LLADDR, ETH_ALEN, &fdb->key.addr))
0130         goto nla_put_failure;
0131     if (nla_put_u32(skb, NDA_MASTER, br->dev->ifindex))
0132         goto nla_put_failure;
0133     ci.ndm_used  = jiffies_to_clock_t(now - fdb->used);
0134     ci.ndm_confirmed = 0;
0135     ci.ndm_updated   = jiffies_to_clock_t(now - fdb->updated);
0136     ci.ndm_refcnt    = 0;
0137     if (nla_put(skb, NDA_CACHEINFO, sizeof(ci), &ci))
0138         goto nla_put_failure;
0139 
0140     if (fdb->key.vlan_id && nla_put(skb, NDA_VLAN, sizeof(u16),
0141                     &fdb->key.vlan_id))
0142         goto nla_put_failure;
0143 
0144     if (test_bit(BR_FDB_NOTIFY, &fdb->flags)) {
0145         struct nlattr *nest = nla_nest_start(skb, NDA_FDB_EXT_ATTRS);
0146         u8 notify_bits = FDB_NOTIFY_BIT;
0147 
0148         if (!nest)
0149             goto nla_put_failure;
0150         if (test_bit(BR_FDB_NOTIFY_INACTIVE, &fdb->flags))
0151             notify_bits |= FDB_NOTIFY_INACTIVE_BIT;
0152 
0153         if (nla_put_u8(skb, NFEA_ACTIVITY_NOTIFY, notify_bits)) {
0154             nla_nest_cancel(skb, nest);
0155             goto nla_put_failure;
0156         }
0157 
0158         nla_nest_end(skb, nest);
0159     }
0160 
0161     nlmsg_end(skb, nlh);
0162     return 0;
0163 
0164 nla_put_failure:
0165     nlmsg_cancel(skb, nlh);
0166     return -EMSGSIZE;
0167 }
0168 
0169 static inline size_t fdb_nlmsg_size(void)
0170 {
0171     return NLMSG_ALIGN(sizeof(struct ndmsg))
0172         + nla_total_size(ETH_ALEN) /* NDA_LLADDR */
0173         + nla_total_size(sizeof(u32)) /* NDA_MASTER */
0174         + nla_total_size(sizeof(u16)) /* NDA_VLAN */
0175         + nla_total_size(sizeof(struct nda_cacheinfo))
0176         + nla_total_size(0) /* NDA_FDB_EXT_ATTRS */
0177         + nla_total_size(sizeof(u8)); /* NFEA_ACTIVITY_NOTIFY */
0178 }
0179 
0180 static void fdb_notify(struct net_bridge *br,
0181                const struct net_bridge_fdb_entry *fdb, int type,
0182                bool swdev_notify)
0183 {
0184     struct net *net = dev_net(br->dev);
0185     struct sk_buff *skb;
0186     int err = -ENOBUFS;
0187 
0188     if (swdev_notify)
0189         br_switchdev_fdb_notify(br, fdb, type);
0190 
0191     skb = nlmsg_new(fdb_nlmsg_size(), GFP_ATOMIC);
0192     if (skb == NULL)
0193         goto errout;
0194 
0195     err = fdb_fill_info(skb, br, fdb, 0, 0, type, 0);
0196     if (err < 0) {
0197         /* -EMSGSIZE implies BUG in fdb_nlmsg_size() */
0198         WARN_ON(err == -EMSGSIZE);
0199         kfree_skb(skb);
0200         goto errout;
0201     }
0202     rtnl_notify(skb, net, 0, RTNLGRP_NEIGH, NULL, GFP_ATOMIC);
0203     return;
0204 errout:
0205     rtnl_set_sk_err(net, RTNLGRP_NEIGH, err);
0206 }
0207 
0208 static struct net_bridge_fdb_entry *fdb_find_rcu(struct rhashtable *tbl,
0209                          const unsigned char *addr,
0210                          __u16 vid)
0211 {
0212     struct net_bridge_fdb_key key;
0213 
0214     WARN_ON_ONCE(!rcu_read_lock_held());
0215 
0216     key.vlan_id = vid;
0217     memcpy(key.addr.addr, addr, sizeof(key.addr.addr));
0218 
0219     return rhashtable_lookup(tbl, &key, br_fdb_rht_params);
0220 }
0221 
0222 /* requires bridge hash_lock */
0223 static struct net_bridge_fdb_entry *br_fdb_find(struct net_bridge *br,
0224                         const unsigned char *addr,
0225                         __u16 vid)
0226 {
0227     struct net_bridge_fdb_entry *fdb;
0228 
0229     lockdep_assert_held_once(&br->hash_lock);
0230 
0231     rcu_read_lock();
0232     fdb = fdb_find_rcu(&br->fdb_hash_tbl, addr, vid);
0233     rcu_read_unlock();
0234 
0235     return fdb;
0236 }
0237 
0238 struct net_device *br_fdb_find_port(const struct net_device *br_dev,
0239                     const unsigned char *addr,
0240                     __u16 vid)
0241 {
0242     struct net_bridge_fdb_entry *f;
0243     struct net_device *dev = NULL;
0244     struct net_bridge *br;
0245 
0246     ASSERT_RTNL();
0247 
0248     if (!netif_is_bridge_master(br_dev))
0249         return NULL;
0250 
0251     br = netdev_priv(br_dev);
0252     rcu_read_lock();
0253     f = br_fdb_find_rcu(br, addr, vid);
0254     if (f && f->dst)
0255         dev = f->dst->dev;
0256     rcu_read_unlock();
0257 
0258     return dev;
0259 }
0260 EXPORT_SYMBOL_GPL(br_fdb_find_port);
0261 
0262 struct net_bridge_fdb_entry *br_fdb_find_rcu(struct net_bridge *br,
0263                          const unsigned char *addr,
0264                          __u16 vid)
0265 {
0266     return fdb_find_rcu(&br->fdb_hash_tbl, addr, vid);
0267 }
0268 
0269 /* When a static FDB entry is added, the mac address from the entry is
0270  * added to the bridge private HW address list and all required ports
0271  * are then updated with the new information.
0272  * Called under RTNL.
0273  */
0274 static void fdb_add_hw_addr(struct net_bridge *br, const unsigned char *addr)
0275 {
0276     int err;
0277     struct net_bridge_port *p;
0278 
0279     ASSERT_RTNL();
0280 
0281     list_for_each_entry(p, &br->port_list, list) {
0282         if (!br_promisc_port(p)) {
0283             err = dev_uc_add(p->dev, addr);
0284             if (err)
0285                 goto undo;
0286         }
0287     }
0288 
0289     return;
0290 undo:
0291     list_for_each_entry_continue_reverse(p, &br->port_list, list) {
0292         if (!br_promisc_port(p))
0293             dev_uc_del(p->dev, addr);
0294     }
0295 }
0296 
0297 /* When a static FDB entry is deleted, the HW address from that entry is
0298  * also removed from the bridge private HW address list and updates all
0299  * the ports with needed information.
0300  * Called under RTNL.
0301  */
0302 static void fdb_del_hw_addr(struct net_bridge *br, const unsigned char *addr)
0303 {
0304     struct net_bridge_port *p;
0305 
0306     ASSERT_RTNL();
0307 
0308     list_for_each_entry(p, &br->port_list, list) {
0309         if (!br_promisc_port(p))
0310             dev_uc_del(p->dev, addr);
0311     }
0312 }
0313 
0314 static void fdb_delete(struct net_bridge *br, struct net_bridge_fdb_entry *f,
0315                bool swdev_notify)
0316 {
0317     trace_fdb_delete(br, f);
0318 
0319     if (test_bit(BR_FDB_STATIC, &f->flags))
0320         fdb_del_hw_addr(br, f->key.addr.addr);
0321 
0322     hlist_del_init_rcu(&f->fdb_node);
0323     rhashtable_remove_fast(&br->fdb_hash_tbl, &f->rhnode,
0324                    br_fdb_rht_params);
0325     fdb_notify(br, f, RTM_DELNEIGH, swdev_notify);
0326     call_rcu(&f->rcu, fdb_rcu_free);
0327 }
0328 
0329 /* Delete a local entry if no other port had the same address. */
0330 static void fdb_delete_local(struct net_bridge *br,
0331                  const struct net_bridge_port *p,
0332                  struct net_bridge_fdb_entry *f)
0333 {
0334     const unsigned char *addr = f->key.addr.addr;
0335     struct net_bridge_vlan_group *vg;
0336     const struct net_bridge_vlan *v;
0337     struct net_bridge_port *op;
0338     u16 vid = f->key.vlan_id;
0339 
0340     /* Maybe another port has same hw addr? */
0341     list_for_each_entry(op, &br->port_list, list) {
0342         vg = nbp_vlan_group(op);
0343         if (op != p && ether_addr_equal(op->dev->dev_addr, addr) &&
0344             (!vid || br_vlan_find(vg, vid))) {
0345             f->dst = op;
0346             clear_bit(BR_FDB_ADDED_BY_USER, &f->flags);
0347             return;
0348         }
0349     }
0350 
0351     vg = br_vlan_group(br);
0352     v = br_vlan_find(vg, vid);
0353     /* Maybe bridge device has same hw addr? */
0354     if (p && ether_addr_equal(br->dev->dev_addr, addr) &&
0355         (!vid || (v && br_vlan_should_use(v)))) {
0356         f->dst = NULL;
0357         clear_bit(BR_FDB_ADDED_BY_USER, &f->flags);
0358         return;
0359     }
0360 
0361     fdb_delete(br, f, true);
0362 }
0363 
0364 void br_fdb_find_delete_local(struct net_bridge *br,
0365                   const struct net_bridge_port *p,
0366                   const unsigned char *addr, u16 vid)
0367 {
0368     struct net_bridge_fdb_entry *f;
0369 
0370     spin_lock_bh(&br->hash_lock);
0371     f = br_fdb_find(br, addr, vid);
0372     if (f && test_bit(BR_FDB_LOCAL, &f->flags) &&
0373         !test_bit(BR_FDB_ADDED_BY_USER, &f->flags) && f->dst == p)
0374         fdb_delete_local(br, p, f);
0375     spin_unlock_bh(&br->hash_lock);
0376 }
0377 
0378 static struct net_bridge_fdb_entry *fdb_create(struct net_bridge *br,
0379                            struct net_bridge_port *source,
0380                            const unsigned char *addr,
0381                            __u16 vid,
0382                            unsigned long flags)
0383 {
0384     struct net_bridge_fdb_entry *fdb;
0385     int err;
0386 
0387     fdb = kmem_cache_alloc(br_fdb_cache, GFP_ATOMIC);
0388     if (!fdb)
0389         return NULL;
0390 
0391     memcpy(fdb->key.addr.addr, addr, ETH_ALEN);
0392     WRITE_ONCE(fdb->dst, source);
0393     fdb->key.vlan_id = vid;
0394     fdb->flags = flags;
0395     fdb->updated = fdb->used = jiffies;
0396     err = rhashtable_lookup_insert_fast(&br->fdb_hash_tbl, &fdb->rhnode,
0397                         br_fdb_rht_params);
0398     if (err) {
0399         kmem_cache_free(br_fdb_cache, fdb);
0400         return NULL;
0401     }
0402 
0403     hlist_add_head_rcu(&fdb->fdb_node, &br->fdb_list);
0404 
0405     return fdb;
0406 }
0407 
0408 static int fdb_add_local(struct net_bridge *br, struct net_bridge_port *source,
0409              const unsigned char *addr, u16 vid)
0410 {
0411     struct net_bridge_fdb_entry *fdb;
0412 
0413     if (!is_valid_ether_addr(addr))
0414         return -EINVAL;
0415 
0416     fdb = br_fdb_find(br, addr, vid);
0417     if (fdb) {
0418         /* it is okay to have multiple ports with same
0419          * address, just use the first one.
0420          */
0421         if (test_bit(BR_FDB_LOCAL, &fdb->flags))
0422             return 0;
0423         br_warn(br, "adding interface %s with same address as a received packet (addr:%pM, vlan:%u)\n",
0424             source ? source->dev->name : br->dev->name, addr, vid);
0425         fdb_delete(br, fdb, true);
0426     }
0427 
0428     fdb = fdb_create(br, source, addr, vid,
0429              BIT(BR_FDB_LOCAL) | BIT(BR_FDB_STATIC));
0430     if (!fdb)
0431         return -ENOMEM;
0432 
0433     fdb_add_hw_addr(br, addr);
0434     fdb_notify(br, fdb, RTM_NEWNEIGH, true);
0435     return 0;
0436 }
0437 
0438 void br_fdb_changeaddr(struct net_bridge_port *p, const unsigned char *newaddr)
0439 {
0440     struct net_bridge_vlan_group *vg;
0441     struct net_bridge_fdb_entry *f;
0442     struct net_bridge *br = p->br;
0443     struct net_bridge_vlan *v;
0444 
0445     spin_lock_bh(&br->hash_lock);
0446     vg = nbp_vlan_group(p);
0447     hlist_for_each_entry(f, &br->fdb_list, fdb_node) {
0448         if (f->dst == p && test_bit(BR_FDB_LOCAL, &f->flags) &&
0449             !test_bit(BR_FDB_ADDED_BY_USER, &f->flags)) {
0450             /* delete old one */
0451             fdb_delete_local(br, p, f);
0452 
0453             /* if this port has no vlan information
0454              * configured, we can safely be done at
0455              * this point.
0456              */
0457             if (!vg || !vg->num_vlans)
0458                 goto insert;
0459         }
0460     }
0461 
0462 insert:
0463     /* insert new address,  may fail if invalid address or dup. */
0464     fdb_add_local(br, p, newaddr, 0);
0465 
0466     if (!vg || !vg->num_vlans)
0467         goto done;
0468 
0469     /* Now add entries for every VLAN configured on the port.
0470      * This function runs under RTNL so the bitmap will not change
0471      * from under us.
0472      */
0473     list_for_each_entry(v, &vg->vlan_list, vlist)
0474         fdb_add_local(br, p, newaddr, v->vid);
0475 
0476 done:
0477     spin_unlock_bh(&br->hash_lock);
0478 }
0479 
0480 void br_fdb_change_mac_address(struct net_bridge *br, const u8 *newaddr)
0481 {
0482     struct net_bridge_vlan_group *vg;
0483     struct net_bridge_fdb_entry *f;
0484     struct net_bridge_vlan *v;
0485 
0486     spin_lock_bh(&br->hash_lock);
0487 
0488     /* If old entry was unassociated with any port, then delete it. */
0489     f = br_fdb_find(br, br->dev->dev_addr, 0);
0490     if (f && test_bit(BR_FDB_LOCAL, &f->flags) &&
0491         !f->dst && !test_bit(BR_FDB_ADDED_BY_USER, &f->flags))
0492         fdb_delete_local(br, NULL, f);
0493 
0494     fdb_add_local(br, NULL, newaddr, 0);
0495     vg = br_vlan_group(br);
0496     if (!vg || !vg->num_vlans)
0497         goto out;
0498     /* Now remove and add entries for every VLAN configured on the
0499      * bridge.  This function runs under RTNL so the bitmap will not
0500      * change from under us.
0501      */
0502     list_for_each_entry(v, &vg->vlan_list, vlist) {
0503         if (!br_vlan_should_use(v))
0504             continue;
0505         f = br_fdb_find(br, br->dev->dev_addr, v->vid);
0506         if (f && test_bit(BR_FDB_LOCAL, &f->flags) &&
0507             !f->dst && !test_bit(BR_FDB_ADDED_BY_USER, &f->flags))
0508             fdb_delete_local(br, NULL, f);
0509         fdb_add_local(br, NULL, newaddr, v->vid);
0510     }
0511 out:
0512     spin_unlock_bh(&br->hash_lock);
0513 }
0514 
0515 void br_fdb_cleanup(struct work_struct *work)
0516 {
0517     struct net_bridge *br = container_of(work, struct net_bridge,
0518                          gc_work.work);
0519     struct net_bridge_fdb_entry *f = NULL;
0520     unsigned long delay = hold_time(br);
0521     unsigned long work_delay = delay;
0522     unsigned long now = jiffies;
0523 
0524     /* this part is tricky, in order to avoid blocking learning and
0525      * consequently forwarding, we rely on rcu to delete objects with
0526      * delayed freeing allowing us to continue traversing
0527      */
0528     rcu_read_lock();
0529     hlist_for_each_entry_rcu(f, &br->fdb_list, fdb_node) {
0530         unsigned long this_timer = f->updated + delay;
0531 
0532         if (test_bit(BR_FDB_STATIC, &f->flags) ||
0533             test_bit(BR_FDB_ADDED_BY_EXT_LEARN, &f->flags)) {
0534             if (test_bit(BR_FDB_NOTIFY, &f->flags)) {
0535                 if (time_after(this_timer, now))
0536                     work_delay = min(work_delay,
0537                              this_timer - now);
0538                 else if (!test_and_set_bit(BR_FDB_NOTIFY_INACTIVE,
0539                                &f->flags))
0540                     fdb_notify(br, f, RTM_NEWNEIGH, false);
0541             }
0542             continue;
0543         }
0544 
0545         if (time_after(this_timer, now)) {
0546             work_delay = min(work_delay, this_timer - now);
0547         } else {
0548             spin_lock_bh(&br->hash_lock);
0549             if (!hlist_unhashed(&f->fdb_node))
0550                 fdb_delete(br, f, true);
0551             spin_unlock_bh(&br->hash_lock);
0552         }
0553     }
0554     rcu_read_unlock();
0555 
0556     /* Cleanup minimum 10 milliseconds apart */
0557     work_delay = max_t(unsigned long, work_delay, msecs_to_jiffies(10));
0558     mod_delayed_work(system_long_wq, &br->gc_work, work_delay);
0559 }
0560 
0561 static bool __fdb_flush_matches(const struct net_bridge *br,
0562                 const struct net_bridge_fdb_entry *f,
0563                 const struct net_bridge_fdb_flush_desc *desc)
0564 {
0565     const struct net_bridge_port *dst = READ_ONCE(f->dst);
0566     int port_ifidx = dst ? dst->dev->ifindex : br->dev->ifindex;
0567 
0568     if (desc->vlan_id && desc->vlan_id != f->key.vlan_id)
0569         return false;
0570     if (desc->port_ifindex && desc->port_ifindex != port_ifidx)
0571         return false;
0572     if (desc->flags_mask && (f->flags & desc->flags_mask) != desc->flags)
0573         return false;
0574 
0575     return true;
0576 }
0577 
0578 /* Flush forwarding database entries matching the description */
0579 void br_fdb_flush(struct net_bridge *br,
0580           const struct net_bridge_fdb_flush_desc *desc)
0581 {
0582     struct net_bridge_fdb_entry *f;
0583 
0584     rcu_read_lock();
0585     hlist_for_each_entry_rcu(f, &br->fdb_list, fdb_node) {
0586         if (!__fdb_flush_matches(br, f, desc))
0587             continue;
0588 
0589         spin_lock_bh(&br->hash_lock);
0590         if (!hlist_unhashed(&f->fdb_node))
0591             fdb_delete(br, f, true);
0592         spin_unlock_bh(&br->hash_lock);
0593     }
0594     rcu_read_unlock();
0595 }
0596 
0597 static unsigned long __ndm_state_to_fdb_flags(u16 ndm_state)
0598 {
0599     unsigned long flags = 0;
0600 
0601     if (ndm_state & NUD_PERMANENT)
0602         __set_bit(BR_FDB_LOCAL, &flags);
0603     if (ndm_state & NUD_NOARP)
0604         __set_bit(BR_FDB_STATIC, &flags);
0605 
0606     return flags;
0607 }
0608 
0609 static unsigned long __ndm_flags_to_fdb_flags(u8 ndm_flags)
0610 {
0611     unsigned long flags = 0;
0612 
0613     if (ndm_flags & NTF_USE)
0614         __set_bit(BR_FDB_ADDED_BY_USER, &flags);
0615     if (ndm_flags & NTF_EXT_LEARNED)
0616         __set_bit(BR_FDB_ADDED_BY_EXT_LEARN, &flags);
0617     if (ndm_flags & NTF_OFFLOADED)
0618         __set_bit(BR_FDB_OFFLOADED, &flags);
0619     if (ndm_flags & NTF_STICKY)
0620         __set_bit(BR_FDB_STICKY, &flags);
0621 
0622     return flags;
0623 }
0624 
0625 static int __fdb_flush_validate_ifindex(const struct net_bridge *br,
0626                     int ifindex,
0627                     struct netlink_ext_ack *extack)
0628 {
0629     const struct net_device *dev;
0630 
0631     dev = __dev_get_by_index(dev_net(br->dev), ifindex);
0632     if (!dev) {
0633         NL_SET_ERR_MSG_MOD(extack, "Unknown flush device ifindex");
0634         return -ENODEV;
0635     }
0636     if (!netif_is_bridge_master(dev) && !netif_is_bridge_port(dev)) {
0637         NL_SET_ERR_MSG_MOD(extack, "Flush device is not a bridge or bridge port");
0638         return -EINVAL;
0639     }
0640     if (netif_is_bridge_master(dev) && dev != br->dev) {
0641         NL_SET_ERR_MSG_MOD(extack,
0642                    "Flush bridge device does not match target bridge device");
0643         return -EINVAL;
0644     }
0645     if (netif_is_bridge_port(dev)) {
0646         struct net_bridge_port *p = br_port_get_rtnl(dev);
0647 
0648         if (p->br != br) {
0649             NL_SET_ERR_MSG_MOD(extack, "Port belongs to a different bridge device");
0650             return -EINVAL;
0651         }
0652     }
0653 
0654     return 0;
0655 }
0656 
0657 int br_fdb_delete_bulk(struct ndmsg *ndm, struct nlattr *tb[],
0658                struct net_device *dev, u16 vid,
0659                struct netlink_ext_ack *extack)
0660 {
0661     u8 ndm_flags = ndm->ndm_flags & ~FDB_FLUSH_IGNORED_NDM_FLAGS;
0662     struct net_bridge_fdb_flush_desc desc = { .vlan_id = vid };
0663     struct net_bridge_port *p = NULL;
0664     struct net_bridge *br;
0665 
0666     if (netif_is_bridge_master(dev)) {
0667         br = netdev_priv(dev);
0668     } else {
0669         p = br_port_get_rtnl(dev);
0670         if (!p) {
0671             NL_SET_ERR_MSG_MOD(extack, "Device is not a bridge port");
0672             return -EINVAL;
0673         }
0674         br = p->br;
0675     }
0676 
0677     if (ndm_flags & ~FDB_FLUSH_ALLOWED_NDM_FLAGS) {
0678         NL_SET_ERR_MSG(extack, "Unsupported fdb flush ndm flag bits set");
0679         return -EINVAL;
0680     }
0681     if (ndm->ndm_state & ~FDB_FLUSH_ALLOWED_NDM_STATES) {
0682         NL_SET_ERR_MSG(extack, "Unsupported fdb flush ndm state bits set");
0683         return -EINVAL;
0684     }
0685 
0686     desc.flags |= __ndm_state_to_fdb_flags(ndm->ndm_state);
0687     desc.flags |= __ndm_flags_to_fdb_flags(ndm_flags);
0688     if (tb[NDA_NDM_STATE_MASK]) {
0689         u16 ndm_state_mask = nla_get_u16(tb[NDA_NDM_STATE_MASK]);
0690 
0691         desc.flags_mask |= __ndm_state_to_fdb_flags(ndm_state_mask);
0692     }
0693     if (tb[NDA_NDM_FLAGS_MASK]) {
0694         u8 ndm_flags_mask = nla_get_u8(tb[NDA_NDM_FLAGS_MASK]);
0695 
0696         desc.flags_mask |= __ndm_flags_to_fdb_flags(ndm_flags_mask);
0697     }
0698     if (tb[NDA_IFINDEX]) {
0699         int err, ifidx = nla_get_s32(tb[NDA_IFINDEX]);
0700 
0701         err = __fdb_flush_validate_ifindex(br, ifidx, extack);
0702         if (err)
0703             return err;
0704         desc.port_ifindex = ifidx;
0705     } else if (p) {
0706         /* flush was invoked with port device and NTF_MASTER */
0707         desc.port_ifindex = p->dev->ifindex;
0708     }
0709 
0710     br_debug(br, "flushing port ifindex: %d vlan id: %u flags: 0x%lx flags mask: 0x%lx\n",
0711          desc.port_ifindex, desc.vlan_id, desc.flags, desc.flags_mask);
0712 
0713     br_fdb_flush(br, &desc);
0714 
0715     return 0;
0716 }
0717 
0718 /* Flush all entries referring to a specific port.
0719  * if do_all is set also flush static entries
0720  * if vid is set delete all entries that match the vlan_id
0721  */
0722 void br_fdb_delete_by_port(struct net_bridge *br,
0723                const struct net_bridge_port *p,
0724                u16 vid,
0725                int do_all)
0726 {
0727     struct net_bridge_fdb_entry *f;
0728     struct hlist_node *tmp;
0729 
0730     spin_lock_bh(&br->hash_lock);
0731     hlist_for_each_entry_safe(f, tmp, &br->fdb_list, fdb_node) {
0732         if (f->dst != p)
0733             continue;
0734 
0735         if (!do_all)
0736             if (test_bit(BR_FDB_STATIC, &f->flags) ||
0737                 (test_bit(BR_FDB_ADDED_BY_EXT_LEARN, &f->flags) &&
0738                  !test_bit(BR_FDB_OFFLOADED, &f->flags)) ||
0739                 (vid && f->key.vlan_id != vid))
0740                 continue;
0741 
0742         if (test_bit(BR_FDB_LOCAL, &f->flags))
0743             fdb_delete_local(br, p, f);
0744         else
0745             fdb_delete(br, f, true);
0746     }
0747     spin_unlock_bh(&br->hash_lock);
0748 }
0749 
0750 #if IS_ENABLED(CONFIG_ATM_LANE)
0751 /* Interface used by ATM LANE hook to test
0752  * if an addr is on some other bridge port */
0753 int br_fdb_test_addr(struct net_device *dev, unsigned char *addr)
0754 {
0755     struct net_bridge_fdb_entry *fdb;
0756     struct net_bridge_port *port;
0757     int ret;
0758 
0759     rcu_read_lock();
0760     port = br_port_get_rcu(dev);
0761     if (!port)
0762         ret = 0;
0763     else {
0764         const struct net_bridge_port *dst = NULL;
0765 
0766         fdb = br_fdb_find_rcu(port->br, addr, 0);
0767         if (fdb)
0768             dst = READ_ONCE(fdb->dst);
0769 
0770         ret = dst && dst->dev != dev &&
0771               dst->state == BR_STATE_FORWARDING;
0772     }
0773     rcu_read_unlock();
0774 
0775     return ret;
0776 }
0777 #endif /* CONFIG_ATM_LANE */
0778 
0779 /*
0780  * Fill buffer with forwarding table records in
0781  * the API format.
0782  */
0783 int br_fdb_fillbuf(struct net_bridge *br, void *buf,
0784            unsigned long maxnum, unsigned long skip)
0785 {
0786     struct net_bridge_fdb_entry *f;
0787     struct __fdb_entry *fe = buf;
0788     int num = 0;
0789 
0790     memset(buf, 0, maxnum*sizeof(struct __fdb_entry));
0791 
0792     rcu_read_lock();
0793     hlist_for_each_entry_rcu(f, &br->fdb_list, fdb_node) {
0794         if (num >= maxnum)
0795             break;
0796 
0797         if (has_expired(br, f))
0798             continue;
0799 
0800         /* ignore pseudo entry for local MAC address */
0801         if (!f->dst)
0802             continue;
0803 
0804         if (skip) {
0805             --skip;
0806             continue;
0807         }
0808 
0809         /* convert from internal format to API */
0810         memcpy(fe->mac_addr, f->key.addr.addr, ETH_ALEN);
0811 
0812         /* due to ABI compat need to split into hi/lo */
0813         fe->port_no = f->dst->port_no;
0814         fe->port_hi = f->dst->port_no >> 8;
0815 
0816         fe->is_local = test_bit(BR_FDB_LOCAL, &f->flags);
0817         if (!test_bit(BR_FDB_STATIC, &f->flags))
0818             fe->ageing_timer_value = jiffies_delta_to_clock_t(jiffies - f->updated);
0819         ++fe;
0820         ++num;
0821     }
0822     rcu_read_unlock();
0823 
0824     return num;
0825 }
0826 
0827 /* Add entry for local address of interface */
0828 int br_fdb_add_local(struct net_bridge *br, struct net_bridge_port *source,
0829              const unsigned char *addr, u16 vid)
0830 {
0831     int ret;
0832 
0833     spin_lock_bh(&br->hash_lock);
0834     ret = fdb_add_local(br, source, addr, vid);
0835     spin_unlock_bh(&br->hash_lock);
0836     return ret;
0837 }
0838 
0839 /* returns true if the fdb was modified */
0840 static bool __fdb_mark_active(struct net_bridge_fdb_entry *fdb)
0841 {
0842     return !!(test_bit(BR_FDB_NOTIFY_INACTIVE, &fdb->flags) &&
0843           test_and_clear_bit(BR_FDB_NOTIFY_INACTIVE, &fdb->flags));
0844 }
0845 
0846 void br_fdb_update(struct net_bridge *br, struct net_bridge_port *source,
0847            const unsigned char *addr, u16 vid, unsigned long flags)
0848 {
0849     struct net_bridge_fdb_entry *fdb;
0850 
0851     /* some users want to always flood. */
0852     if (hold_time(br) == 0)
0853         return;
0854 
0855     fdb = fdb_find_rcu(&br->fdb_hash_tbl, addr, vid);
0856     if (likely(fdb)) {
0857         /* attempt to update an entry for a local interface */
0858         if (unlikely(test_bit(BR_FDB_LOCAL, &fdb->flags))) {
0859             if (net_ratelimit())
0860                 br_warn(br, "received packet on %s with own address as source address (addr:%pM, vlan:%u)\n",
0861                     source->dev->name, addr, vid);
0862         } else {
0863             unsigned long now = jiffies;
0864             bool fdb_modified = false;
0865 
0866             if (now != fdb->updated) {
0867                 fdb->updated = now;
0868                 fdb_modified = __fdb_mark_active(fdb);
0869             }
0870 
0871             /* fastpath: update of existing entry */
0872             if (unlikely(source != READ_ONCE(fdb->dst) &&
0873                      !test_bit(BR_FDB_STICKY, &fdb->flags))) {
0874                 br_switchdev_fdb_notify(br, fdb, RTM_DELNEIGH);
0875                 WRITE_ONCE(fdb->dst, source);
0876                 fdb_modified = true;
0877                 /* Take over HW learned entry */
0878                 if (unlikely(test_bit(BR_FDB_ADDED_BY_EXT_LEARN,
0879                               &fdb->flags)))
0880                     clear_bit(BR_FDB_ADDED_BY_EXT_LEARN,
0881                           &fdb->flags);
0882             }
0883 
0884             if (unlikely(test_bit(BR_FDB_ADDED_BY_USER, &flags)))
0885                 set_bit(BR_FDB_ADDED_BY_USER, &fdb->flags);
0886             if (unlikely(fdb_modified)) {
0887                 trace_br_fdb_update(br, source, addr, vid, flags);
0888                 fdb_notify(br, fdb, RTM_NEWNEIGH, true);
0889             }
0890         }
0891     } else {
0892         spin_lock(&br->hash_lock);
0893         fdb = fdb_create(br, source, addr, vid, flags);
0894         if (fdb) {
0895             trace_br_fdb_update(br, source, addr, vid, flags);
0896             fdb_notify(br, fdb, RTM_NEWNEIGH, true);
0897         }
0898         /* else  we lose race and someone else inserts
0899          * it first, don't bother updating
0900          */
0901         spin_unlock(&br->hash_lock);
0902     }
0903 }
0904 
0905 /* Dump information about entries, in response to GETNEIGH */
0906 int br_fdb_dump(struct sk_buff *skb,
0907         struct netlink_callback *cb,
0908         struct net_device *dev,
0909         struct net_device *filter_dev,
0910         int *idx)
0911 {
0912     struct net_bridge *br = netdev_priv(dev);
0913     struct net_bridge_fdb_entry *f;
0914     int err = 0;
0915 
0916     if (!netif_is_bridge_master(dev))
0917         return err;
0918 
0919     if (!filter_dev) {
0920         err = ndo_dflt_fdb_dump(skb, cb, dev, NULL, idx);
0921         if (err < 0)
0922             return err;
0923     }
0924 
0925     rcu_read_lock();
0926     hlist_for_each_entry_rcu(f, &br->fdb_list, fdb_node) {
0927         if (*idx < cb->args[2])
0928             goto skip;
0929         if (filter_dev && (!f->dst || f->dst->dev != filter_dev)) {
0930             if (filter_dev != dev)
0931                 goto skip;
0932             /* !f->dst is a special case for bridge
0933              * It means the MAC belongs to the bridge
0934              * Therefore need a little more filtering
0935              * we only want to dump the !f->dst case
0936              */
0937             if (f->dst)
0938                 goto skip;
0939         }
0940         if (!filter_dev && f->dst)
0941             goto skip;
0942 
0943         err = fdb_fill_info(skb, br, f,
0944                     NETLINK_CB(cb->skb).portid,
0945                     cb->nlh->nlmsg_seq,
0946                     RTM_NEWNEIGH,
0947                     NLM_F_MULTI);
0948         if (err < 0)
0949             break;
0950 skip:
0951         *idx += 1;
0952     }
0953     rcu_read_unlock();
0954 
0955     return err;
0956 }
0957 
0958 int br_fdb_get(struct sk_buff *skb,
0959            struct nlattr *tb[],
0960            struct net_device *dev,
0961            const unsigned char *addr,
0962            u16 vid, u32 portid, u32 seq,
0963            struct netlink_ext_ack *extack)
0964 {
0965     struct net_bridge *br = netdev_priv(dev);
0966     struct net_bridge_fdb_entry *f;
0967     int err = 0;
0968 
0969     rcu_read_lock();
0970     f = br_fdb_find_rcu(br, addr, vid);
0971     if (!f) {
0972         NL_SET_ERR_MSG(extack, "Fdb entry not found");
0973         err = -ENOENT;
0974         goto errout;
0975     }
0976 
0977     err = fdb_fill_info(skb, br, f, portid, seq,
0978                 RTM_NEWNEIGH, 0);
0979 errout:
0980     rcu_read_unlock();
0981     return err;
0982 }
0983 
0984 /* returns true if the fdb is modified */
0985 static bool fdb_handle_notify(struct net_bridge_fdb_entry *fdb, u8 notify)
0986 {
0987     bool modified = false;
0988 
0989     /* allow to mark an entry as inactive, usually done on creation */
0990     if ((notify & FDB_NOTIFY_INACTIVE_BIT) &&
0991         !test_and_set_bit(BR_FDB_NOTIFY_INACTIVE, &fdb->flags))
0992         modified = true;
0993 
0994     if ((notify & FDB_NOTIFY_BIT) &&
0995         !test_and_set_bit(BR_FDB_NOTIFY, &fdb->flags)) {
0996         /* enabled activity tracking */
0997         modified = true;
0998     } else if (!(notify & FDB_NOTIFY_BIT) &&
0999            test_and_clear_bit(BR_FDB_NOTIFY, &fdb->flags)) {
1000         /* disabled activity tracking, clear notify state */
1001         clear_bit(BR_FDB_NOTIFY_INACTIVE, &fdb->flags);
1002         modified = true;
1003     }
1004 
1005     return modified;
1006 }
1007 
1008 /* Update (create or replace) forwarding database entry */
1009 static int fdb_add_entry(struct net_bridge *br, struct net_bridge_port *source,
1010              const u8 *addr, struct ndmsg *ndm, u16 flags, u16 vid,
1011              struct nlattr *nfea_tb[])
1012 {
1013     bool is_sticky = !!(ndm->ndm_flags & NTF_STICKY);
1014     bool refresh = !nfea_tb[NFEA_DONT_REFRESH];
1015     struct net_bridge_fdb_entry *fdb;
1016     u16 state = ndm->ndm_state;
1017     bool modified = false;
1018     u8 notify = 0;
1019 
1020     /* If the port cannot learn allow only local and static entries */
1021     if (source && !(state & NUD_PERMANENT) && !(state & NUD_NOARP) &&
1022         !(source->state == BR_STATE_LEARNING ||
1023           source->state == BR_STATE_FORWARDING))
1024         return -EPERM;
1025 
1026     if (!source && !(state & NUD_PERMANENT)) {
1027         pr_info("bridge: RTM_NEWNEIGH %s without NUD_PERMANENT\n",
1028             br->dev->name);
1029         return -EINVAL;
1030     }
1031 
1032     if (is_sticky && (state & NUD_PERMANENT))
1033         return -EINVAL;
1034 
1035     if (nfea_tb[NFEA_ACTIVITY_NOTIFY]) {
1036         notify = nla_get_u8(nfea_tb[NFEA_ACTIVITY_NOTIFY]);
1037         if ((notify & ~BR_FDB_NOTIFY_SETTABLE_BITS) ||
1038             (notify & BR_FDB_NOTIFY_SETTABLE_BITS) == FDB_NOTIFY_INACTIVE_BIT)
1039             return -EINVAL;
1040     }
1041 
1042     fdb = br_fdb_find(br, addr, vid);
1043     if (fdb == NULL) {
1044         if (!(flags & NLM_F_CREATE))
1045             return -ENOENT;
1046 
1047         fdb = fdb_create(br, source, addr, vid, 0);
1048         if (!fdb)
1049             return -ENOMEM;
1050 
1051         modified = true;
1052     } else {
1053         if (flags & NLM_F_EXCL)
1054             return -EEXIST;
1055 
1056         if (READ_ONCE(fdb->dst) != source) {
1057             WRITE_ONCE(fdb->dst, source);
1058             modified = true;
1059         }
1060     }
1061 
1062     if (fdb_to_nud(br, fdb) != state) {
1063         if (state & NUD_PERMANENT) {
1064             set_bit(BR_FDB_LOCAL, &fdb->flags);
1065             if (!test_and_set_bit(BR_FDB_STATIC, &fdb->flags))
1066                 fdb_add_hw_addr(br, addr);
1067         } else if (state & NUD_NOARP) {
1068             clear_bit(BR_FDB_LOCAL, &fdb->flags);
1069             if (!test_and_set_bit(BR_FDB_STATIC, &fdb->flags))
1070                 fdb_add_hw_addr(br, addr);
1071         } else {
1072             clear_bit(BR_FDB_LOCAL, &fdb->flags);
1073             if (test_and_clear_bit(BR_FDB_STATIC, &fdb->flags))
1074                 fdb_del_hw_addr(br, addr);
1075         }
1076 
1077         modified = true;
1078     }
1079 
1080     if (is_sticky != test_bit(BR_FDB_STICKY, &fdb->flags)) {
1081         change_bit(BR_FDB_STICKY, &fdb->flags);
1082         modified = true;
1083     }
1084 
1085     if (fdb_handle_notify(fdb, notify))
1086         modified = true;
1087 
1088     set_bit(BR_FDB_ADDED_BY_USER, &fdb->flags);
1089 
1090     fdb->used = jiffies;
1091     if (modified) {
1092         if (refresh)
1093             fdb->updated = jiffies;
1094         fdb_notify(br, fdb, RTM_NEWNEIGH, true);
1095     }
1096 
1097     return 0;
1098 }
1099 
1100 static int __br_fdb_add(struct ndmsg *ndm, struct net_bridge *br,
1101             struct net_bridge_port *p, const unsigned char *addr,
1102             u16 nlh_flags, u16 vid, struct nlattr *nfea_tb[],
1103             struct netlink_ext_ack *extack)
1104 {
1105     int err = 0;
1106 
1107     if (ndm->ndm_flags & NTF_USE) {
1108         if (!p) {
1109             pr_info("bridge: RTM_NEWNEIGH %s with NTF_USE is not supported\n",
1110                 br->dev->name);
1111             return -EINVAL;
1112         }
1113         if (!nbp_state_should_learn(p))
1114             return 0;
1115 
1116         local_bh_disable();
1117         rcu_read_lock();
1118         br_fdb_update(br, p, addr, vid, BIT(BR_FDB_ADDED_BY_USER));
1119         rcu_read_unlock();
1120         local_bh_enable();
1121     } else if (ndm->ndm_flags & NTF_EXT_LEARNED) {
1122         if (!p && !(ndm->ndm_state & NUD_PERMANENT)) {
1123             NL_SET_ERR_MSG_MOD(extack,
1124                        "FDB entry towards bridge must be permanent");
1125             return -EINVAL;
1126         }
1127         err = br_fdb_external_learn_add(br, p, addr, vid, true);
1128     } else {
1129         spin_lock_bh(&br->hash_lock);
1130         err = fdb_add_entry(br, p, addr, ndm, nlh_flags, vid, nfea_tb);
1131         spin_unlock_bh(&br->hash_lock);
1132     }
1133 
1134     return err;
1135 }
1136 
1137 static const struct nla_policy br_nda_fdb_pol[NFEA_MAX + 1] = {
1138     [NFEA_ACTIVITY_NOTIFY]  = { .type = NLA_U8 },
1139     [NFEA_DONT_REFRESH] = { .type = NLA_FLAG },
1140 };
1141 
1142 /* Add new permanent fdb entry with RTM_NEWNEIGH */
1143 int br_fdb_add(struct ndmsg *ndm, struct nlattr *tb[],
1144            struct net_device *dev,
1145            const unsigned char *addr, u16 vid, u16 nlh_flags,
1146            struct netlink_ext_ack *extack)
1147 {
1148     struct nlattr *nfea_tb[NFEA_MAX + 1], *attr;
1149     struct net_bridge_vlan_group *vg;
1150     struct net_bridge_port *p = NULL;
1151     struct net_bridge_vlan *v;
1152     struct net_bridge *br = NULL;
1153     int err = 0;
1154 
1155     trace_br_fdb_add(ndm, dev, addr, vid, nlh_flags);
1156 
1157     if (!(ndm->ndm_state & (NUD_PERMANENT|NUD_NOARP|NUD_REACHABLE))) {
1158         pr_info("bridge: RTM_NEWNEIGH with invalid state %#x\n", ndm->ndm_state);
1159         return -EINVAL;
1160     }
1161 
1162     if (is_zero_ether_addr(addr)) {
1163         pr_info("bridge: RTM_NEWNEIGH with invalid ether address\n");
1164         return -EINVAL;
1165     }
1166 
1167     if (netif_is_bridge_master(dev)) {
1168         br = netdev_priv(dev);
1169         vg = br_vlan_group(br);
1170     } else {
1171         p = br_port_get_rtnl(dev);
1172         if (!p) {
1173             pr_info("bridge: RTM_NEWNEIGH %s not a bridge port\n",
1174                 dev->name);
1175             return -EINVAL;
1176         }
1177         br = p->br;
1178         vg = nbp_vlan_group(p);
1179     }
1180 
1181     if (tb[NDA_FDB_EXT_ATTRS]) {
1182         attr = tb[NDA_FDB_EXT_ATTRS];
1183         err = nla_parse_nested(nfea_tb, NFEA_MAX, attr,
1184                        br_nda_fdb_pol, extack);
1185         if (err)
1186             return err;
1187     } else {
1188         memset(nfea_tb, 0, sizeof(struct nlattr *) * (NFEA_MAX + 1));
1189     }
1190 
1191     if (vid) {
1192         v = br_vlan_find(vg, vid);
1193         if (!v || !br_vlan_should_use(v)) {
1194             pr_info("bridge: RTM_NEWNEIGH with unconfigured vlan %d on %s\n", vid, dev->name);
1195             return -EINVAL;
1196         }
1197 
1198         /* VID was specified, so use it. */
1199         err = __br_fdb_add(ndm, br, p, addr, nlh_flags, vid, nfea_tb,
1200                    extack);
1201     } else {
1202         err = __br_fdb_add(ndm, br, p, addr, nlh_flags, 0, nfea_tb,
1203                    extack);
1204         if (err || !vg || !vg->num_vlans)
1205             goto out;
1206 
1207         /* We have vlans configured on this port and user didn't
1208          * specify a VLAN.  To be nice, add/update entry for every
1209          * vlan on this port.
1210          */
1211         list_for_each_entry(v, &vg->vlan_list, vlist) {
1212             if (!br_vlan_should_use(v))
1213                 continue;
1214             err = __br_fdb_add(ndm, br, p, addr, nlh_flags, v->vid,
1215                        nfea_tb, extack);
1216             if (err)
1217                 goto out;
1218         }
1219     }
1220 
1221 out:
1222     return err;
1223 }
1224 
1225 static int fdb_delete_by_addr_and_port(struct net_bridge *br,
1226                        const struct net_bridge_port *p,
1227                        const u8 *addr, u16 vlan)
1228 {
1229     struct net_bridge_fdb_entry *fdb;
1230 
1231     fdb = br_fdb_find(br, addr, vlan);
1232     if (!fdb || READ_ONCE(fdb->dst) != p)
1233         return -ENOENT;
1234 
1235     fdb_delete(br, fdb, true);
1236 
1237     return 0;
1238 }
1239 
1240 static int __br_fdb_delete(struct net_bridge *br,
1241                const struct net_bridge_port *p,
1242                const unsigned char *addr, u16 vid)
1243 {
1244     int err;
1245 
1246     spin_lock_bh(&br->hash_lock);
1247     err = fdb_delete_by_addr_and_port(br, p, addr, vid);
1248     spin_unlock_bh(&br->hash_lock);
1249 
1250     return err;
1251 }
1252 
1253 /* Remove neighbor entry with RTM_DELNEIGH */
1254 int br_fdb_delete(struct ndmsg *ndm, struct nlattr *tb[],
1255           struct net_device *dev,
1256           const unsigned char *addr, u16 vid,
1257           struct netlink_ext_ack *extack)
1258 {
1259     struct net_bridge_vlan_group *vg;
1260     struct net_bridge_port *p = NULL;
1261     struct net_bridge_vlan *v;
1262     struct net_bridge *br;
1263     int err;
1264 
1265     if (netif_is_bridge_master(dev)) {
1266         br = netdev_priv(dev);
1267         vg = br_vlan_group(br);
1268     } else {
1269         p = br_port_get_rtnl(dev);
1270         if (!p) {
1271             pr_info("bridge: RTM_DELNEIGH %s not a bridge port\n",
1272                 dev->name);
1273             return -EINVAL;
1274         }
1275         vg = nbp_vlan_group(p);
1276         br = p->br;
1277     }
1278 
1279     if (vid) {
1280         v = br_vlan_find(vg, vid);
1281         if (!v) {
1282             pr_info("bridge: RTM_DELNEIGH with unconfigured vlan %d on %s\n", vid, dev->name);
1283             return -EINVAL;
1284         }
1285 
1286         err = __br_fdb_delete(br, p, addr, vid);
1287     } else {
1288         err = -ENOENT;
1289         err &= __br_fdb_delete(br, p, addr, 0);
1290         if (!vg || !vg->num_vlans)
1291             return err;
1292 
1293         list_for_each_entry(v, &vg->vlan_list, vlist) {
1294             if (!br_vlan_should_use(v))
1295                 continue;
1296             err &= __br_fdb_delete(br, p, addr, v->vid);
1297         }
1298     }
1299 
1300     return err;
1301 }
1302 
1303 int br_fdb_sync_static(struct net_bridge *br, struct net_bridge_port *p)
1304 {
1305     struct net_bridge_fdb_entry *f, *tmp;
1306     int err = 0;
1307 
1308     ASSERT_RTNL();
1309 
1310     /* the key here is that static entries change only under rtnl */
1311     rcu_read_lock();
1312     hlist_for_each_entry_rcu(f, &br->fdb_list, fdb_node) {
1313         /* We only care for static entries */
1314         if (!test_bit(BR_FDB_STATIC, &f->flags))
1315             continue;
1316         err = dev_uc_add(p->dev, f->key.addr.addr);
1317         if (err)
1318             goto rollback;
1319     }
1320 done:
1321     rcu_read_unlock();
1322 
1323     return err;
1324 
1325 rollback:
1326     hlist_for_each_entry_rcu(tmp, &br->fdb_list, fdb_node) {
1327         /* We only care for static entries */
1328         if (!test_bit(BR_FDB_STATIC, &tmp->flags))
1329             continue;
1330         if (tmp == f)
1331             break;
1332         dev_uc_del(p->dev, tmp->key.addr.addr);
1333     }
1334 
1335     goto done;
1336 }
1337 
1338 void br_fdb_unsync_static(struct net_bridge *br, struct net_bridge_port *p)
1339 {
1340     struct net_bridge_fdb_entry *f;
1341 
1342     ASSERT_RTNL();
1343 
1344     rcu_read_lock();
1345     hlist_for_each_entry_rcu(f, &br->fdb_list, fdb_node) {
1346         /* We only care for static entries */
1347         if (!test_bit(BR_FDB_STATIC, &f->flags))
1348             continue;
1349 
1350         dev_uc_del(p->dev, f->key.addr.addr);
1351     }
1352     rcu_read_unlock();
1353 }
1354 
1355 int br_fdb_external_learn_add(struct net_bridge *br, struct net_bridge_port *p,
1356                   const unsigned char *addr, u16 vid,
1357                   bool swdev_notify)
1358 {
1359     struct net_bridge_fdb_entry *fdb;
1360     bool modified = false;
1361     int err = 0;
1362 
1363     trace_br_fdb_external_learn_add(br, p, addr, vid);
1364 
1365     spin_lock_bh(&br->hash_lock);
1366 
1367     fdb = br_fdb_find(br, addr, vid);
1368     if (!fdb) {
1369         unsigned long flags = BIT(BR_FDB_ADDED_BY_EXT_LEARN);
1370 
1371         if (swdev_notify)
1372             flags |= BIT(BR_FDB_ADDED_BY_USER);
1373 
1374         if (!p)
1375             flags |= BIT(BR_FDB_LOCAL);
1376 
1377         fdb = fdb_create(br, p, addr, vid, flags);
1378         if (!fdb) {
1379             err = -ENOMEM;
1380             goto err_unlock;
1381         }
1382         fdb_notify(br, fdb, RTM_NEWNEIGH, swdev_notify);
1383     } else {
1384         fdb->updated = jiffies;
1385 
1386         if (READ_ONCE(fdb->dst) != p) {
1387             WRITE_ONCE(fdb->dst, p);
1388             modified = true;
1389         }
1390 
1391         if (test_bit(BR_FDB_ADDED_BY_EXT_LEARN, &fdb->flags)) {
1392             /* Refresh entry */
1393             fdb->used = jiffies;
1394         } else if (!test_bit(BR_FDB_ADDED_BY_USER, &fdb->flags)) {
1395             /* Take over SW learned entry */
1396             set_bit(BR_FDB_ADDED_BY_EXT_LEARN, &fdb->flags);
1397             modified = true;
1398         }
1399 
1400         if (swdev_notify)
1401             set_bit(BR_FDB_ADDED_BY_USER, &fdb->flags);
1402 
1403         if (!p)
1404             set_bit(BR_FDB_LOCAL, &fdb->flags);
1405 
1406         if (modified)
1407             fdb_notify(br, fdb, RTM_NEWNEIGH, swdev_notify);
1408     }
1409 
1410 err_unlock:
1411     spin_unlock_bh(&br->hash_lock);
1412 
1413     return err;
1414 }
1415 
1416 int br_fdb_external_learn_del(struct net_bridge *br, struct net_bridge_port *p,
1417                   const unsigned char *addr, u16 vid,
1418                   bool swdev_notify)
1419 {
1420     struct net_bridge_fdb_entry *fdb;
1421     int err = 0;
1422 
1423     spin_lock_bh(&br->hash_lock);
1424 
1425     fdb = br_fdb_find(br, addr, vid);
1426     if (fdb && test_bit(BR_FDB_ADDED_BY_EXT_LEARN, &fdb->flags))
1427         fdb_delete(br, fdb, swdev_notify);
1428     else
1429         err = -ENOENT;
1430 
1431     spin_unlock_bh(&br->hash_lock);
1432 
1433     return err;
1434 }
1435 
1436 void br_fdb_offloaded_set(struct net_bridge *br, struct net_bridge_port *p,
1437               const unsigned char *addr, u16 vid, bool offloaded)
1438 {
1439     struct net_bridge_fdb_entry *fdb;
1440 
1441     spin_lock_bh(&br->hash_lock);
1442 
1443     fdb = br_fdb_find(br, addr, vid);
1444     if (fdb && offloaded != test_bit(BR_FDB_OFFLOADED, &fdb->flags))
1445         change_bit(BR_FDB_OFFLOADED, &fdb->flags);
1446 
1447     spin_unlock_bh(&br->hash_lock);
1448 }
1449 
1450 void br_fdb_clear_offload(const struct net_device *dev, u16 vid)
1451 {
1452     struct net_bridge_fdb_entry *f;
1453     struct net_bridge_port *p;
1454 
1455     ASSERT_RTNL();
1456 
1457     p = br_port_get_rtnl(dev);
1458     if (!p)
1459         return;
1460 
1461     spin_lock_bh(&p->br->hash_lock);
1462     hlist_for_each_entry(f, &p->br->fdb_list, fdb_node) {
1463         if (f->dst == p && f->key.vlan_id == vid)
1464             clear_bit(BR_FDB_OFFLOADED, &f->flags);
1465     }
1466     spin_unlock_bh(&p->br->hash_lock);
1467 }
1468 EXPORT_SYMBOL_GPL(br_fdb_clear_offload);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!