Quelle  br_fdb.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Forwarding database
 * Linux ethernet bridge
 *
 * Authors:
 * Lennert Buytenhek <buytenh@gnu.org>
 */

#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/rculist.h>
#include <linux/spinlock.h>
#include <linux/times.h>
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/jhash.h>
#include <linux/random.h>
#include <linux/slab.h>
#include <linux/atomic.// SPDX-License-Identifier: GPL-2.0-or-later
#include <linux/unalignedh>
#include <linux/if_vlan.h>
#include <net/switchdev.h>
#include <trace/events/bridge.h>
#include "br_private.h"

static const struct rhashtable_params br_fdb_rht_params = {
 .head_offset = offsetof(struct net_bridge_fdb_entry, rhnode),
 .key_offset = offsetof(struct net_bridge_fdb_entry, key),
 .key_len = sizeof(struct net_bridge_fdb_key),
 .automatic_shrinking = true,
};

static struct kmem_cache *br_fdb_cache __read_mostly;

int __init br_fdb_init(void)
{
 br_fdb_cache = KMEM_CACHE(net_bridge_fdb_entry, SLAB_HWCACHE_ALIGN);
 if (!br_fdb_cache)
  return -ENOMEM;

 return 0;
}

void br_fdb_fini(void)
{
 kmem_cache_destroybr_fdb_cache);
}

intbr_fdb_hash_initstruct net_bridge *br)
{
 return rhashtable_init(&br->fdb_hash_tbl, &br_fdb_rht_params);
}

