Release 4.8 net/bridge/br_if.c

Directory: net/bridge
/*
 *      Userspace interface
 *      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/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/netpoll.h>
#include <linux/ethtool.h>
#include <linux/if_arp.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/rtnetlink.h>
#include <linux/if_ether.h>
#include <linux/slab.h>
#include <net/sock.h>
#include <linux/if_vlan.h>
#include <net/switchdev.h>

#include "br_private.h"

/*
 * Determine initial path cost based on speed.
 * using recommendations from 802.1d standard
 *
 * Since driver might sleep need to not be holding any locks.
 */


static int port_cost(struct net_device *dev)
{
	struct ethtool_link_ksettings ecmd;

	if (!__ethtool_get_link_ksettings(dev, &ecmd)) {
		switch (ecmd.base.speed) {
		case SPEED_10000:
			return 2;
		case SPEED_1000:
			return 4;
		case SPEED_100:
			return 19;
		case SPEED_10:
			return 100;
		}
	}

	/* Old silly heuristics based on name */
	if (!strncmp(dev->name, "lec", 3))
		return 7;

	if (!strncmp(dev->name, "plip", 4))
		return 2500;

	return 100;	/* assume old 10Mbps */
}


Contributors
Person Tokens Prop Commits CommitProp
stephen hemminger stephen hemminger 48 47.52% 3 50.00%
pre-git pre-git 45 44.55% 1 16.67%
david decotigny david decotigny 6 5.94% 1 16.67%
matthew wilcox matthew wilcox 2 1.98% 1 16.67%
Total 101 100.00% 6 100.00%

/* Check for port carrier transitions. */


void br_port_carrier_check(struct net_bridge_port *p)
{
	struct net_device *dev = p->dev;
	struct net_bridge *br = p->br;

	if (!(p->flags & BR_ADMIN_COST) &&
	    netif_running(dev) && netif_oper_up(dev))
		p->path_cost = port_cost(dev);

	if (!netif_running(br->dev))
		return;

	spin_lock_bh(&br->lock);
	if (netif_running(dev) && netif_oper_up(dev)) {
		if (p->state == BR_STATE_DISABLED)
			br_stp_enable_port(p);
	} else {
		if (p->state != BR_STATE_DISABLED)
			br_stp_disable_port(p);
	}
	spin_unlock_bh(&br->lock);
}

Contributors
Person Tokens Prop Commits CommitProp
stephen hemminger stephen hemminger 123 96.09% 7 87.50%
david howells david howells 5 3.91% 1 12.50%
Total 128 100.00% 8 100.00%



static void br_port_set_promisc(struct net_bridge_port *p)
{
	int err = 0;

	if (br_promisc_port(p))
		return;

	err = dev_set_promiscuity(p->dev, 1);
	if (err)
		return;

	br_fdb_unsync_static(p->br, p);
	p->flags |= BR_PROMISC;
}

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



static void br_port_clear_promisc(struct net_bridge_port *p)
{
	int err;

	/* Check if the port is already non-promisc or if it doesn't
         * support UNICAST filtering.  Without unicast filtering support
         * we'll end up re-enabling promisc mode anyway, so just check for
         * it here.
         */
	if (!br_promisc_port(p) || !(p->dev->priv_flags & IFF_UNICAST_FLT))
		return;

	/* Since we'll be clearing the promisc mode, program the port
         * first so that we don't have interruption in traffic.
         */
	err = br_fdb_sync_static(p->br, p);
	if (err)
		return;

	dev_set_promiscuity(p->dev, -1);
	p->flags &= ~BR_PROMISC;
}

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

/* When a port is added or removed or when certain port flags
 * change, this function is called to automatically manage
 * promiscuity setting of all the bridge ports.  We are always called
 * under RTNL so can skip using rcu primitives.
 */


void br_manage_promisc(struct net_bridge *br)
{
	struct net_bridge_port *p;
	bool set_all = false;

	/* If vlan filtering is disabled or bridge interface is placed
         * into promiscuous mode, place all ports in promiscuous mode.
         */
	if ((br->dev->flags & IFF_PROMISC) || !br_vlan_enabled(br))
		set_all = true;

	list_for_each_entry(p, &br->port_list, list) {
		if (set_all) {
			br_port_set_promisc(p);
		} else {
			/* If the number of auto-ports is <= 1, then all other
                         * ports will have their output configuration
                         * statically specified through fdbs.  Since ingress
                         * on the auto-port becomes forwarding/egress to other
                         * ports and egress configuration is statically known,
                         * we can say that ingress configuration of the
                         * auto-port is also statically known.
                         * This lets us disable promiscuous mode and write
                         * this config to hw.
                         */
			if (br->auto_cnt == 0 ||
			    (br->auto_cnt == 1 && br_auto_port(p)))
				br_port_clear_promisc(p);
			else
				br_port_set_promisc(p);
		}
	}
}

