Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit bfc17d00 authored by David S. Miller's avatar David S. Miller
Browse files

Merge branch 'hv_netvsc-notification-and-namespace-fixes' 



Stephen Hemminger says:

====================
hv_netvsc: notification and namespace fixes

This set of patches addresses two set of fixes. First it backs out
the common callback model which was merged in net-next without
completing all the review feedback or getting maintainer approval.

Then it fixes the transparent VF management code to handle network
namespaces.
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents 01a1a170 c0a41b88

drivers/net/hyperv/Kconfig

+0 −1
Original line number Diff line number Diff line
@@ -2,6 +2,5 @@ config HYPERV_NET 
	tristate "Microsoft Hyper-V virtual network driver"

	depends on HYPERV

	select UCS2_STRING

	select FAILOVER

	help

	  Select this option to enable the Hyper-V virtual network driver.

drivers/net/hyperv/hyperv_net.h

+2 −2
Original line number Diff line number Diff line
@@ -901,6 +901,8 @@ struct net_device_context { 
	struct hv_device *device_ctx;

	/* netvsc_device */

	struct netvsc_device __rcu *nvdev;

	/* list of netvsc net_devices */

	struct list_head list;

	/* reconfigure work */

	struct delayed_work dwork;

	/* last reconfig time */
@@ -931,8 +933,6 @@ struct net_device_context { 
	u32 vf_alloc;

	/* Serial number of the VF to team with */

	u32 vf_serial;



	struct failover *failover;

};



/* Per channel data */

drivers/net/hyperv/netvsc_drv.c

+182 −60
Original line number Diff line number Diff line
@@ -42,7 +42,6 @@ 
#include <net/pkt_sched.h>

#include <net/checksum.h>

#include <net/ip6_checksum.h>

#include <net/failover.h>



#include "hyperv_net.h"
@@ -68,6 +67,8 @@ static int debug = -1; 
module_param(debug, int, 0444);

MODULE_PARM_DESC(debug, "Debug level (0=none,...,16=all)");



static LIST_HEAD(netvsc_dev_list);



static void netvsc_change_rx_flags(struct net_device *net, int change)

{

	struct net_device_context *ndev_ctx = netdev_priv(net);
@@ -1780,6 +1781,36 @@ static void netvsc_link_change(struct work_struct *w) 
	rtnl_unlock();

}



static struct net_device *get_netvsc_bymac(const u8 *mac)

{

	struct net_device_context *ndev_ctx;



	list_for_each_entry(ndev_ctx, &netvsc_dev_list, list) {

		struct net_device *dev = hv_get_drvdata(ndev_ctx->device_ctx);



		if (ether_addr_equal(mac, dev->perm_addr))

			return dev;

	}



	return NULL;

}



static struct net_device *get_netvsc_byref(struct net_device *vf_netdev)

{

	struct net_device_context *net_device_ctx;

	struct net_device *dev;



	dev = netdev_master_upper_dev_get(vf_netdev);

	if (!dev || dev->netdev_ops != &device_ops)

		return NULL;	/* not a netvsc device */



	net_device_ctx = netdev_priv(dev);

	if (!rtnl_dereference(net_device_ctx->nvdev))

		return NULL;	/* device is removed */



	return dev;

}



/* Called when VF is injecting data into network stack.

 * Change the associated network device from VF to netvsc.

 * note: already called with rcu_read_lock
@@ -1802,6 +1833,46 @@ static rx_handler_result_t netvsc_vf_handle_frame(struct sk_buff **pskb) 
	return RX_HANDLER_ANOTHER;

}



static int netvsc_vf_join(struct net_device *vf_netdev,

			  struct net_device *ndev)

{

	struct net_device_context *ndev_ctx = netdev_priv(ndev);

	int ret;



	ret = netdev_rx_handler_register(vf_netdev,

					 netvsc_vf_handle_frame, ndev);

	if (ret != 0) {

		netdev_err(vf_netdev,

			   "can not register netvsc VF receive handler (err = %d)\n",

			   ret);

		goto rx_handler_failed;

	}



	ret = netdev_master_upper_dev_link(vf_netdev, ndev,

					   NULL, NULL, NULL);

	if (ret != 0) {

		netdev_err(vf_netdev,

			   "can not set master device %s (err = %d)\n",

			   ndev->name, ret);

		goto upper_link_failed;

	}



	/* set slave flag before open to prevent IPv6 addrconf */

	vf_netdev->flags |= IFF_SLAVE;



	schedule_delayed_work(&ndev_ctx->vf_takeover, VF_TAKEOVER_INT);



	call_netdevice_notifiers(NETDEV_JOIN, vf_netdev);



	netdev_info(vf_netdev, "joined to %s\n", ndev->name);

	return 0;



upper_link_failed:

	netdev_rx_handler_unregister(vf_netdev);

rx_handler_failed:

	return ret;

}



