net/hsr: Move slave init to hsr_slave.c. (51f3c605) · Commits · 戴 / test

net/hsr/hsr_device.c

+55 −137

Original line number	Original line	Diff line number	Diff line
	@@ -15,7 +15,6 @@
	#include <linux/netdevice.h>		#include <linux/netdevice.h>
	#include <linux/skbuff.h>		#include <linux/skbuff.h>
	#include <linux/etherdevice.h>		#include <linux/etherdevice.h>
	#include <linux/if_arp.h>
	#include <linux/rtnetlink.h>		#include <linux/rtnetlink.h>
	#include <linux/pkt_sched.h>		#include <linux/pkt_sched.h>
	#include "hsr_device.h"		#include "hsr_device.h"
	@@ -108,23 +107,27 @@ void hsr_check_carrier_and_operstate(struct hsr_priv *hsr)
	hsr_check_announce(hsr->dev, old_operstate);		hsr_check_announce(hsr->dev, old_operstate);
	}		}


	int hsr_get_max_mtu(struct hsr_priv *hsr)		int hsr_get_max_mtu(struct hsr_priv *hsr)
	{		{
	int mtu_max;		unsigned int mtu_max;
			struct net_device *slave;
	if (hsr->slave[0] && hsr->slave[1])
	mtu_max = min(hsr->slave[0]->mtu, hsr->slave[1]->mtu);		mtu_max = ETH_DATA_LEN;
	else if (hsr->slave[0])		rcu_read_lock();
	mtu_max = hsr->slave[0]->mtu;		slave = hsr->slave[0];
	else if (hsr->slave[1])		if (slave)
	mtu_max = hsr->slave[1]->mtu;		mtu_max = min(slave->mtu, mtu_max);
	else		slave = hsr->slave[1];
	mtu_max = HSR_HLEN;		if (slave)
			mtu_max = min(slave->mtu, mtu_max);
			rcu_read_unlock();

			if (mtu_max < HSR_HLEN)
			return 0;
	return mtu_max - HSR_HLEN;		return mtu_max - HSR_HLEN;
	}		}


	static int hsr_dev_change_mtu(struct net_device *dev, int new_mtu)		static int hsr_dev_change_mtu(struct net_device *dev, int new_mtu)
	{		{
	struct hsr_priv *hsr;		struct hsr_priv *hsr;
	@@ -145,18 +148,20 @@ static int hsr_dev_change_mtu(struct net_device *dev, int new_mtu)
	static int hsr_dev_open(struct net_device *dev)		static int hsr_dev_open(struct net_device *dev)
	{		{
	struct hsr_priv *hsr;		struct hsr_priv *hsr;
			struct net_device *slave;
	int i;		int i;
	char *slave_name;		char *slave_name;

	hsr = netdev_priv(dev);		hsr = netdev_priv(dev);

	for (i = 0; i < HSR_MAX_SLAVE; i++) {		for (i = 0; i < HSR_MAX_SLAVE; i++) {
	if (hsr->slave[i])		slave = hsr->slave[i];
	slave_name = hsr->slave[i]->name;		if (slave)
			slave_name = slave->name;
	else		else
	slave_name = "null";		slave_name = "null";

	if (!is_slave_up(hsr->slave[i]))		if (!is_slave_up(slave))
	netdev_warn(dev, "Slave %c (%s) is not up; please bring it up to get a working HSR network\n",		netdev_warn(dev, "Slave %c (%s) is not up; please bring it up to get a working HSR network\n",
	'A' + i, slave_name);		'A' + i, slave_name);
	}		}
	@@ -223,6 +228,8 @@ static int slave_xmit(struct sk_buff skb, struct hsr_priv hsr,
	hsr_ethhdr = (struct hsr_ethhdr *) skb->data;		hsr_ethhdr = (struct hsr_ethhdr *) skb->data;

	skb->dev = hsr->slave[dev_idx];		skb->dev = hsr->slave[dev_idx];
			if (unlikely(!skb->dev))
			return NET_XMIT_DROP;

	hsr_addr_subst_dest(hsr, &hsr_ethhdr->ethhdr, dev_idx);		hsr_addr_subst_dest(hsr, &hsr_ethhdr->ethhdr, dev_idx);

	@@ -252,13 +259,7 @@ static int hsr_dev_xmit(struct sk_buff skb, struct net_device dev)
	}		}

	skb2 = pskb_copy(skb, GFP_ATOMIC);		skb2 = pskb_copy(skb, GFP_ATOMIC);

	res1 = NET_XMIT_DROP;
	if (likely(hsr->slave[HSR_DEV_SLAVE_A]))
	res1 = slave_xmit(skb, hsr, HSR_DEV_SLAVE_A);		res1 = slave_xmit(skb, hsr, HSR_DEV_SLAVE_A);

	res2 = NET_XMIT_DROP;
	if (likely(skb2 && hsr->slave[HSR_DEV_SLAVE_B]))
	res2 = slave_xmit(skb2, hsr, HSR_DEV_SLAVE_B);		res2 = slave_xmit(skb2, hsr, HSR_DEV_SLAVE_B);

	if (likely(res1 == NET_XMIT_SUCCESS \|\| res1 == NET_XMIT_CN \|\|		if (likely(res1 == NET_XMIT_SUCCESS \|\| res1 == NET_XMIT_CN \|\|
	@@ -406,28 +407,10 @@ static void hsr_announce(unsigned long data)
	static void restore_slaves(struct net_device *hsr_dev)		static void restore_slaves(struct net_device *hsr_dev)
	{		{
	struct hsr_priv *hsr;		struct hsr_priv *hsr;
	int i;
	int res;

	hsr = netdev_priv(hsr_dev);		hsr = netdev_priv(hsr_dev);
			hsr_del_slave(hsr, 1);
	rtnl_lock();		hsr_del_slave(hsr, 0);

	for (i = 0; i < HSR_MAX_SLAVE; i++) {
	if (!hsr->slave[i])
	continue;
	res = dev_set_promiscuity(hsr->slave[i], -1);
	if (res)
	netdev_info(hsr_dev,
	"Cannot restore slave promiscuity (%s, %d)\n",
	hsr->slave[i]->name, res);

	if (hsr->slave[i]->rx_handler == hsr_handle_frame)
	netdev_rx_handler_unregister(hsr->slave[i]);
	}


	rtnl_unlock();
	}		}

	static void reclaim_hsr_dev(struct rcu_head *rh)		static void reclaim_hsr_dev(struct rcu_head *rh)
	@@ -483,38 +466,6 @@ bool is_hsr_master(struct net_device *dev)
	return (dev->netdev_ops->ndo_start_xmit == hsr_dev_xmit);		return (dev->netdev_ops->ndo_start_xmit == hsr_dev_xmit);
	}		}

	static int check_slave_ok(struct net_device *dev)
	{
	/* Don't allow HSR on non-ethernet like devices */
	if ((dev->flags & IFF_LOOPBACK) \|\| (dev->type != ARPHRD_ETHER) \|\|
	(dev->addr_len != ETH_ALEN)) {
	netdev_info(dev, "Cannot use loopback or non-ethernet device as HSR slave.\n");
	return -EINVAL;
	}

	/* Don't allow enslaving hsr devices */
	if (is_hsr_master(dev)) {
	netdev_info(dev, "Cannot create trees of HSR devices.\n");
	return -EINVAL;
	}

	if (is_hsr_slave(dev)) {
	netdev_info(dev, "This device is already a HSR slave.\n");
	return -EINVAL;
	}

	if (dev->priv_flags & IFF_802_1Q_VLAN) {
	netdev_info(dev, "HSR on top of VLAN is not yet supported in this driver.\n");
	return -EINVAL;
	}

	/* HSR over bonded devices has not been tested, but I'm not sure it
	* won't work...
	*/

	return 0;
	}


	/* Default multicast address for HSR Supervision frames */		/* Default multicast address for HSR Supervision frames */
	static const unsigned char def_multicast_addr[ETH_ALEN] __aligned(2) = {		static const unsigned char def_multicast_addr[ETH_ALEN] __aligned(2) = {
	@@ -525,15 +476,30 @@ int hsr_dev_finalize(struct net_device hsr_dev, struct net_device slave[2],
	unsigned char multicast_spec)		unsigned char multicast_spec)
	{		{
	struct hsr_priv *hsr;		struct hsr_priv *hsr;
	int i;
	int res;		int res;

	hsr = netdev_priv(hsr_dev);		hsr = netdev_priv(hsr_dev);
	hsr->dev = hsr_dev;		hsr->dev = hsr_dev;
			hsr->slave[0] = NULL;
			hsr->slave[1] = NULL;
	INIT_LIST_HEAD(&hsr->node_db);		INIT_LIST_HEAD(&hsr->node_db);
	INIT_LIST_HEAD(&hsr->self_node_db);		INIT_LIST_HEAD(&hsr->self_node_db);
	for (i = 0; i < HSR_MAX_SLAVE; i++)
	hsr->slave[i] = slave[i];		ether_addr_copy(hsr_dev->dev_addr, slave[0]->dev_addr);

			/* Make sure we recognize frames from ourselves in hsr_rcv() */
			res = hsr_create_self_node(&hsr->self_node_db, hsr_dev->dev_addr,
			slave[1]->dev_addr);
			if (res < 0)
			return res;

			hsr_dev->features = slave[0]->features & slave[1]->features;
			/* Prevent recursive tx locking */
			hsr_dev->features \|= NETIF_F_LLTX;
			/* VLAN on top of HSR needs testing and probably some work on
			* hsr_header_create() etc.
			*/
			hsr_dev->features \|= NETIF_F_VLAN_CHALLENGED;

	spin_lock_init(&hsr->seqnr_lock);		spin_lock_init(&hsr->seqnr_lock);
	/* Overflow soon to find bugs easier: */		/* Overflow soon to find bugs easier: */
	@@ -560,65 +526,21 @@ int hsr_dev_finalize(struct net_device hsr_dev, struct net_device slave[2],
	* IFF_HSR_MASTER/SLAVE?		* IFF_HSR_MASTER/SLAVE?
	*/		*/

	for (i = 0; i < HSR_MAX_SLAVE; i++) {
	res = check_slave_ok(slave[i]);
	if (res)
	return res;
	}

	hsr_dev->features = slave[0]->features & slave[1]->features;
	/* Prevent recursive tx locking */
	hsr_dev->features \|= NETIF_F_LLTX;
	/* VLAN on top of HSR needs testing and probably some work on
	* hsr_header_create() etc.
	*/
	hsr_dev->features \|= NETIF_F_VLAN_CHALLENGED;

	/* Set hsr_dev's MAC address to that of mac_slave1 */
	ether_addr_copy(hsr_dev->dev_addr, hsr->slave[0]->dev_addr);

	/* Set required header length */
	for (i = 0; i < HSR_MAX_SLAVE; i++) {
	if (slave[i]->hard_header_len + HSR_HLEN >
	hsr_dev->hard_header_len)
	hsr_dev->hard_header_len =
	slave[i]->hard_header_len + HSR_HLEN;
	}

	/* MTU */
	for (i = 0; i < HSR_MAX_SLAVE; i++)
	if (slave[i]->mtu - HSR_HLEN < hsr_dev->mtu)
	hsr_dev->mtu = slave[i]->mtu - HSR_HLEN;

	/* Make sure the 1st call to netif_carrier_on() gets through */		/* Make sure the 1st call to netif_carrier_on() gets through */
	netif_carrier_off(hsr_dev);		netif_carrier_off(hsr_dev);

	/* Promiscuity */		res = register_netdevice(hsr_dev);
	for (i = 0; i < HSR_MAX_SLAVE; i++) {
	res = dev_set_promiscuity(slave[i], 1);
	if (res) {
	netdev_info(hsr_dev, "Cannot set slave promiscuity (%s, %d)\n",
	slave[i]->name, res);
	goto fail;
	}
	}

	for (i = 0; i < HSR_MAX_SLAVE; i++) {
	res = netdev_rx_handler_register(slave[i], hsr_handle_frame,
	hsr);
	if (res)		if (res)
	goto fail;		return res;
	}

	/* Make sure we recognize frames from ourselves in hsr_rcv() */
	res = hsr_create_self_node(&hsr->self_node_db, hsr_dev->dev_addr,
	hsr->slave[1]->dev_addr);
	if (res < 0)
	goto fail;

	res = register_netdevice(hsr_dev);		res = hsr_add_slave(hsr, slave[0], 0);
	if (res)		if (res)
	goto fail;		return res;
			res = hsr_add_slave(hsr, slave[1], 1);
			if (res) {
			hsr_del_slave(hsr, 0);
			return res;
			}

	hsr->prune_timer.expires = jiffies + msecs_to_jiffies(PRUNE_PERIOD);		hsr->prune_timer.expires = jiffies + msecs_to_jiffies(PRUNE_PERIOD);
	add_timer(&hsr->prune_timer);		add_timer(&hsr->prune_timer);
	@@ -626,8 +548,4 @@ int hsr_dev_finalize(struct net_device hsr_dev, struct net_device slave[2],
	register_hsr_master(hsr);		register_hsr_master(hsr);

	return 0;		return 0;

	fail:
	restore_slaves(hsr_dev);
	return res;
	}		}

net/hsr/hsr_framereg.c

+4 −2

Original line number	Original line	Diff line number	Diff line
	@@ -455,6 +455,7 @@ int hsr_get_node_data(struct hsr_priv *hsr,
	u16 *if2_seq)		u16 *if2_seq)
	{		{
	struct hsr_node *node;		struct hsr_node *node;
			struct net_device *slave;
	unsigned long tdiff;		unsigned long tdiff;


	@@ -491,8 +492,9 @@ int hsr_get_node_data(struct hsr_priv *hsr,
	*if1_seq = node->seq_out[HSR_DEV_SLAVE_B];		*if1_seq = node->seq_out[HSR_DEV_SLAVE_B];
	*if2_seq = node->seq_out[HSR_DEV_SLAVE_A];		*if2_seq = node->seq_out[HSR_DEV_SLAVE_A];

	if ((node->AddrB_if != HSR_DEV_NONE) && hsr->slave[node->AddrB_if])		slave = hsr->slave[node->AddrB_if];
	*addr_b_ifindex = hsr->slave[node->AddrB_if]->ifindex;		if ((node->AddrB_if != HSR_DEV_NONE) && slave)
			*addr_b_ifindex = slave->ifindex;
	else		else
	*addr_b_ifindex = -1;		*addr_b_ifindex = -1;

net/hsr/hsr_main.c

+14 −10

Original line number	Original line	Diff line number	Diff line
	@@ -17,6 +17,7 @@
	#include "hsr_device.h"		#include "hsr_device.h"
	#include "hsr_netlink.h"		#include "hsr_netlink.h"
	#include "hsr_framereg.h"		#include "hsr_framereg.h"
			#include "hsr_slave.h"


	/* List of all registered virtual HSR devices */		/* List of all registered virtual HSR devices */
	@@ -124,22 +125,21 @@ static int hsr_netdev_notify(struct notifier_block *nb, unsigned long event,
	if (dev == hsr->dev)		if (dev == hsr->dev)
	break;		break;

	if (dev == hsr->slave[0])		if (dev == hsr->slave[0]) {
	ether_addr_copy(hsr->dev->dev_addr,		ether_addr_copy(hsr->dev->dev_addr, dev->dev_addr);
	hsr->slave[0]->dev_addr);		call_netdevice_notifiers(NETDEV_CHANGEADDR, hsr->dev);
			}

	/* Make sure we recognize frames from ourselves in hsr_rcv() */		/* Make sure we recognize frames from ourselves in hsr_rcv() */
			other_slave = hsr->slave[1];
	res = hsr_create_self_node(&hsr->self_node_db,		res = hsr_create_self_node(&hsr->self_node_db,
	hsr->dev->dev_addr,		hsr->dev->dev_addr,
	hsr->slave[1] ?		other_slave ?
	hsr->slave[1]->dev_addr :		other_slave->dev_addr :
	hsr->dev->dev_addr);		hsr->dev->dev_addr);
	if (res)		if (res)
	netdev_warn(hsr->dev,		netdev_warn(hsr->dev,
	"Could not update HSR node address.\n");		"Could not update HSR node address.\n");

	if (dev == hsr->slave[0])
	call_netdevice_notifiers(NETDEV_CHANGEADDR, hsr->dev);
	break;		break;
	case NETDEV_CHANGEMTU:		case NETDEV_CHANGEMTU:
	if (dev == hsr->dev)		if (dev == hsr->dev)
	@@ -149,10 +149,14 @@ static int hsr_netdev_notify(struct notifier_block *nb, unsigned long event,
	dev_set_mtu(hsr->dev, mtu_max);		dev_set_mtu(hsr->dev, mtu_max);
	break;		break;
	case NETDEV_UNREGISTER:		case NETDEV_UNREGISTER:
	if (dev == hsr->slave[0])		if (dev == hsr->slave[0]) {
	hsr->slave[0] = NULL;		hsr->slave[0] = NULL;
	if (dev == hsr->slave[1])		hsr_del_slave(hsr, 0);
			}
			if (dev == hsr->slave[1]) {
	hsr->slave[1] = NULL;		hsr->slave[1] = NULL;
			hsr_del_slave(hsr, 1);
			}

	/* There should really be a way to set a new slave device... */		/* There should really be a way to set a new slave device... */

net/hsr/hsr_netlink.c

+38 −15

Original line number	Original line	Diff line number	Diff line
	@@ -64,15 +64,27 @@ static int hsr_newlink(struct net src_net, struct net_device dev,
	static int hsr_fill_info(struct sk_buff skb, const struct net_device dev)		static int hsr_fill_info(struct sk_buff skb, const struct net_device dev)
	{		{
	struct hsr_priv *hsr;		struct hsr_priv *hsr;
			struct net_device *slave;
			int res;

	hsr = netdev_priv(dev);		hsr = netdev_priv(dev);

	if (hsr->slave[0])		res = 0;
	if (nla_put_u32(skb, IFLA_HSR_SLAVE1, hsr->slave[0]->ifindex))
			rcu_read_lock();
			slave = hsr->slave[0];
			if (slave)
			res = nla_put_u32(skb, IFLA_HSR_SLAVE1, slave->ifindex);
			rcu_read_unlock();
			if (res)
	goto nla_put_failure;		goto nla_put_failure;

	if (hsr->slave[1])		rcu_read_lock();
	if (nla_put_u32(skb, IFLA_HSR_SLAVE2, hsr->slave[1]->ifindex))		slave = hsr->slave[1];
			if (slave)
			res = nla_put_u32(skb, IFLA_HSR_SLAVE2, slave->ifindex);
			rcu_read_unlock();
			if (res)
	goto nla_put_failure;		goto nla_put_failure;

	if (nla_put(skb, IFLA_HSR_SUPERVISION_ADDR, ETH_ALEN,		if (nla_put(skb, IFLA_HSR_SUPERVISION_ADDR, ETH_ALEN,
	@@ -132,6 +144,7 @@ void hsr_nl_ringerror(struct hsr_priv *hsr, unsigned char addr[ETH_ALEN],
	enum hsr_dev_idx dev_idx)		enum hsr_dev_idx dev_idx)
	{		{
	struct sk_buff *skb;		struct sk_buff *skb;
			struct net_device *slave;
	void *msg_head;		void *msg_head;
	int res;		int res;
	int ifindex;		int ifindex;
	@@ -148,10 +161,14 @@ void hsr_nl_ringerror(struct hsr_priv *hsr, unsigned char addr[ETH_ALEN],
	if (res < 0)		if (res < 0)
	goto nla_put_failure;		goto nla_put_failure;

	if (hsr->slave[dev_idx])		rcu_read_lock();
	ifindex = hsr->slave[dev_idx]->ifindex;		slave = hsr->slave[dev_idx];
			if (slave)
			ifindex = slave->ifindex;
	else		else
	ifindex = -1;		ifindex = -1;
			rcu_read_unlock();

	res = nla_put_u32(skb, HSR_A_IFINDEX, ifindex);		res = nla_put_u32(skb, HSR_A_IFINDEX, ifindex);
	if (res < 0)		if (res < 0)
	goto nla_put_failure;		goto nla_put_failure;
	@@ -215,7 +232,7 @@ static int hsr_get_node_status(struct sk_buff skb_in, struct genl_info info)
	{		{
	/* For receiving */		/* For receiving */
	struct nlattr *na;		struct nlattr *na;
	struct net_device *hsr_dev;		struct net_device hsr_dev, slave;

	/* For sending */		/* For sending */
	struct sk_buff *skb_out;		struct sk_buff *skb_out;
	@@ -301,9 +318,11 @@ static int hsr_get_node_status(struct sk_buff skb_in, struct genl_info info)
	res = nla_put_u16(skb_out, HSR_A_IF1_SEQ, hsr_node_if1_seq);		res = nla_put_u16(skb_out, HSR_A_IF1_SEQ, hsr_node_if1_seq);
	if (res < 0)		if (res < 0)
	goto nla_put_failure;		goto nla_put_failure;
	if (hsr->slave[0])		rcu_read_lock();
	res = nla_put_u32(skb_out, HSR_A_IF1_IFINDEX,		slave = hsr->slave[0];
	hsr->slave[0]->ifindex);		if (slave)
			res = nla_put_u32(skb_out, HSR_A_IF1_IFINDEX, slave->ifindex);
			rcu_read_unlock();
	if (res < 0)		if (res < 0)
	goto nla_put_failure;		goto nla_put_failure;

	@@ -313,9 +332,13 @@ static int hsr_get_node_status(struct sk_buff skb_in, struct genl_info info)
	res = nla_put_u16(skb_out, HSR_A_IF2_SEQ, hsr_node_if2_seq);		res = nla_put_u16(skb_out, HSR_A_IF2_SEQ, hsr_node_if2_seq);
	if (res < 0)		if (res < 0)
	goto nla_put_failure;		goto nla_put_failure;
	if (hsr->slave[1])		rcu_read_lock();
	res = nla_put_u32(skb_out, HSR_A_IF2_IFINDEX,		slave = hsr->slave[1];
	hsr->slave[1]->ifindex);		if (slave)
			res = nla_put_u32(skb_out, HSR_A_IF2_IFINDEX, slave->ifindex);
			rcu_read_unlock();
			if (res < 0)
			goto nla_put_failure;

	genlmsg_end(skb_out, msg_head);		genlmsg_end(skb_out, msg_head);
	genlmsg_unicast(genl_info_net(info), skb_out, info->snd_portid);		genlmsg_unicast(genl_info_net(info), skb_out, info->snd_portid);

net/hsr/hsr_slave.c

+91 −0

Original line number	Original line	Diff line number	Diff line
	@@ -11,10 +11,45 @@

	#include "hsr_slave.h"		#include "hsr_slave.h"
	#include <linux/etherdevice.h>		#include <linux/etherdevice.h>
			#include <linux/if_arp.h>
	#include "hsr_main.h"		#include "hsr_main.h"
			#include "hsr_device.h"
	#include "hsr_framereg.h"		#include "hsr_framereg.h"


			static int check_slave_ok(struct net_device *dev)
			{
			/* Don't allow HSR on non-ethernet like devices */
			if ((dev->flags & IFF_LOOPBACK) \|\| (dev->type != ARPHRD_ETHER) \|\|
			(dev->addr_len != ETH_ALEN)) {
			netdev_info(dev, "Cannot use loopback or non-ethernet device as HSR slave.\n");
			return -EINVAL;
			}

			/* Don't allow enslaving hsr devices */
			if (is_hsr_master(dev)) {
			netdev_info(dev, "Cannot create trees of HSR devices.\n");
			return -EINVAL;
			}

			if (is_hsr_slave(dev)) {
			netdev_info(dev, "This device is already a HSR slave.\n");
			return -EINVAL;
			}

			if (dev->priv_flags & IFF_802_1Q_VLAN) {
			netdev_info(dev, "HSR on top of VLAN is not yet supported in this driver.\n");
			return -EINVAL;
			}

			/* HSR over bonded devices has not been tested, but I'm not sure it
			* won't work...
			*/

			return 0;
			}


	static struct sk_buff hsr_pull_tag(struct sk_buff skb)		static struct sk_buff hsr_pull_tag(struct sk_buff skb)
	{		{
	struct hsr_tag *hsr_tag;		struct hsr_tag *hsr_tag;
	@@ -241,3 +276,59 @@ forward:

	return RX_HANDLER_CONSUMED;		return RX_HANDLER_CONSUMED;
	}		}

			int hsr_add_slave(struct hsr_priv hsr, struct net_device dev, int idx)
			{
			int res;

			dev_hold(dev);

			res = check_slave_ok(dev);
			if (res)
			goto fail;

			res = dev_set_promiscuity(dev, 1);
			if (res)
			goto fail;

			res = netdev_rx_handler_register(dev, hsr_handle_frame, hsr);
			if (res)
			goto fail_rx_handler;


			hsr->slave[idx] = dev;

			/* Set required header length */
			if (dev->hard_header_len + HSR_HLEN > hsr->dev->hard_header_len)
			hsr->dev->hard_header_len = dev->hard_header_len + HSR_HLEN;

			dev_set_mtu(hsr->dev, hsr_get_max_mtu(hsr));

			return 0;

			fail_rx_handler:
			dev_set_promiscuity(dev, -1);

			fail:
			dev_put(dev);
			return res;
			}

			void hsr_del_slave(struct hsr_priv *hsr, int idx)
			{
			struct net_device *slave;

			slave = hsr->slave[idx];
			hsr->slave[idx] = NULL;

			netdev_update_features(hsr->dev);
			dev_set_mtu(hsr->dev, hsr_get_max_mtu(hsr));

			if (slave) {
			netdev_rx_handler_unregister(slave);
			dev_set_promiscuity(slave, -1);
			}

			synchronize_rcu();
			dev_put(slave);
			}

Admin message