Contributors
Person Tokens Prop Commits CommitProp
vlad yasevich vlad yasevich 89 89.00% 1 50.00%
toshiaki makita toshiaki makita 11 11.00% 1 50.00%
Total 100 100.00% 2 100.00%



static void nbp_update_port_count(struct net_bridge *br)
{
	struct net_bridge_port *p;
	u32 cnt = 0;

	list_for_each_entry(p, &br->port_list, list) {
		if (br_auto_port(p))
			cnt++;
	}
	if (br->auto_cnt != cnt) {
		br->auto_cnt = cnt;
		br_manage_promisc(br);
	}
}

Contributors
Person Tokens Prop Commits CommitProp
vlad yasevich vlad yasevich 62 100.00% 2 100.00%
Total 62 100.00% 2 100.00%



static void nbp_delete_promisc(struct net_bridge_port *p)
{
	/* If port is currently promiscuous, unset promiscuity.
         * Otherwise, it is a static port so remove all addresses
         * from it.
         */
	dev_set_allmulti(p->dev, -1);
	if (br_promisc_port(p))
		dev_set_promiscuity(p->dev, -1);
	else
		br_fdb_unsync_static(p->br, p);
}

Contributors
Person Tokens Prop Commits CommitProp
vlad yasevich vlad yasevich 48 97.96% 2 66.67%
stephen hemminger stephen hemminger 1 2.04% 1 33.33%
Total 49 100.00% 3 100.00%



static void release_nbp(struct kobject *kobj)
{
	struct net_bridge_port *p
		= container_of(kobj, struct net_bridge_port, kobj);
	kfree(p);
}

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


static struct kobj_type brport_ktype = {
#ifdef CONFIG_SYSFS
	.sysfs_ops = &brport_sysfs_ops,
#endif
	.release = release_nbp,
};



static void destroy_nbp(struct net_bridge_port *p)
{
	struct net_device *dev = p->dev;

	p->br = NULL;
	p->dev = NULL;
	dev_put(dev);

	kobject_put(&p->kobj);
}

Contributors
Person Tokens Prop Commits CommitProp
stephen hemminger stephen hemminger 43 95.56% 5 83.33%
andrew morton andrew morton 2 4.44% 1 16.67%
Total 45 100.00% 6 100.00%



static void destroy_nbp_rcu(struct rcu_head *head)
{
	struct net_bridge_port *p =
			container_of(head, struct net_bridge_port, rcu);
	destroy_nbp(p);
}

Contributors
Person Tokens Prop Commits CommitProp
andrew morton andrew morton 31 100.00% 1 100.00%
Total 31 100.00% 1 100.00%



static unsigned get_max_headroom(struct net_bridge *br)
{
	unsigned max_headroom = 0;
	struct net_bridge_port *p;

	list_for_each_entry(p, &br->port_list, list) {
		unsigned dev_headroom = netdev_get_fwd_headroom(p->dev);

		if (dev_headroom > max_headroom)
			max_headroom = dev_headroom;
	}

	return max_headroom;
}

Contributors
Person Tokens Prop Commits CommitProp
paolo abeni paolo abeni 54 100.00% 1 100.00%
Total 54 100.00% 1 100.00%



static void update_headroom(struct net_bridge *br, int new_hr)
{
	struct net_bridge_port *p;

	list_for_each_entry(p, &br->port_list, list)
		netdev_set_rx_headroom(p->dev, new_hr);

	br->dev->needed_headroom = new_hr;
}

Contributors
Person Tokens Prop Commits CommitProp
paolo abeni paolo abeni 44 100.00% 1 100.00%
Total 44 100.00% 1 100.00%

/* Delete port(interface) from bridge is done in two steps.
 * via RCU. First step, marks device as down. That deletes
 * all the timers and stops new packets from flowing through.
 *
 * Final cleanup doesn't occur until after all CPU's finished
 * processing packets.
 *
 * Protected from multiple admin operations by RTNL mutex
 */