static void __netvsc_vf_setup(struct net_device *ndev,

			      struct net_device *vf_netdev)

{
@@ -1852,95 +1923,104 @@ static void netvsc_vf_setup(struct work_struct *w) 
	rtnl_unlock();

}



static int netvsc_pre_register_vf(struct net_device *vf_netdev,

				  struct net_device *ndev)

static int netvsc_register_vf(struct net_device *vf_netdev)

{

	struct net_device *ndev;

	struct net_device_context *net_device_ctx;

	struct netvsc_device *netvsc_dev;

	int ret;



	if (vf_netdev->addr_len != ETH_ALEN)

		return NOTIFY_DONE;



	/*

	 * We will use the MAC address to locate the synthetic interface to

	 * associate with the VF interface. If we don't find a matching

	 * synthetic interface, move on.

	 */

	ndev = get_netvsc_bymac(vf_netdev->perm_addr);

	if (!ndev)

		return NOTIFY_DONE;



	net_device_ctx = netdev_priv(ndev);

	netvsc_dev = rtnl_dereference(net_device_ctx->nvdev);

	if (!netvsc_dev || rtnl_dereference(net_device_ctx->vf_netdev))

		return -ENODEV;

		return NOTIFY_DONE;



	return 0;

	/* if syntihetic interface is a different namespace,

	 * then move the VF to that namespace; join will be

	 * done again in that context.

	 */

	if (!net_eq(dev_net(ndev), dev_net(vf_netdev))) {

		ret = dev_change_net_namespace(vf_netdev,

					       dev_net(ndev), "eth%d");

		if (ret)

			netdev_err(vf_netdev,

				   "could not move to same namespace as %s: %d\n",

				   ndev->name, ret);

		else

			netdev_info(vf_netdev,

				    "VF moved to namespace with: %s\n",

				    ndev->name);

		return NOTIFY_DONE;

	}



static int netvsc_register_vf(struct net_device *vf_netdev,

			      struct net_device *ndev)

{

	struct net_device_context *ndev_ctx = netdev_priv(ndev);

	netdev_info(ndev, "VF registering: %s\n", vf_netdev->name);



	/* set slave flag before open to prevent IPv6 addrconf */

	vf_netdev->flags |= IFF_SLAVE;



	schedule_delayed_work(&ndev_ctx->vf_takeover, VF_TAKEOVER_INT);



	call_netdevice_notifiers(NETDEV_JOIN, vf_netdev);



	netdev_info(vf_netdev, "joined to %s\n", ndev->name);

	if (netvsc_vf_join(vf_netdev, ndev) != 0)

		return NOTIFY_DONE;



	dev_hold(vf_netdev);

	rcu_assign_pointer(ndev_ctx->vf_netdev, vf_netdev);



	return 0;

	rcu_assign_pointer(net_device_ctx->vf_netdev, vf_netdev);

	return NOTIFY_OK;

}



/* VF up/down change detected, schedule to change data path */

static int netvsc_vf_changed(struct net_device *vf_netdev,

			     struct net_device *ndev)

static int netvsc_vf_changed(struct net_device *vf_netdev)

{

	struct net_device_context *net_device_ctx;

	struct netvsc_device *netvsc_dev;

	struct net_device *ndev;

	bool vf_is_up = netif_running(vf_netdev);



	ndev = get_netvsc_byref(vf_netdev);

	if (!ndev)

		return NOTIFY_DONE;



	net_device_ctx = netdev_priv(ndev);

	netvsc_dev = rtnl_dereference(net_device_ctx->nvdev);

	if (!netvsc_dev)

		return -ENODEV;

		return NOTIFY_DONE;



	netvsc_switch_datapath(ndev, vf_is_up);

	netdev_info(ndev, "Data path switched %s VF: %s\n",

		    vf_is_up ? "to" : "from", vf_netdev->name);



	return 0;

	return NOTIFY_OK;

}



static int netvsc_pre_unregister_vf(struct net_device *vf_netdev,

				    struct net_device *ndev)

static int netvsc_unregister_vf(struct net_device *vf_netdev)

{

	struct net_device *ndev;

	struct net_device_context *net_device_ctx;



	net_device_ctx = netdev_priv(ndev);

	cancel_delayed_work_sync(&net_device_ctx->vf_takeover);



	return 0;

}



static int netvsc_unregister_vf(struct net_device *vf_netdev,

				struct net_device *ndev)

{

	struct net_device_context *net_device_ctx;

	ndev = get_netvsc_byref(vf_netdev);

	if (!ndev)

		return NOTIFY_DONE;



	net_device_ctx = netdev_priv(ndev);

	cancel_delayed_work_sync(&net_device_ctx->vf_takeover);



	netdev_info(ndev, "VF unregistering: %s\n", vf_netdev->name);



	netdev_rx_handler_unregister(vf_netdev);

	netdev_upper_dev_unlink(vf_netdev, ndev);

	RCU_INIT_POINTER(net_device_ctx->vf_netdev, NULL);

	dev_put(vf_netdev);



	return 0;

	return NOTIFY_OK;

}



static struct failover_ops netvsc_failover_ops = {

	.slave_pre_register	= netvsc_pre_register_vf,

	.slave_register		= netvsc_register_vf,

	.slave_pre_unregister	= netvsc_pre_unregister_vf,

	.slave_unregister	= netvsc_unregister_vf,

	.slave_link_change	= netvsc_vf_changed,

	.slave_handle_frame	= netvsc_vf_handle_frame,

};



static int netvsc_probe(struct hv_device *dev,

			const struct hv_vmbus_device_id *dev_id)

{
@@ -2024,23 +2104,19 @@ static int netvsc_probe(struct hv_device *dev, 
	else

		net->max_mtu = ETH_DATA_LEN;



	ret = register_netdev(net);

	rtnl_lock();

	ret = register_netdevice(net);

	if (ret != 0) {

		pr_err("Unable to register netdev.\n");

		goto register_failed;

	}



	net_device_ctx->failover = failover_register(net, &netvsc_failover_ops);

	if (IS_ERR(net_device_ctx->failover)) {

		ret = PTR_ERR(net_device_ctx->failover);

		goto err_failover;

	}



	return ret;

	list_add(&net_device_ctx->list, &netvsc_dev_list);

	rtnl_unlock();

	return 0;



err_failover:

	unregister_netdev(net);

register_failed:

	rtnl_unlock();

	rndis_filter_device_remove(dev, nvdev);

rndis_failed:

	free_percpu(net_device_ctx->vf_stats);
@@ -2080,14 +2156,13 @@ static int netvsc_remove(struct hv_device *dev) 
	rtnl_lock();

	vf_netdev = rtnl_dereference(ndev_ctx->vf_netdev);

	if (vf_netdev)

		failover_slave_unregister(vf_netdev);

		netvsc_unregister_vf(vf_netdev);



	if (nvdev)

		rndis_filter_device_remove(dev, nvdev);



	unregister_netdevice(net);



	failover_unregister(ndev_ctx->failover);

	list_del(&ndev_ctx->list);



	rtnl_unlock();

	rcu_read_unlock();
@@ -2115,8 +2190,54 @@ static struct hv_driver netvsc_drv = { 
	.remove = netvsc_remove,

};



/*

 * On Hyper-V, every VF interface is matched with a corresponding

 * synthetic interface. The synthetic interface is presented first

 * to the guest. When the corresponding VF instance is registered,

 * we will take care of switching the data path.

 */

static int netvsc_netdev_event(struct notifier_block *this,

			       unsigned long event, void *ptr)

{

	struct net_device *event_dev = netdev_notifier_info_to_dev(ptr);



	/* Skip our own events */

	if (event_dev->netdev_ops == &device_ops)

		return NOTIFY_DONE;



	/* Avoid non-Ethernet type devices */

	if (event_dev->type != ARPHRD_ETHER)

		return NOTIFY_DONE;



	/* Avoid Vlan dev with same MAC registering as VF */

	if (is_vlan_dev(event_dev))

		return NOTIFY_DONE;



	/* Avoid Bonding master dev with same MAC registering as VF */

	if ((event_dev->priv_flags & IFF_BONDING) &&

	    (event_dev->flags & IFF_MASTER))

		return NOTIFY_DONE;



	switch (event) {

	case NETDEV_REGISTER:

		return netvsc_register_vf(event_dev);

	case NETDEV_UNREGISTER:

		return netvsc_unregister_vf(event_dev);

	case NETDEV_UP:

	case NETDEV_DOWN:

		return netvsc_vf_changed(event_dev);

	default:

		return NOTIFY_DONE;

	}

}



static struct notifier_block netvsc_netdev_notifier = {

	.notifier_call = netvsc_netdev_event,

};



static void __exit netvsc_drv_exit(void)

{

	unregister_netdevice_notifier(&netvsc_netdev_notifier);

	vmbus_driver_unregister(&netvsc_drv);

}
@@ -2135,6 +2256,7 @@ static int __init netvsc_drv_init(void) 
	if (ret)

		return ret;



	register_netdevice_notifier(&netvsc_netdev_notifier);

	return 0;

}