2009-07-13 22:34:54 +00:00
|
|
|
/*
|
|
|
|
* Copyright (c) 2009, Microsoft Corporation.
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify it
|
|
|
|
* under the terms and conditions of the GNU General Public License,
|
|
|
|
* version 2, as published by the Free Software Foundation.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope it will be useful, but WITHOUT
|
|
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
|
|
|
|
* more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License along with
|
2013-12-06 14:28:47 +00:00
|
|
|
* this program; if not, see <http://www.gnu.org/licenses/>.
|
2009-07-13 22:34:54 +00:00
|
|
|
*
|
|
|
|
* Authors:
|
2009-11-23 17:00:22 +00:00
|
|
|
* Haiyang Zhang <haiyangz@microsoft.com>
|
2009-07-13 22:34:54 +00:00
|
|
|
* Hank Janssen <hjanssen@microsoft.com>
|
|
|
|
*/
|
2011-03-29 20:58:48 +00:00
|
|
|
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
|
|
|
|
|
2009-07-14 22:08:20 +00:00
|
|
|
#include <linux/kernel.h>
|
2011-02-11 17:59:43 +00:00
|
|
|
#include <linux/sched.h>
|
|
|
|
#include <linux/wait.h>
|
2009-07-15 18:06:01 +00:00
|
|
|
#include <linux/mm.h>
|
2009-07-16 18:50:41 +00:00
|
|
|
#include <linux/delay.h>
|
2009-09-02 17:33:05 +00:00
|
|
|
#include <linux/io.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 08:04:11 +00:00
|
|
|
#include <linux/slab.h>
|
2011-09-01 19:19:41 +00:00
|
|
|
#include <linux/netdevice.h>
|
2011-12-15 21:45:16 +00:00
|
|
|
#include <linux/if_ether.h>
|
2015-06-02 09:01:38 +00:00
|
|
|
#include <linux/vmalloc.h>
|
2014-04-30 17:14:31 +00:00
|
|
|
#include <asm/sync_bitops.h>
|
2011-05-13 02:34:15 +00:00
|
|
|
|
2011-05-13 02:34:37 +00:00
|
|
|
#include "hyperv_net.h"
|
2009-07-13 22:34:54 +00:00
|
|
|
|
2016-04-14 23:31:54 +00:00
|
|
|
/*
|
|
|
|
* Switch the data path from the synthetic interface to the VF
|
|
|
|
* interface.
|
|
|
|
*/
|
2016-05-13 11:55:23 +00:00
|
|
|
void netvsc_switch_datapath(struct net_device *ndev, bool vf)
|
2016-04-14 23:31:54 +00:00
|
|
|
{
|
2016-05-13 11:55:22 +00:00
|
|
|
struct net_device_context *net_device_ctx = netdev_priv(ndev);
|
|
|
|
struct hv_device *dev = net_device_ctx->device_ctx;
|
2016-05-13 11:55:23 +00:00
|
|
|
struct netvsc_device *nv_dev = net_device_ctx->nvdev;
|
|
|
|
struct nvsp_message *init_pkt = &nv_dev->channel_init_pkt;
|
2016-04-14 23:31:54 +00:00
|
|
|
|
|
|
|
memset(init_pkt, 0, sizeof(struct nvsp_message));
|
|
|
|
init_pkt->hdr.msg_type = NVSP_MSG4_TYPE_SWITCH_DATA_PATH;
|
|
|
|
if (vf)
|
|
|
|
init_pkt->msg.v4_msg.active_dp.active_datapath =
|
|
|
|
NVSP_DATAPATH_VF;
|
|
|
|
else
|
|
|
|
init_pkt->msg.v4_msg.active_dp.active_datapath =
|
|
|
|
NVSP_DATAPATH_SYNTHETIC;
|
|
|
|
|
|
|
|
vmbus_sendpacket(dev->channel, init_pkt,
|
|
|
|
sizeof(struct nvsp_message),
|
|
|
|
(unsigned long)init_pkt,
|
|
|
|
VM_PKT_DATA_INBAND, 0);
|
|
|
|
}
|
|
|
|
|
2016-05-13 11:55:25 +00:00
|
|
|
static struct netvsc_device *alloc_net_device(void)
|
2009-07-13 22:34:54 +00:00
|
|
|
{
|
2010-12-10 20:03:54 +00:00
|
|
|
struct netvsc_device *net_device;
|
2009-07-13 22:34:54 +00:00
|
|
|
|
2010-12-10 20:03:54 +00:00
|
|
|
net_device = kzalloc(sizeof(struct netvsc_device), GFP_KERNEL);
|
|
|
|
if (!net_device)
|
2009-07-13 22:34:54 +00:00
|
|
|
return NULL;
|
|
|
|
|
2017-01-24 21:06:07 +00:00
|
|
|
net_device->chan_table[0].mrc.buf
|
|
|
|
= vzalloc(NETVSC_RECVSLOT_MAX * sizeof(struct recv_comp_data));
|
2016-08-19 21:47:09 +00:00
|
|
|
|
2012-06-04 06:42:38 +00:00
|
|
|
init_waitqueue_head(&net_device->wait_drain);
|
2011-08-27 18:31:12 +00:00
|
|
|
net_device->destroy = false;
|
2016-04-14 23:31:54 +00:00
|
|
|
atomic_set(&net_device->open_cnt, 0);
|
2015-03-26 16:03:37 +00:00
|
|
|
net_device->max_pkt = RNDIS_MAX_PKT_DEFAULT;
|
|
|
|
net_device->pkt_align = RNDIS_PKT_ALIGN_DEFAULT;
|
2016-08-23 19:17:51 +00:00
|
|
|
init_completion(&net_device->channel_init_wait);
|
2015-03-26 16:03:37 +00:00
|
|
|
|
2010-12-10 20:03:54 +00:00
|
|
|
return net_device;
|
2009-07-13 22:34:54 +00:00
|
|
|
}
|
|
|
|
|
2017-03-22 21:51:00 +00:00
|
|
|
static void free_netvsc_device(struct rcu_head *head)
|
2014-08-15 19:18:19 +00:00
|
|
|
{
|
2017-03-22 21:51:00 +00:00
|
|
|
struct netvsc_device *nvdev
|
|
|
|
= container_of(head, struct netvsc_device, rcu);
|
2016-08-19 21:47:09 +00:00
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < VRSS_CHANNEL_MAX; i++)
|
2017-01-24 21:06:07 +00:00
|
|
|
vfree(nvdev->chan_table[i].mrc.buf);
|
2016-08-19 21:47:09 +00:00
|
|
|
|
2014-08-15 19:18:19 +00:00
|
|
|
kfree(nvdev);
|
|
|
|
}
|
|
|
|
|
2017-03-22 21:51:00 +00:00
|
|
|
static void free_netvsc_device_rcu(struct netvsc_device *nvdev)
|
|
|
|
{
|
|
|
|
call_rcu(&nvdev->rcu, free_netvsc_device);
|
|
|
|
}
|
2009-07-13 22:34:54 +00:00
|
|
|
|
2016-08-23 19:17:54 +00:00
|
|
|
static void netvsc_destroy_buf(struct hv_device *device)
|
2011-04-21 19:30:43 +00:00
|
|
|
{
|
|
|
|
struct nvsp_message *revoke_packet;
|
2016-05-13 11:55:22 +00:00
|
|
|
struct net_device *ndev = hv_get_drvdata(device);
|
2016-06-03 15:50:59 +00:00
|
|
|
struct netvsc_device *net_device = net_device_to_netvsc_device(ndev);
|
2016-08-23 19:17:54 +00:00
|
|
|
int ret;
|
2011-04-21 19:30:43 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If we got a section count, it means we received a
|
|
|
|
* SendReceiveBufferComplete msg (ie sent
|
|
|
|
* NvspMessage1TypeSendReceiveBuffer msg) therefore, we need
|
|
|
|
* to send a revoke msg here
|
|
|
|
*/
|
|
|
|
if (net_device->recv_section_cnt) {
|
|
|
|
/* Send the revoke receive buffer */
|
|
|
|
revoke_packet = &net_device->revoke_packet;
|
|
|
|
memset(revoke_packet, 0, sizeof(struct nvsp_message));
|
|
|
|
|
|
|
|
revoke_packet->hdr.msg_type =
|
|
|
|
NVSP_MSG1_TYPE_REVOKE_RECV_BUF;
|
|
|
|
revoke_packet->msg.v1_msg.
|
|
|
|
revoke_recv_buf.id = NETVSC_RECEIVE_BUFFER_ID;
|
|
|
|
|
2016-05-13 11:55:22 +00:00
|
|
|
ret = vmbus_sendpacket(device->channel,
|
2011-04-21 19:30:43 +00:00
|
|
|
revoke_packet,
|
|
|
|
sizeof(struct nvsp_message),
|
|
|
|
(unsigned long)revoke_packet,
|
|
|
|
VM_PKT_DATA_INBAND, 0);
|
2017-04-19 20:53:49 +00:00
|
|
|
/* If the failure is because the channel is rescinded;
|
|
|
|
* ignore the failure since we cannot send on a rescinded
|
|
|
|
* channel. This would allow us to properly cleanup
|
|
|
|
* even when the channel is rescinded.
|
|
|
|
*/
|
|
|
|
if (device->channel->rescind)
|
|
|
|
ret = 0;
|
2011-04-21 19:30:43 +00:00
|
|
|
/*
|
|
|
|
* If we failed here, we might as well return and
|
|
|
|
* have a leak rather than continue and a bugchk
|
|
|
|
*/
|
|
|
|
if (ret != 0) {
|
2011-09-01 19:19:41 +00:00
|
|
|
netdev_err(ndev, "unable to send "
|
2011-09-01 19:19:40 +00:00
|
|
|
"revoke receive buffer to netvsp\n");
|
2016-08-23 19:17:54 +00:00
|
|
|
return;
|
2011-04-21 19:30:43 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Teardown the gpadl on the vsp end */
|
|
|
|
if (net_device->recv_buf_gpadl_handle) {
|
2016-05-13 11:55:22 +00:00
|
|
|
ret = vmbus_teardown_gpadl(device->channel,
|
|
|
|
net_device->recv_buf_gpadl_handle);
|
2011-04-21 19:30:43 +00:00
|
|
|
|
|
|
|
/* If we failed here, we might as well return and have a leak
|
|
|
|
* rather than continue and a bugchk
|
|
|
|
*/
|
|
|
|
if (ret != 0) {
|
2011-09-01 19:19:41 +00:00
|
|
|
netdev_err(ndev,
|
2011-09-01 19:19:40 +00:00
|
|
|
"unable to teardown receive buffer's gpadl\n");
|
2016-08-23 19:17:54 +00:00
|
|
|
return;
|
2011-04-21 19:30:43 +00:00
|
|
|
}
|
|
|
|
net_device->recv_buf_gpadl_handle = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (net_device->recv_buf) {
|
|
|
|
/* Free up the receive buffer */
|
2014-01-27 23:03:42 +00:00
|
|
|
vfree(net_device->recv_buf);
|
2011-04-21 19:30:43 +00:00
|
|
|
net_device->recv_buf = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (net_device->recv_section) {
|
|
|
|
net_device->recv_section_cnt = 0;
|
|
|
|
kfree(net_device->recv_section);
|
|
|
|
net_device->recv_section = NULL;
|
|
|
|
}
|
|
|
|
|
2014-04-30 17:14:31 +00:00
|
|
|
/* Deal with the send buffer we may have setup.
|
|
|
|
* If we got a send section size, it means we received a
|
2014-12-20 02:25:18 +00:00
|
|
|
* NVSP_MSG1_TYPE_SEND_SEND_BUF_COMPLETE msg (ie sent
|
|
|
|
* NVSP_MSG1_TYPE_SEND_SEND_BUF msg) therefore, we need
|
2014-04-30 17:14:31 +00:00
|
|
|
* to send a revoke msg here
|
|
|
|
*/
|
|
|
|
if (net_device->send_section_size) {
|
|
|
|
/* Send the revoke receive buffer */
|
|
|
|
revoke_packet = &net_device->revoke_packet;
|
|
|
|
memset(revoke_packet, 0, sizeof(struct nvsp_message));
|
|
|
|
|
|
|
|
revoke_packet->hdr.msg_type =
|
|
|
|
NVSP_MSG1_TYPE_REVOKE_SEND_BUF;
|
2014-12-20 02:25:18 +00:00
|
|
|
revoke_packet->msg.v1_msg.revoke_send_buf.id =
|
|
|
|
NETVSC_SEND_BUFFER_ID;
|
2014-04-30 17:14:31 +00:00
|
|
|
|
2016-05-13 11:55:22 +00:00
|
|
|
ret = vmbus_sendpacket(device->channel,
|
2014-04-30 17:14:31 +00:00
|
|
|
revoke_packet,
|
|
|
|
sizeof(struct nvsp_message),
|
|
|
|
(unsigned long)revoke_packet,
|
|
|
|
VM_PKT_DATA_INBAND, 0);
|
2017-04-19 20:53:49 +00:00
|
|
|
|
|
|
|
/* If the failure is because the channel is rescinded;
|
|
|
|
* ignore the failure since we cannot send on a rescinded
|
|
|
|
* channel. This would allow us to properly cleanup
|
|
|
|
* even when the channel is rescinded.
|
|
|
|
*/
|
|
|
|
if (device->channel->rescind)
|
|
|
|
ret = 0;
|
|
|
|
|
2014-04-30 17:14:31 +00:00
|
|
|
/* If we failed here, we might as well return and
|
|
|
|
* have a leak rather than continue and a bugchk
|
|
|
|
*/
|
|
|
|
if (ret != 0) {
|
|
|
|
netdev_err(ndev, "unable to send "
|
|
|
|
"revoke send buffer to netvsp\n");
|
2016-08-23 19:17:54 +00:00
|
|
|
return;
|
2014-04-30 17:14:31 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
/* Teardown the gpadl on the vsp end */
|
|
|
|
if (net_device->send_buf_gpadl_handle) {
|
2016-05-13 11:55:22 +00:00
|
|
|
ret = vmbus_teardown_gpadl(device->channel,
|
2014-04-30 17:14:31 +00:00
|
|
|
net_device->send_buf_gpadl_handle);
|
|
|
|
|
|
|
|
/* If we failed here, we might as well return and have a leak
|
|
|
|
* rather than continue and a bugchk
|
|
|
|
*/
|
|
|
|
if (ret != 0) {
|
|
|
|
netdev_err(ndev,
|
|
|
|
"unable to teardown send buffer's gpadl\n");
|
2016-08-23 19:17:54 +00:00
|
|
|
return;
|
2014-04-30 17:14:31 +00:00
|
|
|
}
|
2014-06-16 20:59:02 +00:00
|
|
|
net_device->send_buf_gpadl_handle = 0;
|
2014-04-30 17:14:31 +00:00
|
|
|
}
|
|
|
|
if (net_device->send_buf) {
|
2014-12-20 02:25:18 +00:00
|
|
|
/* Free up the send buffer */
|
2014-08-02 17:42:02 +00:00
|
|
|
vfree(net_device->send_buf);
|
2014-04-30 17:14:31 +00:00
|
|
|
net_device->send_buf = NULL;
|
|
|
|
}
|
|
|
|
kfree(net_device->send_section_map);
|
2011-04-21 19:30:43 +00:00
|
|
|
}
|
|
|
|
|
2017-06-08 23:21:22 +00:00
|
|
|
static int netvsc_init_buf(struct hv_device *device,
|
|
|
|
struct netvsc_device *net_device)
|
2009-07-13 22:34:54 +00:00
|
|
|
{
|
2009-09-02 17:33:05 +00:00
|
|
|
int ret = 0;
|
2010-12-10 20:03:54 +00:00
|
|
|
struct nvsp_message *init_packet;
|
2011-09-13 17:59:49 +00:00
|
|
|
struct net_device *ndev;
|
2017-04-25 01:33:38 +00:00
|
|
|
size_t map_words;
|
2015-05-29 00:08:06 +00:00
|
|
|
int node;
|
2009-07-13 22:34:54 +00:00
|
|
|
|
2016-05-13 11:55:23 +00:00
|
|
|
ndev = hv_get_drvdata(device);
|
2009-07-13 22:34:54 +00:00
|
|
|
|
2015-05-29 00:08:06 +00:00
|
|
|
node = cpu_to_node(device->channel->target_cpu);
|
|
|
|
net_device->recv_buf = vzalloc_node(net_device->recv_buf_size, node);
|
|
|
|
if (!net_device->recv_buf)
|
|
|
|
net_device->recv_buf = vzalloc(net_device->recv_buf_size);
|
|
|
|
|
2010-12-10 20:03:59 +00:00
|
|
|
if (!net_device->recv_buf) {
|
2011-09-01 19:19:41 +00:00
|
|
|
netdev_err(ndev, "unable to allocate receive "
|
2011-09-01 19:19:40 +00:00
|
|
|
"buffer of size %d\n", net_device->recv_buf_size);
|
2011-08-25 16:49:13 +00:00
|
|
|
ret = -ENOMEM;
|
2011-02-11 17:59:43 +00:00
|
|
|
goto cleanup;
|
2009-07-13 22:34:54 +00:00
|
|
|
}
|
|
|
|
|
2009-07-27 20:47:24 +00:00
|
|
|
/*
|
|
|
|
* Establish the gpadl handle for this buffer on this
|
|
|
|
* channel. Note: This call uses the vmbus connection rather
|
|
|
|
* than the channel to establish the gpadl handle.
|
|
|
|
*/
|
2010-12-10 20:03:59 +00:00
|
|
|
ret = vmbus_establish_gpadl(device->channel, net_device->recv_buf,
|
|
|
|
net_device->recv_buf_size,
|
|
|
|
&net_device->recv_buf_gpadl_handle);
|
2009-09-02 17:33:05 +00:00
|
|
|
if (ret != 0) {
|
2011-09-01 19:19:41 +00:00
|
|
|
netdev_err(ndev,
|
2011-09-01 19:19:40 +00:00
|
|
|
"unable to establish receive buffer's gpadl\n");
|
2011-02-11 17:59:43 +00:00
|
|
|
goto cleanup;
|
2009-07-13 22:34:54 +00:00
|
|
|
}
|
|
|
|
|
2009-07-27 20:47:24 +00:00
|
|
|
/* Notify the NetVsp of the gpadl handle */
|
2010-12-10 20:03:59 +00:00
|
|
|
init_packet = &net_device->channel_init_pkt;
|
2010-12-10 20:03:54 +00:00
|
|
|
memset(init_packet, 0, sizeof(struct nvsp_message));
|
2010-12-10 20:03:59 +00:00
|
|
|
init_packet->hdr.msg_type = NVSP_MSG1_TYPE_SEND_RECV_BUF;
|
|
|
|
init_packet->msg.v1_msg.send_recv_buf.
|
|
|
|
gpadl_handle = net_device->recv_buf_gpadl_handle;
|
|
|
|
init_packet->msg.v1_msg.
|
|
|
|
send_recv_buf.id = NETVSC_RECEIVE_BUFFER_ID;
|
2009-07-13 22:34:54 +00:00
|
|
|
|
2009-07-27 20:47:24 +00:00
|
|
|
/* Send the gpadl notification request */
|
2010-12-10 20:03:54 +00:00
|
|
|
ret = vmbus_sendpacket(device->channel, init_packet,
|
2010-10-21 16:43:24 +00:00
|
|
|
sizeof(struct nvsp_message),
|
2010-12-10 20:03:54 +00:00
|
|
|
(unsigned long)init_packet,
|
2011-01-26 20:12:13 +00:00
|
|
|
VM_PKT_DATA_INBAND,
|
2010-10-21 16:43:24 +00:00
|
|
|
VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
|
2009-09-02 17:33:05 +00:00
|
|
|
if (ret != 0) {
|
2011-09-01 19:19:41 +00:00
|
|
|
netdev_err(ndev,
|
2011-09-01 19:19:40 +00:00
|
|
|
"unable to send receive buffer's gpadl to netvsp\n");
|
2011-02-11 17:59:43 +00:00
|
|
|
goto cleanup;
|
2009-07-13 22:34:54 +00:00
|
|
|
}
|
|
|
|
|
2016-06-09 10:44:03 +00:00
|
|
|
wait_for_completion(&net_device->channel_init_wait);
|
2009-07-13 22:34:54 +00:00
|
|
|
|
2009-07-27 20:47:24 +00:00
|
|
|
/* Check the response */
|
2010-12-10 20:03:59 +00:00
|
|
|
if (init_packet->msg.v1_msg.
|
|
|
|
send_recv_buf_complete.status != NVSP_STAT_SUCCESS) {
|
2011-09-01 19:19:41 +00:00
|
|
|
netdev_err(ndev, "Unable to complete receive buffer "
|
2011-09-01 19:19:48 +00:00
|
|
|
"initialization with NetVsp - status %d\n",
|
2010-12-10 20:03:59 +00:00
|
|
|
init_packet->msg.v1_msg.
|
|
|
|
send_recv_buf_complete.status);
|
2011-08-25 16:49:13 +00:00
|
|
|
ret = -EINVAL;
|
2011-02-11 17:59:43 +00:00
|
|
|
goto cleanup;
|
2009-07-13 22:34:54 +00:00
|
|
|
}
|
|
|
|
|
2009-07-27 20:47:24 +00:00
|
|
|
/* Parse the response */
|
2009-07-13 22:34:54 +00:00
|
|
|
|
2010-12-10 20:03:59 +00:00
|
|
|
net_device->recv_section_cnt = init_packet->msg.
|
|
|
|
v1_msg.send_recv_buf_complete.num_sections;
|
2009-07-13 22:34:54 +00:00
|
|
|
|
2011-11-30 15:19:07 +00:00
|
|
|
net_device->recv_section = kmemdup(
|
|
|
|
init_packet->msg.v1_msg.send_recv_buf_complete.sections,
|
|
|
|
net_device->recv_section_cnt *
|
|
|
|
sizeof(struct nvsp_1_receive_buffer_section),
|
|
|
|
GFP_KERNEL);
|
2010-12-10 20:03:59 +00:00
|
|
|
if (net_device->recv_section == NULL) {
|
2011-08-25 16:49:13 +00:00
|
|
|
ret = -EINVAL;
|
2011-02-11 17:59:43 +00:00
|
|
|
goto cleanup;
|
2009-07-13 22:34:54 +00:00
|
|
|
}
|
|
|
|
|
2009-09-02 17:33:05 +00:00
|
|
|
/*
|
|
|
|
* For 1st release, there should only be 1 section that represents the
|
|
|
|
* entire receive buffer
|
|
|
|
*/
|
2010-12-10 20:03:59 +00:00
|
|
|
if (net_device->recv_section_cnt != 1 ||
|
|
|
|
net_device->recv_section->offset != 0) {
|
2011-08-25 16:49:13 +00:00
|
|
|
ret = -EINVAL;
|
2011-02-11 17:59:43 +00:00
|
|
|
goto cleanup;
|
2009-07-13 22:34:54 +00:00
|
|
|
}
|
|
|
|
|
2014-04-30 17:14:31 +00:00
|
|
|
/* Now setup the send buffer.
|
|
|
|
*/
|
2015-05-29 00:08:07 +00:00
|
|
|
net_device->send_buf = vzalloc_node(net_device->send_buf_size, node);
|
|
|
|
if (!net_device->send_buf)
|
|
|
|
net_device->send_buf = vzalloc(net_device->send_buf_size);
|
2014-04-30 17:14:31 +00:00
|
|
|
if (!net_device->send_buf) {
|
|
|
|
netdev_err(ndev, "unable to allocate send "
|
|
|
|
"buffer of size %d\n", net_device->send_buf_size);
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Establish the gpadl handle for this buffer on this
|
|
|
|
* channel. Note: This call uses the vmbus connection rather
|
|
|
|
* than the channel to establish the gpadl handle.
|
|
|
|
*/
|
|
|
|
ret = vmbus_establish_gpadl(device->channel, net_device->send_buf,
|
|
|
|
net_device->send_buf_size,
|
|
|
|
&net_device->send_buf_gpadl_handle);
|
|
|
|
if (ret != 0) {
|
|
|
|
netdev_err(ndev,
|
|
|
|
"unable to establish send buffer's gpadl\n");
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Notify the NetVsp of the gpadl handle */
|
|
|
|
init_packet = &net_device->channel_init_pkt;
|
|
|
|
memset(init_packet, 0, sizeof(struct nvsp_message));
|
|
|
|
init_packet->hdr.msg_type = NVSP_MSG1_TYPE_SEND_SEND_BUF;
|
2014-12-20 02:25:18 +00:00
|
|
|
init_packet->msg.v1_msg.send_send_buf.gpadl_handle =
|
2014-04-30 17:14:31 +00:00
|
|
|
net_device->send_buf_gpadl_handle;
|
2014-12-20 02:25:18 +00:00
|
|
|
init_packet->msg.v1_msg.send_send_buf.id = NETVSC_SEND_BUFFER_ID;
|
2014-04-30 17:14:31 +00:00
|
|
|
|
|
|
|
/* Send the gpadl notification request */
|
|
|
|
ret = vmbus_sendpacket(device->channel, init_packet,
|
|
|
|
sizeof(struct nvsp_message),
|
|
|
|
(unsigned long)init_packet,
|
|
|
|
VM_PKT_DATA_INBAND,
|
|
|
|
VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
|
|
|
|
if (ret != 0) {
|
|
|
|
netdev_err(ndev,
|
|
|
|
"unable to send send buffer's gpadl to netvsp\n");
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
2016-06-09 10:44:03 +00:00
|
|
|
wait_for_completion(&net_device->channel_init_wait);
|
2014-04-30 17:14:31 +00:00
|
|
|
|
|
|
|
/* Check the response */
|
|
|
|
if (init_packet->msg.v1_msg.
|
|
|
|
send_send_buf_complete.status != NVSP_STAT_SUCCESS) {
|
|
|
|
netdev_err(ndev, "Unable to complete send buffer "
|
|
|
|
"initialization with NetVsp - status %d\n",
|
|
|
|
init_packet->msg.v1_msg.
|
2014-12-20 02:25:18 +00:00
|
|
|
send_send_buf_complete.status);
|
2014-04-30 17:14:31 +00:00
|
|
|
ret = -EINVAL;
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Parse the response */
|
|
|
|
net_device->send_section_size = init_packet->msg.
|
|
|
|
v1_msg.send_send_buf_complete.section_size;
|
|
|
|
|
|
|
|
/* Section count is simply the size divided by the section size.
|
|
|
|
*/
|
|
|
|
net_device->send_section_cnt =
|
2016-08-23 19:17:47 +00:00
|
|
|
net_device->send_buf_size / net_device->send_section_size;
|
2014-04-30 17:14:31 +00:00
|
|
|
|
2016-11-28 17:25:44 +00:00
|
|
|
netdev_dbg(ndev, "Send section size: %d, Section count:%d\n",
|
|
|
|
net_device->send_section_size, net_device->send_section_cnt);
|
2014-04-30 17:14:31 +00:00
|
|
|
|
|
|
|
/* Setup state for managing the send buffer. */
|
2017-04-25 01:33:38 +00:00
|
|
|
map_words = DIV_ROUND_UP(net_device->send_section_cnt, BITS_PER_LONG);
|
2014-04-30 17:14:31 +00:00
|
|
|
|
2017-04-25 01:33:38 +00:00
|
|
|
net_device->send_section_map = kcalloc(map_words, sizeof(ulong), GFP_KERNEL);
|
2014-07-23 01:00:35 +00:00
|
|
|
if (net_device->send_section_map == NULL) {
|
|
|
|
ret = -ENOMEM;
|
2014-04-30 17:14:31 +00:00
|
|
|
goto cleanup;
|
2014-07-23 01:00:35 +00:00
|
|
|
}
|
2014-04-30 17:14:31 +00:00
|
|
|
|
2011-02-11 17:59:43 +00:00
|
|
|
goto exit;
|
2009-07-13 22:34:54 +00:00
|
|
|
|
2011-02-11 17:59:43 +00:00
|
|
|
cleanup:
|
2016-05-13 11:55:22 +00:00
|
|
|
netvsc_destroy_buf(device);
|
2009-07-13 22:34:54 +00:00
|
|
|
|
2011-02-11 17:59:43 +00:00
|
|
|
exit:
|
2009-07-13 22:34:54 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2011-12-15 21:45:16 +00:00
|
|
|
/* Negotiate NVSP protocol version */
|
|
|
|
static int negotiate_nvsp_ver(struct hv_device *device,
|
|
|
|
struct netvsc_device *net_device,
|
|
|
|
struct nvsp_message *init_packet,
|
|
|
|
u32 nvsp_ver)
|
2009-07-13 22:34:54 +00:00
|
|
|
{
|
2016-05-13 11:55:23 +00:00
|
|
|
struct net_device *ndev = hv_get_drvdata(device);
|
2015-01-25 14:46:31 +00:00
|
|
|
int ret;
|
2009-07-13 22:34:54 +00:00
|
|
|
|
2010-12-10 20:03:54 +00:00
|
|
|
memset(init_packet, 0, sizeof(struct nvsp_message));
|
2010-12-10 20:03:59 +00:00
|
|
|
init_packet->hdr.msg_type = NVSP_MSG_TYPE_INIT;
|
2011-12-15 21:45:16 +00:00
|
|
|
init_packet->msg.init_msg.init.min_protocol_ver = nvsp_ver;
|
|
|
|
init_packet->msg.init_msg.init.max_protocol_ver = nvsp_ver;
|
2009-07-13 22:34:54 +00:00
|
|
|
|
2009-07-27 20:47:24 +00:00
|
|
|
/* Send the init request */
|
2010-12-10 20:03:54 +00:00
|
|
|
ret = vmbus_sendpacket(device->channel, init_packet,
|
2010-10-21 16:43:24 +00:00
|
|
|
sizeof(struct nvsp_message),
|
2010-12-10 20:03:54 +00:00
|
|
|
(unsigned long)init_packet,
|
2011-01-26 20:12:13 +00:00
|
|
|
VM_PKT_DATA_INBAND,
|
2010-10-21 16:43:24 +00:00
|
|
|
VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
|
2009-09-02 17:33:05 +00:00
|
|
|
|
2011-03-29 20:58:45 +00:00
|
|
|
if (ret != 0)
|
2011-12-15 21:45:16 +00:00
|
|
|
return ret;
|
2009-07-13 22:34:54 +00:00
|
|
|
|
2016-06-09 10:44:03 +00:00
|
|
|
wait_for_completion(&net_device->channel_init_wait);
|
2009-07-13 22:34:54 +00:00
|
|
|
|
2010-12-10 20:03:59 +00:00
|
|
|
if (init_packet->msg.init_msg.init_complete.status !=
|
2011-12-15 21:45:16 +00:00
|
|
|
NVSP_STAT_SUCCESS)
|
|
|
|
return -EINVAL;
|
2009-07-13 22:34:54 +00:00
|
|
|
|
2014-02-19 23:49:45 +00:00
|
|
|
if (nvsp_ver == NVSP_PROTOCOL_VERSION_1)
|
2011-12-15 21:45:16 +00:00
|
|
|
return 0;
|
|
|
|
|
2015-07-24 17:08:40 +00:00
|
|
|
/* NVSPv2 or later: Send NDIS config */
|
2011-12-15 21:45:16 +00:00
|
|
|
memset(init_packet, 0, sizeof(struct nvsp_message));
|
|
|
|
init_packet->hdr.msg_type = NVSP_MSG2_TYPE_SEND_NDIS_CONFIG;
|
2016-05-13 11:55:23 +00:00
|
|
|
init_packet->msg.v2_msg.send_ndis_config.mtu = ndev->mtu + ETH_HLEN;
|
2012-03-12 10:20:50 +00:00
|
|
|
init_packet->msg.v2_msg.send_ndis_config.capability.ieee8021q = 1;
|
2011-12-15 21:45:16 +00:00
|
|
|
|
2016-08-04 17:42:15 +00:00
|
|
|
if (nvsp_ver >= NVSP_PROTOCOL_VERSION_5) {
|
2015-07-24 17:08:40 +00:00
|
|
|
init_packet->msg.v2_msg.send_ndis_config.capability.sriov = 1;
|
|
|
|
|
2016-08-04 17:42:15 +00:00
|
|
|
/* Teaming bit is needed to receive link speed updates */
|
|
|
|
init_packet->msg.v2_msg.send_ndis_config.capability.teaming = 1;
|
|
|
|
}
|
|
|
|
|
2011-12-15 21:45:16 +00:00
|
|
|
ret = vmbus_sendpacket(device->channel, init_packet,
|
|
|
|
sizeof(struct nvsp_message),
|
|
|
|
(unsigned long)init_packet,
|
|
|
|
VM_PKT_DATA_INBAND, 0);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2017-06-08 23:21:22 +00:00
|
|
|
static int netvsc_connect_vsp(struct hv_device *device,
|
|
|
|
struct netvsc_device *net_device)
|
2011-12-15 21:45:16 +00:00
|
|
|
{
|
2016-08-23 19:17:49 +00:00
|
|
|
const u32 ver_list[] = {
|
|
|
|
NVSP_PROTOCOL_VERSION_1, NVSP_PROTOCOL_VERSION_2,
|
2017-06-08 23:21:22 +00:00
|
|
|
NVSP_PROTOCOL_VERSION_4, NVSP_PROTOCOL_VERSION_5
|
|
|
|
};
|
|
|
|
struct nvsp_message *init_packet;
|
|
|
|
int ndis_version, i, ret;
|
2011-12-15 21:45:16 +00:00
|
|
|
|
|
|
|
init_packet = &net_device->channel_init_pkt;
|
|
|
|
|
|
|
|
/* Negotiate the latest NVSP protocol supported */
|
2016-08-23 19:17:49 +00:00
|
|
|
for (i = ARRAY_SIZE(ver_list) - 1; i >= 0; i--)
|
2014-02-19 23:49:45 +00:00
|
|
|
if (negotiate_nvsp_ver(device, net_device, init_packet,
|
|
|
|
ver_list[i]) == 0) {
|
|
|
|
net_device->nvsp_version = ver_list[i];
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (i < 0) {
|
2011-08-25 16:49:14 +00:00
|
|
|
ret = -EPROTO;
|
2011-02-11 17:59:43 +00:00
|
|
|
goto cleanup;
|
2009-07-13 22:34:54 +00:00
|
|
|
}
|
2011-12-15 21:45:16 +00:00
|
|
|
|
|
|
|
pr_debug("Negotiated NVSP version:%x\n", net_device->nvsp_version);
|
|
|
|
|
2009-07-27 20:47:24 +00:00
|
|
|
/* Send the ndis version */
|
2010-12-10 20:03:54 +00:00
|
|
|
memset(init_packet, 0, sizeof(struct nvsp_message));
|
2009-07-13 22:34:54 +00:00
|
|
|
|
2014-02-19 23:49:45 +00:00
|
|
|
if (net_device->nvsp_version <= NVSP_PROTOCOL_VERSION_4)
|
2014-04-09 22:00:46 +00:00
|
|
|
ndis_version = 0x00060001;
|
2014-02-19 23:49:45 +00:00
|
|
|
else
|
|
|
|
ndis_version = 0x0006001e;
|
2009-07-13 22:34:54 +00:00
|
|
|
|
2010-12-10 20:03:59 +00:00
|
|
|
init_packet->hdr.msg_type = NVSP_MSG1_TYPE_SEND_NDIS_VER;
|
|
|
|
init_packet->msg.v1_msg.
|
|
|
|
send_ndis_ver.ndis_major_ver =
|
2010-12-10 20:03:54 +00:00
|
|
|
(ndis_version & 0xFFFF0000) >> 16;
|
2010-12-10 20:03:59 +00:00
|
|
|
init_packet->msg.v1_msg.
|
|
|
|
send_ndis_ver.ndis_minor_ver =
|
2010-12-10 20:03:54 +00:00
|
|
|
ndis_version & 0xFFFF;
|
2009-07-13 22:34:54 +00:00
|
|
|
|
2009-07-27 20:47:24 +00:00
|
|
|
/* Send the init request */
|
2010-12-10 20:03:54 +00:00
|
|
|
ret = vmbus_sendpacket(device->channel, init_packet,
|
2011-02-11 17:59:43 +00:00
|
|
|
sizeof(struct nvsp_message),
|
|
|
|
(unsigned long)init_packet,
|
|
|
|
VM_PKT_DATA_INBAND, 0);
|
2011-08-25 16:49:14 +00:00
|
|
|
if (ret != 0)
|
2011-02-11 17:59:43 +00:00
|
|
|
goto cleanup;
|
2009-07-27 20:47:24 +00:00
|
|
|
|
|
|
|
/* Post the big receive buffer to NetVSP */
|
2014-03-09 23:10:59 +00:00
|
|
|
if (net_device->nvsp_version <= NVSP_PROTOCOL_VERSION_2)
|
|
|
|
net_device->recv_buf_size = NETVSC_RECEIVE_BUFFER_SIZE_LEGACY;
|
|
|
|
else
|
|
|
|
net_device->recv_buf_size = NETVSC_RECEIVE_BUFFER_SIZE;
|
2014-04-30 17:14:31 +00:00
|
|
|
net_device->send_buf_size = NETVSC_SEND_BUFFER_SIZE;
|
2014-03-09 23:10:59 +00:00
|
|
|
|
2017-06-08 23:21:22 +00:00
|
|
|
ret = netvsc_init_buf(device, net_device);
|
2009-07-13 22:34:54 +00:00
|
|
|
|
2011-02-11 17:59:43 +00:00
|
|
|
cleanup:
|
2009-07-13 22:34:54 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2016-05-13 11:55:22 +00:00
|
|
|
static void netvsc_disconnect_vsp(struct hv_device *device)
|
2009-07-13 22:34:54 +00:00
|
|
|
{
|
2016-05-13 11:55:22 +00:00
|
|
|
netvsc_destroy_buf(device);
|
2009-07-13 22:34:54 +00:00
|
|
|
}
|
|
|
|
|
2010-03-04 22:11:00 +00:00
|
|
|
/*
|
2010-12-10 20:03:55 +00:00
|
|
|
* netvsc_device_remove - Callback when the root bus device is removed
|
2009-09-02 17:33:05 +00:00
|
|
|
*/
|
2016-08-23 19:17:50 +00:00
|
|
|
void netvsc_device_remove(struct hv_device *device)
|
2009-07-13 22:34:54 +00:00
|
|
|
{
|
2016-05-13 11:55:22 +00:00
|
|
|
struct net_device *ndev = hv_get_drvdata(device);
|
|
|
|
struct net_device_context *net_device_ctx = netdev_priv(ndev);
|
|
|
|
struct netvsc_device *net_device = net_device_ctx->nvdev;
|
2017-02-27 18:26:49 +00:00
|
|
|
int i;
|
2009-07-13 22:34:54 +00:00
|
|
|
|
2016-05-13 11:55:22 +00:00
|
|
|
netvsc_disconnect_vsp(device);
|
2011-08-27 18:31:16 +00:00
|
|
|
|
2017-03-22 21:51:00 +00:00
|
|
|
RCU_INIT_POINTER(net_device_ctx->nvdev, NULL);
|
2011-08-27 18:31:14 +00:00
|
|
|
|
2011-09-13 17:59:54 +00:00
|
|
|
/*
|
|
|
|
* At this point, no one should be accessing net_device
|
|
|
|
* except in here
|
|
|
|
*/
|
2016-11-28 17:25:44 +00:00
|
|
|
netdev_dbg(ndev, "net device safe to remove\n");
|
2009-07-13 22:34:54 +00:00
|
|
|
|
2009-07-27 20:47:24 +00:00
|
|
|
/* Now, we can close the channel safely */
|
2010-12-10 20:03:54 +00:00
|
|
|
vmbus_close(device->channel);
|
2009-07-13 22:34:54 +00:00
|
|
|
|
2017-04-19 22:22:02 +00:00
|
|
|
/* And dissassociate NAPI context from device */
|
2017-03-09 23:04:15 +00:00
|
|
|
for (i = 0; i < net_device->num_chn; i++)
|
2017-04-19 22:22:02 +00:00
|
|
|
netif_napi_del(&net_device->chan_table[i].napi);
|
2017-02-27 18:26:49 +00:00
|
|
|
|
2009-07-27 20:47:24 +00:00
|
|
|
/* Release all resources */
|
2017-03-22 21:51:00 +00:00
|
|
|
free_netvsc_device_rcu(net_device);
|
2009-07-13 22:34:54 +00:00
|
|
|
}
|
|
|
|
|
2012-03-27 13:20:45 +00:00
|
|
|
#define RING_AVAIL_PERCENT_HIWATER 20
|
|
|
|
#define RING_AVAIL_PERCENT_LOWATER 10
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Get the percentage of available bytes to write in the ring.
|
|
|
|
* The return value is in range from 0 to 100.
|
|
|
|
*/
|
|
|
|
static inline u32 hv_ringbuf_avail_percent(
|
|
|
|
struct hv_ring_buffer_info *ring_info)
|
|
|
|
{
|
|
|
|
u32 avail_read, avail_write;
|
|
|
|
|
|
|
|
hv_get_ringbuffer_availbytes(ring_info, &avail_read, &avail_write);
|
|
|
|
|
|
|
|
return avail_write * 100 / ring_info->ring_datasize;
|
|
|
|
}
|
|
|
|
|
2014-04-30 17:14:31 +00:00
|
|
|
static inline void netvsc_free_send_slot(struct netvsc_device *net_device,
|
|
|
|
u32 index)
|
|
|
|
{
|
|
|
|
sync_change_bit(index, net_device->send_section_map);
|
|
|
|
}
|
|
|
|
|
2016-08-23 19:17:53 +00:00
|
|
|
static void netvsc_send_tx_complete(struct netvsc_device *net_device,
|
|
|
|
struct vmbus_channel *incoming_channel,
|
|
|
|
struct hv_device *device,
|
2017-04-07 18:41:19 +00:00
|
|
|
const struct vmpacket_descriptor *desc,
|
|
|
|
int budget)
|
2016-08-23 19:17:53 +00:00
|
|
|
{
|
2017-02-27 18:26:47 +00:00
|
|
|
struct sk_buff *skb = (struct sk_buff *)(unsigned long)desc->trans_id;
|
2016-08-23 19:17:53 +00:00
|
|
|
struct net_device *ndev = hv_get_drvdata(device);
|
|
|
|
struct vmbus_channel *channel = device->channel;
|
|
|
|
u16 q_idx = 0;
|
|
|
|
int queue_sends;
|
|
|
|
|
|
|
|
/* Notify the layer above us */
|
|
|
|
if (likely(skb)) {
|
2017-01-24 21:06:12 +00:00
|
|
|
const struct hv_netvsc_packet *packet
|
2016-08-23 19:17:53 +00:00
|
|
|
= (struct hv_netvsc_packet *)skb->cb;
|
2017-01-24 21:06:12 +00:00
|
|
|
u32 send_index = packet->send_buf_index;
|
|
|
|
struct netvsc_stats *tx_stats;
|
2016-08-23 19:17:53 +00:00
|
|
|
|
|
|
|
if (send_index != NETVSC_INVALID_INDEX)
|
|
|
|
netvsc_free_send_slot(net_device, send_index);
|
2017-01-24 21:06:12 +00:00
|
|
|
q_idx = packet->q_idx;
|
2016-08-23 19:17:53 +00:00
|
|
|
channel = incoming_channel;
|
|
|
|
|
2017-01-24 21:06:13 +00:00
|
|
|
tx_stats = &net_device->chan_table[q_idx].tx_stats;
|
2017-01-24 21:06:12 +00:00
|
|
|
|
|
|
|
u64_stats_update_begin(&tx_stats->syncp);
|
|
|
|
tx_stats->packets += packet->total_packets;
|
|
|
|
tx_stats->bytes += packet->total_bytes;
|
|
|
|
u64_stats_update_end(&tx_stats->syncp);
|
|
|
|
|
2017-04-07 18:41:19 +00:00
|
|
|
napi_consume_skb(skb, budget);
|
2016-08-23 19:17:53 +00:00
|
|
|
}
|
|
|
|
|
2017-01-24 21:06:07 +00:00
|
|
|
queue_sends =
|
|
|
|
atomic_dec_return(&net_device->chan_table[q_idx].queue_sends);
|
2016-08-23 19:17:53 +00:00
|
|
|
|
2017-01-24 21:06:11 +00:00
|
|
|
if (net_device->destroy && queue_sends == 0)
|
2016-08-23 19:17:53 +00:00
|
|
|
wake_up(&net_device->wait_drain);
|
|
|
|
|
|
|
|
if (netif_tx_queue_stopped(netdev_get_tx_queue(ndev, q_idx)) &&
|
|
|
|
(hv_ringbuf_avail_percent(&channel->outbound) > RING_AVAIL_PERCENT_HIWATER ||
|
|
|
|
queue_sends < 1))
|
|
|
|
netif_tx_wake_queue(netdev_get_tx_queue(ndev, q_idx));
|
|
|
|
}
|
|
|
|
|
2014-02-17 00:38:44 +00:00
|
|
|
static void netvsc_send_completion(struct netvsc_device *net_device,
|
2015-12-02 00:43:05 +00:00
|
|
|
struct vmbus_channel *incoming_channel,
|
2014-02-17 00:38:44 +00:00
|
|
|
struct hv_device *device,
|
2017-04-07 18:41:19 +00:00
|
|
|
const struct vmpacket_descriptor *desc,
|
|
|
|
int budget)
|
2009-07-13 22:34:54 +00:00
|
|
|
{
|
2017-02-27 18:26:48 +00:00
|
|
|
struct nvsp_message *nvsp_packet = hv_pkt_data(desc);
|
2016-05-13 11:55:22 +00:00
|
|
|
struct net_device *ndev = hv_get_drvdata(device);
|
2009-07-13 22:34:54 +00:00
|
|
|
|
2016-08-23 19:17:53 +00:00
|
|
|
switch (nvsp_packet->hdr.msg_type) {
|
|
|
|
case NVSP_MSG_TYPE_INIT_COMPLETE:
|
|
|
|
case NVSP_MSG1_TYPE_SEND_RECV_BUF_COMPLETE:
|
|
|
|
case NVSP_MSG1_TYPE_SEND_SEND_BUF_COMPLETE:
|
|
|
|
case NVSP_MSG5_TYPE_SUBCHANNEL:
|
2009-07-27 20:47:24 +00:00
|
|
|
/* Copy the response back */
|
2010-12-10 20:03:59 +00:00
|
|
|
memcpy(&net_device->channel_init_pkt, nvsp_packet,
|
2009-09-02 17:33:05 +00:00
|
|
|
sizeof(struct nvsp_message));
|
2011-05-10 14:55:41 +00:00
|
|
|
complete(&net_device->channel_init_wait);
|
2016-08-23 19:17:53 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case NVSP_MSG1_TYPE_SEND_RNDIS_PKT_COMPLETE:
|
|
|
|
netvsc_send_tx_complete(net_device, incoming_channel,
|
2017-04-07 18:41:19 +00:00
|
|
|
device, desc, budget);
|
2016-08-23 19:17:53 +00:00
|
|
|
break;
|
2009-07-13 22:34:54 +00:00
|
|
|
|
2016-08-23 19:17:53 +00:00
|
|
|
default:
|
|
|
|
netdev_err(ndev,
|
|
|
|
"Unknown send completion type %d received!!\n",
|
|
|
|
nvsp_packet->hdr.msg_type);
|
2009-07-13 22:34:54 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-04-30 17:14:31 +00:00
|
|
|
static u32 netvsc_get_next_send_section(struct netvsc_device *net_device)
|
|
|
|
{
|
2017-01-24 21:06:14 +00:00
|
|
|
unsigned long *map_addr = net_device->send_section_map;
|
|
|
|
unsigned int i;
|
|
|
|
|
2017-04-25 01:33:38 +00:00
|
|
|
for_each_clear_bit(i, map_addr, net_device->send_section_cnt) {
|
2017-01-24 21:06:14 +00:00
|
|
|
if (sync_test_and_set_bit(i, map_addr) == 0)
|
|
|
|
return i;
|
2014-04-30 17:14:31 +00:00
|
|
|
}
|
2017-01-24 21:06:14 +00:00
|
|
|
|
|
|
|
return NETVSC_INVALID_INDEX;
|
2014-04-30 17:14:31 +00:00
|
|
|
}
|
|
|
|
|
2015-02-05 15:06:33 +00:00
|
|
|
static u32 netvsc_copy_to_send_buf(struct netvsc_device *net_device,
|
|
|
|
unsigned int section_index,
|
2015-03-26 16:03:37 +00:00
|
|
|
u32 pend_size,
|
2015-12-02 00:43:06 +00:00
|
|
|
struct hv_netvsc_packet *packet,
|
2015-12-02 00:43:13 +00:00
|
|
|
struct rndis_message *rndis_msg,
|
2015-12-02 00:43:15 +00:00
|
|
|
struct hv_page_buffer **pb,
|
|
|
|
struct sk_buff *skb)
|
2014-04-30 17:14:31 +00:00
|
|
|
{
|
|
|
|
char *start = net_device->send_buf;
|
2015-03-26 16:03:37 +00:00
|
|
|
char *dest = start + (section_index * net_device->send_section_size)
|
|
|
|
+ pend_size;
|
2014-04-30 17:14:31 +00:00
|
|
|
int i;
|
|
|
|
u32 msg_size = 0;
|
2015-03-26 16:03:37 +00:00
|
|
|
u32 padding = 0;
|
|
|
|
u32 remain = packet->total_data_buflen % net_device->pkt_align;
|
2015-04-13 23:34:35 +00:00
|
|
|
u32 page_count = packet->cp_partial ? packet->rmsg_pgcnt :
|
|
|
|
packet->page_buf_cnt;
|
2015-03-26 16:03:37 +00:00
|
|
|
|
|
|
|
/* Add padding */
|
2017-03-22 21:51:04 +00:00
|
|
|
if (skb->xmit_more && remain && !packet->cp_partial) {
|
2015-03-26 16:03:37 +00:00
|
|
|
padding = net_device->pkt_align - remain;
|
2015-12-02 00:43:06 +00:00
|
|
|
rndis_msg->msg_len += padding;
|
2015-03-26 16:03:37 +00:00
|
|
|
packet->total_data_buflen += padding;
|
|
|
|
}
|
2014-04-30 17:14:31 +00:00
|
|
|
|
2015-04-13 23:34:35 +00:00
|
|
|
for (i = 0; i < page_count; i++) {
|
2015-12-02 00:43:13 +00:00
|
|
|
char *src = phys_to_virt((*pb)[i].pfn << PAGE_SHIFT);
|
|
|
|
u32 offset = (*pb)[i].offset;
|
|
|
|
u32 len = (*pb)[i].len;
|
2014-04-30 17:14:31 +00:00
|
|
|
|
|
|
|
memcpy(dest, (src + offset), len);
|
|
|
|
msg_size += len;
|
|
|
|
dest += len;
|
|
|
|
}
|
2015-03-26 16:03:37 +00:00
|
|
|
|
|
|
|
if (padding) {
|
|
|
|
memset(dest, 0, padding);
|
|
|
|
msg_size += padding;
|
|
|
|
}
|
|
|
|
|
2014-04-30 17:14:31 +00:00
|
|
|
return msg_size;
|
|
|
|
}
|
|
|
|
|
2016-09-09 19:45:24 +00:00
|
|
|
static inline int netvsc_send_pkt(
|
2016-05-13 11:55:23 +00:00
|
|
|
struct hv_device *device,
|
2015-03-26 16:03:37 +00:00
|
|
|
struct hv_netvsc_packet *packet,
|
2015-12-02 00:43:13 +00:00
|
|
|
struct netvsc_device *net_device,
|
2015-12-02 00:43:14 +00:00
|
|
|
struct hv_page_buffer **pb,
|
|
|
|
struct sk_buff *skb)
|
2009-07-13 22:34:54 +00:00
|
|
|
{
|
2015-03-26 16:03:37 +00:00
|
|
|
struct nvsp_message nvmsg;
|
2017-01-24 21:06:07 +00:00
|
|
|
struct netvsc_channel *nvchan
|
|
|
|
= &net_device->chan_table[packet->q_idx];
|
|
|
|
struct vmbus_channel *out_channel = nvchan->channel;
|
2016-05-13 11:55:23 +00:00
|
|
|
struct net_device *ndev = hv_get_drvdata(device);
|
2017-01-24 21:06:07 +00:00
|
|
|
struct netdev_queue *txq = netdev_get_tx_queue(ndev, packet->q_idx);
|
2015-03-26 16:03:37 +00:00
|
|
|
u64 req_id;
|
|
|
|
int ret;
|
2015-04-13 23:34:35 +00:00
|
|
|
struct hv_page_buffer *pgbuf;
|
2015-05-11 22:39:46 +00:00
|
|
|
u32 ring_avail = hv_ringbuf_avail_percent(&out_channel->outbound);
|
2014-04-30 17:14:31 +00:00
|
|
|
|
2015-03-26 16:03:37 +00:00
|
|
|
nvmsg.hdr.msg_type = NVSP_MSG1_TYPE_SEND_RNDIS_PKT;
|
2015-12-02 00:43:15 +00:00
|
|
|
if (skb != NULL) {
|
2009-09-02 17:33:05 +00:00
|
|
|
/* 0 is RMC_DATA; */
|
2015-03-26 16:03:37 +00:00
|
|
|
nvmsg.msg.v1_msg.send_rndis_pkt.channel_type = 0;
|
2009-09-02 17:33:05 +00:00
|
|
|
} else {
|
|
|
|
/* 1 is RMC_CONTROL; */
|
2015-03-26 16:03:37 +00:00
|
|
|
nvmsg.msg.v1_msg.send_rndis_pkt.channel_type = 1;
|
2009-09-02 17:33:05 +00:00
|
|
|
}
|
2009-07-13 22:34:54 +00:00
|
|
|
|
2015-03-26 16:03:37 +00:00
|
|
|
nvmsg.msg.v1_msg.send_rndis_pkt.send_buf_section_index =
|
|
|
|
packet->send_buf_index;
|
|
|
|
if (packet->send_buf_index == NETVSC_INVALID_INDEX)
|
|
|
|
nvmsg.msg.v1_msg.send_rndis_pkt.send_buf_section_size = 0;
|
|
|
|
else
|
|
|
|
nvmsg.msg.v1_msg.send_rndis_pkt.send_buf_section_size =
|
|
|
|
packet->total_data_buflen;
|
2009-09-02 17:33:05 +00:00
|
|
|
|
2015-12-02 00:43:14 +00:00
|
|
|
req_id = (ulong)skb;
|
2013-04-05 11:44:40 +00:00
|
|
|
|
2014-12-01 21:28:39 +00:00
|
|
|
if (out_channel->rescind)
|
|
|
|
return -ENODEV;
|
|
|
|
|
2010-12-10 20:03:58 +00:00
|
|
|
if (packet->page_buf_cnt) {
|
2015-12-02 00:43:13 +00:00
|
|
|
pgbuf = packet->cp_partial ? (*pb) +
|
|
|
|
packet->rmsg_pgcnt : (*pb);
|
2015-05-11 22:39:46 +00:00
|
|
|
ret = vmbus_sendpacket_pagebuffer_ctl(out_channel,
|
|
|
|
pgbuf,
|
|
|
|
packet->page_buf_cnt,
|
|
|
|
&nvmsg,
|
|
|
|
sizeof(struct nvsp_message),
|
|
|
|
req_id,
|
2017-02-06 00:20:34 +00:00
|
|
|
VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
|
2009-09-02 17:33:05 +00:00
|
|
|
} else {
|
2015-05-11 22:39:46 +00:00
|
|
|
ret = vmbus_sendpacket_ctl(out_channel, &nvmsg,
|
|
|
|
sizeof(struct nvsp_message),
|
|
|
|
req_id,
|
|
|
|
VM_PKT_DATA_INBAND,
|
2017-02-06 00:20:34 +00:00
|
|
|
VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
|
2009-07-13 22:34:54 +00:00
|
|
|
}
|
|
|
|
|
2011-12-02 19:56:25 +00:00
|
|
|
if (ret == 0) {
|
2017-01-24 21:06:07 +00:00
|
|
|
atomic_inc_return(&nvchan->queue_sends);
|
2014-04-21 17:20:28 +00:00
|
|
|
|
2017-01-24 21:06:11 +00:00
|
|
|
if (ring_avail < RING_AVAIL_PERCENT_LOWATER)
|
2017-01-24 21:06:07 +00:00
|
|
|
netif_tx_stop_queue(txq);
|
2011-12-02 19:56:25 +00:00
|
|
|
} else if (ret == -EAGAIN) {
|
2017-01-24 21:06:07 +00:00
|
|
|
netif_tx_stop_queue(txq);
|
|
|
|
if (atomic_read(&nvchan->queue_sends) < 1) {
|
|
|
|
netif_tx_wake_queue(txq);
|
2012-03-27 13:20:45 +00:00
|
|
|
ret = -ENOSPC;
|
|
|
|
}
|
2011-12-02 19:56:25 +00:00
|
|
|
} else {
|
2011-09-01 19:19:41 +00:00
|
|
|
netdev_err(ndev, "Unable to send packet %p ret %d\n",
|
2010-12-10 20:03:54 +00:00
|
|
|
packet, ret);
|
2011-12-02 19:56:25 +00:00
|
|
|
}
|
2009-07-13 22:34:54 +00:00
|
|
|
|
2015-03-26 16:03:37 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2016-01-25 17:49:31 +00:00
|
|
|
/* Move packet out of multi send data (msd), and clear msd */
|
|
|
|
static inline void move_pkt_msd(struct hv_netvsc_packet **msd_send,
|
|
|
|
struct sk_buff **msd_skb,
|
|
|
|
struct multi_send_data *msdp)
|
|
|
|
{
|
|
|
|
*msd_skb = msdp->skb;
|
|
|
|
*msd_send = msdp->pkt;
|
|
|
|
msdp->skb = NULL;
|
|
|
|
msdp->pkt = NULL;
|
|
|
|
msdp->count = 0;
|
|
|
|
}
|
|
|
|
|
2015-03-26 16:03:37 +00:00
|
|
|
int netvsc_send(struct hv_device *device,
|
2015-12-02 00:43:06 +00:00
|
|
|
struct hv_netvsc_packet *packet,
|
2015-12-02 00:43:13 +00:00
|
|
|
struct rndis_message *rndis_msg,
|
2015-12-02 00:43:14 +00:00
|
|
|
struct hv_page_buffer **pb,
|
|
|
|
struct sk_buff *skb)
|
2015-03-26 16:03:37 +00:00
|
|
|
{
|
2017-06-08 23:21:23 +00:00
|
|
|
struct netvsc_device *net_device = hv_device_to_netvsc_device(device);
|
2016-08-23 19:17:55 +00:00
|
|
|
int ret = 0;
|
2017-01-24 21:06:07 +00:00
|
|
|
struct netvsc_channel *nvchan;
|
2015-03-26 16:03:37 +00:00
|
|
|
u32 pktlen = packet->total_data_buflen, msd_len = 0;
|
|
|
|
unsigned int section_index = NETVSC_INVALID_INDEX;
|
|
|
|
struct multi_send_data *msdp;
|
|
|
|
struct hv_netvsc_packet *msd_send = NULL, *cur_send = NULL;
|
2016-01-25 17:49:31 +00:00
|
|
|
struct sk_buff *msd_skb = NULL;
|
2015-04-13 23:34:35 +00:00
|
|
|
bool try_batch;
|
2015-12-02 00:43:17 +00:00
|
|
|
bool xmit_more = (skb != NULL) ? skb->xmit_more : false;
|
2015-03-26 16:03:37 +00:00
|
|
|
|
2017-06-08 23:21:23 +00:00
|
|
|
/* If device is rescinded, return error and packet will get dropped. */
|
|
|
|
if (unlikely(net_device->destroy))
|
2015-03-26 16:03:37 +00:00
|
|
|
return -ENODEV;
|
|
|
|
|
2016-10-19 13:53:01 +00:00
|
|
|
/* We may race with netvsc_connect_vsp()/netvsc_init_buf() and get
|
|
|
|
* here before the negotiation with the host is finished and
|
|
|
|
* send_section_map may not be allocated yet.
|
|
|
|
*/
|
2017-06-08 23:21:21 +00:00
|
|
|
if (unlikely(!net_device->send_section_map))
|
2016-10-19 13:53:01 +00:00
|
|
|
return -EAGAIN;
|
|
|
|
|
2017-01-24 21:06:07 +00:00
|
|
|
nvchan = &net_device->chan_table[packet->q_idx];
|
2015-03-26 16:03:37 +00:00
|
|
|
packet->send_buf_index = NETVSC_INVALID_INDEX;
|
2015-04-13 23:34:35 +00:00
|
|
|
packet->cp_partial = false;
|
2015-03-26 16:03:37 +00:00
|
|
|
|
2015-12-10 20:19:35 +00:00
|
|
|
/* Send control message directly without accessing msd (Multi-Send
|
|
|
|
* Data) field which may be changed during data packet processing.
|
|
|
|
*/
|
|
|
|
if (!skb) {
|
|
|
|
cur_send = packet;
|
|
|
|
goto send_now;
|
|
|
|
}
|
|
|
|
|
2015-03-26 16:03:37 +00:00
|
|
|
/* batch packets in send buffer if possible */
|
2017-01-24 21:06:07 +00:00
|
|
|
msdp = &nvchan->msd;
|
2015-03-26 16:03:37 +00:00
|
|
|
if (msdp->pkt)
|
|
|
|
msd_len = msdp->pkt->total_data_buflen;
|
|
|
|
|
2017-03-22 21:51:04 +00:00
|
|
|
try_batch = msd_len > 0 && msdp->count < net_device->max_pkt;
|
2015-04-13 23:34:35 +00:00
|
|
|
if (try_batch && msd_len + pktlen + net_device->pkt_align <
|
2015-03-26 16:03:37 +00:00
|
|
|
net_device->send_section_size) {
|
|
|
|
section_index = msdp->pkt->send_buf_index;
|
|
|
|
|
2015-04-13 23:34:35 +00:00
|
|
|
} else if (try_batch && msd_len + packet->rmsg_size <
|
|
|
|
net_device->send_section_size) {
|
|
|
|
section_index = msdp->pkt->send_buf_index;
|
|
|
|
packet->cp_partial = true;
|
|
|
|
|
2017-03-22 21:51:04 +00:00
|
|
|
} else if (pktlen + net_device->pkt_align <
|
2015-03-26 16:03:37 +00:00
|
|
|
net_device->send_section_size) {
|
|
|
|
section_index = netvsc_get_next_send_section(net_device);
|
|
|
|
if (section_index != NETVSC_INVALID_INDEX) {
|
2016-01-25 17:49:31 +00:00
|
|
|
move_pkt_msd(&msd_send, &msd_skb, msdp);
|
|
|
|
msd_len = 0;
|
2015-03-26 16:03:37 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (section_index != NETVSC_INVALID_INDEX) {
|
|
|
|
netvsc_copy_to_send_buf(net_device,
|
|
|
|
section_index, msd_len,
|
2015-12-02 00:43:15 +00:00
|
|
|
packet, rndis_msg, pb, skb);
|
2015-03-30 04:08:42 +00:00
|
|
|
|
2015-03-26 16:03:37 +00:00
|
|
|
packet->send_buf_index = section_index;
|
2015-04-13 23:34:35 +00:00
|
|
|
|
|
|
|
if (packet->cp_partial) {
|
|
|
|
packet->page_buf_cnt -= packet->rmsg_pgcnt;
|
|
|
|
packet->total_data_buflen = msd_len + packet->rmsg_size;
|
|
|
|
} else {
|
|
|
|
packet->page_buf_cnt = 0;
|
|
|
|
packet->total_data_buflen += msd_len;
|
|
|
|
}
|
2015-03-26 16:03:37 +00:00
|
|
|
|
2017-01-24 21:06:12 +00:00
|
|
|
if (msdp->pkt) {
|
|
|
|
packet->total_packets += msdp->pkt->total_packets;
|
|
|
|
packet->total_bytes += msdp->pkt->total_bytes;
|
|
|
|
}
|
|
|
|
|
2016-01-25 17:49:31 +00:00
|
|
|
if (msdp->skb)
|
2016-09-22 23:56:29 +00:00
|
|
|
dev_consume_skb_any(msdp->skb);
|
2015-04-06 22:22:54 +00:00
|
|
|
|
2015-12-02 00:43:17 +00:00
|
|
|
if (xmit_more && !packet->cp_partial) {
|
2016-01-25 17:49:31 +00:00
|
|
|
msdp->skb = skb;
|
2015-03-26 16:03:37 +00:00
|
|
|
msdp->pkt = packet;
|
|
|
|
msdp->count++;
|
|
|
|
} else {
|
|
|
|
cur_send = packet;
|
2016-01-25 17:49:31 +00:00
|
|
|
msdp->skb = NULL;
|
2015-03-26 16:03:37 +00:00
|
|
|
msdp->pkt = NULL;
|
|
|
|
msdp->count = 0;
|
|
|
|
}
|
|
|
|
} else {
|
2016-01-25 17:49:31 +00:00
|
|
|
move_pkt_msd(&msd_send, &msd_skb, msdp);
|
2015-03-26 16:03:37 +00:00
|
|
|
cur_send = packet;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (msd_send) {
|
2016-08-23 19:17:55 +00:00
|
|
|
int m_ret = netvsc_send_pkt(device, msd_send, net_device,
|
|
|
|
NULL, msd_skb);
|
2015-03-26 16:03:37 +00:00
|
|
|
|
|
|
|
if (m_ret != 0) {
|
|
|
|
netvsc_free_send_slot(net_device,
|
|
|
|
msd_send->send_buf_index);
|
2016-01-25 17:49:31 +00:00
|
|
|
dev_kfree_skb_any(msd_skb);
|
2015-03-26 16:03:37 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-12-10 20:19:35 +00:00
|
|
|
send_now:
|
2015-03-26 16:03:37 +00:00
|
|
|
if (cur_send)
|
2016-05-13 11:55:23 +00:00
|
|
|
ret = netvsc_send_pkt(device, cur_send, net_device, pb, skb);
|
2015-03-26 16:03:37 +00:00
|
|
|
|
2015-05-04 17:57:16 +00:00
|
|
|
if (ret != 0 && section_index != NETVSC_INVALID_INDEX)
|
|
|
|
netvsc_free_send_slot(net_device, section_index);
|
2015-01-29 20:34:49 +00:00
|
|
|
|
2009-07-13 22:34:54 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2016-08-19 21:47:09 +00:00
|
|
|
static int netvsc_send_recv_completion(struct vmbus_channel *channel,
|
|
|
|
u64 transaction_id, u32 status)
|
2011-04-21 19:30:42 +00:00
|
|
|
{
|
|
|
|
struct nvsp_message recvcompMessage;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
recvcompMessage.hdr.msg_type =
|
|
|
|
NVSP_MSG1_TYPE_SEND_RNDIS_PKT_COMPLETE;
|
|
|
|
|
2012-10-02 05:30:23 +00:00
|
|
|
recvcompMessage.msg.v1_msg.send_rndis_pkt_complete.status = status;
|
2011-04-21 19:30:42 +00:00
|
|
|
|
|
|
|
/* Send the completion */
|
2014-04-21 17:20:28 +00:00
|
|
|
ret = vmbus_sendpacket(channel, &recvcompMessage,
|
2016-08-19 21:47:09 +00:00
|
|
|
sizeof(struct nvsp_message_header) + sizeof(u32),
|
|
|
|
transaction_id, VM_PKT_COMP, 0);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void count_recv_comp_slot(struct netvsc_device *nvdev, u16 q_idx,
|
|
|
|
u32 *filled, u32 *avail)
|
|
|
|
{
|
2017-01-24 21:06:07 +00:00
|
|
|
struct multi_recv_comp *mrc = &nvdev->chan_table[q_idx].mrc;
|
|
|
|
u32 first = mrc->first;
|
|
|
|
u32 next = mrc->next;
|
2016-08-19 21:47:09 +00:00
|
|
|
|
|
|
|
*filled = (first > next) ? NETVSC_RECVSLOT_MAX - first + next :
|
|
|
|
next - first;
|
|
|
|
|
|
|
|
*avail = NETVSC_RECVSLOT_MAX - *filled - 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Read the first filled slot, no change to index */
|
|
|
|
static inline struct recv_comp_data *read_recv_comp_slot(struct netvsc_device
|
|
|
|
*nvdev, u16 q_idx)
|
|
|
|
{
|
2017-01-24 21:06:07 +00:00
|
|
|
struct multi_recv_comp *mrc = &nvdev->chan_table[q_idx].mrc;
|
2016-08-19 21:47:09 +00:00
|
|
|
u32 filled, avail;
|
|
|
|
|
2017-01-24 21:06:07 +00:00
|
|
|
if (unlikely(!mrc->buf))
|
2016-08-19 21:47:09 +00:00
|
|
|
return NULL;
|
|
|
|
|
|
|
|
count_recv_comp_slot(nvdev, q_idx, &filled, &avail);
|
|
|
|
if (!filled)
|
|
|
|
return NULL;
|
|
|
|
|
2017-01-24 21:06:07 +00:00
|
|
|
return mrc->buf + mrc->first * sizeof(struct recv_comp_data);
|
2016-08-19 21:47:09 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Put the first filled slot back to available pool */
|
|
|
|
static inline void put_recv_comp_slot(struct netvsc_device *nvdev, u16 q_idx)
|
|
|
|
{
|
2017-01-24 21:06:07 +00:00
|
|
|
struct multi_recv_comp *mrc = &nvdev->chan_table[q_idx].mrc;
|
2016-08-19 21:47:09 +00:00
|
|
|
int num_recv;
|
|
|
|
|
2017-01-24 21:06:07 +00:00
|
|
|
mrc->first = (mrc->first + 1) % NETVSC_RECVSLOT_MAX;
|
2016-08-19 21:47:09 +00:00
|
|
|
|
|
|
|
num_recv = atomic_dec_return(&nvdev->num_outstanding_recvs);
|
|
|
|
|
|
|
|
if (nvdev->destroy && num_recv == 0)
|
|
|
|
wake_up(&nvdev->wait_drain);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Check and send pending recv completions */
|
|
|
|
static void netvsc_chk_recv_comp(struct netvsc_device *nvdev,
|
|
|
|
struct vmbus_channel *channel, u16 q_idx)
|
|
|
|
{
|
|
|
|
struct recv_comp_data *rcd;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
while (true) {
|
|
|
|
rcd = read_recv_comp_slot(nvdev, q_idx);
|
|
|
|
if (!rcd)
|
|
|
|
break;
|
|
|
|
|
|
|
|
ret = netvsc_send_recv_completion(channel, rcd->tid,
|
|
|
|
rcd->status);
|
|
|
|
if (ret)
|
|
|
|
break;
|
|
|
|
|
|
|
|
put_recv_comp_slot(nvdev, q_idx);
|
2011-04-21 19:30:42 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-08-19 21:47:09 +00:00
|
|
|
#define NETVSC_RCD_WATERMARK 80
|
|
|
|
|
|
|
|
/* Get next available slot */
|
|
|
|
static inline struct recv_comp_data *get_recv_comp_slot(
|
|
|
|
struct netvsc_device *nvdev, struct vmbus_channel *channel, u16 q_idx)
|
|
|
|
{
|
2017-01-24 21:06:07 +00:00
|
|
|
struct multi_recv_comp *mrc = &nvdev->chan_table[q_idx].mrc;
|
2016-08-19 21:47:09 +00:00
|
|
|
u32 filled, avail, next;
|
|
|
|
struct recv_comp_data *rcd;
|
|
|
|
|
2017-01-24 21:06:07 +00:00
|
|
|
if (unlikely(!nvdev->recv_section))
|
2016-08-19 21:47:09 +00:00
|
|
|
return NULL;
|
|
|
|
|
2017-01-24 21:06:07 +00:00
|
|
|
if (unlikely(!mrc->buf))
|
2016-08-19 21:47:09 +00:00
|
|
|
return NULL;
|
|
|
|
|
|
|
|
if (atomic_read(&nvdev->num_outstanding_recvs) >
|
|
|
|
nvdev->recv_section->num_sub_allocs * NETVSC_RCD_WATERMARK / 100)
|
|
|
|
netvsc_chk_recv_comp(nvdev, channel, q_idx);
|
|
|
|
|
|
|
|
count_recv_comp_slot(nvdev, q_idx, &filled, &avail);
|
|
|
|
if (!avail)
|
|
|
|
return NULL;
|
|
|
|
|
2017-01-24 21:06:07 +00:00
|
|
|
next = mrc->next;
|
|
|
|
rcd = mrc->buf + next * sizeof(struct recv_comp_data);
|
|
|
|
mrc->next = (next + 1) % NETVSC_RECVSLOT_MAX;
|
2016-08-19 21:47:09 +00:00
|
|
|
|
|
|
|
atomic_inc(&nvdev->num_outstanding_recvs);
|
|
|
|
|
|
|
|
return rcd;
|
|
|
|
}
|
|
|
|
|
2017-02-27 18:26:49 +00:00
|
|
|
static int netvsc_receive(struct net_device *ndev,
|
2017-01-24 21:06:08 +00:00
|
|
|
struct netvsc_device *net_device,
|
|
|
|
struct net_device_context *net_device_ctx,
|
|
|
|
struct hv_device *device,
|
|
|
|
struct vmbus_channel *channel,
|
2017-02-27 18:26:48 +00:00
|
|
|
const struct vmpacket_descriptor *desc,
|
2017-01-24 21:06:08 +00:00
|
|
|
struct nvsp_message *nvsp)
|
2009-07-13 22:34:54 +00:00
|
|
|
{
|
2017-02-27 18:26:48 +00:00
|
|
|
const struct vmtransfer_page_packet_header *vmxferpage_packet
|
|
|
|
= container_of(desc, const struct vmtransfer_page_packet_header, d);
|
2017-02-27 18:26:49 +00:00
|
|
|
u16 q_idx = channel->offermsg.offer.sub_channel_index;
|
2017-01-24 21:06:08 +00:00
|
|
|
char *recv_buf = net_device->recv_buf;
|
2014-04-21 21:54:43 +00:00
|
|
|
u32 status = NVSP_STAT_SUCCESS;
|
2011-12-15 21:45:15 +00:00
|
|
|
int i;
|
|
|
|
int count = 0;
|
2016-08-19 21:47:09 +00:00
|
|
|
int ret;
|
2011-04-26 16:20:22 +00:00
|
|
|
|
2009-07-27 20:47:24 +00:00
|
|
|
/* Make sure this is a valid nvsp packet */
|
2017-01-24 21:06:08 +00:00
|
|
|
if (unlikely(nvsp->hdr.msg_type != NVSP_MSG1_TYPE_SEND_RNDIS_PKT)) {
|
|
|
|
netif_err(net_device_ctx, rx_err, ndev,
|
|
|
|
"Unknown nvsp packet type received %u\n",
|
|
|
|
nvsp->hdr.msg_type);
|
2017-02-27 18:26:49 +00:00
|
|
|
return 0;
|
2009-07-13 22:34:54 +00:00
|
|
|
}
|
|
|
|
|
2017-01-24 21:06:08 +00:00
|
|
|
if (unlikely(vmxferpage_packet->xfer_pageset_id != NETVSC_RECEIVE_BUFFER_ID)) {
|
|
|
|
netif_err(net_device_ctx, rx_err, ndev,
|
|
|
|
"Invalid xfer page set id - expecting %x got %x\n",
|
|
|
|
NETVSC_RECEIVE_BUFFER_ID,
|
|
|
|
vmxferpage_packet->xfer_pageset_id);
|
2017-02-27 18:26:49 +00:00
|
|
|
return 0;
|
2009-07-13 22:34:54 +00:00
|
|
|
}
|
|
|
|
|
2014-04-21 21:54:43 +00:00
|
|
|
count = vmxferpage_packet->range_cnt;
|
2009-07-13 22:34:54 +00:00
|
|
|
|
2009-07-27 20:47:24 +00:00
|
|
|
/* Each range represents 1 RNDIS pkt that contains 1 ethernet frame */
|
2014-04-21 21:54:43 +00:00
|
|
|
for (i = 0; i < count; i++) {
|
2017-01-24 21:06:08 +00:00
|
|
|
void *data = recv_buf
|
|
|
|
+ vmxferpage_packet->ranges[i].byte_offset;
|
|
|
|
u32 buflen = vmxferpage_packet->ranges[i].byte_count;
|
2009-07-13 22:34:54 +00:00
|
|
|
|
2009-07-27 20:47:24 +00:00
|
|
|
/* Pass it to the upper layer */
|
2017-01-24 21:06:08 +00:00
|
|
|
status = rndis_filter_receive(ndev, net_device, device,
|
|
|
|
channel, data, buflen);
|
2009-07-13 22:34:54 +00:00
|
|
|
}
|
|
|
|
|
2017-02-27 18:26:49 +00:00
|
|
|
if (net_device->chan_table[q_idx].mrc.buf) {
|
|
|
|
struct recv_comp_data *rcd;
|
|
|
|
|
|
|
|
rcd = get_recv_comp_slot(net_device, channel, q_idx);
|
|
|
|
if (rcd) {
|
|
|
|
rcd->tid = vmxferpage_packet->d.trans_id;
|
|
|
|
rcd->status = status;
|
|
|
|
} else {
|
|
|
|
netdev_err(ndev, "Recv_comp full buf q:%hd, tid:%llx\n",
|
|
|
|
q_idx, vmxferpage_packet->d.trans_id);
|
|
|
|
}
|
|
|
|
} else {
|
2016-08-19 21:47:09 +00:00
|
|
|
ret = netvsc_send_recv_completion(channel,
|
|
|
|
vmxferpage_packet->d.trans_id,
|
|
|
|
status);
|
|
|
|
if (ret)
|
|
|
|
netdev_err(ndev, "Recv_comp q:%hd, tid:%llx, err:%d\n",
|
|
|
|
q_idx, vmxferpage_packet->d.trans_id, ret);
|
|
|
|
}
|
2017-02-27 18:26:49 +00:00
|
|
|
return count;
|
2009-07-13 22:34:54 +00:00
|
|
|
}
|
|
|
|
|
2014-04-21 17:20:28 +00:00
|
|
|
static void netvsc_send_table(struct hv_device *hdev,
|
2015-07-24 17:08:40 +00:00
|
|
|
struct nvsp_message *nvmsg)
|
2014-04-21 17:20:28 +00:00
|
|
|
{
|
2016-05-13 11:55:23 +00:00
|
|
|
struct net_device *ndev = hv_get_drvdata(hdev);
|
2017-03-09 22:58:29 +00:00
|
|
|
struct net_device_context *net_device_ctx = netdev_priv(ndev);
|
2014-04-21 17:20:28 +00:00
|
|
|
int i;
|
|
|
|
u32 count, *tab;
|
|
|
|
|
|
|
|
count = nvmsg->msg.v5_msg.send_table.count;
|
|
|
|
if (count != VRSS_SEND_TAB_SIZE) {
|
|
|
|
netdev_err(ndev, "Received wrong send-table size:%u\n", count);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
tab = (u32 *)((unsigned long)&nvmsg->msg.v5_msg.send_table +
|
|
|
|
nvmsg->msg.v5_msg.send_table.offset);
|
|
|
|
|
|
|
|
for (i = 0; i < count; i++)
|
2017-03-09 22:58:29 +00:00
|
|
|
net_device_ctx->tx_send_table[i] = tab[i];
|
2014-04-21 17:20:28 +00:00
|
|
|
}
|
|
|
|
|
2016-08-15 15:48:39 +00:00
|
|
|
static void netvsc_send_vf(struct net_device_context *net_device_ctx,
|
2015-07-24 17:08:40 +00:00
|
|
|
struct nvsp_message *nvmsg)
|
|
|
|
{
|
2016-08-15 15:48:39 +00:00
|
|
|
net_device_ctx->vf_alloc = nvmsg->msg.v4_msg.vf_assoc.allocated;
|
|
|
|
net_device_ctx->vf_serial = nvmsg->msg.v4_msg.vf_assoc.serial;
|
2015-07-24 17:08:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void netvsc_receive_inband(struct hv_device *hdev,
|
2016-08-15 15:48:39 +00:00
|
|
|
struct net_device_context *net_device_ctx,
|
|
|
|
struct nvsp_message *nvmsg)
|
2015-07-24 17:08:40 +00:00
|
|
|
{
|
|
|
|
switch (nvmsg->hdr.msg_type) {
|
|
|
|
case NVSP_MSG5_TYPE_SEND_INDIRECTION_TABLE:
|
|
|
|
netvsc_send_table(hdev, nvmsg);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case NVSP_MSG4_TYPE_SEND_VF_ASSOCIATION:
|
2016-08-15 15:48:39 +00:00
|
|
|
netvsc_send_vf(net_device_ctx, nvmsg);
|
2015-07-24 17:08:40 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-27 18:26:49 +00:00
|
|
|
static int netvsc_process_raw_pkt(struct hv_device *device,
|
|
|
|
struct vmbus_channel *channel,
|
|
|
|
struct netvsc_device *net_device,
|
|
|
|
struct net_device *ndev,
|
2017-04-07 18:41:19 +00:00
|
|
|
const struct vmpacket_descriptor *desc,
|
|
|
|
int budget)
|
2016-07-05 23:52:46 +00:00
|
|
|
{
|
2016-08-15 15:48:39 +00:00
|
|
|
struct net_device_context *net_device_ctx = netdev_priv(ndev);
|
2017-02-27 18:26:48 +00:00
|
|
|
struct nvsp_message *nvmsg = hv_pkt_data(desc);
|
2016-07-05 23:52:46 +00:00
|
|
|
|
|
|
|
switch (desc->type) {
|
|
|
|
case VM_PKT_COMP:
|
2017-04-07 18:41:19 +00:00
|
|
|
netvsc_send_completion(net_device, channel, device,
|
|
|
|
desc, budget);
|
2016-07-05 23:52:46 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case VM_PKT_DATA_USING_XFER_PAGES:
|
2017-02-27 18:26:49 +00:00
|
|
|
return netvsc_receive(ndev, net_device, net_device_ctx,
|
|
|
|
device, channel, desc, nvmsg);
|
2016-07-05 23:52:46 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case VM_PKT_DATA_INBAND:
|
2016-08-15 15:48:39 +00:00
|
|
|
netvsc_receive_inband(device, net_device_ctx, nvmsg);
|
2016-07-05 23:52:46 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
netdev_err(ndev, "unhandled packet type %d, tid %llx\n",
|
2017-03-22 21:50:57 +00:00
|
|
|
desc->type, desc->trans_id);
|
2016-07-05 23:52:46 +00:00
|
|
|
break;
|
|
|
|
}
|
2017-02-27 18:26:49 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct hv_device *netvsc_channel_to_device(struct vmbus_channel *channel)
|
|
|
|
{
|
|
|
|
struct vmbus_channel *primary = channel->primary_channel;
|
|
|
|
|
|
|
|
return primary ? primary->device_obj : channel->device_obj;
|
|
|
|
}
|
|
|
|
|
2017-03-16 23:12:38 +00:00
|
|
|
/* Network processing softirq
|
|
|
|
* Process data in incoming ring buffer from host
|
|
|
|
* Stops when ring is empty or budget is met or exceeded.
|
|
|
|
*/
|
2017-02-27 18:26:49 +00:00
|
|
|
int netvsc_poll(struct napi_struct *napi, int budget)
|
|
|
|
{
|
|
|
|
struct netvsc_channel *nvchan
|
|
|
|
= container_of(napi, struct netvsc_channel, napi);
|
|
|
|
struct vmbus_channel *channel = nvchan->channel;
|
|
|
|
struct hv_device *device = netvsc_channel_to_device(channel);
|
|
|
|
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);
|
|
|
|
int work_done = 0;
|
|
|
|
|
2017-03-22 21:50:57 +00:00
|
|
|
/* If starting a new interval */
|
|
|
|
if (!nvchan->desc)
|
|
|
|
nvchan->desc = hv_pkt_iter_first(channel);
|
2017-02-27 18:26:49 +00:00
|
|
|
|
2017-03-22 21:50:57 +00:00
|
|
|
while (nvchan->desc && work_done < budget) {
|
|
|
|
work_done += netvsc_process_raw_pkt(device, channel, net_device,
|
2017-04-07 18:41:19 +00:00
|
|
|
ndev, nvchan->desc, budget);
|
2017-03-22 21:50:57 +00:00
|
|
|
nvchan->desc = hv_pkt_iter_next(channel, nvchan->desc);
|
2017-02-27 18:26:49 +00:00
|
|
|
}
|
|
|
|
|
2017-03-22 21:50:57 +00:00
|
|
|
/* If receive ring was exhausted
|
|
|
|
* and not doing busy poll
|
2017-03-16 23:12:38 +00:00
|
|
|
* then re-enable host interrupts
|
|
|
|
* and reschedule if ring is not empty.
|
|
|
|
*/
|
2017-02-27 18:26:49 +00:00
|
|
|
if (work_done < budget &&
|
|
|
|
napi_complete_done(napi, work_done) &&
|
|
|
|
hv_end_read(&channel->inbound) != 0)
|
|
|
|
napi_reschedule(napi);
|
|
|
|
|
|
|
|
netvsc_chk_recv_comp(net_device, channel, q_idx);
|
2017-03-22 21:50:57 +00:00
|
|
|
|
|
|
|
/* Driver may overshoot since multiple packets per descriptor */
|
|
|
|
return min(work_done, budget);
|
2016-07-05 23:52:46 +00:00
|
|
|
}
|
|
|
|
|
2017-03-16 23:12:38 +00:00
|
|
|
/* Call back when data is available in host ring buffer.
|
|
|
|
* Processing is deferred until network softirq (NAPI)
|
|
|
|
*/
|
2014-04-21 17:20:28 +00:00
|
|
|
void netvsc_channel_cb(void *context)
|
2009-07-13 22:34:54 +00:00
|
|
|
{
|
2017-03-16 23:12:37 +00:00
|
|
|
struct netvsc_channel *nvchan = context;
|
2017-01-24 21:05:58 +00:00
|
|
|
|
2017-03-22 21:50:57 +00:00
|
|
|
if (napi_schedule_prep(&nvchan->napi)) {
|
|
|
|
/* disable interupts from host */
|
|
|
|
hv_begin_read(&nvchan->channel->inbound);
|
2017-03-09 23:04:14 +00:00
|
|
|
|
2017-03-22 21:50:57 +00:00
|
|
|
__napi_schedule(&nvchan->napi);
|
|
|
|
}
|
2009-07-13 22:34:54 +00:00
|
|
|
}
|
2011-04-21 19:30:40 +00:00
|
|
|
|
2011-04-21 19:30:45 +00:00
|
|
|
/*
|
|
|
|
* netvsc_device_add - Callback when the device belonging to this
|
|
|
|
* driver is added
|
|
|
|
*/
|
2017-01-24 21:06:09 +00:00
|
|
|
int netvsc_device_add(struct hv_device *device,
|
|
|
|
const struct netvsc_device_info *device_info)
|
2011-04-21 19:30:45 +00:00
|
|
|
{
|
2016-05-13 11:55:25 +00:00
|
|
|
int i, ret = 0;
|
2017-01-24 21:06:09 +00:00
|
|
|
int ring_size = device_info->ring_size;
|
2011-04-21 19:30:45 +00:00
|
|
|
struct netvsc_device *net_device;
|
2016-05-13 11:55:25 +00:00
|
|
|
struct net_device *ndev = hv_get_drvdata(device);
|
|
|
|
struct net_device_context *net_device_ctx = netdev_priv(ndev);
|
2011-04-21 19:30:45 +00:00
|
|
|
|
2016-05-13 11:55:25 +00:00
|
|
|
net_device = alloc_net_device();
|
2014-09-04 11:11:23 +00:00
|
|
|
if (!net_device)
|
|
|
|
return -ENOMEM;
|
2011-04-21 19:30:45 +00:00
|
|
|
|
2014-04-21 17:20:28 +00:00
|
|
|
net_device->ring_size = ring_size;
|
|
|
|
|
2017-02-27 18:26:49 +00:00
|
|
|
/* Because the device uses NAPI, all the interrupt batching and
|
|
|
|
* control is done via Net softirq, not the channel handling
|
|
|
|
*/
|
|
|
|
set_channel_read_mode(device->channel, HV_CALL_ISR);
|
|
|
|
|
2017-04-06 21:59:21 +00:00
|
|
|
/* If we're reopening the device we may have multiple queues, fill the
|
|
|
|
* chn_table with the default channel to use it before subchannels are
|
|
|
|
* opened.
|
|
|
|
* Initialize the channel state before we open;
|
|
|
|
* we can be interrupted as soon as we open the channel.
|
|
|
|
*/
|
|
|
|
|
|
|
|
for (i = 0; i < VRSS_CHANNEL_MAX; i++) {
|
|
|
|
struct netvsc_channel *nvchan = &net_device->chan_table[i];
|
|
|
|
|
|
|
|
nvchan->channel = device->channel;
|
|
|
|
}
|
|
|
|
|
2017-05-03 23:59:21 +00:00
|
|
|
/* Enable NAPI handler before init callbacks */
|
|
|
|
netif_napi_add(ndev, &net_device->chan_table[0].napi,
|
|
|
|
netvsc_poll, NAPI_POLL_WEIGHT);
|
|
|
|
|
2011-04-21 19:30:45 +00:00
|
|
|
/* Open the channel */
|
2011-05-13 02:35:05 +00:00
|
|
|
ret = vmbus_open(device->channel, ring_size * PAGE_SIZE,
|
|
|
|
ring_size * PAGE_SIZE, NULL, 0,
|
2017-03-16 23:12:37 +00:00
|
|
|
netvsc_channel_cb,
|
|
|
|
net_device->chan_table);
|
2011-04-21 19:30:45 +00:00
|
|
|
|
|
|
|
if (ret != 0) {
|
2017-05-03 23:59:21 +00:00
|
|
|
netif_napi_del(&net_device->chan_table[0].napi);
|
2011-09-01 19:19:41 +00:00
|
|
|
netdev_err(ndev, "unable to open channel: %d\n", ret);
|
2011-04-21 19:30:45 +00:00
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Channel is opened */
|
2016-11-28 17:25:44 +00:00
|
|
|
netdev_dbg(ndev, "hv_netvsc channel opened successfully\n");
|
2011-04-21 19:30:45 +00:00
|
|
|
|
2017-02-27 18:26:49 +00:00
|
|
|
napi_enable(&net_device->chan_table[0].napi);
|
2016-05-13 11:55:25 +00:00
|
|
|
|
|
|
|
/* Writing nvdev pointer unlocks netvsc_send(), make sure chn_table is
|
|
|
|
* populated.
|
|
|
|
*/
|
2017-03-22 21:51:00 +00:00
|
|
|
rcu_assign_pointer(net_device_ctx->nvdev, net_device);
|
2014-04-21 17:20:28 +00:00
|
|
|
|
2011-04-21 19:30:45 +00:00
|
|
|
/* Connect with the NetVsp */
|
2017-06-08 23:21:22 +00:00
|
|
|
ret = netvsc_connect_vsp(device, net_device);
|
2011-04-21 19:30:45 +00:00
|
|
|
if (ret != 0) {
|
2011-09-01 19:19:41 +00:00
|
|
|
netdev_err(ndev,
|
2011-09-01 19:19:40 +00:00
|
|
|
"unable to connect to NetVSP - %d\n", ret);
|
2011-04-21 19:30:45 +00:00
|
|
|
goto close;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
close:
|
2017-04-19 22:22:02 +00:00
|
|
|
netif_napi_del(&net_device->chan_table[0].napi);
|
2017-02-27 18:26:49 +00:00
|
|
|
|
2011-04-21 19:30:45 +00:00
|
|
|
/* Now, we can close the channel safely */
|
|
|
|
vmbus_close(device->channel);
|
|
|
|
|
|
|
|
cleanup:
|
2017-03-22 21:51:00 +00:00
|
|
|
free_netvsc_device(&net_device->rcu);
|
2011-04-21 19:30:45 +00:00
|
|
|
|
|
|
|
return ret;
|
2017-06-08 23:21:22 +00:00
|
|
|
|
2011-04-21 19:30:45 +00:00
|
|
|
}
|