static void del_nbp(struct net_bridge_port *p)
{
	struct net_bridge *br = p->br;
	struct net_device *dev = p->dev;

	sysfs_remove_link(br->ifobj, p->dev->name);

	nbp_delete_promisc(p);

	spin_lock_bh(&br->lock);
	br_stp_disable_port(p);
	spin_unlock_bh(&br->lock);

	br_ifinfo_notify(RTM_DELLINK, p);

	list_del_rcu(&p->list);
	if (netdev_get_fwd_headroom(dev) == br->dev->needed_headroom)
		update_headroom(br, get_max_headroom(br));
	netdev_reset_rx_headroom(dev);

	nbp_vlan_flush(p);
	br_fdb_delete_by_port(br, p, 0, 1);
	switchdev_deferred_process();

	nbp_update_port_count(br);

	netdev_upper_dev_unlink(dev, br->dev);

	dev->priv_flags &= ~IFF_BRIDGE_PORT;

	netdev_rx_handler_unregister(dev);

	br_multicast_del_port(p);

	kobject_uevent(&p->kobj, KOBJ_REMOVE);
	kobject_del(&p->kobj);

	br_netpoll_disable(p);

	call_rcu(&p->rcu, destroy_nbp_rcu);
}

Contributors
Person Tokens Prop Commits CommitProp
stephen hemminger stephen hemminger 84 43.30% 9 36.00%
paolo abeni paolo abeni 28 14.43% 1 4.00%
pre-git pre-git 26 13.40% 1 4.00%
jiri pirko jiri pirko 20 10.31% 4 16.00%
vlad yasevich vlad yasevich 15 7.73% 2 8.00%
nikolay aleksandrov nikolay aleksandrov 7 3.61% 2 8.00%
herbert xu herbert xu 6 3.09% 2 8.00%
americo wang americo wang 3 1.55% 1 4.00%
randy dunlap randy dunlap 3 1.55% 1 4.00%
andrew morton andrew morton 1 0.52% 1 4.00%
simon arlott simon arlott 1 0.52% 1 4.00%
Total 194 100.00% 25 100.00%

/* Delete bridge device */


void br_dev_delete(struct net_device *dev, struct list_head *head)
{
	struct net_bridge *br = netdev_priv(dev);
	struct net_bridge_port *p, *n;

	list_for_each_entry_safe(p, n, &br->port_list, list) {
		del_nbp(p);
	}

	br_fdb_delete_by_port(br, NULL, 0, 1);

	br_vlan_flush(br);
	br_multicast_dev_del(br);
	del_timer_sync(&br->gc_timer);

	br_sysfs_delbr(br->dev);
	unregister_netdevice_queue(br->dev, head);
}

Contributors
Person Tokens Prop Commits CommitProp
stephen hemminger stephen hemminger 55 57.89% 4 40.00%
pre-git pre-git 11 11.58% 1 10.00%
ding tianhong ding tianhong 9 9.47% 1 10.00%
eric dumazet eric dumazet 8 8.42% 1 10.00%
toshiaki makita toshiaki makita 5 5.26% 1 10.00%
satish ashok satish ashok 5 5.26% 1 10.00%
nikolay aleksandrov nikolay aleksandrov 2 2.11% 1 10.00%
Total 95 100.00% 10 100.00%

/* find an available port number */


static int find_portno(struct net_bridge *br)
{
	int index;
	struct net_bridge_port *p;
	unsigned long *inuse;

	inuse = kcalloc(BITS_TO_LONGS(BR_MAX_PORTS), sizeof(unsigned long),
			GFP_KERNEL);
	if (!inuse)
		return -ENOMEM;

	set_bit(0, inuse);	/* zero is reserved */
	list_for_each_entry(p, &br->port_list, list) {
		set_bit(p->port_no, inuse);
	}
	index = find_first_zero_bit(inuse, BR_MAX_PORTS);
	kfree(inuse);

	return (index >= BR_MAX_PORTS) ? -EXFULL : index;
}

Contributors
Person Tokens Prop Commits CommitProp
stephen hemminger stephen hemminger 104 100.00% 4 100.00%
Total 104 100.00% 4 100.00%

/* called with RTNL but without bridge lock */


