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

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

Merge branch 'netvsc-bug-fixes-and-cleanups' 



Stephen Hemminger says:

====================
netvsc: bug fixes and cleanups

These fix NAPI issues and bugs found during testing of shutdown
testing.
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents 6069f3fb ce12b810

drivers/net/hyperv/hyperv_net.h

+6 −6
Original line number Diff line number Diff line
@@ -686,7 +686,7 @@ struct net_device_context { 
	/* point back to our device context */

	struct hv_device *device_ctx;

	/* netvsc_device */

	struct netvsc_device *nvdev;

	struct netvsc_device __rcu *nvdev;

	/* reconfigure work */

	struct delayed_work dwork;

	/* last reconfig time */
@@ -708,9 +708,6 @@ struct net_device_context { 
	u32 speed;

	struct netvsc_ethtool_stats eth_stats;



	/* the device is going away */

	bool start_remove;



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

	struct net_device __rcu *vf_netdev;
@@ -723,6 +720,7 @@ struct net_device_context { 
/* Per channel data */

struct netvsc_channel {

	struct vmbus_channel *channel;

	const struct vmpacket_descriptor *desc;

	struct napi_struct napi;

	struct multi_send_data msd;

	struct multi_recv_comp mrc;
@@ -763,8 +761,8 @@ struct netvsc_device { 


	u32 max_chn;

	u32 num_chn;

	spinlock_t sc_lock; /* Protects num_sc_offered variable */

	u32 num_sc_offered;



	refcount_t sc_offered;



	/* Holds rndis device info */

	void *extension;
@@ -779,6 +777,8 @@ struct netvsc_device { 
	atomic_t open_cnt;



	struct netvsc_channel chan_table[VRSS_CHANNEL_MAX];



	struct rcu_head rcu;

};



static inline struct netvsc_device *

drivers/net/hyperv/netvsc.c

+32 −38
Original line number Diff line number Diff line
@@ -80,8 +80,10 @@ static struct netvsc_device *alloc_net_device(void) 
	return net_device;

}



static void free_netvsc_device(struct netvsc_device *nvdev)

static void free_netvsc_device(struct rcu_head *head)

{

	struct netvsc_device *nvdev

		= container_of(head, struct netvsc_device, rcu);

	int i;



	for (i = 0; i < VRSS_CHANNEL_MAX; i++)
@@ -90,6 +92,10 @@ static void free_netvsc_device(struct netvsc_device *nvdev) 
	kfree(nvdev);

}



static void free_netvsc_device_rcu(struct netvsc_device *nvdev)

{

	call_rcu(&nvdev->rcu, free_netvsc_device);

}



static struct netvsc_device *get_outbound_net_device(struct hv_device *device)

{
@@ -551,7 +557,7 @@ void netvsc_device_remove(struct hv_device *device) 


	netvsc_disconnect_vsp(device);



	net_device_ctx->nvdev = NULL;

	RCU_INIT_POINTER(net_device_ctx->nvdev, NULL);



	/*

	 * At this point, no one should be accessing net_device
@@ -566,7 +572,7 @@ void netvsc_device_remove(struct hv_device *device) 
		napi_disable(&net_device->chan_table[i].napi);



	/* Release all resources */

	free_netvsc_device(net_device);

	free_netvsc_device_rcu(net_device);

}



#define RING_AVAIL_PERCENT_HIWATER 20
@@ -599,7 +605,6 @@ static void netvsc_send_tx_complete(struct netvsc_device *net_device, 
{

	struct sk_buff *skb = (struct sk_buff *)(unsigned long)desc->trans_id;

	struct net_device *ndev = hv_get_drvdata(device);

	struct net_device_context *net_device_ctx = netdev_priv(ndev);

	struct vmbus_channel *channel = device->channel;

	u16 q_idx = 0;

	int queue_sends;
@@ -633,7 +638,6 @@ static void netvsc_send_tx_complete(struct netvsc_device *net_device, 
		wake_up(&net_device->wait_drain);



	if (netif_tx_queue_stopped(netdev_get_tx_queue(ndev, q_idx)) &&

	    !net_device_ctx->start_remove &&

	    (hv_ringbuf_avail_percent(&channel->outbound) > RING_AVAIL_PERCENT_HIWATER ||

	     queue_sends < 1))

		netif_tx_wake_queue(netdev_get_tx_queue(ndev, q_idx));
@@ -702,8 +706,7 @@ static u32 netvsc_copy_to_send_buf(struct netvsc_device *net_device, 
		packet->page_buf_cnt;



	/* Add padding */

	if (skb && skb->xmit_more && remain &&

	    !packet->cp_partial) {

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

		padding = net_device->pkt_align - remain;

		rndis_msg->msg_len += padding;

		packet->total_data_buflen += padding;
@@ -861,9 +864,7 @@ int netvsc_send(struct hv_device *device, 
	if (msdp->pkt)

		msd_len = msdp->pkt->total_data_buflen;



	try_batch = (skb != NULL) && msd_len > 0 && msdp->count <

		    net_device->max_pkt;



	try_batch =  msd_len > 0 && msdp->count < net_device->max_pkt;

	if (try_batch && msd_len + pktlen + net_device->pkt_align <

	    net_device->send_section_size) {

		section_index = msdp->pkt->send_buf_index;
@@ -873,7 +874,7 @@ int netvsc_send(struct hv_device *device, 
		section_index = msdp->pkt->send_buf_index;

		packet->cp_partial = true;



	} else if ((skb != NULL) && pktlen + net_device->pkt_align <

	} else if (pktlen + net_device->pkt_align <

		   net_device->send_section_size) {

		section_index = netvsc_get_next_send_section(net_device);

		if (section_index != NETVSC_INVALID_INDEX) {
@@ -1173,7 +1174,6 @@ static int netvsc_process_raw_pkt(struct hv_device *device, 
				  struct vmbus_channel *channel,

				  struct netvsc_device *net_device,

				  struct net_device *ndev,

				  u64 request_id,

				  const struct vmpacket_descriptor *desc)

{

	struct net_device_context *net_device_ctx = netdev_priv(ndev);
@@ -1195,7 +1195,7 @@ static int netvsc_process_raw_pkt(struct hv_device *device, 


	default:

		netdev_err(ndev, "unhandled packet type %d, tid %llx\n",

			   desc->type, request_id);

			   desc->type, desc->trans_id);

		break;

	}
@@ -1222,28 +1222,20 @@ int netvsc_poll(struct napi_struct *napi, int budget) 
	u16 q_idx = channel->offermsg.offer.sub_channel_index;

	struct net_device *ndev = hv_get_drvdata(device);

	struct netvsc_device *net_device = net_device_to_netvsc_device(ndev);

	const struct vmpacket_descriptor *desc;

	int work_done = 0;



	desc = hv_pkt_iter_first(channel);

	while (desc) {

		int count;



		count = netvsc_process_raw_pkt(device, channel, net_device,

					       ndev, desc->trans_id, desc);

		work_done += count;

		desc = __hv_pkt_iter_next(channel, desc);

	/* If starting a new interval */

	if (!nvchan->desc)

		nvchan->desc = hv_pkt_iter_first(channel);



		/* If receive packet budget is exhausted, reschedule */

		if (work_done >= budget) {

			work_done = budget;

			break;

		}

	while (nvchan->desc && work_done < budget) {

		work_done += netvsc_process_raw_pkt(device, channel, net_device,

						    ndev, nvchan->desc);

		nvchan->desc = hv_pkt_iter_next(channel, nvchan->desc);

	}

	hv_pkt_iter_close(channel);



	/* If budget was not exhausted and

	 * not doing busy poll

	/* If receive ring was exhausted

	 * and not doing busy poll

	 * then re-enable host interrupts

	 *  and reschedule if ring is not empty.

	 */
@@ -1253,7 +1245,9 @@ int netvsc_poll(struct napi_struct *napi, int budget) 
		napi_reschedule(napi);



	netvsc_chk_recv_comp(net_device, channel, q_idx);

	return work_done;



	/* Driver may overshoot since multiple packets per descriptor */

	return min(work_done, budget);

}



/* Call back when data is available in host ring buffer.
@@ -1263,10 +1257,12 @@ void netvsc_channel_cb(void *context) 
{

	struct netvsc_channel *nvchan = context;



	if (napi_schedule_prep(&nvchan->napi)) {

		/* disable interupts from host */

		hv_begin_read(&nvchan->channel->inbound);



	napi_schedule(&nvchan->napi);

		__napi_schedule(&nvchan->napi);

	}

}



/*
@@ -1325,9 +1321,7 @@ int netvsc_device_add(struct hv_device *device, 
	/* Writing nvdev pointer unlocks netvsc_send(), make sure chn_table is

	 * populated.

	 */

	wmb();



	net_device_ctx->nvdev = net_device;

	rcu_assign_pointer(net_device_ctx->nvdev, net_device);



	/* Connect with the NetVsp */

	ret = netvsc_connect_vsp(device);
@@ -1346,7 +1340,7 @@ int netvsc_device_add(struct hv_device *device, 
	vmbus_close(device->channel);



cleanup:

	free_netvsc_device(net_device);

	free_netvsc_device(&net_device->rcu);



	return ret;

}

drivers/net/hyperv/netvsc_drv.c

+71 −50
Original line number Diff line number Diff line
@@ -62,7 +62,7 @@ static void do_set_multicast(struct work_struct *w) 
		container_of(w, struct net_device_context, work);

	struct hv_device *device_obj = ndevctx->device_ctx;

	struct net_device *ndev = hv_get_drvdata(device_obj);

	struct netvsc_device *nvdev = ndevctx->nvdev;

	struct netvsc_device *nvdev = rcu_dereference(ndevctx->nvdev);

	struct rndis_device *rdev;



	if (!nvdev)
@@ -116,7 +116,7 @@ static int netvsc_open(struct net_device *net) 
static int netvsc_close(struct net_device *net)

{

	struct net_device_context *net_device_ctx = netdev_priv(net);

	struct netvsc_device *nvdev = net_device_ctx->nvdev;

	struct netvsc_device *nvdev = rtnl_dereference(net_device_ctx->nvdev);

	int ret;

	u32 aread, awrite, i, msec = 10, retry = 0, retry_max = 20;

	struct vmbus_channel *chn;
@@ -637,9 +637,9 @@ int netvsc_recv_callback(struct net_device *net, 
			 const struct ndis_pkt_8021q_info *vlan)

{

	struct net_device_context *net_device_ctx = netdev_priv(net);

	struct netvsc_device *net_device = net_device_ctx->nvdev;

	struct netvsc_device *net_device;

	u16 q_idx = channel->offermsg.offer.sub_channel_index;

	struct netvsc_channel *nvchan = &net_device->chan_table[q_idx];

	struct netvsc_channel *nvchan;

	struct net_device *vf_netdev;

	struct sk_buff *skb;

	struct netvsc_stats *rx_stats;
@@ -655,6 +655,11 @@ int netvsc_recv_callback(struct net_device *net, 
	 * interface in the guest.

	 */

	rcu_read_lock();

	net_device = rcu_dereference(net_device_ctx->nvdev);

	if (unlikely(!net_device))

		goto drop;



	nvchan = &net_device->chan_table[q_idx];

	vf_netdev = rcu_dereference(net_device_ctx->vf_netdev);

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

		net = vf_netdev;
@@ -663,6 +668,7 @@ int netvsc_recv_callback(struct net_device *net, 
	skb = netvsc_alloc_recv_skb(net, &nvchan->napi,

				    csum_info, vlan, data, len);

	if (unlikely(!skb)) {

drop:

		++net->stats.rx_dropped;

		rcu_read_unlock();

		return NVSP_STAT_FAIL;
@@ -704,7 +710,7 @@ static void netvsc_get_channels(struct net_device *net, 
				struct ethtool_channels *channel)

{

	struct net_device_context *net_device_ctx = netdev_priv(net);

	struct netvsc_device *nvdev = net_device_ctx->nvdev;

	struct netvsc_device *nvdev = rtnl_dereference(net_device_ctx->nvdev);



	if (nvdev) {

		channel->max_combined	= nvdev->max_chn;
@@ -741,8 +747,9 @@ static int netvsc_set_channels(struct net_device *net, 
{

	struct net_device_context *net_device_ctx = netdev_priv(net);

	struct hv_device *dev = net_device_ctx->device_ctx;

	struct netvsc_device *nvdev = net_device_ctx->nvdev;

	struct netvsc_device *nvdev = rtnl_dereference(net_device_ctx->nvdev);

	unsigned int count = channels->combined_count;

	bool was_running;

	int ret;



	/* We do not support separate count for rx, tx, or other */
@@ -753,7 +760,7 @@ static int netvsc_set_channels(struct net_device *net, 
	if (count > net->num_tx_queues || count > net->num_rx_queues)

		return -EINVAL;



	if (net_device_ctx->start_remove || !nvdev || nvdev->destroy)

	if (!nvdev || nvdev->destroy)

		return -ENODEV;



	if (nvdev->nvsp_version < NVSP_PROTOCOL_VERSION_5)
@@ -762,11 +769,13 @@ static int netvsc_set_channels(struct net_device *net, 
	if (count > nvdev->max_chn)

		return -EINVAL;



	was_running = netif_running(net);

	if (was_running) {

		ret = netvsc_close(net);

		if (ret)

			return ret;

	}



	net_device_ctx->start_remove = true;

	rndis_filter_device_remove(dev, nvdev);



	ret = netvsc_set_queues(net, dev, count);
@@ -775,8 +784,8 @@ static int netvsc_set_channels(struct net_device *net, 
	else

		netvsc_set_queues(net, dev, nvdev->num_chn);



	netvsc_open(net);

	net_device_ctx->start_remove = false;

	if (was_running)

		ret = netvsc_open(net);



	/* We may have missed link change notifications */

	schedule_delayed_work(&net_device_ctx->dwork, 0);
@@ -842,24 +851,27 @@ static int netvsc_set_link_ksettings(struct net_device *dev, 
static int netvsc_change_mtu(struct net_device *ndev, int mtu)

{

	struct net_device_context *ndevctx = netdev_priv(ndev);

	struct netvsc_device *nvdev = ndevctx->nvdev;

	struct netvsc_device *nvdev = rtnl_dereference(ndevctx->nvdev);

	struct hv_device *hdev = ndevctx->device_ctx;

	struct netvsc_device_info device_info;

	bool was_running;

	int ret;



	if (ndevctx->start_remove || !nvdev || nvdev->destroy)

	if (!nvdev || nvdev->destroy)

		return -ENODEV;



	was_running = netif_running(ndev);

	if (was_running) {

		ret = netvsc_close(ndev);

		if (ret)

		goto out;

			return ret;

	}



	memset(&device_info, 0, sizeof(device_info));

	device_info.ring_size = ring_size;

	device_info.num_chn = nvdev->num_chn;

	device_info.max_num_vrss_chns = nvdev->num_chn;



	ndevctx->start_remove = true;

	rndis_filter_device_remove(hdev, nvdev);



	/* 'nvdev' has been freed in rndis_filter_device_remove() ->
@@ -872,9 +884,8 @@ static int netvsc_change_mtu(struct net_device *ndev, int mtu) 


	rndis_filter_device_add(hdev, &device_info);



out:

	netvsc_open(ndev);

	ndevctx->start_remove = false;

	if (was_running)

		ret = netvsc_open(ndev);



	/* We may have missed link change notifications */

	schedule_delayed_work(&ndevctx->dwork, 0);
@@ -886,7 +897,7 @@ static void netvsc_get_stats64(struct net_device *net, 
			       struct rtnl_link_stats64 *t)

{

	struct net_device_context *ndev_ctx = netdev_priv(net);

	struct netvsc_device *nvdev = ndev_ctx->nvdev;

	struct netvsc_device *nvdev = rcu_dereference(ndev_ctx->nvdev);

	int i;



	if (!nvdev)
@@ -971,7 +982,10 @@ static const struct { 
static int netvsc_get_sset_count(struct net_device *dev, int string_set)

{

	struct net_device_context *ndc = netdev_priv(dev);

	struct netvsc_device *nvdev = ndc->nvdev;

	struct netvsc_device *nvdev = rcu_dereference(ndc->nvdev);



	if (!nvdev)

		return -ENODEV;



	switch (string_set) {

	case ETH_SS_STATS:
@@ -985,13 +999,16 @@ static void netvsc_get_ethtool_stats(struct net_device *dev, 
				     struct ethtool_stats *stats, u64 *data)

{

	struct net_device_context *ndc = netdev_priv(dev);

	struct netvsc_device *nvdev = ndc->nvdev;

	struct netvsc_device *nvdev = rcu_dereference(ndc->nvdev);

	const void *nds = &ndc->eth_stats;

	const struct netvsc_stats *qstats;

	unsigned int start;

	u64 packets, bytes;

	int i, j;



	if (!nvdev)

		return;



	for (i = 0; i < NETVSC_GLOBAL_STATS_LEN; i++)

		data[i] = *(unsigned long *)(nds + netvsc_stats[i].offset);
@@ -1020,10 +1037,13 @@ static void netvsc_get_ethtool_stats(struct net_device *dev, 
static void netvsc_get_strings(struct net_device *dev, u32 stringset, u8 *data)

{

	struct net_device_context *ndc = netdev_priv(dev);

	struct netvsc_device *nvdev = ndc->nvdev;

	struct netvsc_device *nvdev = rcu_dereference(ndc->nvdev);

	u8 *p = data;

	int i;



	if (!nvdev)

		return;



	switch (stringset) {

	case ETH_SS_STATS:

		for (i = 0; i < ARRAY_SIZE(netvsc_stats); i++)
@@ -1075,7 +1095,10 @@ netvsc_get_rxnfc(struct net_device *dev, struct ethtool_rxnfc *info, 
		 u32 *rules)

{

	struct net_device_context *ndc = netdev_priv(dev);

	struct netvsc_device *nvdev = ndc->nvdev;

	struct netvsc_device *nvdev = rcu_dereference(ndc->nvdev);



	if (!nvdev)

		return -ENODEV;



	switch (info->cmd) {

	case ETHTOOL_GRXRINGS:
@@ -1111,10 +1134,13 @@ static int netvsc_get_rxfh(struct net_device *dev, u32 *indir, u8 *key, 
			   u8 *hfunc)

{

	struct net_device_context *ndc = netdev_priv(dev);

	struct netvsc_device *ndev = ndc->nvdev;

	struct netvsc_device *ndev = rcu_dereference(ndc->nvdev);

	struct rndis_device *rndis_dev = ndev->extension;

	int i;



	if (!ndev)

		return -ENODEV;



	if (hfunc)

		*hfunc = ETH_RSS_HASH_TOP;	/* Toeplitz */
@@ -1133,10 +1159,13 @@ static int netvsc_set_rxfh(struct net_device *dev, const u32 *indir, 
			   const u8 *key, const u8 hfunc)

{

	struct net_device_context *ndc = netdev_priv(dev);

	struct netvsc_device *ndev = ndc->nvdev;

	struct netvsc_device *ndev = rtnl_dereference(ndc->nvdev);

	struct rndis_device *rndis_dev = ndev->extension;

	int i;



	if (!ndev)

		return -ENODEV;



	if (hfunc != ETH_RSS_HASH_NO_CHANGE && hfunc != ETH_RSS_HASH_TOP)

		return -EOPNOTSUPP;
@@ -1210,10 +1239,10 @@ static void netvsc_link_change(struct work_struct *w) 
	unsigned long flags, next_reconfig, delay;



	rtnl_lock();

	if (ndev_ctx->start_remove)

	net_device = rtnl_dereference(ndev_ctx->nvdev);

	if (!net_device)

		goto out_unlock;



	net_device = ndev_ctx->nvdev;

	rdev = net_device->extension;



	next_reconfig = ndev_ctx->last_reconfig + LINKCHANGE_INT;
@@ -1354,7 +1383,7 @@ static int netvsc_register_vf(struct net_device *vf_netdev) 
		return NOTIFY_DONE;



	net_device_ctx = netdev_priv(ndev);

	netvsc_dev = net_device_ctx->nvdev;

	netvsc_dev = rtnl_dereference(net_device_ctx->nvdev);

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

		return NOTIFY_DONE;
@@ -1380,7 +1409,7 @@ static int netvsc_vf_up(struct net_device *vf_netdev) 
		return NOTIFY_DONE;



	net_device_ctx = netdev_priv(ndev);

	netvsc_dev = net_device_ctx->nvdev;

	netvsc_dev = rtnl_dereference(net_device_ctx->nvdev);



	netdev_info(ndev, "VF up: %s\n", vf_netdev->name);
@@ -1414,7 +1443,7 @@ static int netvsc_vf_down(struct net_device *vf_netdev) 
		return NOTIFY_DONE;



	net_device_ctx = netdev_priv(ndev);

	netvsc_dev = net_device_ctx->nvdev;

	netvsc_dev = rtnl_dereference(net_device_ctx->nvdev);



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

	netvsc_switch_datapath(ndev, false);
@@ -1474,8 +1503,6 @@ static int netvsc_probe(struct hv_device *dev, 


	hv_set_drvdata(dev, net);



	net_device_ctx->start_remove = false;



	INIT_DELAYED_WORK(&net_device_ctx->dwork, netvsc_link_change);

	INIT_WORK(&net_device_ctx->work, do_set_multicast);
@@ -1492,8 +1519,7 @@ static int netvsc_probe(struct hv_device *dev, 
	/* Notify the netvsc driver of the new device */

	memset(&device_info, 0, sizeof(device_info));

	device_info.ring_size = ring_size;

	device_info.max_num_vrss_chns = min_t(u32, VRSS_CHANNEL_DEFAULT,

					      num_online_cpus());

	device_info.num_chn = VRSS_CHANNEL_DEFAULT;

	ret = rndis_filter_device_add(dev, &device_info);

	if (ret != 0) {

		netdev_err(net, "unable to add netvsc device (ret %d)\n", ret);
@@ -1509,6 +1535,7 @@ static int netvsc_probe(struct hv_device *dev, 
		NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_HW_VLAN_CTAG_RX;

	net->vlan_features = net->features;



	/* RCU not necessary here, device not registered */

	nvdev = net_device_ctx->nvdev;

	netif_set_real_num_tx_queues(net, nvdev->num_chn);

	netif_set_real_num_rx_queues(net, nvdev->num_chn);
@@ -1544,26 +1571,20 @@ static int netvsc_remove(struct hv_device *dev) 


	ndev_ctx = netdev_priv(net);



	/* Avoid racing with netvsc_change_mtu()/netvsc_set_channels()

	 * removing the device.

	 */

	rtnl_lock();

	ndev_ctx->start_remove = true;

	rtnl_unlock();

	netif_device_detach(net);



	cancel_delayed_work_sync(&ndev_ctx->dwork);

	cancel_work_sync(&ndev_ctx->work);



	/* Stop outbound asap */

	netif_tx_disable(net);



	unregister_netdev(net);



	/*

	 * Call to the vsc driver to let it know that the device is being

	 * removed

	 * removed. Also blocks mtu and channel changes.

	 */

	rtnl_lock();

	rndis_filter_device_remove(dev, ndev_ctx->nvdev);

	rtnl_unlock();



	unregister_netdev(net);



	hv_set_drvdata(dev, NULL);

drivers/net/hyperv/rndis_filter.c

+29 −62
Original line number Diff line number Diff line
@@ -819,16 +819,14 @@ int rndis_filter_set_packet_filter(struct rndis_device *dev, u32 new_filter) 
{

	struct rndis_request *request;

	struct rndis_set_request *set;

	struct rndis_set_complete *set_complete;

	int ret;



	request = get_rndis_request(dev, RNDIS_MSG_SET,

			RNDIS_MESSAGE_SIZE(struct rndis_set_request) +

			sizeof(u32));

	if (!request) {

		ret = -ENOMEM;

		goto cleanup;

	}

	if (!request)

		return -ENOMEM;





	/* Setup the rndis set */

	set = &request->request_msg.msg.set_req;
@@ -840,15 +838,11 @@ int rndis_filter_set_packet_filter(struct rndis_device *dev, u32 new_filter) 
	       &new_filter, sizeof(u32));



	ret = rndis_filter_send_request(dev, request);

	if (ret != 0)

		goto cleanup;



	if (ret == 0)

		wait_for_completion(&request->wait_event);



	set_complete = &request->response_msg.msg.set_complete;

cleanup:

	if (request)

	put_rndis_request(dev, request);



	return ret;

}
@@ -926,8 +920,6 @@ static void rndis_filter_halt_device(struct rndis_device *dev) 
	struct rndis_halt_request *halt;

	struct net_device_context *net_device_ctx = netdev_priv(dev->ndev);

	struct netvsc_device *nvdev = net_device_ctx->nvdev;

	struct hv_device *hdev = net_device_ctx->device_ctx;

	ulong flags;



	/* Attempt to do a rndis device halt */

	request = get_rndis_request(dev, RNDIS_MSG_HALT,
@@ -945,9 +937,10 @@ static void rndis_filter_halt_device(struct rndis_device *dev) 
	dev->state = RNDIS_DEV_UNINITIALIZED;



cleanup:

	spin_lock_irqsave(&hdev->channel->inbound_lock, flags);

	nvdev->destroy = true;

	spin_unlock_irqrestore(&hdev->channel->inbound_lock, flags);



	/* Force flag to be ordered before waiting */

	wmb();



	/* Wait for all send completions */

	wait_event(nvdev->wait_drain, netvsc_device_idle(nvdev));
@@ -997,7 +990,6 @@ static void netvsc_sc_open(struct vmbus_channel *new_sc) 
	struct netvsc_device *nvscdev = net_device_to_netvsc_device(ndev);

	u16 chn_index = new_sc->offermsg.offer.sub_channel_index;

	struct netvsc_channel *nvchan;

	unsigned long flags;

	int ret;



	if (chn_index >= nvscdev->num_chn)
@@ -1019,10 +1011,7 @@ static void netvsc_sc_open(struct vmbus_channel *new_sc) 


	napi_enable(&nvchan->napi);



	spin_lock_irqsave(&nvscdev->sc_lock, flags);

	nvscdev->num_sc_offered--;

	spin_unlock_irqrestore(&nvscdev->sc_lock, flags);

	if (nvscdev->num_sc_offered == 0)

	if (refcount_dec_and_test(&nvscdev->sc_offered))

		complete(&nvscdev->channel_init_wait);

}
@@ -1039,12 +1028,9 @@ int rndis_filter_device_add(struct hv_device *dev, 
	struct ndis_recv_scale_cap rsscap;

	u32 rsscap_size = sizeof(struct ndis_recv_scale_cap);

	unsigned int gso_max_size = GSO_MAX_SIZE;

	u32 mtu, size;

	u32 num_rss_qs;

	u32 sc_delta;

	u32 mtu, size, num_rss_qs;

	const struct cpumask *node_cpu_mask;

	u32 num_possible_rss_qs;

	unsigned long flags;

	int i, ret;



	rndis_device = get_rndis_device();
@@ -1067,7 +1053,7 @@ int rndis_filter_device_add(struct hv_device *dev, 
	net_device->max_chn = 1;

	net_device->num_chn = 1;



	spin_lock_init(&net_device->sc_lock);

	refcount_set(&net_device->sc_offered, 0);



	net_device->extension = rndis_device;

	rndis_device->ndev = net;
@@ -1181,34 +1167,30 @@ int rndis_filter_device_add(struct hv_device *dev, 
	if (ret || rsscap.num_recv_que < 2)

		goto out;



	net_device->max_chn = min_t(u32, VRSS_CHANNEL_MAX, rsscap.num_recv_que);



	num_rss_qs = min(device_info->max_num_vrss_chns, net_device->max_chn);



	/*

	 * We will limit the VRSS channels to the number CPUs in the NUMA node

	 * the primary channel is currently bound to.

	 *

	 * This also guarantees that num_possible_rss_qs <= num_online_cpus

	 */

	node_cpu_mask = cpumask_of_node(cpu_to_node(dev->channel->target_cpu));

	num_possible_rss_qs = cpumask_weight(node_cpu_mask);

	num_possible_rss_qs = min_t(u32, cpumask_weight(node_cpu_mask),

				    rsscap.num_recv_que);



	/* We will use the given number of channels if available. */

	if (device_info->num_chn && device_info->num_chn < net_device->max_chn)

		net_device->num_chn = device_info->num_chn;

	else

		net_device->num_chn = min(num_possible_rss_qs, num_rss_qs);

	net_device->max_chn = min_t(u32, VRSS_CHANNEL_MAX, num_possible_rss_qs);



	num_rss_qs = net_device->num_chn - 1;

	/* We will use the given number of channels if available. */

	net_device->num_chn = min(net_device->max_chn, device_info->num_chn);



	for (i = 0; i < ITAB_NUM; i++)

		rndis_device->ind_table[i] = ethtool_rxfh_indir_default(i,

							net_device->num_chn);



	net_device->num_sc_offered = num_rss_qs;



	if (net_device->num_chn == 1)

		goto out;

	num_rss_qs = net_device->num_chn - 1;

	if (num_rss_qs == 0)

		return 0;



	refcount_set(&net_device->sc_offered, num_rss_qs);

	vmbus_set_sc_create_callback(dev->channel, netvsc_sc_open);



	init_packet = &net_device->channel_init_pkt;
@@ -1224,32 +1206,23 @@ int rndis_filter_device_add(struct hv_device *dev, 
			       VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);

	if (ret)

		goto out;

	wait_for_completion(&net_device->channel_init_wait);



	if (init_packet->msg.v5_msg.subchn_comp.status !=

	    NVSP_STAT_SUCCESS) {

	if (init_packet->msg.v5_msg.subchn_comp.status != NVSP_STAT_SUCCESS) {

		ret = -ENODEV;

		goto out;

	}

	wait_for_completion(&net_device->channel_init_wait);



	net_device->num_chn = 1 +

		init_packet->msg.v5_msg.subchn_comp.num_subchannels;



	ret = rndis_filter_set_rss_param(rndis_device, netvsc_hash_key,

	/* ignore failues from setting rss parameters, still have channels */

	rndis_filter_set_rss_param(rndis_device, netvsc_hash_key,

				   net_device->num_chn);



	/*

	 * Set the number of sub-channels to be received.

	 */

	spin_lock_irqsave(&net_device->sc_lock, flags);

	sc_delta = num_rss_qs - (net_device->num_chn - 1);

	net_device->num_sc_offered -= sc_delta;

	spin_unlock_irqrestore(&net_device->sc_lock, flags);



out:

	if (ret) {

		net_device->max_chn = 1;

		net_device->num_chn = 1;

		net_device->num_sc_offered = 0;

	}



	return 0; /* return 0 because primary channel can be used alone */
@@ -1264,12 +1237,6 @@ void rndis_filter_device_remove(struct hv_device *dev, 
{

	struct rndis_device *rndis_dev = net_dev->extension;



	/* If not all subchannel offers are complete, wait for them until

	 * completion to avoid race.

	 */

	if (net_dev->num_sc_offered > 0)

		wait_for_completion(&net_dev->channel_init_wait);



	/* Halt and release the rndis device */

	rndis_filter_halt_device(rndis_dev);