Release 4.8 net/bridge/br_fdb.c

Directory: net/bridge
/*
 *      Forwarding database
 *      Linux ethernet bridge
 *
 *      Authors:
 *      Lennert Buytenhek               <buytenh@gnu.org>
 *
 *      This program is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU General Public License
 *      as published by the Free Software Foundation; either version
 *      2 of the License, or (at your option) any later version.
 */

#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.h>
#include <asm/unaligned.h>
#include <linux/if_vlan.h>
#include <net/switchdev.h>
#include "br_private.h"


static struct kmem_cache *br_fdb_cache __read_mostly;
static struct net_bridge_fdb_entry *fdb_find(struct hlist_head *head,
					     const unsigned char *addr,
					     __u16 vid);
static int fdb_insert(struct net_bridge *br, struct net_bridge_port *source,
		      const unsigned char *addr, u16 vid);
static void fdb_notify(struct net_bridge *br,
		       const struct net_bridge_fdb_entry *, int);


static u32 fdb_salt __read_mostly;



int __init br_fdb_init(void)
{
	br_fdb_cache = kmem_cache_create("bridge_fdb_cache",
					 sizeof(struct net_bridge_fdb_entry),
					 0,
					 SLAB_HWCACHE_ALIGN, NULL);
	if (!br_fdb_cache)
		return -ENOMEM;

	get_random_bytes(&fdb_salt, sizeof(fdb_salt));
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
stephen hemminger stephen hemminger 37 74.00% 2 66.67%
akinobu mita akinobu mita 13 26.00% 1 33.33%
Total 50 100.00% 3 100.00%



void br_fdb_fini(void)
{
	kmem_cache_destroy(br_fdb_cache);
}


Contributors
Person Tokens Prop Commits CommitProp
stephen hemminger stephen hemminger 12 100.00% 1 100.00%
Total 12 100.00% 1 100.00%

/* 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)
{
	return br->topology_change ? br->forward_delay : br->ageing_time;
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 18 66.67% 1 33.33%
stephen hemminger stephen hemminger 9 33.33% 2 66.67%
Total 27 100.00% 3 100.00%



static inline int has_expired(const struct net_bridge *br,
				  const struct net_bridge_fdb_entry *fdb)
{
	return !fdb->is_static &&
		time_before_eq(fdb->updated + hold_time(br), jiffies);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 30 76.92% 1 25.00%
stephen hemminger stephen hemminger 9 23.08% 3 75.00%
Total 39 100.00% 4 100.00%



static inline int br_mac_hash(const unsigned char *mac, __u16 vid)
{
	/* use 1 byte of OUI and 3 bytes of NIC */
	u32 key = get_unaligned((u32 *)(mac + 2));
	return jhash_2words(key, vid, fdb_salt) & (BR_HASH_SIZE - 1);
}

Contributors
Person Tokens Prop Commits CommitProp
stephen hemminger stephen hemminger 23 46.94% 3 60.00%
pre-git pre-git 19 38.78% 1 20.00%
vlad yasevich vlad yasevich 7 14.29% 1 20.00%
Total 49 100.00% 5 100.00%



static void fdb_rcu_free(struct rcu_head *head)
{
	struct net_bridge_fdb_entry *ent
		= container_of(head, struct net_bridge_fdb_entry, rcu);
	kmem_cache_free(br_fdb_cache, ent);
}

Contributors
Person Tokens Prop Commits CommitProp
michal miroslaw michal miroslaw 33 100.00% 1 100.00%
Total 33 100.00% 1 100.00%

/* When a static FDB entry is added, the 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)
{
	int err;
	struct net_bridge_port *p;

	ASSERT_RTNL();

	list_for_each_entry(p, &br->port_list, list) {
		if (!br_promisc_port(p)) {
			err = dev_uc_add(p->dev, addr);
			if (err)
				goto undo;
		}
	}

	return;
undo:
	list_for_each_entry_continue_reverse(p, &br->port_list, list) {
		if (!br_promisc_port(p))
			dev_uc_del(p->dev, addr);
	}
}

Contributors
Person Tokens Prop Commits CommitProp
vlad yasevich vlad yasevich 91 94.79% 1 33.33%
li rongqing li rongqing 4 4.17% 1 33.33%
jiri pirko jiri pirko 1 1.04% 1 33.33%
Total 96 100.00% 3 100.00%

/* 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 fdb_del_hw_addr(struct net_bridge *br, const unsigned char *addr)
{
	struct net_bridge_port *p;

	ASSERT_RTNL();

	list_for_each_entry(p, &br->port_list, list) {
		if (!br_promisc_port(p))
			dev_uc_del(p->dev, addr);
	}
}

Contributors
Person Tokens Prop Commits CommitProp
vlad yasevich vlad yasevich 51 98.08% 1 50.00%
jiri pirko jiri pirko 1 1.92% 1 50.00%
Total 52 100.00% 2 100.00%



static void fdb_del_external_learn(struct net_bridge_fdb_entry *f)
{
	struct switchdev_obj_port_fdb fdb = {
		.obj = {
			.orig_dev = f->dst->dev,
			.id = SWITCHDEV_OBJ_ID_PORT_FDB,
			.flags = SWITCHDEV_F_DEFER,
                },
		.vid = f->vlan_id,
        };

	ether_addr_copy(fdb.addr, f->addr.addr);
	switchdev_port_obj_del(f->dst->dev, &fdb.obj);
}

Contributors
Person Tokens Prop Commits CommitProp
scott feldman scott feldman 33 44.00% 1 12.50%
jiri pirko jiri pirko 31 41.33% 5 62.50%
ido schimmel ido schimmel 9 12.00% 1 12.50%
vivien didelot vivien didelot 2 2.67% 1 12.50%
Total 75 100.00% 8 100.00%



static void fdb_delete(struct net_bridge *br, struct net_bridge_fdb_entry *f)
{
	if (f->is_static)
		fdb_del_hw_addr(br, f->addr.addr);

	if (f->added_by_external_learn)
		fdb_del_external_learn(f);

	hlist_del_rcu(&f->hlist);
	fdb_notify(br, f, RTM_DELNEIGH);
	call_rcu(&f->rcu, fdb_rcu_free);
}

Contributors
Person Tokens Prop Commits CommitProp
stephen hemminger stephen hemminger 37 52.11% 3 42.86%
vlad yasevich vlad yasevich 16 22.54% 1 14.29%
scott feldman scott feldman 11 15.49% 1 14.29%
michal miroslaw michal miroslaw 6 8.45% 1 14.29%
jiri pirko jiri pirko 1 1.41% 1 14.29%
Total 71 100.00% 7 100.00%

/* Delete a local entry if no other port had the same address. */


