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

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

Merge branch 'hv_netvsc-next' 



Stephen Hemminger says:

====================
hv_netvsc changes

These are mostly about improving the handling of interaction between
the virtual network device (netvsc) and the SR-IOV VF network device.
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents dd5a3005 f7ad75b7

drivers/net/hyperv/hyperv_net.h

+4 −3
Original line number Diff line number Diff line
@@ -649,6 +649,8 @@ struct multi_recv_comp { 
struct netvsc_stats {

	u64 packets;

	u64 bytes;

	u64 broadcast;

	u64 multicast;

	struct u64_stats_sync syncp;

};
@@ -695,9 +697,8 @@ struct net_device_context { 
	bool start_remove;



	/* State to manage the associated VF interface. */

	struct net_device *vf_netdev;

	bool vf_inject;

	atomic_t vf_use_cnt;

	struct net_device __rcu *vf_netdev;



	/* 1: allocated, serial number is valid. 0: not allocated */

	u32 vf_alloc;

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

drivers/net/hyperv/netvsc.c

+2 −2
Original line number Diff line number Diff line
@@ -635,7 +635,7 @@ static void netvsc_send_tx_complete(struct netvsc_device *net_device, 
		q_idx = nvsc_packet->q_idx;

		channel = incoming_channel;



		dev_kfree_skb_any(skb);

		dev_consume_skb_any(skb);

	}



	num_outstanding_sends =
@@ -944,7 +944,7 @@ int netvsc_send(struct hv_device *device, 
		}



		if (msdp->skb)

			dev_kfree_skb_any(msdp->skb);

			dev_consume_skb_any(msdp->skb);



		if (xmit_more && !packet->cp_partial) {

			msdp->skb = skb;

drivers/net/hyperv/netvsc_drv.c

+84 −104
Original line number Diff line number Diff line
@@ -667,51 +667,23 @@ int netvsc_recv_callback(struct hv_device *device_obj, 
{

	struct net_device *net = hv_get_drvdata(device_obj);

	struct net_device_context *net_device_ctx = netdev_priv(net);

	struct net_device *vf_netdev;

	struct sk_buff *skb;

	struct sk_buff *vf_skb;

	struct netvsc_stats *rx_stats;

	u32 bytes_recvd = packet->total_data_buflen;

	int ret = 0;



	if (!net || net->reg_state != NETREG_REGISTERED)

	if (net->reg_state != NETREG_REGISTERED)

		return NVSP_STAT_FAIL;



	if (READ_ONCE(net_device_ctx->vf_inject)) {

		atomic_inc(&net_device_ctx->vf_use_cnt);

		if (!READ_ONCE(net_device_ctx->vf_inject)) {

			/*

			 * We raced; just move on.

			 */

			atomic_dec(&net_device_ctx->vf_use_cnt);

			goto vf_injection_done;

		}



	/*

		 * Inject this packet into the VF inerface.

		 * On Hyper-V, multicast and brodcast packets

		 * are only delivered on the synthetic interface

		 * (after subjecting these to policy filters on

		 * the host). Deliver these via the VF interface

		 * in the guest.

	 * If necessary, inject this packet into the VF interface.

	 * On Hyper-V, multicast and brodcast packets are only delivered

	 * to the synthetic interface (after subjecting these to

	 * policy filters on the host). Deliver these via the VF

	 * interface in the guest.

	 */

		vf_skb = netvsc_alloc_recv_skb(net_device_ctx->vf_netdev,

					       packet, csum_info, *data,

					       vlan_tci);

		if (vf_skb != NULL) {

			++net_device_ctx->vf_netdev->stats.rx_packets;

			net_device_ctx->vf_netdev->stats.rx_bytes +=

				bytes_recvd;

			netif_receive_skb(vf_skb);

		} else {

			++net->stats.rx_dropped;

			ret = NVSP_STAT_FAIL;

		}

		atomic_dec(&net_device_ctx->vf_use_cnt);

		return ret;

	}



vf_injection_done:

	rx_stats = this_cpu_ptr(net_device_ctx->rx_stats);

	vf_netdev = rcu_dereference(net_device_ctx->vf_netdev);

	if (vf_netdev && (vf_netdev->flags & IFF_UP))

		net = vf_netdev;



	/* Allocate a skb - TODO direct I/O to pages? */

	skb = netvsc_alloc_recv_skb(net, packet, csum_info, *data, vlan_tci);
@@ -719,12 +691,25 @@ int netvsc_recv_callback(struct hv_device *device_obj, 
		++net->stats.rx_dropped;

		return NVSP_STAT_FAIL;

	}

	skb_record_rx_queue(skb, channel->

			    offermsg.offer.sub_channel_index);



	if (net != vf_netdev)

		skb_record_rx_queue(skb,

				    channel->offermsg.offer.sub_channel_index);



	/*

	 * Even if injecting the packet, record the statistics

	 * on the synthetic device because modifying the VF device

	 * statistics will not work correctly.

	 */

	rx_stats = this_cpu_ptr(net_device_ctx->rx_stats);

	u64_stats_update_begin(&rx_stats->syncp);

	rx_stats->packets++;

	rx_stats->bytes += packet->total_data_buflen;



	if (skb->pkt_type == PACKET_BROADCAST)

		++rx_stats->broadcast;

	else if (skb->pkt_type == PACKET_MULTICAST)

		++rx_stats->multicast;

	u64_stats_update_end(&rx_stats->syncp);



	/*
@@ -967,7 +952,7 @@ static struct rtnl_link_stats64 *netvsc_get_stats64(struct net_device *net, 
							    cpu);

		struct netvsc_stats *rx_stats = per_cpu_ptr(ndev_ctx->rx_stats,

							    cpu);

		u64 tx_packets, tx_bytes, rx_packets, rx_bytes;

		u64 tx_packets, tx_bytes, rx_packets, rx_bytes, rx_multicast;

		unsigned int start;



		do {
@@ -980,12 +965,14 @@ static struct rtnl_link_stats64 *netvsc_get_stats64(struct net_device *net, 
			start = u64_stats_fetch_begin_irq(&rx_stats->syncp);

			rx_packets = rx_stats->packets;

			rx_bytes = rx_stats->bytes;

			rx_multicast = rx_stats->multicast + rx_stats->broadcast;

		} while (u64_stats_fetch_retry_irq(&rx_stats->syncp, start));



		t->tx_bytes	+= tx_bytes;

		t->tx_packets	+= tx_packets;

		t->rx_bytes	+= rx_bytes;

		t->rx_packets	+= rx_packets;

		t->multicast	+= rx_multicast;

	}



	t->tx_dropped	= net->stats.tx_dropped;
@@ -1215,22 +1202,44 @@ static void netvsc_free_netdev(struct net_device *netdev) 
	free_netdev(netdev);

}



static struct net_device *get_netvsc_net_device(char *mac)

static struct net_device *get_netvsc_bymac(const u8 *mac)

{

	struct net_device *dev, *found = NULL;

	struct net_device *dev;



	ASSERT_RTNL();



	for_each_netdev(&init_net, dev) {

		if (memcmp(dev->dev_addr, mac, ETH_ALEN) == 0) {

		if (dev->netdev_ops != &device_ops)

				continue;

			found = dev;

			break;

			continue;	/* not a netvsc device */



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

			return dev;

	}



	return NULL;

}



	return found;

static struct net_device *get_netvsc_byref(struct net_device *vf_netdev)

{

	struct net_device *dev;



	ASSERT_RTNL();



	for_each_netdev(&init_net, dev) {

		struct net_device_context *net_device_ctx;



		if (dev->netdev_ops != &device_ops)

			continue;	/* not a netvsc device */



		net_device_ctx = netdev_priv(dev);

		if (net_device_ctx->nvdev == NULL)

			continue;	/* device is removed */



		if (rtnl_dereference(net_device_ctx->vf_netdev) == vf_netdev)

			return dev;	/* a match */

	}



	return NULL;

}



static int netvsc_register_vf(struct net_device *vf_netdev)
@@ -1238,9 +1247,8 @@ 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;

	const struct ethtool_ops *eth_ops = vf_netdev->ethtool_ops;



	if (eth_ops == NULL || eth_ops == &ethtool_ops)

	if (vf_netdev->addr_len != ETH_ALEN)

		return NOTIFY_DONE;



	/*
@@ -1248,13 +1256,13 @@ static int netvsc_register_vf(struct net_device *vf_netdev) 
	 * associate with the VF interface. If we don't find a matching

	 * synthetic interface, move on.

	 */

	ndev = get_netvsc_net_device(vf_netdev->dev_addr);

	ndev = get_netvsc_bymac(vf_netdev->perm_addr);

	if (!ndev)

		return NOTIFY_DONE;



	net_device_ctx = netdev_priv(ndev);

	netvsc_dev = net_device_ctx->nvdev;

	if (!netvsc_dev || net_device_ctx->vf_netdev)

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

		return NOTIFY_DONE;



	netdev_info(ndev, "VF registering: %s\n", vf_netdev->name);
@@ -1262,46 +1270,26 @@ static int netvsc_register_vf(struct net_device *vf_netdev) 
	 * Take a reference on the module.

	 */

	try_module_get(THIS_MODULE);

	net_device_ctx->vf_netdev = vf_netdev;

	return NOTIFY_OK;

}



static void netvsc_inject_enable(struct net_device_context *net_device_ctx)

{

	net_device_ctx->vf_inject = true;

}



static void netvsc_inject_disable(struct net_device_context *net_device_ctx)

{

	net_device_ctx->vf_inject = false;



	/* Wait for currently active users to drain out. */

	while (atomic_read(&net_device_ctx->vf_use_cnt) != 0)

		udelay(50);

	dev_hold(vf_netdev);

	rcu_assign_pointer(net_device_ctx->vf_netdev, vf_netdev);

	return NOTIFY_OK;

}



static int netvsc_vf_up(struct net_device *vf_netdev)

{

	struct net_device *ndev;

	struct netvsc_device *netvsc_dev;

	const struct ethtool_ops *eth_ops = vf_netdev->ethtool_ops;

	struct net_device_context *net_device_ctx;



	if (eth_ops == &ethtool_ops)

		return NOTIFY_DONE;



	ndev = get_netvsc_net_device(vf_netdev->dev_addr);

	ndev = get_netvsc_byref(vf_netdev);

	if (!ndev)

		return NOTIFY_DONE;



	net_device_ctx = netdev_priv(ndev);

	netvsc_dev = net_device_ctx->nvdev;



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

		return NOTIFY_DONE;



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

	netvsc_inject_enable(net_device_ctx);



	/*

	 * Open the device before switching data path.
@@ -1327,23 +1315,15 @@ static int netvsc_vf_down(struct net_device *vf_netdev) 
	struct net_device *ndev;

	struct netvsc_device *netvsc_dev;

	struct net_device_context *net_device_ctx;

	const struct ethtool_ops *eth_ops = vf_netdev->ethtool_ops;



	if (eth_ops == &ethtool_ops)

		return NOTIFY_DONE;



	ndev = get_netvsc_net_device(vf_netdev->dev_addr);

	ndev = get_netvsc_byref(vf_netdev);

	if (!ndev)

		return NOTIFY_DONE;



	net_device_ctx = netdev_priv(ndev);

	netvsc_dev = net_device_ctx->nvdev;



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

		return NOTIFY_DONE;



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

	netvsc_inject_disable(net_device_ctx);

	netvsc_switch_datapath(ndev, false);

	netdev_info(ndev, "Data path switched from VF: %s\n", vf_netdev->name);

	rndis_filter_close(netvsc_dev);
@@ -1359,23 +1339,19 @@ static int netvsc_unregister_vf(struct net_device *vf_netdev) 
{

	struct net_device *ndev;

	struct netvsc_device *netvsc_dev;

	const struct ethtool_ops *eth_ops = vf_netdev->ethtool_ops;

	struct net_device_context *net_device_ctx;



	if (eth_ops == &ethtool_ops)

		return NOTIFY_DONE;



	ndev = get_netvsc_net_device(vf_netdev->dev_addr);

	ndev = get_netvsc_byref(vf_netdev);

	if (!ndev)

		return NOTIFY_DONE;



	net_device_ctx = netdev_priv(ndev);

	netvsc_dev = net_device_ctx->nvdev;

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

		return NOTIFY_DONE;



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

	netvsc_inject_disable(net_device_ctx);

	net_device_ctx->vf_netdev = NULL;



	RCU_INIT_POINTER(net_device_ctx->vf_netdev, NULL);

	dev_put(vf_netdev);

	module_put(THIS_MODULE);

	return NOTIFY_OK;

}
@@ -1427,10 +1403,6 @@ static int netvsc_probe(struct hv_device *dev, 
	spin_lock_init(&net_device_ctx->lock);

	INIT_LIST_HEAD(&net_device_ctx->reconfig_events);



	atomic_set(&net_device_ctx->vf_use_cnt, 0);

	net_device_ctx->vf_netdev = NULL;

	net_device_ctx->vf_inject = false;



	net->netdev_ops = &device_ops;



	net->hw_features = NETVSC_HW_FEATURES;
@@ -1539,13 +1511,21 @@ static int netvsc_netdev_event(struct notifier_block *this, 
{

	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 (event_dev->priv_flags & IFF_802_1Q_VLAN)

		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)

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

	    (event_dev->flags & IFF_MASTER))

		return NOTIFY_DONE;



	switch (event) {