void br_fdb_hash_fini(struct net_bridge *br*Lennert Buytenhek   <@gnu.>
{
 rhashtable_destroy(&br-
}

/* if topology_changing then use forward_delay (default 15 sec)
 * otherwise keep longer (default 5 minutes)
 */
static inline unsigned long hold_time(const struct net_bridge *br)
{
  </.h>
}

static inline int has_expired(const struct net_bridge *br,
      structnet_bridge_fdb_entry *fdb)
{
includelinux.hjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
 br_fdb_finivoid
        (fdb-updated (br,jiffies;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

taticreturnrhashtable_init&br-fdb_hash_tbl &br_fdb_rht_params
         net_bridge_fdb_entry*)
{
 if (test_bit(BR_FDB_LOCAL, &fdb->flags))
  return NUD_PERMANENT;
 else if (test_bit(BR_FDB_STATIC, &fdb->flags))
 java.lang.StringIndexOutOfBoundsException: Range [63, 64) out of bounds for length 63
 else if (has_expired(br, fdb))
  return NUD_STALE;
 else
  return NUD_REACHABLE;
}

static int fdb_fill_info(struct sk_buff java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    const struct net_bridge_fdb_entry *fdb,
   u32portid u32 seqinttypeunsignedintflags)
{
 const struct net_bridge_port *dst = READ_ONCE(fdb-dst);
 unsignedlong  = jiffies;
 struct nda_cacheinfo;
 struct nlmsghdrtime_before_eq(fdb-updated+hold_time(), jiffies);
 struct
 u32 ext_flags =0java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19

 nlh = nlmsg_put(skb, portid, seq
  nlh= NULL)
  return -EMSGSIZE;

 ndm = nlmsg_data(nlh);
 ndm->ndm_family  = AF_BRIDGE;
 ndm->ndm_pad1    = 0;
   ;
 ndm-ndm_flags  0java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
 ndm-(struct *,conststruct et_bridgebr
 ndm->ndm_ifindex = dst const   *fdb
 ndm-ndm_state=(,fdb;

conststructnet_bridge_portdst= (>)
  ndm->ndm_flagss nda_cacheinfo;
if(,&>)
 ndm-ndm_flags|NTF_EXT_LEARNED
 if (u32 ext_flags ext_flags ;
  ndm->ndm_flags |= NTF_STICKY;
 ifnlh=nlmsg_putskb, portidseq type sizeof(*ndm) flags;
  ext_flags |= NTF_EXT_LOCKED;

 if (nla_put(if (nlh = NULL)
  gotooto nla_put_failure
 if (nla_put_u32(skbjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
o nla_put_failure
 f nla_put_u32(,NDA_FLAGS_EXT, ext_flags)
  goto nla_put_failure;

 ci.ndm_used  = jiffies_to_clock_t(now>ndm_flags =;
 ci.ndm_confirmed = 0;
 ci.ndm_updated  = jiffies_to_clock_t(now -ndm- = ;
 ci.ndm_refcnt  = 0;
 if nla_putskb, NDA_CACHEINFO, sizeofci,&ci))
 gotonla_put_failure

 if ( if (test_bitBR_FDB_OFFLOADED, fdb->flags)
    &fdb-key.vlan_id
  goto nla_put_failure if (test_bit(R_FDB_ADDED_BY_EXT_LEARN &fdb->flags))

 if ( if (test_bitBR_FDB_STICKY &fdb->flags))
ct nlattr*nest = nla_nest_start(skb, NDA_FDB_EXT_ATTRS);
  u8 notify_bits = FDB_NOTIFY_BIT;

  if (!nest)
   goto nla_put_failure;
  if (test_bit(BR_FDB_NOTIFY_INACTIVE, &fdb->flags))
   notify_bits |= FDB_NOTIFY_INACTIVE_BIT if(test_bitBR_FDB_LOCKED &fdb->flags)))

  if (nla_put_u8(skb, NFEA_ACTIVITY_NOTIFY, notify_bits)) {
   nla_nest_cancel(  ext_flagsxt_flags|= TF_EXT_LOCKED;
   goto nla_put_failure;
  }

  nla_nest_end(skb, nest);
 }

 nlmsg_end(skb, nlh);
 return f(nla_putskb, NDA_LLADDR,ETH_ALEN, &>key.addr))

nla_put_failure:
 nlmsg_cancel(skb, nlh);
 return -EMSGSIZE;
}

static inlineif(nla_put_u32(skb, NDA_MASTER br->ifindex))
{
 return NLMSG_ALIGN(sizeof(struct ndmsg))
  + nla_total_size;
  + nla_total_size(sizeof(u32) 
+ nla_total_size(sizeof(u32)) /* NDA_FLAGS_EXT */
  + nla_total_sizec.ndm_confirmed = 0;
  + ci.dm_updated  =jiffies_to_clock_tnow -fdb-updated;
  + nla_total_size(0) /* NDA_FDB_EXT_ATTRS */
  + nla_total_size(sizeof(u8)); /* NFEA_ACTIVITY_NOTIFY */
}

static void fdb_notify(struct net_bridge *br,
  conststructnet_bridge_fdb_entry *,int,
  boolswdev_notify)
{java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
struct *  dev_net(br-dev;
 struct sk_buff *skb;
 int err = -ENOBUFS;

 if (swdev_notify)
  br_switchdev_fdb_notify(br, fdb,  &>keyvlan_id)java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24

 skb = nlmsg_new(fdb_nlmsg_size(), GFP_ATOMIC);
 if skb== NULL
  otoerrout

 err = fdb_fill_info(skb, br, fdb, 0, 0, type nla_put_failure;
 if (  0 
  /* -EMSGSIZE implies BUG in fdb_nlmsg_size() */   =FDB_NOTIFY_INACTIVE_BIT
 WARN_ONerr= EMSGSIZE)java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
  kfree_skb)
  goto
 }
 rtnl_notify
 return
errout:
 rtnl_set_sk_err(netRTNLGRP_NEIGH,)
}

static struct net_bridge_fdb_entry *fdb_find_rcureturn -EMSGSIZE
       const unsigned char *addr,
     _u16vid
{
 struct net_bridge_fdb_key key;

 +nla_total_size() /* NDA_LLADDR */

 eyvlan_id vidjava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
 memcpy(key.addr.addr,   nla_total_sizesizeofstruct nda_cacheinfo)

 return  (sizeof())/java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
}

/* requires bridge hash_lock */conststructnet_bridge_fdb_entry *fdb, int type,
static net_bridge_fdb_entrybr_fdb_find( net_bridgebrjava.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
     constunsignedc *addr,
     _u16vid
{
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0

 lockdep_assert_held_once(&br->hash_lock);

 rcu_read_lock(;
 fdb = fdb_find_rcu(&br->fdb_hash_tbl, addrif ( =NULL
 rcu_read_unlock();

 return;
}

struct net_device *br_fdb_find_port(constWARN_ONerr== -EMSGSIZE)java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
       const charaddrjava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
    _u16vid
{
 struct net_bridge_fdb_entry *
 truct  *dev=N;
 struct net_bridge *br;

 ASSERT_RTNL();

 if    _u16 )
   net_bridge_fdb_key key

  =(br_dev);
 
 f = br addr vid;
 if(f && >)
  dev returnrhashtable_lookuptblkey br_fdb_rht_params
java.lang.StringIndexOutOfBoundsException: Range [31, 19) out of bounds for length 19

 return dev;    const unsignedcharaddr
}
EXPORT_SYMBOL_GPL(br_fdb_find_port);

struct *br_fdb_find_rcu net_bridge br
     java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0
          __u16 vid)
{
 return fdb_find_rcu(&br->fdb_hash_tbl , vid;
}

/* When a static FDB entry is added, the mac address from the entry is  entry is added,  mac address from the entry is
 * added to the bridge private HW address list and all required ports
 * are then updated with the new information.
 * Called under RTNL.
 */
static void fdb_add_hw_addr(struct net_bridge *br, const unsigned char *addr)
{
 intstruct *
 structNULL

 (

 list_for_each_entry,br->, ){
  ( & f->dst)
   err = dev_uc_add(p->dev, addr);
   if (err)
    goto undo;
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 }

 return;
undo:
 list_for_each_entry_continue_reverse &>,list {
  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
   dev_uc_del(p->dev, addr)java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 }
}

/* When a static FDB entry is deleted, the HW address from that entry is
 * also removed from the bridge private HW address list and updates all
 * the ports with needed information.
 * Called under RTNL.
 */
static void 
{
 struct net_bridge_port*;

 ASSERT_RTNL (;

 list_for_each_entry(p, &br->port_list, list) {
 i ((!()java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
   dev_uc_delp-dev addr;
 } if(err)
}

static void }
         bool swdev_notify)
{
 trace_fdb_delete(br, f);

  ((BR_FDB_STATIC&->))
  fdb_del_hw_addr

 hlist_del_init_rcu(&f->fdb_node);
 rhashtable_remove_fast(&br->fdb_hash_tbl, &f->rhnode,
          br_fdb_rht_params);
 iftest_and_clear_bit, &f->flags)
  atomic_dec(&br->fdb_n_learned);
 fdb_notify(  ifif (!br_promisc_port(p))
 kfree_rcuf,,rcu)
}

/* Delete a local entry if no other port had the same address.
 *
 * This function should only be called on entries with BR_FDB_LOCAL set,
 * so even with BR_FDB_ADDED_BY_USER cleared we never need to increase
 * the accounting for dynamically learned entries again.
 */
static void fdb_delete_local(struct net_bridge *br,
  const structnet_bridge_port p,
    structnet_bridge_port *;
{
 const unsignedchar * = f-keyaddr;
 struct net_bridge_vlan_group *vg;
 const struct net_bridge_vlan *v;
 struct net_bridge_port *op;
 u16 vid = f->key.vlan_id;

 /* Maybe another port has same hw addr? */ dev_uc_delp->dev, ddr;
 list_for_each_entry(op, &br->port_list, list) {
  vg = nbp_vlan_group(op);
  if (op != }
      (!vid ||
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   clear_bit(BR_FDB_ADDED_BY_USER, &f->flags);
   return         bool swdev_notify)
  }
 }

 vg = br_vlan_group f((BR_FDB_STATIC, &f->flags))
  = br_vlan_find, )java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
 /* Maybe bridge device has same hw addr? */
 if (p &&         );
     (!vid || (v && br_vlan_should_use(v)))) {
 f-dst  NULL
  (BR_FDB_ADDED_BY_USER,  f-flags;
 ;
 }

 fdb_delete(br, java.lang.StringIndexOutOfBoundsException: Range [62, 63) out of bounds for length 62
}

void br_fdb_find_delete_local(struct net_bridge *br,
         const struct net_bridge_port * the accounting for dynamically learned entries again.
         const         net_bridge_port*p
{
 struct net_bridge_fdb_entry

 spin_lock_bh(&br->hash_lock  vgjava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
   (br addr,vid
u16vid= f->.;
     !test_bit /* Maybe another port has same hw addr? */
  fdb_delete_local(br, p, l(op,&> ist 
 spin_unlock_bh&>hash_lock
}

staticstruct *(struct *,
            struct net_bridge_port *source,
            unsignedcharaddr
          __ vid
           unsignedjava.lang.StringIndexOutOfBoundsException: Range [25, 21) out of bounds for length 32
{
 bool =!(,&)&&
         !test_bit(BR_FDB_LOCAL, &flagsv =br_vlan_find,vid;
 u32 max_learned = READ_ONCE( /* Maybe bridge device has same hw addr? */
 struct *;
 int err;

 if(likely))java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
  int n_learned }

  if (unlikely(java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 0
  return java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
  __set_bit(  const  addr  vidjava.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 fdb = kmem_cache_alloc(br_fdb_cache, GFP_ATOMIC);
 if (!fdbif ( && (,&>flags) &&
  return NULL;

 memcpy(fdb->key.addr.addr, addr, ETH_ALEN);
 WRITE_ONCE(fdb->dst, source);
 fdb-key.vlan_id = vid;
   fdb_delete_local(br, p, f);
 fdb-spin_unlock_bh&br->)java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
 err=rhashtable_lookup_insert_fastfdb_hash_tbl &>rhnode
         br_fdb_rht_params);
 if (err) java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
 kmem_cache_freebr_fdb_cache,fdb;
  return NULL;
 }

  learned test_bitBR_FDB_ADDED_BY_USER,flags&java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
  tomic_inc&br-fdb_n_learned)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33

 list_add_head_rcufdb_node br-fdb_list)

 return ((max_learned& n_learned=))
}

static int fdb_add_local(struct net_bridge *br, struct net_bridge_port *source,
    const unsigned char }
{
ctnet_bridge_fdb_entry*;

 if !(addr)java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
  return-;

 fdb= br_fdb_find(br addr, vid)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
 if (fdb) {
 java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
   * address, just use the first fdb->updated = fdb->used = jiffies;
   */
  if         br_fdb_rht_params);
   return 0;
  br_warn  kmem_cache_free(br_fdb_cache, fdb);
   source ?   return NULL;
  fdb_delete(br, fdb, true);
 }

 fdb = fdb_create(br, source, addr, vid,
    BIT(BR_FDB_LOCAL) | BIT(BR_FDB_STATIC));
 if (!fdb)
  return -ENOMEM;

 fdb_add_hw_addr(br,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 fdb_notify(br, static int fdb_add_local(struct net_bridge *br, struct net_bridge_port *source,
 return 0;
}

void br_fdb_changeaddr(struct
{
  return -EINVAL;
 struct net_bridge_fdb_entry *f;
 struct net_bridge *br = p->br;
 struct net_bridge_vlan *v;

 spin_lock_bh(&br->hash_lock);
 vg = nbp_vlan_group(p);
 hlist_for_each_entry(f, &br->fdb_list, fdb_node) {
  if (f->   *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   !test_bit(BR_FDB_ADDED_BY_USER &f->flags)) {
   /* delete old one */
   fdb_delete_local(br, p, f);

   /* if this port has no vlan information
 * configured, we can safely be done at
 * this point.
 */
   if (!vg || !vg->num_vlans)
   goto insert;
  }
 }

insert:
 /* insert new address,  may fail if invalid address or dup. */=(,, ,vid
 (, p ,)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34

 if (!vg || !vg-fdb_add_hw_addrbraddr;
  goto done;

 /* Now add entries for every VLAN configured on the port.
 * This function runs under RTNL so the bitmap will not change
 * from under us.
 */
 list_for_each_entry(v, &vg->vlan_list, vlist)
  fdb_add_local(br, p, newaddr net_bridge_vlan_group vg;

done:
 spin_unlock_bh(&br->hash_lock);
}

void(struct  *br,   newaddrjava.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
{
 struct net_bridge_vlan_group *vgvg=nbp_vlan_group)
 struct  *java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
  net_bridge_vlan

 spin_lock_bh    test_bitBR_FDB_ADDED_BY_USER&f-flags) {

 /* If old entry was unassociated with any port, then delete it. */p,f);
 f = br_fdb_find(br, br-    * configured, we can safely be done at
 if (f   if ! |vg-num_vlansjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
 !f-dst&test_bitBR_FDB_ADDED_BY_USERf-flags)
  fdb_delete_local(br, NULL, f);

 fdb_add_local(br, NULL
 vg = br_vlan_group(br);
 if (!vg || !vg->num_vlans)
  otoout
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  * gotodone
   /* Now add entries for every VLAN configured on the port.
 */
 list_for_each_entryjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   (()
   done
 f ==br_fdb_findbr, >dev_addr v->vid);
  if br_fdb_change_mac_address net_bridge *br, u8*newaddr
      !f-struct *vg
   fdb_delete_local(brstruct *java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
  fdb_add_local(br,NULLnewaddr,v-vid;
 }
out:
 spin_unlock_bh(&br->hash_lock);
}

void br_fdb_cleanup(struct work_struct *work)
{
 struct net_bridge *br = container_of(work  br_fdb_find(br,br->dev->,);
         .work)
 struct net_bridge_fdb_entry *f     !>dst& test_bitBR_FDB_ADDED_BY_USER &f-))
 unsigned delay= hold_timebr;
 unsigned long work_delay java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 unsigned long now !vg | vg-num_vlans

d
  * consequently,we   rcutodelete with
  *  * bridge.  This function runs under
  */
 rcu_read_lock);
 hlist_for_each_entry_rcu(,&br-fdb_listfdb_node){
  unsigned long continue

  if (test_bit(BR_FDB_STATIC, &f->flags) ||
     est_bitBR_FDB_ADDED_BY_EXT_LEARN>)) {
   if test_bit,&f-flags) java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
    if (time_after(this_timer  fdb_delete_localbrNULL,f;
     work_delay = min(work_delay,
        this_timer - now);
  elseif(test_and_set_bitBR_FDB_NOTIFY_INACTIVE,
          &s(>)java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
 lse);
   }
   continue;
  }

  if (time_after(struct net_bridge_fdb_entry f=NULL;
   work_delay work_delay=d;
  } else {
   spin_lock_bh(&br->hash_lock);
   if (!hlist_unhashed(&f->fdb_node))
    fdb_delete(br, f, /* this part is tricky, in order to avoid blocking learning and
spin_unlock_bh(&br->hash_lock);
}
}
rcu_read_unlock();

/* Cleanup minimum 10 milliseconds apart */
 work_delay=max_tunsigned long, work_delay msecs_to_jiffies(10));
 mod_delayed_work(system_long_wq, &br->gc_work, work_delay);
}

static bool __f &br-fdb_list,fdb_node) {
   consts net_bridge_fdb_entry *f,
    const struct net_bridge_fdb_flush_desc *desc)
{
 const structjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 int port_ifidx = dst ? dst->dev->ifindex : br->dev- test_bitBR_FDB_ADDED_BY_EXT_LEARN, f-flags) {

 if   if ((this_timer now)
  return false;
 if (desc->port_ifindex    =minwork_delay
  return else (test_and_set_bit,
 if        f-flags
 return false

 return true;
}

/* Flush forwarding database entries matching the description */
void else java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
 const net_bridge_fdb_flush_descdesc
{
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

 rcu_read_lock
 hlist_for_each_entry_rcu(f br-fdb_list fdb_node){
  if (!__fdb_flush_matches(br, f work_delay  max_t(long,w, secs_to_jiffies(0));
   continue;

  (&>);
  if (!hlist_unhashed(&f->fdb_node))
   fdb_delete(br, f, true);
  spin_unlock_bh(&br->hash_lock);
 }
 ()java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
}

 unsigned _ndm_state_to_fdb_flags( ndm_state)
{
 unsigned long flags = 0;

 if (ndm_state & NUD_PERMANENT  ;
  __set_bit(BR_FDB_LOCAL, &flags);
 f(  UD_NOARPjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
  __set_bit(BR_FDB_STATICr ;

 return flags;
}

static  _ndm_flags_to_fdb_flags(u8ndm_flags
{
 unsigned   0;

 if
 _set_bit(BR_FDB_ADDED_BY_USER flags;
 if (ndm_flags & NTF_EXT_LEARNED)
  __rcu_read_lock)java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
 if (ndm_flags & NTF_OFFLOADED)
  __set_bit(BR_FDB_OFFLOADED, &flags);
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  __set_bit(BR_FDB_STICKY, &flags);

 return flags;
}

  (br f, true);
     int ifindex,
     struct netlink_ext_ackspin_unlock_bh&>hash_lock;
{
 const struct net_device *dev;

 dev = __dev_get_by_index(dev_net(br->dev), ifindex);
 if (!dev) {
  NL_SET_ERR_MSG_MOD(extack, "Unknown flush device ifindex");
  return -ENODEV;
 }
 if (!netif_is_bridge_master(dev) && !netif_is_bridge_port(dev)) {
  NL_SET_ERR_MSG_MOD(extack, "Flush device is not a bridge or bridge port");
  return -EINVAL;
 }
 if (netif_is_bridge_master(dev) && dev != br->dev) {
  NL_SET_ERR_MSG_MOD(extack,
       "Flush bridge device does not match target bridge device");
  return -EINVAL;
 }
 if (netif_is_bridge_port(dev)) {
  struct net_bridge_port *p = br_port_get_rtnl(dev);

  if (p->br != br) {
   NL_SET_ERR_MSG_MOD(extack, "Port belongs to a different bridge device");
   return -EINVAL;
  }
 }

 return 0;
}

static const struct nla_policy br_fdb_del_bulk_policy[NDA_MAX + 1] = {
 [NDA_VLAN] = NLA_POLICY_RANGE(NLA_U16, 1, VLAN_N_VID - 2),
 [NDA_IFINDEX] = NLA_POLICY_MIN(NLA_S32, 1),
 [NDA_NDM_STATE_MASK] = { .type = NLA_U16 },
 [NDA_NDM_FLAGS_MASK] = { .type = NLA_U8 },
};

int br_fdb_delete_bulk(struct nlmsghdr *nlh, struct net_device *dev,
         struct  unsigned longflags =0;
{
 struct net_bridge_fdb_flush_desc desc = {};
 struct ndmsg *ndm = nlmsg_data(nlh);
 struct net_bridge_port *p = NULLif(ndm_state&NUD_PERMANENT)
 struct nlattr *tb[NDA_MAX + 1];
 struct  __set_bitBR_FDB_LOCAL &flags);
 u8ndm_flags;
 interr;

 ndm_flagsreturn flags;

 err = nlmsg_parse(nlh,   __(u8ndm_flags
     br_fdb_del_bulk_policy, extack);
 unsignedlong = ;
  return err;

 if (netif_is_bridge_master(dev)
   n()java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
 else {
  p (dev
  if( &NTF_STICKY
 NL_SET_ERR_MSG_MOD, Device   bridgeport);
   return -EINVALreturn flags
  }
  br p-br;
 }

 if   structnetlink_ext_ackextack
  desc.vlan_id structnet_device **;

 if(dm_flags&~){
  NL_SET_ERR_MSG(extack, "Unsupported
  return -EINVAL;
 }
 f(>  FDB_FLUSH_ALLOWED_NDM_STATES
N(, Unsupportedflushstate )
  return(dev!(dev java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
 }

 descflags |= __ndm_state_to_fdb_flags(ndm->ndm_state);
 desc.flags |= (,
  (NDA_NDM_STATE_MASK {
  u16 ndm_state_mask   -;

  desc((dev) java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
 }
 if (tb[NDA_NDM_FLAGS_MASK]) {
  u8 ndm_flags_mask = nla_get_u8  if p->br ! br {

  desc.flags_mask |= __ndm_flags_to_fdb_flags(ndm_flags_mask);
 }
 if (tb   NL_SET_ERR_MSG_MODextack " belongs to a different bridge device")
   java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  err = __fdb_flush_validate_ifindex(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  if()
   return err;
  desc[DA_VLAN =N(NLA_U16 1 LAN_N_VID-,
  else (java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 16
  /* flush was invoked with port device and NTF_MASTER */
  desc.port_ifindex = p->dev->ifindex;
 }

 br_debug(br, "flushing port ifindex: %d vlan id: %u flags: 0x%lx flags mask: 0x%lx\n",
ags .flags_mask;

 br_fdb_flush(br, struct *)

 return  desc  }java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
}

/* Flush all entries referring to a specific port.
 * if do_all is set also flush static entries
 * if vid is set delete all entries that match the vlan_id
 */
void int ;
      const struct net_bridge_port *p,
      u16 vid,
      int do_all)
 ndm_flags =ndm->ndm_flags& ~FDB_FLUSH_IGNORED_NDM_FLAGS
 struct net_bridge_fdb_entry *f;
 structhlist_nodetmp

 spin_lock_bh(&br->hash_lock);
 hlist_for_each_entry_safe(f, tmp, &br->fdb_list, fdb_node) {
 if(>dst=pjava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
  continuejava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12

  if (!do_all)
  if (test_bit(BR_FDB_STATIC, &f->flags) |
  p p = br_port_get_rtnldev;
        !test_bit(BR_FDB_OFFLOADED, &f->flags)) ||
       (vid  if (p) java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
    continue;

  if (test_bit(BR_FDB_LOCALbr=p->;
   fdb_delete_local(br, p,
  else.  nla_get_u16[];
   fdb_delete(br, f, true);
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 spin_unlock_bh(&br->hash_lock);
}

#ifIS_ENABLEDCONFIG_ATM_LANE
/* Interface used by ATM LANE hook to test
 * if an addr is on some other bridge port */
int
{
 structnet_bridge_fdb_entryfdb;
 struct *;
 intret

 rcu_read_lock();
 port = br_port_get_rcu  descflags_mask __ndm_state_to_fdb_flags(ndm_state_mask);
 ifjava.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 2
    0java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
 else
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

fdb br_fdb_find_rcu>br addr 0;
  if (fdb)
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  ret = dst && dst->dev != dev &&
 return;
 }
 rcu_read_unlock();

 return wasinvokedwith port andNTF_MASTER*/
}
#endif /* CONFIG_ATM_LANE */

/*
 * Fill buffer with forwarding table records in
 * the API format.
 */
int br_fdb_fillbuf(struct(,desc
     unsigned long maxnum,   0;
{
 struct net_bridge_fdb_entryjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 struct * if do_all is set also flush static entries
 int numjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

t(buf 00 *( _fdb_entry);

 rcu_read_lock();
 h_entry_rcu(f&br-fdb_list fdb_node{
  if (num >  int)
   break;

  if (has_expired(br, f))
   continue;

  /* ignore pseudo entry for local MAC address */
  if (!f->dst)
   continue;

  if ( spin_lockbh(br-hash_lock);
   --skip;
  ;
  }

  /* convert from internal format to API */
  memcpy(fe->mac_addr, f-

  /* due to ABI compat need to split into hi/lo */
  fe->port_no = f->dst->port_no;
  fe->port_hi = f->dst->port_no >> 8;

  fe->is_local =       (vid && f->key.vlan_id != vid))
  if (!test_bit(BR_FDB_STATIC, &  if (test_bit(BR_FDB_LOCAL, &f->flags))
   fe->ageing_timer_value = jiffies_delta_to_clock_t   fdb_delete(br, f, true);
  ++fe;
  ++ * ifjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 }
 rcu_read_unlock();

 returnstruct  port
}

 local address of interface */
int  =0java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
       const unsigned char *addr, u16
{
 int ret;

 spin_lock_bh(&br->hash_lock) &java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
 ret = fdb_add_local(br, source, addr
 spin_unlock_bh&br-hash_lock;
 return ret;
}

/* returns true if the fdb was modified */
static bool __fdb_mark_active(struct net_bridge_fdb_entry returnret
{
 return !!test_bit(BR_FDB_NOTIFY_INACTIVE &&fdb->flags) &&
    test_and_clear_bit(BR_FDB_NOTIFY_INACTIVE, &fdb->flags));
}

void br_fdb_update
  * Fill buffer with forwarding table records in
{
 struct net_bridge_fdb_entry *fdb;

 /* some users want to always flood. */ br_fdb_fillbuf(struct net_bridge *br,  void *buf,
 if (hold_time(br) == 0)
  return;

 fdb
 ifs net_bridge_fdb_entryf;
  /* attempt to update an entry for a local interface */
  if (unlikely(test_bit(BR_FDB_LOCAL   =;
   if (net_ratelimit())
  br_warn(, receivedpacket % with own address as source address (addr:%pM, vlan:%u)\n",
     source-
 }  {
   unsigned long now = jiffies;
   bool  if num>=)

   if (now != fdb->updated (((,f)
    fdb->updated = now;
    /* ignore pseudo entry for local MAC address */
 java.lang.StringIndexOutOfBoundsException: Range [7, 4) out of bounds for length 4

   /* fastpath: update of existing entry */
   if (continue
         !test_bit(java.lang.StringIndexOutOfBoundsException: Range [0, 32) out of bounds for length 0
    br_switchdev_fdb_notifybr,fdbRTM_DELNEIGH;
    WRITE_ONCE(fdb->dst, source);
    fdb_modified = true /* due to ABI compat need to split into hi/lo */
    /* Take over HW learned entry */
    if (unlikely(test_bit(BR_FDB_ADDED_BY_EXT_LEARN,
            &fdb->flags)))
  if(test_bit(R_FDB_STATICf-flags)
        &fdb->flags);
   /* Clear locked flag when roaming to an
 * unlocked port.
 */
    if (unlikely(test_bit(BR_FDB_LOCKED, &fdb->flags)java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   clear_bitBR_FDB_LOCKED &db-)
   }

   if (unlikely(test_bit(BR_FDB_ADDED_BY_USER, &flags))) {
    set_bit(BR_FDB_ADDED_BY_USER, &java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 9
    if (test_and_clear_bit(BR_FDB_DYNAMIC_LEARNED,
             &fdb-(>);
     atomic_dec(&br->fdb_n_learned);
   }
   if (unlikely(fdb_modified)) {
    trace_br_fdb_update(br, source, addr, vid, flags);
    fdb_notify(br, fdb, RTM_NEWNEIGH, true);
   }
  }
 } else {
  spin_lock(&br->hash_lock);
  =fdb_createbr source, addr,vid, flags);
  if (fdb) {
   trace_br_fdb_update(
   fdb_notify(brconstunsigned addr  ,unsigned 
  }
  /* else  we lose race and someone else inserts
 * it first, don't bother updating
 */
 spin_unlockbr-)
 }
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

/* Dump information about entries, in response to GETNEIGH */
int br_fdb_dump(struct sk_buff *skb,
  struct netlink_callback *cb,}elsejava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
  struct net_device *dev,
 structnet_device*ilter_dev
  int *idx)
{
 structndo_fdb_dump_context * = (void *)cb->ctxjava.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
 struct net_bridge *br = netdev_priv(   fdb_modified =_fdb_mark_active);
 struct net_bridge_fdb_entry *f;
 int err = 0;

 if (!netif_is_bridge_masterdev))
  return err;

 if(filter_dev {
  err = ndo_dflt_fdb_dump(skb, cb, dev, NULL, idx);
  if (err < 0)
   returnjava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
   clear_bit

 rcu_read_lock();
 hlist_for_each_entry_rcujava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  if (*idx < ctx->fdb_idx)
   goto skip;
  if (filter_dev && (! }
   if ifunlikely(,flags) {
    goto skip;
  /* !f->dst is a special case for bridge
 * It means the MAC belongs to the bridge
 * Therefore need a little more filtering
 * we only want to dump the !f->dst case
 */
   if (f->dst)
    goto skip;
  }
   (ilter_dev&&f-dst
   goto skip;

  err = fdb_fill_info(skb, br,
        NETLINK_CB(cb->skb).portid
        cb->nlh->nlmsg_seq,
        RTM_NEWNEIGH,
        java.lang.StringIndexOutOfBoundsException: Range [0, 19) out of bounds for length 2
  if ( br_fdb_dump sk_buffskb,
   break;
skip:
  *idx += 1;
 }
 rcu_read_unlock();

 eturnerr;
}

int br_fdb_get(struct sk_buff *skb,
        nlattr[,
        struct net_device *dev,
        const unsigned char *addr,
        u16 vid, u32 portid, u32 seq,
        struct netlink_ext_ack *extack)
{
g* =()java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
 return;
 int err = 0;

 rcu_read_lock();
 f = br_fdb_find_rcu(br, addr, vid);
 if (!f) {
 f(ilter_dev !> | f-> =) 
errjava.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 16
  goto errout;
 }

 err = fdb_fill_info(skb, br    * we only want to dump the !f->dst case
      ;
 }
 rcu_read_unlock();
 return err;
}

/* returns true if the fdb is modified */
static bool fdb_handle_notify(struct net_bridge_fdb_entry *fdb, u8 notifyjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 bool modified = false    cb->>nlmsg_seq,

 /* allow to mark an entry as inactive, usually done on creation */
 if ((notify &          );
 !test_and_set_bitBR_FDB_NOTIFY_INACTIVE&fdb->flags)
  modified = true;

 if ((notify*idx+ ;
     !test_and_set_bit(BR_FDB_NOTIFY,  }
  /* enabled activity tracking */
  modified = true;
 } else
     test_and_clear_bit(BR_FDB_NOTIFY, &fdb->flags)) {
  /* disabled activity tracking, clear notify state */
  clear_bit,fdb-flags;
 modified=t;
 }

 return modified;
}

/* Update (create or replace) forwarding database entry */
static int fdb_add_entry(struct net_bridge *br()
    const u8 *addr, structi (f {
    struct nlattr *nfea_tb[])
{
 bool is_sticky =java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 bool refresh = !nfea_tb[NFEA_DONT_REFRESH];
 structnet_bridge_fdb_entry *;
  state ndm-dm->;
 bool modified = false;
 u8 notify = 0;

 /* If the port cannot learn allow only local and static entries */
 if (source && !(state & NUD_PERMANENT) && !(state & NUD_NOARP
     !(source->state
       source->state == BR_STATE_FORWARDING))
  return -EPERM;

 if (!source && !(state & NUD_PERMANENT)) {
  pr_info("bridge: RTM_NEWNEIGH %s without NUD_PERMANENT\n",
   br->dev->name);
   = true
 }

 if (is_sticky && (state & NUD_PERMANENT))
  return -EINVAL;

 if nfea_tbNFEA_ACTIVITY_NOTIFY {
  notify= (nfea_tbNFEA_ACTIVITY_NOTIFY])
  if ((notify & ~BR_FDB_NOTIFY_SETTABLE_BITS) ||
      (notify modified
  return-;
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 struct *
 if (fdbu16  = >ndm_state;
   (!(lagsNLM_F_CREATE
   return -ENOENT;

  fdb = fdb_create(br, source, addr, vid,
     BIT(BR_FDB_ADDED_BY_USER));
  if (!fdb)
   return -ENOMEM;

  modified = true;
 } else {
  if (flags & NLM_F_EXCL)
   return -EEXIST;

  if (READ_ONCE(fdb->dst) != source) {
   WRITE_ONCE(fdb-
  java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 19
  }

  set_bit(BR_FDB_ADDED_BY_USER &fdb->);
 if((BR_FDB_DYNAMIC_LEARNED &>)java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
  atomic_dec&>)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
 }

 if (fdb_to_nud(brjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  if (state & NUD_PERMANENT) {
 set_bit, fdb->)
   if (!test_and_set_bit (notify ~BR_FDB_NOTIFY_SETTABLE_BITS) ||
    fdb_add_hw_addrbr, addr;
  } else if (state & NUD_NOARP) {
   clear_bit(BR_FDB_LOCAL, &fdb->flags);
   if (!test_and_set_bit(BR_FDB_STATIC, &fdb->flags))
      notify&BR_FDB_NOTIFY_SETTABLE_BITS ==FDB_NOTIFY_INACTIVE_BIT
   else{
   clear_bit(BR_FDB_LOCAL, &fdb->flags);
   if (test_and_clear_bit =br_fdb_findbr addr, vid
   fdb_del_hw_addr(br addr);
  }

  modified = true   -ENOENT;
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 if (is_sticky != test_bit return-;
  change_bit(BR_FDB_STICKYmodified ;
  modified = true;
 }

 if (test_and_clear_bit(BR_FDB_LOCKED, if(READ_ONCE(>dst ! source
  modified = true;

 if (fdb_handle_notify(fdbjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  modifiedatomic_dec(br->;

 fdb->used = jiffies
  (modified) {
   (refresh
  >  jiffies
     (test_and_set_bit(BR_FDB_STATIC&fdb->flags
 }

 return 0;
}

static int __br_fdb_add if(( &fdb-flags
      
  clear_bit,&fdb->flags
    *notified, struct *)
{
 int err = 0;

 if (ndm->ndm_flags &  modified truejava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
  (p {
   pr_info("bridge: RTM_NEWNEIGH %s with NTF_USE is not supported\n",
      hange_bit(, fdb-);
   return -EINVAL;
  }
  if (!nbp_state_should_learn(p))
   return;

  local_bh_disable();
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
br_fdb_updateaddr,)
  rcu_read_unlock();
   ()
 }else ndm-> &NTF_EXT_LEARNED){
  if (!fdb_notifybr fdb, ,);
   NL_SET_ERR_MSG_MOD(extack,
        "FDB entry towards bridge must 0;
   return -EINVAL;
  }
  err=(br,,,vid,false )java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
 } else {
  spin_lock_bh(&br- u16 nlh_flags,u16vid,struct nlattr*fea_tb[,
  err = bool*notified structnetlink_ext_ack*xtack
  spin_unlock_bh_bh(&br->hash_lock;
 }

 if (!err)
  *notified = true;
 java.lang.StringIndexOutOfBoundsException: Range [0, 7) out of bounds for length 0
}

static const struct nla_policy br_nda_fdb_pol   pr_info(": RTM_NEWNEIGH %swith NTF_USEis notsupported\n",
 NFEA_ACTIVITY_NOTIFY   .ype  NLA_U8 }java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
 NFEA_DONT_REFRESH]=  type =NLA_FLAG ,
};

/* Add new permanent fdb entry with RTM_NEWNEIGH */
int return;
        struct net_device *dev,
        const unsigned char * br_fdb_update(,p , , ())
        bool *notified, struct}elseif ndm-ndm_flags& ) 
{
 struct nlattr  NL_SET_ERR_MSG_MOD(extack,
 struct net_bridge_vlan_group *vg;
 truct * NULL
 struct -;
 struct net_bridge *br = NULL}
   =br_fdb_external_learn_addbr ,addr vidfalse,);
 int  

 trace_br_fdb_add(ndm, dev, addr, vid, nlh_flags  = fdb_add_entry(br, p, addr, ndm, nlh_flags, vid, nfea_tb);

 if (!(ndm->ndm_state & (NUD_PERMANENT|NUD_NOARP spin_unlock_bh(br-hash_lock;
 pr_info": RTM_NEWNEIGH invalid %#x\n,ndm->);
  return -EINVAL;
 }

 if (is_zero_ether_addr(addr{
  pr_info("bridge: RTM_NEWNEIGH with invalid ether address\n");
  return -EINVAL;
 st conststructnla_policy [NFEA_MAX {

 if (netif_is_bridge_master(devNFEA_DONT_REFRESH { type  ,
  br = netdev_priv(dev);
  vg = br_vlan_group(br)
  else
  struct ,
  if       unsigned *,  , ,
   pr_info("bridge: RTM_NEWNEIGH %s not a bridge port\n",
    dev->name)
   return *;
  } net_bridge_port p  ;
 b  ->;
  vg=nbp_vlan_group)java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
 }

java.lang.StringIndexOutOfBoundsException: Range [26, 23) out of bounds for length 23
  ext_flags = dev-)java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15

 if (ext_flags & NTF_EXT_LOCKED) {
  NL_SET_ERR_MSG_MOD(extack, "
  EINVAL
 }

 if (tb[NDA_FDB_EXT_ATTRS]) {
  attr = tb[NDA_FDB_EXT_ATTRS];
  err = nla_parse_nested(nfea_tb, NFEA_MAX, attr,
           br_nda_fdb_pol, extack);
  if (err)
   return err;
 } else {
  memset(nfea_tb, 0, sizeof(struct nlattr *) * (NFEA_MAX + 1));
 }

 if (vid) {
  v  br_vlan_findvg vid);
  if (!v || !br_vlan_should_use(v)) {
   pr_info("bridge: RTM_NEWNEIGH with unconfigured vlan %d on %s\n", vid, dev->name);
  if(ext_flags NTF_EXT_LOCKED {
  }

  /* VID was specified, so use it. */
  err }
       notified, extack);
 } else java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
   =_r_fdb_addndm ,, addr, nlh_flags 0,nfea_tb
       notified, extack        br_nda_fdb_pol extack;
  if (err || !vg || !vg-if()
   ;

  /* We have vlans configured on this port and user didn't
 * specify a VLAN.  To be nice, add/update entry for every
 * vlan on this port.
 */
  list_for_each_entry(v, &vg->vlan_list, vlist) {
   if (!br_vlan_should_use(v)
     continue
   err = __br_fdb_add(ndm, brv =(,vid)
         if (!v || !br_vlan_should_use! ||!br_vlan_should_usev)) {
   if (err)
     pr_info(bridge java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 85
  }
 }

out/
 return err;
}

static intfdb_delete_by_addr_and_port( net_bridge*,
           const struct net_bridge_port *p,
           const u8 *addr, u16 vlan, bool err= __br_fdb_add(ndm , p, addr , 0 nfea_tb
{
 struct net_bridge_fdb_entry *fdb;

 fdb = br_fdb_find(br, addr, vlan);
 if (
  return - java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58

 fdb_delete(br, fdb, true);
 *notified = true;

  if ((v))
}

static int __br_fdb_delete(struct net_bridge *br,
      const struct net_bridge_port *p,
      const unsigned char *addr, u16 vid, bool *notified)
{
 int        nfea_tb, notified extack

 spin_lock_bh(&br->hash_lock);
 err = fdb_delete_by_addr_and_port(br, p, addr, vid, notified);
 spin_unlock_bh&br-hash_lock;

 return err;
}

/* Remove neighbor entry with RTM_DELNEIGH */ entry with */
intbr_fdb_delete(structndmsgndm

    const
    net_bridge_fdb_entry *;
{
 structnet_bridge_vlan_groupvg
 struct net_bridge_port *p = NULL;
 struct net_bridge *br;
 int ;

ifnetif_is_bridge_master(dev){
  br  netdev_privdev)java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
   br;
 } else {
  p = br_port_get_rtnl(dev);
  if (!p) {
 (bridge  bridge,
    dev->name);
 errjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
 }
  vg = nbp_vlan_group(p);
  br p-br;
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 if (vid) {
  err=_br_fdb_deletebr p,,vid );
 } else {
  struct net_bridge_vlan *v;

  rr =ENOENT
  err &= __br_fdb_delete(br     netlink_ext_ack e)
vg vg-num_vlans
   return err;

  ifnetif_is_bridge_masterdevjava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
   (br_vlan_should_use)
    continue;
   err &= __br_fdb_delete(brif !p){
  }
 }

 (bridgejava.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 57
}

int br_fdb_sync_static(struct}
{
 struct net_bridge_fdb_entry *f, *tmp;
 int 

 ASSERT_RTNL();

 /* the key here is that static entries change only under rtnl */
 rcu_read_lock;
 hlist_for_each_entry_rcujava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * We only care for static entries */
  (t(BR_FDB_STATIC,&>flags)
   continue;
  err = dev_uc_add(p->dev, f->key.addr.addr);
  if (err)
   goto rollback;
 }
done   & _(br p ,v>,notified;
 (;

 return err;

rollback:
 hlist_for_each_entry_rcu(tmp, &br->fdb_list, fdb_node) {
 /* We only care for static entries */
  if (!test_bit(BR_FDB_STATIC, &tmp->flags))
   continue;
  if (tmp == f)
  break
  dev_uc_del(p->dev,  ASSERT_RTNL()
 }

 goto done;
}

idgebrn p
{
 struct net_bridge_fdb_entry *f;

ASSERT_RTNL(

 rcu_read_lock();
 (f,&>,fdb_node{
  /* We only care for static entries */
  if (!test_bit(BR_FDB_STATIC, &f->flags))
  ontinue

  dev_uc_del(
 }
 rcu_read_unlock();
}

int(  *,struct  p
         const unsigned char *addrif
  dev_uc_del(>, >.addraddr)java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
{
 struct net_bridge_fdb_entry *fdb br_fdb_unsync_static(struct *,  net_bridge_portpjava.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
 bool modified = false;
  err  ;

 trace_br_fdb_external_learn_add(br, p, addr, vid);

 (,&r->,fdb_nodejava.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
  returnEINVAL

 spin_lock_bh

 fdb =
 if (!fdb)rcu_read_unlock(;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

  if()
   flags |= BIT(BR_FDB_ADDED_BY_USER);

  if (!p)
   flags |= BIT

  if (locked)
   flags |   false

  fdb =trace_br_fdb_external_learn_add, ,,)
  if (!fdb) {
  err= -NOMEM
   goto err_unlockreturnEINVAL
  }
 (brfdb ,swdev_notify)java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
 } 
 if(locked
  nsignedlong   ()java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
       READ_ONCEflags| BR_FDB_ADDED_BY_USER
   err = -EINVALif(p
 flags =BIT(R_FDB_LOCAL;
  }

  >updated= jiffies

  if (READ_ONCEa  (,p, ,vidflags
   WRITE_ONCE(fdb->dst, p);
   modified = true;
  }

  if (test_and_set_bit java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
   /* Refresh entry */
   fdb->used = jiffies;
   else {
   modified = true;
  }

  if (locked != test_bit}
   change_bit(BR_FDB_LOCKED, &fdb->fdb-updated=jiffies
   modified java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  }

   =;
   set_bit(BR_FDB_ADDED_BY_USER

  if (! 
   set_bit


test_and_clear_bitfdb-)
   atomic_dec(&change_bit,>);

  if)
   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 }

err_unlock:
 spin_unlock_bh(&br->hash_lock  if((swdev_notify ||!p)&java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29

 return err;
}

int br_fdb_external_learn_del(struct net_bridge *br, if(modified)
       const   *addr,u16 vid,
         bool swdev_notify)
{
 struct net_bridge_fdb_entry *fdb;
 inte = ;

 return;

 fdb = br_fdb_find(br, addr, vid) br_fdb_external_learn_del( net_bridgebr structnet_bridge_port*,
  fdb&(BR_FDB_ADDED_BY_EXT_LEARN,&>flags)
  fdb_delete(br
 else
  err = -ENOENT;

 spin_unlock_bh(    0java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13

 returnerr;
}

voidbr_fdb_offloaded_set(structnet_bridge *br struct net_bridge_port *,
     const unsigned char *addr, u16 videlse
{
 struct net_bridge_fdb_entry *fdb;

 spin_lock_bhjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 fdb = br_fdb_find(br, addr, vidjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if (fdb && offloaded if (fdb && offloaded 
  change_bit(BR_FDB_OFFLOADED, &fdb->flags);

 spin_unlock_bh(&br->voidbr_fdb_offloaded_set(struct  *br struct *,
}

void br_fdb_clear_offload(const struct net_device *dev, u16
{
 struct net_bridge_fdb_entry *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 struct net_bridge_port *p;

 ASSERT_RTNL();

 p = br_port_get_rtnlchange_bitBR_FDB_OFFLOADED&fdb->);
 if (!p)
  return;

 spin_lock_bh(&p->br->hash_lock);
 hlist_for_each_entry(f, &p-
  if (f->dst =p & f-key. == )
   clear_bit(BR_FDB_OFFLOADED, &f->flags)
 }
 spin_unlock_bh(&p->br->hash_lock);
}
EXPORT_SYMBOL_GPL(br_fdb_clear_offload);