static void fdb_delete_local(struct net_bridge *br,
			     const struct net_bridge_port *p,
			     struct net_bridge_fdb_entry *f)
{
	const unsigned char *addr = f->addr.addr;
	struct net_bridge_vlan_group *vg;
	const struct net_bridge_vlan *v;
	struct net_bridge_port *op;
	u16 vid = f->vlan_id;

	/* Maybe another port has same hw addr? */
	list_for_each_entry(op, &br->port_list, list) {
		vg = nbp_vlan_group(op);
		if (op != p && ether_addr_equal(op->dev->dev_addr, addr) &&
		    (!vid || br_vlan_find(vg, vid))) {
			f->dst = op;
			f->added_by_user = 0;
			return;
		}
	}

	vg = br_vlan_group(br);
	v = br_vlan_find(vg, vid);
	/* Maybe bridge device has same hw addr? */
	if (p && ether_addr_equal(br->dev->dev_addr, addr) &&
	    (!vid || (v && br_vlan_should_use(v)))) {
		f->dst = NULL;
		f->added_by_user = 0;
		return;
	}

	fdb_delete(br, f);
}

Contributors
Person Tokens Prop Commits CommitProp
toshiaki makita toshiaki makita 140 74.87% 2 66.67%
nikolay aleksandrov nikolay aleksandrov 47 25.13% 1 33.33%
Total 187 100.00% 3 100.00%



void br_fdb_find_delete_local(struct net_bridge *br,
			      const struct net_bridge_port *p,
			      const unsigned char *addr, u16 vid)
{
	struct hlist_head *head = &br->hash[br_mac_hash(addr, vid)];
	struct net_bridge_fdb_entry *f;

	spin_lock_bh(&br->hash_lock);
	f = fdb_find(head, addr, vid);
	if (f && f->is_local && !f->added_by_user && f->dst == p)
		fdb_delete_local(br, p, f);
	spin_unlock_bh(&br->hash_lock);
}

Contributors
Person Tokens Prop Commits CommitProp
toshiaki makita toshiaki makita 103 100.00% 1 100.00%
Total 103 100.00% 1 100.00%