static struct net_bridge_port *new_nbp(struct net_bridge *br,
				       struct net_device *dev)
{
	struct net_bridge_port *p;
	int index, err;

	index = find_portno(br);
	if (index < 0)
		return ERR_PTR(index);

	p = kzalloc(sizeof(*p), GFP_KERNEL);
	if (p == NULL)
		return ERR_PTR(-ENOMEM);

	p->br = br;
	dev_hold(dev);
	p->dev = dev;
	p->path_cost = port_cost(dev);
	p->priority = 0x8000 >> BR_PORT_BITS;
	p->port_no = index;
	p->flags = BR_LEARNING | BR_FLOOD;
	br_init_port(p);
	br_set_state(p, BR_STATE_DISABLED);
	br_stp_port_timer_init(p);
	err = br_multicast_add_port(p);
	if (err) {
		dev_put(dev);
		kfree(p);
		p = ERR_PTR(err);
	}

	return p;
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 80 46.78% 1 7.14%
stephen hemminger stephen hemminger 44 25.73% 7 50.00%
nikolay aleksandrov nikolay aleksandrov 30 17.54% 1 7.14%
anna fischer anna fischer 5 2.92% 1 7.14%
herbert xu herbert xu 5 2.92% 1 7.14%
florian fainelli florian fainelli 4 2.34% 1 7.14%
vlad yasevich vlad yasevich 3 1.75% 2 14.29%
Total 171 100.00% 14 100.00%



int br_add_bridge(struct net *net, const char *name)
{
	struct net_device *dev;
	int res;

	dev = alloc_netdev(sizeof(struct net_bridge), name, NET_NAME_UNKNOWN,
			   br_dev_setup);

	if (!dev)
		return -ENOMEM;

	dev_net_set(dev, net);
	dev->rtnl_link_ops = &br_link_ops;

	res = register_netdev(dev);
	if (res)
		free_netdev(dev);
	return res;
}

Contributors
Person Tokens Prop Commits CommitProp
stephen hemminger stephen hemminger 30 36.59% 5 45.45%
pre-git pre-git 21 25.61% 1 9.09%
eric dumazet eric dumazet 17 20.73% 1 9.09%
alexey dobriyan alexey dobriyan 6 7.32% 1 9.09%
pavel emelianov pavel emelianov 3 3.66% 1 9.09%
marcel holtmann marcel holtmann 3 3.66% 1 9.09%
tom gundersen tom gundersen 2 2.44% 1 9.09%
Total 82 100.00% 11 100.00%



int br_del_bridge(struct net *net, const char *name)
{
	struct net_device *dev;
	int ret = 0;

	rtnl_lock();
	dev = __dev_get_by_name(net, name);
	if (dev == NULL)
		ret =  -ENXIO; 	/* Could not find device */

	else if (!(dev->priv_flags & IFF_EBRIDGE)) {
		/* Attempt to delete non bridge device! */
		ret = -EPERM;
	}

	else if (dev->flags & IFF_UP) {
		/* Not shutdown yet. */
		ret = -EBUSY;
	}

	else
		br_dev_delete(dev, NULL);

	rtnl_unlock();
	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
stephen hemminger stephen hemminger 57 57.00% 5 55.56%
pre-git pre-git 34 34.00% 1 11.11%
alexey dobriyan alexey dobriyan 6 6.00% 1 11.11%
eric dumazet eric dumazet 2 2.00% 1 11.11%
eric w. biederman eric w. biederman 1 1.00% 1 11.11%
Total 100 100.00% 9 100.00%

/* MTU of the bridge pseudo-device: ETH_DATA_LEN or the minimum of the ports */


int br_min_mtu(const struct net_bridge *br)
{
	const struct net_bridge_port *p;
	int mtu = 0;

	ASSERT_RTNL();

	if (list_empty(&br->port_list))
		mtu = ETH_DATA_LEN;
	else {
		list_for_each_entry(p, &br->port_list, list) {
			if (!mtu  || p->dev->mtu < mtu)
				mtu = p->dev->mtu;
		}
	}
	return mtu;
}

Contributors
Person Tokens Prop Commits CommitProp
stephen hemminger stephen hemminger 75 98.68% 1 50.00%
kris katterjohn kris katterjohn 1 1.32% 1 50.00%
Total 76 100.00% 2 100.00%



static void br_set_gso_limits(struct net_bridge *br)
{
	unsigned int gso_max_size = GSO_MAX_SIZE;
	u16 gso_max_segs = GSO_MAX_SEGS;
	const struct net_bridge_port *p;

	list_for_each_entry(p, &br->port_list, list) {
		gso_max_size = min(gso_max_size, p->dev->gso_max_size);
		gso_max_segs = min(gso_max_segs, p->dev->gso_max_segs);
	}
	br->dev->gso_max_size = gso_max_size;
	br->dev->gso_max_segs = gso_max_segs;
}

Contributors
Person Tokens Prop Commits CommitProp
eric dumazet eric dumazet 80 100.00% 1 100.00%
Total 80 100.00% 1 100.00%

/*
 * Recomputes features using slave's features
 */


netdev_features_t br_features_recompute(struct net_bridge *br,
	netdev_features_t features)
{
	struct net_bridge_port *p;
	netdev_features_t mask;

	if (list_empty(&br->port_list))
		return features;

	mask = features;
	features &= ~NETIF_F_ONE_FOR_ALL;

	list_for_each_entry(p, &br->port_list, list) {
		features = netdev_increment_features(features,
						     p->dev->features, mask);
	}
	features = netdev_add_tso_features(features, mask);

	return features;
}

Contributors
Person Tokens Prop Commits CommitProp
herbert xu herbert xu 30 37.50% 3 37.50%
stephen hemminger stephen hemminger 26 32.50% 1 12.50%
michal miroslaw michal miroslaw 15 18.75% 3 37.50%
toshiaki makita toshiaki makita 9 11.25% 1 12.50%
Total 80 100.00% 8 100.00%

/* called with RTNL */


int br_add_if(struct net_bridge *br, struct net_device *dev)
{
	struct net_bridge_port *p;
	int err = 0;
	unsigned br_hr, dev_hr;
	bool changed_addr;

	/* Don't allow bridging non-ethernet like devices, or DSA-enabled
         * master network devices since the bridge layer rx_handler prevents
         * the DSA fake ethertype handler to be invoked, so we do not strip off
         * the DSA switch tag protocol header and the bridge layer just return
         * RX_HANDLER_CONSUMED, stopping RX processing for these frames.
         */
	if ((dev->flags & IFF_LOOPBACK) ||
	    dev->type != ARPHRD_ETHER || dev->addr_len != ETH_ALEN ||
	    !is_valid_ether_addr(dev->dev_addr) ||
	    netdev_uses_dsa(dev))
		return -EINVAL;

	/* No bridging of bridges */
	if (dev->netdev_ops->ndo_start_xmit == br_dev_xmit)
		return -ELOOP;

	/* Device is already being bridged */
	if (br_port_exists(dev))
		return -EBUSY;

	/* No bridging devices that dislike that (e.g. wireless) */
	if (dev->priv_flags & IFF_DONT_BRIDGE)
		return -EOPNOTSUPP;

	p = new_nbp(br, dev);
	if (IS_ERR(p))
		return PTR_ERR(p);

	call_netdevice_notifiers(NETDEV_JOIN, dev);

	err = dev_set_allmulti(dev, 1);
	if (err)
		goto put_back;

	err = kobject_init_and_add(&p->kobj, &brport_ktype, &(dev->dev.kobj),
				   SYSFS_BRIDGE_PORT_ATTR);
	if (err)
		goto err1;

	err = br_sysfs_addif(p);
	if (err)
		goto err2;

	err = br_netpoll_enable(p);
	if (err)
		goto err3;

	err = netdev_rx_handler_register(dev, br_handle_frame, p);
	if (err)
		goto err4;

	dev->priv_flags |= IFF_BRIDGE_PORT;

	err = netdev_master_upper_dev_link(dev, br->dev, NULL, NULL);
	if (err)
		goto err5;

	dev_disable_lro(dev);

	list_add_rcu(&p->list, &br->port_list);

	nbp_update_port_count(br);

	netdev_update_features(br->dev);

	br_hr = br->dev->needed_headroom;
	dev_hr = netdev_get_fwd_headroom(dev);
	if (br_hr < dev_hr)
		update_headroom(br, dev_hr);
	else
		netdev_set_rx_headroom(dev, br_hr);

	if (br_fdb_insert(br, p, dev->dev_addr, 0))
		netdev_err(dev, "failed insert local address bridge forwarding table\n");

	err = nbp_vlan_init(p);
	if (err) {
		netdev_err(dev, "failed to initialize vlan filtering on this port\n");
		goto err6;
	}

	spin_lock_bh(&br->lock);
	changed_addr = br_stp_recalculate_bridge_id(br);

	if (netif_running(dev) && netif_oper_up(dev) &&
	    (br->dev->flags & IFF_UP))
		br_stp_enable_port(p);
	spin_unlock_bh(&br->lock);

	br_ifinfo_notify(RTM_NEWLINK, p);

	if (changed_addr)
		call_netdevice_notifiers(NETDEV_CHANGEADDR, br->dev);

	dev_set_mtu(br->dev, br_min_mtu(br));
	br_set_gso_limits(br);

	kobject_uevent(&p->kobj, KOBJ_ADD);

	return 0;

err6:
	list_del_rcu(&p->list);
	br_fdb_delete_by_port(br, p, 0, 1);
	nbp_update_port_count(br);
	netdev_upper_dev_unlink(dev, br->dev);

err5:
	dev->priv_flags &= ~IFF_BRIDGE_PORT;
	netdev_rx_handler_unregister(dev);
err4:
	br_netpoll_disable(p);
err3:
	sysfs_remove_link(br->ifobj, p->dev->name);
err2:
	kobject_put(&p->kobj);
	p = NULL; /* kobject_put frees */
err1:
	dev_set_allmulti(dev, -1);
put_back:
	dev_put(dev);
	kfree(p);
	return err;
}

Contributors
Person Tokens Prop Commits CommitProp
stephen hemminger stephen hemminger 182 31.11% 16 33.33%
jiri pirko jiri pirko 60 10.26% 7 14.58%
pre-git pre-git 48 8.21% 2 4.17%
elad raz elad raz 46 7.86% 1 2.08%
paolo abeni paolo abeni 31 5.30% 1 2.08%
wang chen wang chen 27 4.62% 1 2.08%
herbert xu herbert xu 25 4.27% 1 2.08%
aji srinivas aji srinivas 23 3.93% 1 2.08%
toshiaki makita toshiaki makita 22 3.76% 1 2.08%
vlad yasevich vlad yasevich 18 3.08% 3 6.25%
florian fainelli florian fainelli 16 2.74% 2 4.17%
greg kroah-hartman greg kroah-hartman 15 2.56% 1 2.08%
johannes berg johannes berg 13 2.22% 1 2.08%
linus torvalds linus torvalds 11 1.88% 1 2.08%
gao feng gao feng 10 1.71% 1 2.08%
volodymyr g. lukiianyk volodymyr g. lukiianyk 7 1.20% 1 2.08%
americo wang americo wang 7 1.20% 1 2.08%
michal miroslaw michal miroslaw 7 1.20% 1 2.08%
ben hutchings ben hutchings 5 0.85% 1 2.08%
jeff hansen jeff hansen 5 0.85% 1 2.08%
eric dumazet eric dumazet 5 0.85% 1 2.08%
xiaotian feng xiaotian feng 1 0.17% 1 2.08%
wang weidong wang weidong 1 0.17% 1 2.08%
Total 585 100.00% 48 100.00%

/* called with RTNL */


int br_del_if(struct net_bridge *br, struct net_device *dev)
{
	struct net_bridge_port *p;
	bool changed_addr;

	p = br_port_get_rtnl(dev);
	if (!p || p->br != br)
		return -EINVAL;

	/* Since more than one interface can be attached to a bridge,
         * there still maybe an alternate path for netconsole to use;
         * therefore there is no reason for a NETDEV_RELEASE event.
         */
	del_nbp(p);

	dev_set_mtu(br->dev, br_min_mtu(br));
	br_set_gso_limits(br);

	spin_lock_bh(&br->lock);
	changed_addr = br_stp_recalculate_bridge_id(br);
	spin_unlock_bh(&br->lock);

	if (changed_addr)
		call_netdevice_notifiers(NETDEV_CHANGEADDR, br->dev);

	netdev_update_features(br->dev);

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
stephen hemminger stephen hemminger 39 34.21% 5 38.46%
pre-git pre-git 25 21.93% 1 7.69%
andrei warkentin andrei warkentin 18 15.79% 1 7.69%
venkat venkatsubra venkat venkatsubra 12 10.53% 1 7.69%
jiri pirko jiri pirko 7 6.14% 1 7.69%
michal miroslaw michal miroslaw 6 5.26% 1 7.69%
eric dumazet eric dumazet 6 5.26% 2 15.38%
americo wang americo wang 1 0.88% 1 7.69%
Total 114 100.00% 13 100.00%



void br_port_flags_change(struct net_bridge_port *p, unsigned long mask)
{
	struct net_bridge *br = p->br;

	if (mask & BR_AUTO_MASK)
		nbp_update_port_count(br);
}
Contributors
Person Tokens Prop Commits CommitProp
vlad yasevich vlad yasevich 34 100.00% 1 100.00%
Total 34 100.00% 1 100.00%

Overall Contributors
Person Tokens Prop Commits CommitProp
stephen hemminger stephen hemminger 987 38.49% 44 36.97%
vlad yasevich vlad yasevich 397 15.48% 6 5.04%
pre-git pre-git 302 11.78% 2 1.68%
paolo abeni paolo abeni 157 6.12% 1 0.84%
eric dumazet eric dumazet 118 4.60% 4 3.36%
jiri pirko jiri pirko 90 3.51% 8 6.72%
herbert xu herbert xu 66 2.57% 5 4.20%
toshiaki makita toshiaki makita 47 1.83% 4 3.36%
elad raz elad raz 46 1.79% 1 0.84%
nikolay aleksandrov nikolay aleksandrov 39 1.52% 3 2.52%
andrew morton andrew morton 34 1.33% 1 0.84%
michal miroslaw michal miroslaw 28 1.09% 3 2.52%
wang chen wang chen 27 1.05% 1 0.84%
aji srinivas aji srinivas 23 0.90% 1 0.84%
florian fainelli florian fainelli 20 0.78% 3 2.52%
andrei warkentin andrei warkentin 18 0.70% 1 0.84%
greg kroah-hartman greg kroah-hartman 15 0.59% 1 0.84%
americo wang americo wang 14 0.55% 3 2.52%
johannes berg johannes berg 13 0.51% 1 0.84%
alexey dobriyan alexey dobriyan 12 0.47% 1 0.84%
venkat venkatsubra venkat venkatsubra 12 0.47% 1 0.84%
linus torvalds linus torvalds 11 0.43% 1 0.84%
gao feng gao feng 10 0.39% 1 0.84%
ding tianhong ding tianhong 9 0.35% 1 0.84%
volodymyr g. lukiianyk volodymyr g. lukiianyk 7 0.27% 1 0.84%
david decotigny david decotigny 6 0.23% 1 0.84%
kris katterjohn kris katterjohn 5 0.20% 1 0.84%
anna fischer anna fischer 5 0.20% 1 0.84%
david howells david howells 5 0.20% 1 0.84%
satish ashok satish ashok 5 0.20% 1 0.84%
jeff hansen jeff hansen 5 0.20% 1 0.84%
ben hutchings ben hutchings 5 0.20% 1 0.84%
tejun heo tejun heo 3 0.12% 1 0.84%
david s. miller david s. miller 3 0.12% 1 0.84%
marcel holtmann marcel holtmann 3 0.12% 1 0.84%
randy dunlap randy dunlap 3 0.12% 1 0.84%
pavel emelianov pavel emelianov 3 0.12% 1 0.84%
matthew wilcox matthew wilcox 3 0.12% 1 0.84%
tom gundersen tom gundersen 2 0.08% 1 0.84%
wang weidong wang weidong 1 0.04% 1 0.84%
adrian bunk adrian bunk 1 0.04% 1 0.84%
simon arlott simon arlott 1 0.04% 1 0.84%
tan xiaojun tan xiaojun 1 0.04% 1 0.84%
xiaotian feng xiaotian feng 1 0.04% 1 0.84%
eric w. biederman eric w. biederman 1 0.04% 1 0.84%
Total 2564 100.00% 119 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	48	47.52%	3	50.00%
pre-git	pre-git	45	44.55%	1	16.67%
david decotigny	david decotigny	6	5.94%	1	16.67%
matthew wilcox	matthew wilcox	2	1.98%	1	16.67%
	Total	101	100.00%	6	100.00%
cregit-Linux how code gets into the kernel

Release 4.8 net/bridge/br_if.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

Overall Contributors