void br_fdb_changeaddr(struct net_bridge_port *p, const unsigned char *newaddr)
{
	struct net_bridge_vlan_group *vg;
	struct net_bridge *br = p->br;
	struct net_bridge_vlan *v;
	int i;

	spin_lock_bh(&br->hash_lock);

	vg = nbp_vlan_group(p);
	/* Search all chains since old address/hash is unknown */
	for (i = 0; i < BR_HASH_SIZE; i++) {
		struct hlist_node *h;
		hlist_for_each(h, &br->hash[i]) {
			struct net_bridge_fdb_entry *f;

			f = hlist_entry(h, struct net_bridge_fdb_entry, hlist);
			if (f->dst == p && f->is_local && !f->added_by_user) {
				/* 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. */
	fdb_insert(br, p, newaddr, 0);

	if (!vg || !vg->num_vlans)
		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_insert(br, p, newaddr, v->vid);

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

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 71 35.32% 1 8.33%
stephen hemminger stephen hemminger 48 23.88% 6 50.00%
toshiaki makita toshiaki makita 38 18.91% 3 25.00%
nikolay aleksandrov nikolay aleksandrov 34 16.92% 1 8.33%
vlad yasevich vlad yasevich 10 4.98% 1 8.33%
Total 201 100.00% 12 100.00%



void br_fdb_change_mac_address(struct net_bridge *br, const u8 *newaddr)
{
	struct net_bridge_vlan_group *vg;
	struct net_bridge_fdb_entry *f;
	struct net_bridge_vlan *v;

	spin_lock_bh(&br->hash_lock);

	/* If old entry was unassociated with any port, then delete it. */
	f = __br_fdb_get(br, br->dev->dev_addr, 0);
	if (f && f->is_local && !f->dst && !f->added_by_user)
		fdb_delete_local(br, NULL, f);

	fdb_insert(br, NULL, newaddr, 0);
	vg = br_vlan_group(br);
	if (!vg || !vg->num_vlans)
		goto out;
	/* Now remove and add entries for every VLAN configured on the
         * bridge.  This function runs under RTNL so the bitmap will not
         * change from under us.
         */
	list_for_each_entry(v, &vg->vlan_list, vlist) {
		if (!br_vlan_should_use(v))
			continue;
		f = __br_fdb_get(br, br->dev->dev_addr, v->vid);
		if (f && f->is_local && !f->dst && !f->added_by_user)
			fdb_delete_local(br, NULL, f);
		fdb_insert(br, NULL, newaddr, v->vid);
	}
out:
	spin_unlock_bh(&br->hash_lock);
}

Contributors
Person Tokens Prop Commits CommitProp
vlad yasevich vlad yasevich 67 33.67% 2 25.00%
stephen hemminger stephen hemminger 62 31.16% 1 12.50%
toshiaki makita toshiaki makita 46 23.12% 4 50.00%
nikolay aleksandrov nikolay aleksandrov 24 12.06% 1 12.50%
Total 199 100.00% 8 100.00%



void br_fdb_cleanup(unsigned long _data)
{
	struct net_bridge *br = (struct net_bridge *)_data;
	unsigned long delay = hold_time(br);
	unsigned long next_timer = jiffies + br->ageing_time;
	int i;

	spin_lock(&br->hash_lock);
	for (i = 0; i < BR_HASH_SIZE; i++) {
		struct net_bridge_fdb_entry *f;
		struct hlist_node *n;

		hlist_for_each_entry_safe(f, n, &br->hash[i], hlist) {
			unsigned long this_timer;
			if (f->is_static)
				continue;
			if (f->added_by_external_learn)
				continue;
			this_timer = f->updated + delay;
			if (time_before_eq(this_timer, jiffies))
				fdb_delete(br, f);
			else if (time_before(this_timer, next_timer))
				next_timer = this_timer;
		}
	}
	spin_unlock(&br->hash_lock);

	mod_timer(&br->gc_timer, round_jiffies_up(next_timer));
}

Contributors
Person Tokens Prop Commits CommitProp
stephen hemminger stephen hemminger 70 42.42% 6 50.00%
pre-git pre-git 44 26.67% 1 8.33%
baruch even baruch even 36 21.82% 1 8.33%
siva mannem siva mannem 7 4.24% 1 8.33%
fabio checconi fabio checconi 4 2.42% 1 8.33%
eric dumazet eric dumazet 2 1.21% 1 8.33%
andrew morton andrew morton 2 1.21% 1 8.33%
Total 165 100.00% 12 100.00%

/* Completely flush all dynamic entries in forwarding database.*/


void br_fdb_flush(struct net_bridge *br)
{
	int i;

	spin_lock_bh(&br->hash_lock);
	for (i = 0; i < BR_HASH_SIZE; i++) {
		struct net_bridge_fdb_entry *f;
		struct hlist_node *n;
		hlist_for_each_entry_safe(f, n, &br->hash[i], hlist) {
			if (!f->is_static)
				fdb_delete(br, f);
		}
	}
	spin_unlock_bh(&br->hash_lock);
}

Contributors
Person Tokens Prop Commits CommitProp
stephen hemminger stephen hemminger 80 100.00% 2 100.00%
Total 80 100.00% 2 100.00%

/* 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 br_fdb_delete_by_port(struct net_bridge *br,
			   const struct net_bridge_port *p,
			   u16 vid,
			   int do_all)
{
	int i;

	spin_lock_bh(&br->hash_lock);
	for (i = 0; i < BR_HASH_SIZE; i++) {
		struct hlist_node *h, *g;

		hlist_for_each_safe(h, g, &br->hash[i]) {
			struct net_bridge_fdb_entry *f
				= hlist_entry(h, struct net_bridge_fdb_entry, hlist);
			if (f->dst != p)
				continue;

			if (!do_all)
				if (f->is_static || (vid && f->vlan_id != vid))
					continue;

			if (f->is_local)
				fdb_delete_local(br, p, f);
			else
				fdb_delete(br, f);
		}
	}
	spin_unlock_bh(&br->hash_lock);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 67 46.85% 1 12.50%
stephen hemminger stephen hemminger 56 39.16% 5 62.50%
nikolay aleksandrov nikolay aleksandrov 17 11.89% 1 12.50%
toshiaki makita toshiaki makita 3 2.10% 1 12.50%
Total 143 100.00% 8 100.00%

/* No locking or refcounting, assumes caller has rcu_read_lock */


struct net_bridge_fdb_entry *__br_fdb_get(struct net_bridge *br,
					  const unsigned char *addr,
					  __u16 vid)
{
	struct net_bridge_fdb_entry *fdb;

	hlist_for_each_entry_rcu(fdb,
				&br->hash[br_mac_hash(addr, vid)], hlist) {
		if (ether_addr_equal(fdb->addr.addr, addr) &&
		    fdb->vlan_id == vid) {
			if (unlikely(has_expired(br, fdb)))
				break;
			return fdb;
		}
	}

	return NULL;
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 39 51.32% 1 20.00%
stephen hemminger stephen hemminger 26 34.21% 2 40.00%
vlad yasevich vlad yasevich 10 13.16% 1 20.00%
joe perches joe perches 1 1.32% 1 20.00%
Total 76 100.00% 5 100.00%

#if IS_ENABLED(CONFIG_ATM_LANE)
/* Interface used by ATM LANE hook to test
 * if an addr is on some other bridge port */


int br_fdb_test_addr(struct net_device *dev, unsigned char *addr)
{
	struct net_bridge_fdb_entry *fdb;
	struct net_bridge_port *port;
	int ret;

	rcu_read_lock();
	port = br_port_get_rcu(dev);
	if (!port)
		ret = 0;
	else {
		fdb = __br_fdb_get(port->br, addr, 0);
		ret = fdb && fdb->dst && fdb->dst->dev != dev &&
			fdb->dst->state == BR_STATE_FORWARDING;
	}
	rcu_read_unlock();

	return ret;
}
Contributors
Person Tokens Prop Commits CommitProp
stephen hemminger stephen hemminger 50 53.76% 3 37.50%
michal miroslaw michal miroslaw 26 27.96% 1 12.50%
pre-git pre-git 11 11.83% 1 12.50%
vlad yasevich vlad yasevich 2 2.15% 1 12.50%
patrick mchardy patrick mchardy 2 2.15% 1 12.50%
jiri pirko jiri pirko 2 2.15% 1 12.50%
Total 93 100.00% 8 100.00%

#endif /* CONFIG_ATM_LANE */

/*
 * Fill buffer with forwarding table records in
 * the API format.
 */


int br_fdb_fillbuf(struct net_bridge *br, void *buf,
		   unsigned long maxnum, unsigned long skip)
{
	struct __fdb_entry *fe = buf;
	int i, num = 0;
	struct net_bridge_fdb_entry *f;

	memset(buf, 0, maxnum*sizeof(struct __fdb_entry));

	rcu_read_lock();
	for (i = 0; i < BR_HASH_SIZE; i++) {
		hlist_for_each_entry_rcu(f, &br->hash[i], hlist) {
			if (num >= maxnum)
				goto out;

			if (has_expired(br, f))
				continue;

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

			if (skip) {
				--skip;
				continue;
			}

			/* convert from internal format to API */
			memcpy(fe->mac_addr, f->addr.addr, ETH_ALEN);

			/* 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 = f->is_local;
			if (!f->is_static)
				fe->ageing_timer_value = jiffies_delta_to_clock_t(jiffies - f->updated);
			++fe;
			++num;
		}
	}

 out:
	rcu_read_unlock();

	return num;
}

Contributors
Person Tokens Prop Commits CommitProp
stephen hemminger stephen hemminger 119 58.62% 7 70.00%
pre-git pre-git 83 40.89% 2 20.00%
eric dumazet eric dumazet 1 0.49% 1 10.00%
Total 203 100.00% 10 100.00%



static struct net_bridge_fdb_entry *fdb_find(struct hlist_head *head,
					     const unsigned char *addr,
					     __u16 vid)
{
	struct net_bridge_fdb_entry *fdb;

	hlist_for_each_entry(fdb, head, hlist) {
		if (ether_addr_equal(fdb->addr.addr, addr) &&
		    fdb->vlan_id == vid)
			return fdb;
	}
	return NULL;
}

Contributors
Person Tokens Prop Commits CommitProp
stephen hemminger stephen hemminger 36 58.06% 4 57.14%
pre-git pre-git 16 25.81% 1 14.29%
vlad yasevich vlad yasevich 9 14.52% 1 14.29%
joe perches joe perches 1 1.61% 1 14.29%
Total 62 100.00% 7 100.00%



static struct net_bridge_fdb_entry *fdb_find_rcu(struct hlist_head *head,
						 const unsigned char *addr,
						 __u16 vid)
{
	struct net_bridge_fdb_entry *fdb;

	hlist_for_each_entry_rcu(fdb, head, hlist) {
		if (ether_addr_equal(fdb->addr.addr, addr) &&
		    fdb->vlan_id == vid)
			return fdb;
	}
	return NULL;
}

Contributors
Person Tokens Prop Commits CommitProp
stephen hemminger stephen hemminger 40 64.52% 5 62.50%
pre-git pre-git 12 19.35% 1 12.50%
vlad yasevich vlad yasevich 9 14.52% 1 12.50%
joe perches joe perches 1 1.61% 1 12.50%
Total 62 100.00% 8 100.00%



static struct net_bridge_fdb_entry *fdb_create(struct hlist_head *head,
					       struct net_bridge_port *source,
					       const unsigned char *addr,
					       __u16 vid,
					       unsigned char is_local,
					       unsigned char is_static)
{
	struct net_bridge_fdb_entry *fdb;

	fdb = kmem_cache_alloc(br_fdb_cache, GFP_ATOMIC);
	if (fdb) {
		memcpy(fdb->addr.addr, addr, ETH_ALEN);
		fdb->dst = source;
		fdb->vlan_id = vid;
		fdb->is_local = is_local;
		fdb->is_static = is_static;
		fdb->added_by_user = 0;
		fdb->added_by_external_learn = 0;
		fdb->updated = fdb->used = jiffies;
		hlist_add_head_rcu(&fdb->hlist, head);
	}
	return fdb;
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 46 36.22% 1 10.00%
stephen hemminger stephen hemminger 40 31.50% 4 40.00%
roopa prabhu roopa prabhu 10 7.87% 1 10.00%
pavel emelianov pavel emelianov 10 7.87% 1 10.00%
vlad yasevich vlad yasevich 9 7.09% 1 10.00%
toshiaki makita toshiaki makita 6 4.72% 1 10.00%
scott feldman scott feldman 6 4.72% 1 10.00%
Total 127 100.00% 10 100.00%



static int fdb_insert(struct net_bridge *br, struct net_bridge_port *source,
		  const unsigned char *addr, u16 vid)
{
	struct hlist_head *head = &br->hash[br_mac_hash(addr, vid)];
	struct net_bridge_fdb_entry *fdb;

	if (!is_valid_ether_addr(addr))
		return -EINVAL;

	fdb = fdb_find(head, addr, vid);
	if (fdb) {
		/* it is okay to have multiple ports with same
                 * address, just use the first one.
                 */
		if (fdb->is_local)
			return 0;
		br_warn(br, "adding interface %s with same address "
		       "as a received packet\n",
		       source ? source->dev->name : br->dev->name);
		fdb_delete(br, fdb);
	}

	fdb = fdb_create(head, source, addr, vid, 1, 1);
	if (!fdb)
		return -ENOMEM;

	fdb_add_hw_addr(br, addr);
	fdb_notify(br, fdb, RTM_NEWNEIGH);
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
stephen hemminger stephen hemminger 132 81.99% 6 46.15%
vlad yasevich vlad yasevich 15 9.32% 3 23.08%
hong zhi guo hong zhi guo 8 4.97% 1 7.69%
roopa prabhu roopa prabhu 4 2.48% 1 7.69%
hideaki yoshifuji hideaki yoshifuji 1 0.62% 1 7.69%
jiri pirko jiri pirko 1 0.62% 1 7.69%
Total 161 100.00% 13 100.00%

/* Add entry for local address of interface */


int br_fdb_insert(struct net_bridge *br, struct net_bridge_port *source,
		  const unsigned char *addr, u16 vid)
{
	int ret;

	spin_lock_bh(&br->hash_lock);
	ret = fdb_insert(br, source, addr, vid);
	spin_unlock_bh(&br->hash_lock);
	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
stephen hemminger stephen hemminger 46 77.97% 3 60.00%
pre-git pre-git 8 13.56% 1 20.00%
vlad yasevich vlad yasevich 5 8.47% 1 20.00%
Total 59 100.00% 5 100.00%



void br_fdb_update(struct net_bridge *br, struct net_bridge_port *source,
		   const unsigned char *addr, u16 vid, bool added_by_user)
{
	struct hlist_head *head = &br->hash[br_mac_hash(addr, vid)];
	struct net_bridge_fdb_entry *fdb;
	bool fdb_modified = false;

	/* some users want to always flood. */
	if (hold_time(br) == 0)
		return;

	/* ignore packets unless we are using this port */
	if (!(source->state == BR_STATE_LEARNING ||
	      source->state == BR_STATE_FORWARDING))
		return;

	fdb = fdb_find_rcu(head, addr, vid);
	if (likely(fdb)) {
		/* attempt to update an entry for a local interface */
		if (unlikely(fdb->is_local)) {
			if (net_ratelimit())
				br_warn(br, "received packet on %s with "
					"own address as source address\n",
					source->dev->name);
		} else {
			/* fastpath: update of existing entry */
			if (unlikely(source != fdb->dst)) {
				fdb->dst = source;
				fdb_modified = true;
			}
			fdb->updated = jiffies;
			if (unlikely(added_by_user))
				fdb->added_by_user = 1;
			if (unlikely(fdb_modified))
				fdb_notify(br, fdb, RTM_NEWNEIGH);
		}
	} else {
		spin_lock(&br->hash_lock);
		if (likely(!fdb_find(head, addr, vid))) {
			fdb = fdb_create(head, source, addr, vid, 0, 0);
			if (fdb) {
				if (unlikely(added_by_user))
					fdb->added_by_user = 1;
				fdb_notify(br, fdb, RTM_NEWNEIGH);
			}
		}
		/* else  we lose race and someone else inserts
                 * it first, don't bother updating
                 */
		spin_unlock(&br->hash_lock);
	}
}

Contributors
Person Tokens Prop Commits CommitProp
stephen hemminger stephen hemminger 195 69.64% 10 66.67%
jon maxwell jon maxwell 38 13.57% 1 6.67%
toshiaki makita toshiaki makita 31 11.07% 1 6.67%
vlad yasevich vlad yasevich 11 3.93% 1 6.67%
roopa prabhu roopa prabhu 4 1.43% 1 6.67%
jiri pirko jiri pirko 1 0.36% 1 6.67%
Total 280 100.00% 15 100.00%



static int fdb_to_nud(const struct net_bridge *br,
		      const struct net_bridge_fdb_entry *fdb)
{
	if (fdb->is_local)
		return NUD_PERMANENT;
	else if (fdb->is_static)
		return NUD_NOARP;
	else if (has_expired(br, fdb))
		return NUD_STALE;
	else
		return NUD_REACHABLE;
}

Contributors
Person Tokens Prop Commits CommitProp
stephen hemminger stephen hemminger 48 88.89% 1 50.00%
roopa prabhu roopa prabhu 6 11.11% 1 50.00%
Total 54 100.00% 2 100.00%



static int fdb_fill_info(struct sk_buff *skb, const struct net_bridge *br,
			 const struct net_bridge_fdb_entry *fdb,
			 u32 portid, u32 seq, int type, unsigned int flags)
{
	unsigned long now = jiffies;
	struct nda_cacheinfo ci;
	struct nlmsghdr *nlh;
	struct ndmsg *ndm;

	nlh = nlmsg_put(skb, portid, seq, type, sizeof(*ndm), flags);
	if (nlh == NULL)
		return -EMSGSIZE;

	ndm = nlmsg_data(nlh);
	ndm->ndm_family	 = AF_BRIDGE;
	ndm->ndm_pad1    = 0;
	ndm->ndm_pad2    = 0;
	ndm->ndm_flags	 = fdb->added_by_external_learn ? NTF_EXT_LEARNED : 0;
	ndm->ndm_type	 = 0;
	ndm->ndm_ifindex = fdb->dst ? fdb->dst->dev->ifindex : br->dev->ifindex;
	ndm->ndm_state   = fdb_to_nud(br, fdb);

	if (nla_put(skb, NDA_LLADDR, ETH_ALEN, &fdb->addr))
		goto nla_put_failure;
	if (nla_put_u32(skb, NDA_MASTER, br->dev->ifindex))
		goto nla_put_failure;
	ci.ndm_used	 = jiffies_to_clock_t(now - fdb->used);
	ci.ndm_confirmed = 0;
	ci.ndm_updated	 = jiffies_to_clock_t(now - fdb->updated);
	ci.ndm_refcnt	 = 0;
	if (nla_put(skb, NDA_CACHEINFO, sizeof(ci), &ci))
		goto nla_put_failure;

	if (fdb->vlan_id && nla_put(skb, NDA_VLAN, sizeof(u16), &fdb->vlan_id))
		goto nla_put_failure;

	nlmsg_end(skb, nlh);
	return 0;

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

Contributors
Person Tokens Prop Commits CommitProp
stephen hemminger stephen hemminger 236 76.87% 3 27.27%
vlad yasevich vlad yasevich 22 7.17% 1 9.09%
roopa prabhu roopa prabhu 20 6.51% 2 18.18%
david s. miller david s. miller 14 4.56% 1 9.09%
scott feldman scott feldman 6 1.95% 1 9.09%
toshiaki makita toshiaki makita 4 1.30% 1 9.09%
johannes berg johannes berg 3 0.98% 1 9.09%
eric w. biederman eric w. biederman 2 0.65% 1 9.09%
Total 307 100.00% 11 100.00%



static inline size_t fdb_nlmsg_size(void)
{
	return NLMSG_ALIGN(sizeof(struct ndmsg))
		+ nla_total_size(ETH_ALEN) /* NDA_LLADDR */
		+ nla_total_size(sizeof(u32)) /* NDA_MASTER */
		+ nla_total_size(sizeof(u16)) /* NDA_VLAN */
		+ nla_total_size(sizeof(struct nda_cacheinfo));
}

Contributors
Person Tokens Prop Commits CommitProp
stephen hemminger stephen hemminger 34 65.38% 1 33.33%
vlad yasevich vlad yasevich 9 17.31% 1 33.33%
roopa prabhu roopa prabhu 9 17.31% 1 33.33%
Total 52 100.00% 3 100.00%



static void fdb_notify(struct net_bridge *br,
		       const struct net_bridge_fdb_entry *fdb, int type)
{
	struct net *net = dev_net(br->dev);
	struct sk_buff *skb;
	int err = -ENOBUFS;

	skb = nlmsg_new(fdb_nlmsg_size(), GFP_ATOMIC);
	if (skb == NULL)
		goto errout;

	err = fdb_fill_info(skb, br, fdb, 0, 0, type, 0);
	if (err < 0) {
		/* -EMSGSIZE implies BUG in fdb_nlmsg_size() */
		WARN_ON(err == -EMSGSIZE);
		kfree_skb(skb);
		goto errout;
	}
	rtnl_notify(skb, net, 0, RTNLGRP_NEIGH, NULL, GFP_ATOMIC);
	return;
errout:
	rtnl_set_sk_err(net, RTNLGRP_NEIGH, err);
}

Contributors
Person Tokens Prop Commits CommitProp
stephen hemminger stephen hemminger 133 100.00% 2 100.00%
Total 133 100.00% 2 100.00%

/* Dump information about entries, in response to GETNEIGH */


int br_fdb_dump(struct sk_buff *skb,
		struct netlink_callback *cb,
		struct net_device *dev,
		struct net_device *filter_dev,
		int idx)
{
	struct net_bridge *br = netdev_priv(dev);
	int i;

	if (!(dev->priv_flags & IFF_EBRIDGE))
		goto out;

	if (!filter_dev)
		idx = ndo_dflt_fdb_dump(skb, cb, dev, NULL, idx);

	for (i = 0; i < BR_HASH_SIZE; i++) {
		struct net_bridge_fdb_entry *f;

		hlist_for_each_entry_rcu(f, &br->hash[i], hlist) {
			int err;

			if (idx < cb->args[0])
				goto skip;

			if (filter_dev &&
			    (!f->dst || f->dst->dev != filter_dev)) {
				if (filter_dev != dev)
					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;
			}
			if (!filter_dev && f->dst)
				goto skip;

			err = fdb_fill_info(skb, br, f,
					    NETLINK_CB(cb->skb).portid,
					    cb->nlh->nlmsg_seq,
					    RTM_NEWNEIGH,
					    NLM_F_MULTI);
			if (err < 0) {
				cb->args[1] = err;
				break;
			}
skip:
			++idx;
		}
	}

out:
	return idx;
}

Contributors
Person Tokens Prop Commits CommitProp
stephen hemminger stephen hemminger 127 54.74% 2 25.00%
jamal hadi salim jamal hadi salim 44 18.97% 2 25.00%
hubert sokolowski hubert sokolowski 31 13.36% 1 12.50%
makoto minoura makoto minoura 20 8.62% 1 12.50%
john fastabend john fastabend 9 3.88% 1 12.50%
eric w. biederman eric w. biederman 1 0.43% 1 12.50%
Total 232 100.00% 8 100.00%

/* Update (create or replace) forwarding database entry */


static int fdb_add_entry(struct net_bridge *br, struct net_bridge_port *source,
			 const __u8 *addr, __u16 state, __u16 flags, __u16 vid)
{
	struct hlist_head *head = &br->hash[br_mac_hash(addr, vid)];
	struct net_bridge_fdb_entry *fdb;
	bool modified = false;

	/* If the port cannot learn allow only local and static entries */
	if (source && !(state & NUD_PERMANENT) && !(state & NUD_NOARP) &&
	    !(source->state == BR_STATE_LEARNING ||
	      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);
		return -EINVAL;
	}

	fdb = fdb_find(head, addr, vid);
	if (fdb == NULL) {
		if (!(flags & NLM_F_CREATE))
			return -ENOENT;

		fdb = fdb_create(head, source, addr, vid, 0, 0);
		if (!fdb)
			return -ENOMEM;

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

		if (fdb->dst != source) {
			fdb->dst = source;
			modified = true;
		}
	}

	if (fdb_to_nud(br, fdb) != state) {
		if (state & NUD_PERMANENT) {
			fdb->is_local = 1;
			if (!fdb->is_static) {
				fdb->is_static = 1;
				fdb_add_hw_addr(br, addr);
			}
		} else if (state & NUD_NOARP) {
			fdb->is_local = 0;
			if (!fdb->is_static) {
				fdb->is_static = 1;
				fdb_add_hw_addr(br, addr);
			}
		} else {
			fdb->is_local = 0;
			if (fdb->is_static) {
				fdb->is_static = 0;
				fdb_del_hw_addr(br, addr);
			}
		}

		modified = true;
	}
	fdb->added_by_user = 1;

	fdb->used = jiffies;
	if (modified) {
		fdb->updated = jiffies;
		fdb_notify(br, fdb, RTM_NEWNEIGH);
	}

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
stephen hemminger stephen hemminger 186 49.47% 5 35.71%
vlad yasevich vlad yasevich 61 16.22% 2 14.29%
roopa prabhu roopa prabhu 48 12.77% 3 21.43%
toshiaki makita toshiaki makita 42 11.17% 2 14.29%
wilson kok wilson kok 36 9.57% 1 7.14%
jiri pirko jiri pirko 3 0.80% 1 7.14%
Total 376 100.00% 14 100.00%



static int __br_fdb_add(struct ndmsg *ndm, struct net_bridge *br,
			struct net_bridge_port *p, const unsigned char *addr,
			u16 nlh_flags, u16 vid)
{
	int err = 0;

	if (ndm->ndm_flags & NTF_USE) {
		if (!p) {
			pr_info("bridge: RTM_NEWNEIGH %s with NTF_USE is not supported\n",
				br->dev->name);
			return -EINVAL;
		}
		local_bh_disable();
		rcu_read_lock();
		br_fdb_update(br, p, addr, vid, true);
		rcu_read_unlock();
		local_bh_enable();
	} else {
		spin_lock_bh(&br->hash_lock);
		err = fdb_add_entry(br, p, addr, ndm->ndm_state,
				    nlh_flags, vid);
		spin_unlock_bh(&br->hash_lock);
	}

	return err;
}

Contributors
Person Tokens Prop Commits CommitProp
stephen hemminger stephen hemminger 77 56.62% 4 40.00%
toshiaki makita toshiaki makita 31 22.79% 2 20.00%
vlad yasevich vlad yasevich 11 8.09% 2 20.00%
john fastabend john fastabend 11 8.09% 1 10.00%
nikolay aleksandrov nikolay aleksandrov 6 4.41% 1 10.00%
Total 136 100.00% 10 100.00%

/* Add new permanent fdb entry with RTM_NEWNEIGH */


int br_fdb_add(struct ndmsg *ndm, struct nlattr *tb[],
	       struct net_device *dev,
	       const unsigned char *addr, u16 vid, u16 nlh_flags)
{
	struct net_bridge_vlan_group *vg;
	struct net_bridge_port *p = NULL;
	struct net_bridge_vlan *v;
	struct net_bridge *br = NULL;
	int err = 0;

	if (!(ndm->ndm_state & (NUD_PERMANENT|NUD_NOARP|NUD_REACHABLE))) {
		pr_info("bridge: RTM_NEWNEIGH with invalid state %#x\n", ndm->ndm_state);
		return -EINVAL;
	}

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

	if (dev->priv_flags & IFF_EBRIDGE) {
		br = netdev_priv(dev);
		vg = br_vlan_group(br);
	} else {
		p = br_port_get_rtnl(dev);
		if (!p) {
			pr_info("bridge: RTM_NEWNEIGH %s not a bridge port\n",
				dev->name);
			return -EINVAL;
		}
		br = p->br;
		vg = nbp_vlan_group(p);
	}

	if (vid) {
		v = br_vlan_find(vg, vid);
		if (!v || !br_vlan_should_use(v)) {
			pr_info("bridge: RTM_NEWNEIGH with unconfigured vlan %d on %s\n", vid, dev->name);
			return -EINVAL;
		}

		/* VID was specified, so use it. */
		err = __br_fdb_add(ndm, br, p, addr, nlh_flags, vid);
	} else {
		err = __br_fdb_add(ndm, br, p, addr, nlh_flags, 0);
		if (err || !vg || !vg->num_vlans)
			goto out;

		/* 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, br, p, addr, nlh_flags, v->vid);
			if (err)
				goto out;
		}
	}

out:
	return err;
}

Contributors
Person Tokens Prop Commits CommitProp
vlad yasevich vlad yasevich 160 49.08% 1 9.09%
roopa prabhu roopa prabhu 53 16.26% 1 9.09%
stephen hemminger stephen hemminger 50 15.34% 3 27.27%
nikolay aleksandrov nikolay aleksandrov 34 10.43% 1 9.09%
toshiaki makita toshiaki makita 18 5.52% 2 18.18%
john fastabend john fastabend 7 2.15% 1 9.09%
jiri pirko jiri pirko 3 0.92% 1 9.09%
wei yongjun wei yongjun 1 0.31% 1 9.09%
Total 326 100.00% 11 100.00%



static int fdb_delete_by_addr(struct net_bridge *br, const u8 *addr,
			      u16 vid)
{
	struct hlist_head *head = &br->hash[br_mac_hash(addr, vid)];
	struct net_bridge_fdb_entry *fdb;

	fdb = fdb_find(head, addr, vid);
	if (!fdb)
		return -ENOENT;

	fdb_delete(br, fdb);
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
roopa prabhu roopa prabhu 72 100.00% 1 100.00%
Total 72 100.00% 1 100.00%



static int __br_fdb_delete_by_addr(struct net_bridge *br,
				   const unsigned char *addr, u16 vid)
{
	int err;

	spin_lock_bh(&br->hash_lock);
	err = fdb_delete_by_addr(br, addr, vid);
	spin_unlock_bh(&br->hash_lock);

	return err;
}

Contributors
Person Tokens Prop Commits CommitProp
roopa prabhu roopa prabhu 53 100.00% 1 100.00%
Total 53 100.00% 1 100.00%



static int fdb_delete_by_addr_and_port(struct net_bridge_port *p,
				       const u8 *addr, u16 vlan)
{
	struct net_bridge *br = p->br;
	struct hlist_head *head = &br->hash[br_mac_hash(addr, vlan)];
	struct net_bridge_fdb_entry *fdb;

	fdb = fdb_find(head, addr, vlan);
	if (!fdb || fdb->dst != p)
		return -ENOENT;

	fdb_delete(br, fdb);
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
vlad yasevich vlad yasevich 68 78.16% 1 33.33%
nikolay aleksandrov nikolay aleksandrov 18 20.69% 1 33.33%
toshiaki makita toshiaki makita 1 1.15% 1 33.33%
Total 87 100.00% 3 100.00%



static int __br_fdb_delete(struct net_bridge_port *p,
			   const unsigned char *addr, u16 vid)
{
	int err;

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

	return err;
}

Contributors
Person Tokens Prop Commits CommitProp
stephen hemminger stephen hemminger 30 52.63% 1 33.33%
vlad yasevich vlad yasevich 26 45.61% 1 33.33%
nikolay aleksandrov nikolay aleksandrov 1 1.75% 1 33.33%
Total 57 100.00% 3 100.00%

/* Remove neighbor entry with RTM_DELNEIGH */


int br_fdb_delete(struct ndmsg *ndm, struct nlattr *tb[],
		  struct net_device *dev,
		  const unsigned char *addr, u16 vid)
{
	struct net_bridge_vlan_group *vg;
	struct net_bridge_port *p = NULL;
	struct net_bridge_vlan *v;
	struct net_bridge *br = NULL;
	int err;

	if (dev->priv_flags & IFF_EBRIDGE) {
		br = netdev_priv(dev);
		vg = br_vlan_group(br);
	} else {
		p = br_port_get_rtnl(dev);
		if (!p) {
			pr_info("bridge: RTM_DELNEIGH %s not a bridge port\n",
				dev->name);
			return -EINVAL;
		}
		vg = nbp_vlan_group(p);
	}

	if (vid) {
		v = br_vlan_find(vg, vid);
		if (!v) {
			pr_info("bridge: RTM_DELNEIGH with unconfigured vlan %d on %s\n", vid, dev->name);
			return -EINVAL;
		}

		if (dev->priv_flags & IFF_EBRIDGE)
			err = __br_fdb_delete_by_addr(br, addr, vid);
		else
			err = __br_fdb_delete(p, addr, vid);
	} else {
		err = -ENOENT;
		if (dev->priv_flags & IFF_EBRIDGE)
			err = __br_fdb_delete_by_addr(br, addr, 0);
		else
			err &= __br_fdb_delete(p, addr, 0);

		if (!vg || !vg->num_vlans)
			goto out;

		list_for_each_entry(v, &vg->vlan_list, vlist) {
			if (!br_vlan_should_use(v))
				continue;
			if (dev->priv_flags & IFF_EBRIDGE)
				err = __br_fdb_delete_by_addr(br, addr, v->vid);
			else
				err &= __br_fdb_delete(p, addr, v->vid);
		}
	}
out:
	return err;
}

Contributors
Person Tokens Prop Commits CommitProp
vlad yasevich vlad yasevich 139 46.80% 1 16.67%
roopa prabhu roopa prabhu 111 37.37% 1 16.67%
nikolay aleksandrov nikolay aleksandrov 34 11.45% 1 16.67%
toshiaki makita toshiaki makita 9 3.03% 1 16.67%
jiri pirko jiri pirko 3 1.01% 1 16.67%
wei yongjun wei yongjun 1 0.34% 1 16.67%
Total 297 100.00% 6 100.00%



int br_fdb_sync_static(struct net_bridge *br, struct net_bridge_port *p)
{
	struct net_bridge_fdb_entry *fdb, *tmp;
	int i;
	int err;

	ASSERT_RTNL();

	for (i = 0; i < BR_HASH_SIZE; i++) {
		hlist_for_each_entry(fdb, &br->hash[i], hlist) {
			/* We only care for static entries */
			if (!fdb->is_static)
				continue;

			err = dev_uc_add(p->dev, fdb->addr.addr);
			if (err)
				goto rollback;
		}
	}
	return 0;

rollback:
	for (i = 0; i < BR_HASH_SIZE; i++) {
		hlist_for_each_entry(tmp, &br->hash[i], hlist) {
			/* If we reached the fdb that failed, we can stop */
			if (tmp == fdb)
				break;

			/* We only care for static entries */
			if (!tmp->is_static)
				continue;

			dev_uc_del(p->dev, tmp->addr.addr);
		}
	}
	return err;
}

Contributors
Person Tokens Prop Commits CommitProp
vlad yasevich vlad yasevich 151 100.00% 1 100.00%
Total 151 100.00% 1 100.00%



void br_fdb_unsync_static(struct net_bridge *br, struct net_bridge_port *p)
{
	struct net_bridge_fdb_entry *fdb;
	int i;

	ASSERT_RTNL();

	for (i = 0; i < BR_HASH_SIZE; i++) {
		hlist_for_each_entry_rcu(fdb, &br->hash[i], hlist) {
			/* We only care for static entries */
			if (!fdb->is_static)
				continue;

			dev_uc_del(p->dev, fdb->addr.addr);
		}
	}
}

Contributors
Person Tokens Prop Commits CommitProp
vlad yasevich vlad yasevich 73 100.00% 1 100.00%
Total 73 100.00% 1 100.00%



int br_fdb_external_learn_add(struct net_bridge *br, struct net_bridge_port *p,
			      const unsigned char *addr, u16 vid)
{
	struct hlist_head *head;
	struct net_bridge_fdb_entry *fdb;
	int err = 0;

	ASSERT_RTNL();
	spin_lock_bh(&br->hash_lock);

	head = &br->hash[br_mac_hash(addr, vid)];
	fdb = fdb_find(head, addr, vid);
	if (!fdb) {
		fdb = fdb_create(head, p, addr, vid, 0, 0);
		if (!fdb) {
			err = -ENOMEM;
			goto err_unlock;
		}
		fdb->added_by_external_learn = 1;
		fdb_notify(br, fdb, RTM_NEWNEIGH);
	} else if (fdb->added_by_external_learn) {
		/* Refresh entry */
		fdb->updated = fdb->used = jiffies;
	} else if (!fdb->added_by_user) {
		/* Take over SW learned entry */
		fdb->added_by_external_learn = 1;
		fdb->updated = jiffies;
		fdb_notify(br, fdb, RTM_NEWNEIGH);
	}

err_unlock:
	spin_unlock_bh(&br->hash_lock);

	return err;
}

Contributors
Person Tokens Prop Commits CommitProp
scott feldman scott feldman 183 93.85% 1 33.33%
jiri pirko jiri pirko 8 4.10% 1 33.33%
roopa prabhu roopa prabhu 4 2.05% 1 33.33%
Total 195 100.00% 3 100.00%



int br_fdb_external_learn_del(struct net_bridge *br, struct net_bridge_port *p,
			      const unsigned char *addr, u16 vid)
{
	struct hlist_head *head;
	struct net_bridge_fdb_entry *fdb;
	int err = 0;

	ASSERT_RTNL();
	spin_lock_bh(&br->hash_lock);

	head = &br->hash[br_mac_hash(addr, vid)];
	fdb = fdb_find(head, addr, vid);
	if (fdb && fdb->added_by_external_learn)
		fdb_delete(br, fdb);
	else
		err = -ENOENT;

	spin_unlock_bh(&br->hash_lock);

	return err;
}
Contributors
Person Tokens Prop Commits CommitProp
scott feldman scott feldman 100 92.59% 1 50.00%
jiri pirko jiri pirko 8 7.41% 1 50.00%
Total 108 100.00% 2 100.00%

Overall Contributors
Person Tokens Prop Commits CommitProp
stephen hemminger stephen hemminger 2117 38.10% 37 33.64%
vlad yasevich vlad yasevich 1042 18.75% 5 4.55%
toshiaki makita toshiaki makita 494 8.89% 10 9.09%
pre-git pre-git 477 8.58% 3 2.73%
roopa prabhu roopa prabhu 394 7.09% 4 3.64%
scott feldman scott feldman 342 6.15% 2 1.82%
nikolay aleksandrov nikolay aleksandrov 216 3.89% 4 3.64%
michal miroslaw michal miroslaw 74 1.33% 1 0.91%
jiri pirko jiri pirko 63 1.13% 10 9.09%
jamal hadi salim jamal hadi salim 44 0.79% 2 1.82%
jon maxwell jon maxwell 38 0.68% 1 0.91%
baruch even baruch even 36 0.65% 1 0.91%
wilson kok wilson kok 36 0.65% 1 0.91%
hubert sokolowski hubert sokolowski 31 0.56% 1 0.91%
john fastabend john fastabend 27 0.49% 1 0.91%
makoto minoura makoto minoura 20 0.36% 1 0.91%
david s. miller david s. miller 17 0.31% 2 1.82%
akinobu mita akinobu mita 13 0.23% 1 0.91%
pavel emelianov pavel emelianov 10 0.18% 1 0.91%
ido schimmel ido schimmel 9 0.16% 1 0.91%
hong zhi guo hong zhi guo 8 0.14% 1 0.91%
siva mannem siva mannem 7 0.13% 1 0.91%
li rongqing li rongqing 4 0.07% 1 0.91%
fabio checconi fabio checconi 4 0.07% 1 0.91%
eric dumazet eric dumazet 4 0.07% 3 2.73%
tejun heo tejun heo 3 0.05% 1 0.91%
joe perches joe perches 3 0.05% 1 0.91%
franck bui-huu franck bui-huu 3 0.05% 1 0.91%
johannes berg johannes berg 3 0.05% 1 0.91%
eric w. biederman eric w. biederman 3 0.05% 1 0.91%
hideaki yoshifuji hideaki yoshifuji 2 0.04% 1 0.91%
vivien didelot vivien didelot 2 0.04% 1 0.91%
wei yongjun wei yongjun 2 0.04% 1 0.91%
christoph lameter christoph lameter 2 0.04% 1 0.91%
patrick mchardy patrick mchardy 2 0.04% 1 0.91%
andrew morton andrew morton 2 0.04% 1 0.91%
adrian bunk adrian bunk 1 0.02% 1 0.91%
igor maravic igor maravic 1 0.02% 1 0.91%
arun sharma arun sharma 1 0.02% 1 0.91%
Total 5557 100.00% 110 100.00%
  Directory: net/bridge

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
	Person	Tokens	Prop	Commits	CommitProp
stephen hemminger	stephen hemminger	37	74.00%	2	66.67%
akinobu mita	akinobu mita	13	26.00%	1	33.33%
	Total	50	100.00%	3	100.00%
cregit-Linux how code gets into the kernel

Release 4.8 net/bridge/br_fdb.c

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Overall Contributors
