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-13 22:34:54 +00:00
|
|
|
#include <linux/init.h>
|
2011-06-16 20:16:37 +00:00
|
|
|
#include <linux/atomic.h>
|
2009-07-13 22:34:54 +00:00
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/highmem.h>
|
|
|
|
#include <linux/device.h>
|
|
|
|
#include <linux/io.h>
|
|
|
|
#include <linux/delay.h>
|
|
|
|
#include <linux/netdevice.h>
|
|
|
|
#include <linux/inetdevice.h>
|
|
|
|
#include <linux/etherdevice.h>
|
|
|
|
#include <linux/skbuff.h>
|
2013-05-28 06:15:56 +00:00
|
|
|
#include <linux/if_vlan.h>
|
2009-07-13 22:34:54 +00:00
|
|
|
#include <linux/in.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>
|
2009-07-13 22:34:54 +00:00
|
|
|
#include <net/arp.h>
|
|
|
|
#include <net/route.h>
|
|
|
|
#include <net/sock.h>
|
|
|
|
#include <net/pkt_sched.h>
|
2017-05-30 18:36:56 +00:00
|
|
|
#include <net/checksum.h>
|
|
|
|
#include <net/ip6_checksum.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
|
|
|
|
2012-07-25 08:08:41 +00:00
|
|
|
#define RING_SIZE_MIN 64
|
2015-11-27 10:39:55 +00:00
|
|
|
#define LINKCHANGE_INT (2 * HZ)
|
2016-12-06 21:43:54 +00:00
|
|
|
|
2010-10-12 17:45:23 +00:00
|
|
|
static int ring_size = 128;
|
2010-05-04 16:58:53 +00:00
|
|
|
module_param(ring_size, int, S_IRUGO);
|
|
|
|
MODULE_PARM_DESC(ring_size, "Ring buffer size (# of pages)");
|
2009-07-13 22:34:54 +00:00
|
|
|
|
2015-04-28 08:05:17 +00:00
|
|
|
static const u32 default_msg = NETIF_MSG_DRV | NETIF_MSG_PROBE |
|
|
|
|
NETIF_MSG_LINK | NETIF_MSG_IFUP |
|
|
|
|
NETIF_MSG_IFDOWN | NETIF_MSG_RX_ERR |
|
|
|
|
NETIF_MSG_TX_ERR;
|
|
|
|
|
|
|
|
static int debug = -1;
|
|
|
|
module_param(debug, int, S_IRUGO);
|
|
|
|
MODULE_PARM_DESC(debug, "Debug level (0=none,...,16=all)");
|
|
|
|
|
2011-11-30 15:19:08 +00:00
|
|
|
static void do_set_multicast(struct work_struct *w)
|
|
|
|
{
|
2012-04-19 00:39:37 +00:00
|
|
|
struct net_device_context *ndevctx =
|
|
|
|
container_of(w, struct net_device_context, work);
|
2016-05-13 11:55:23 +00:00
|
|
|
struct hv_device *device_obj = ndevctx->device_ctx;
|
|
|
|
struct net_device *ndev = hv_get_drvdata(device_obj);
|
2017-03-22 21:51:00 +00:00
|
|
|
struct netvsc_device *nvdev = rcu_dereference(ndevctx->nvdev);
|
2011-11-30 15:19:08 +00:00
|
|
|
struct rndis_device *rdev;
|
|
|
|
|
2016-05-13 11:55:23 +00:00
|
|
|
if (!nvdev)
|
2012-04-19 00:39:37 +00:00
|
|
|
return;
|
2011-11-30 15:19:08 +00:00
|
|
|
|
|
|
|
rdev = nvdev->extension;
|
|
|
|
if (rdev == NULL)
|
2012-04-19 00:39:37 +00:00
|
|
|
return;
|
2011-11-30 15:19:08 +00:00
|
|
|
|
2016-05-13 11:55:23 +00:00
|
|
|
if (ndev->flags & IFF_PROMISC)
|
2011-11-30 15:19:08 +00:00
|
|
|
rndis_filter_set_packet_filter(rdev,
|
|
|
|
NDIS_PACKET_TYPE_PROMISCUOUS);
|
|
|
|
else
|
|
|
|
rndis_filter_set_packet_filter(rdev,
|
|
|
|
NDIS_PACKET_TYPE_BROADCAST |
|
|
|
|
NDIS_PACKET_TYPE_ALL_MULTICAST |
|
|
|
|
NDIS_PACKET_TYPE_DIRECTED);
|
|
|
|
}
|
|
|
|
|
2009-07-15 19:45:20 +00:00
|
|
|
static void netvsc_set_multicast_list(struct net_device *net)
|
2009-07-13 22:34:54 +00:00
|
|
|
{
|
2012-04-19 00:39:37 +00:00
|
|
|
struct net_device_context *net_device_ctx = netdev_priv(net);
|
2011-11-30 15:19:08 +00:00
|
|
|
|
2012-04-19 00:39:37 +00:00
|
|
|
schedule_work(&net_device_ctx->work);
|
2009-07-13 22:34:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int netvsc_open(struct net_device *net)
|
|
|
|
{
|
2016-06-03 15:51:00 +00:00
|
|
|
struct netvsc_device *nvdev = net_device_to_netvsc_device(net);
|
2014-02-13 00:54:27 +00:00
|
|
|
struct rndis_device *rdev;
|
2009-09-01 04:09:45 +00:00
|
|
|
int ret = 0;
|
2009-07-13 22:34:54 +00:00
|
|
|
|
2014-02-13 00:54:27 +00:00
|
|
|
netif_carrier_off(net);
|
|
|
|
|
2011-09-28 20:24:15 +00:00
|
|
|
/* Open up the device */
|
2016-06-03 15:51:00 +00:00
|
|
|
ret = rndis_filter_open(nvdev);
|
2011-09-28 20:24:15 +00:00
|
|
|
if (ret != 0) {
|
|
|
|
netdev_err(net, "unable to open device (ret %d).\n", ret);
|
|
|
|
return ret;
|
2009-07-13 22:34:54 +00:00
|
|
|
}
|
|
|
|
|
2015-07-13 20:09:16 +00:00
|
|
|
netif_tx_wake_all_queues(net);
|
2011-09-28 20:24:15 +00:00
|
|
|
|
2014-02-13 00:54:27 +00:00
|
|
|
rdev = nvdev->extension;
|
|
|
|
if (!rdev->link_state)
|
|
|
|
netif_carrier_on(net);
|
|
|
|
|
2009-07-13 22:34:54 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int netvsc_close(struct net_device *net)
|
|
|
|
{
|
|
|
|
struct net_device_context *net_device_ctx = netdev_priv(net);
|
2017-03-22 21:51:00 +00:00
|
|
|
struct netvsc_device *nvdev = rtnl_dereference(net_device_ctx->nvdev);
|
2009-09-01 04:09:45 +00:00
|
|
|
int ret;
|
2017-06-08 23:21:19 +00:00
|
|
|
u32 aread, i, msec = 10, retry = 0, retry_max = 20;
|
2015-07-13 20:09:16 +00:00
|
|
|
struct vmbus_channel *chn;
|
2009-07-13 22:34:54 +00:00
|
|
|
|
2012-02-02 07:17:59 +00:00
|
|
|
netif_tx_disable(net);
|
2009-07-13 22:34:54 +00:00
|
|
|
|
2012-04-19 00:39:37 +00:00
|
|
|
/* Make sure netvsc_set_multicast_list doesn't re-enable filter! */
|
|
|
|
cancel_work_sync(&net_device_ctx->work);
|
2016-06-03 15:51:00 +00:00
|
|
|
ret = rndis_filter_close(nvdev);
|
2015-07-13 20:09:16 +00:00
|
|
|
if (ret != 0) {
|
2011-03-29 20:58:48 +00:00
|
|
|
netdev_err(net, "unable to close device (ret %d).\n", ret);
|
2015-07-13 20:09:16 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Ensure pending bytes in ring are read */
|
|
|
|
while (true) {
|
|
|
|
aread = 0;
|
|
|
|
for (i = 0; i < nvdev->num_chn; i++) {
|
2017-01-24 21:06:07 +00:00
|
|
|
chn = nvdev->chan_table[i].channel;
|
2015-07-13 20:09:16 +00:00
|
|
|
if (!chn)
|
|
|
|
continue;
|
|
|
|
|
2017-06-08 23:21:19 +00:00
|
|
|
aread = hv_get_bytes_to_read(&chn->inbound);
|
2015-07-13 20:09:16 +00:00
|
|
|
if (aread)
|
|
|
|
break;
|
|
|
|
|
2017-06-08 23:21:19 +00:00
|
|
|
aread = hv_get_bytes_to_read(&chn->outbound);
|
2015-07-13 20:09:16 +00:00
|
|
|
if (aread)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
retry++;
|
|
|
|
if (retry > retry_max || aread == 0)
|
|
|
|
break;
|
|
|
|
|
|
|
|
msleep(msec);
|
|
|
|
|
|
|
|
if (msec < 1000)
|
|
|
|
msec *= 2;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (aread) {
|
|
|
|
netdev_err(net, "Ring buffer not empty after closing rndis\n");
|
|
|
|
ret = -ETIMEDOUT;
|
|
|
|
}
|
2009-07-13 22:34:54 +00:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2014-03-09 03:23:14 +00:00
|
|
|
static void *init_ppi_data(struct rndis_message *msg, u32 ppi_size,
|
|
|
|
int pkt_type)
|
|
|
|
{
|
|
|
|
struct rndis_packet *rndis_pkt;
|
|
|
|
struct rndis_per_packet_info *ppi;
|
|
|
|
|
|
|
|
rndis_pkt = &msg->msg.pkt;
|
|
|
|
rndis_pkt->data_offset += ppi_size;
|
|
|
|
|
|
|
|
ppi = (struct rndis_per_packet_info *)((void *)rndis_pkt +
|
|
|
|
rndis_pkt->per_pkt_info_offset + rndis_pkt->per_pkt_info_len);
|
|
|
|
|
|
|
|
ppi->size = ppi_size;
|
|
|
|
ppi->type = pkt_type;
|
|
|
|
ppi->ppi_offset = sizeof(struct rndis_per_packet_info);
|
|
|
|
|
|
|
|
rndis_pkt->per_pkt_info_len += ppi_size;
|
|
|
|
|
|
|
|
return ppi;
|
|
|
|
}
|
|
|
|
|
2017-04-12 18:45:18 +00:00
|
|
|
/* Azure hosts don't support non-TCP port numbers in hashing yet. We compute
|
|
|
|
* hash for non-TCP traffic with only IP numbers.
|
|
|
|
*/
|
|
|
|
static inline u32 netvsc_get_hash(struct sk_buff *skb, struct sock *sk)
|
|
|
|
{
|
|
|
|
struct flow_keys flow;
|
|
|
|
u32 hash;
|
|
|
|
static u32 hashrnd __read_mostly;
|
|
|
|
|
|
|
|
net_get_random_once(&hashrnd, sizeof(hashrnd));
|
|
|
|
|
|
|
|
if (!skb_flow_dissect_flow_keys(skb, &flow, 0))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (flow.basic.ip_proto == IPPROTO_TCP) {
|
|
|
|
return skb_get_hash(skb);
|
|
|
|
} else {
|
|
|
|
if (flow.basic.n_proto == htons(ETH_P_IP))
|
|
|
|
hash = jhash2((u32 *)&flow.addrs.v4addrs, 2, hashrnd);
|
|
|
|
else if (flow.basic.n_proto == htons(ETH_P_IPV6))
|
|
|
|
hash = jhash2((u32 *)&flow.addrs.v6addrs, 8, hashrnd);
|
|
|
|
else
|
|
|
|
hash = 0;
|
|
|
|
|
|
|
|
skb_set_hash(skb, hash, PKT_HASH_TYPE_L3);
|
|
|
|
}
|
|
|
|
|
|
|
|
return hash;
|
|
|
|
}
|
|
|
|
|
2017-04-12 18:35:05 +00:00
|
|
|
static inline int netvsc_get_tx_queue(struct net_device *ndev,
|
|
|
|
struct sk_buff *skb, int old_idx)
|
|
|
|
{
|
|
|
|
const struct net_device_context *ndc = netdev_priv(ndev);
|
|
|
|
struct sock *sk = skb->sk;
|
|
|
|
int q_idx;
|
|
|
|
|
2017-04-12 18:45:18 +00:00
|
|
|
q_idx = ndc->tx_send_table[netvsc_get_hash(skb, sk) &
|
2017-04-12 18:35:05 +00:00
|
|
|
(VRSS_SEND_TAB_SIZE - 1)];
|
|
|
|
|
|
|
|
/* If queue index changed record the new value */
|
|
|
|
if (q_idx != old_idx &&
|
|
|
|
sk && sk_fullsock(sk) && rcu_access_pointer(sk->sk_dst_cache))
|
|
|
|
sk_tx_queue_set(sk, q_idx);
|
|
|
|
|
|
|
|
return q_idx;
|
|
|
|
}
|
|
|
|
|
2017-01-24 21:06:05 +00:00
|
|
|
/*
|
|
|
|
* Select queue for transmit.
|
|
|
|
*
|
|
|
|
* If a valid queue has already been assigned, then use that.
|
|
|
|
* Otherwise compute tx queue based on hash and the send table.
|
|
|
|
*
|
|
|
|
* This is basically similar to default (__netdev_pick_tx) with the added step
|
|
|
|
* of using the host send_table when no other queue has been assigned.
|
|
|
|
*
|
|
|
|
* TODO support XPS - but get_xps_queue not exported
|
|
|
|
*/
|
2014-04-21 17:20:28 +00:00
|
|
|
static u16 netvsc_select_queue(struct net_device *ndev, struct sk_buff *skb,
|
|
|
|
void *accel_priv, select_queue_fallback_t fallback)
|
|
|
|
{
|
2017-03-09 22:58:29 +00:00
|
|
|
unsigned int num_tx_queues = ndev->real_num_tx_queues;
|
2017-04-12 18:35:05 +00:00
|
|
|
int q_idx = sk_tx_queue_get(skb->sk);
|
|
|
|
|
|
|
|
if (q_idx < 0 || skb->ooo_okay) {
|
|
|
|
/* If forwarding a packet, we use the recorded queue when
|
|
|
|
* available for better cache locality.
|
|
|
|
*/
|
|
|
|
if (skb_rx_queue_recorded(skb))
|
|
|
|
q_idx = skb_get_rx_queue(skb);
|
|
|
|
else
|
|
|
|
q_idx = netvsc_get_tx_queue(ndev, skb, q_idx);
|
2017-01-24 21:06:05 +00:00
|
|
|
}
|
2014-04-21 17:20:28 +00:00
|
|
|
|
2017-04-12 18:35:05 +00:00
|
|
|
while (unlikely(q_idx >= num_tx_queues))
|
|
|
|
q_idx -= num_tx_queues;
|
|
|
|
|
2014-04-21 17:20:28 +00:00
|
|
|
return q_idx;
|
|
|
|
}
|
|
|
|
|
2014-03-09 03:23:13 +00:00
|
|
|
static u32 fill_pg_buf(struct page *page, u32 offset, u32 len,
|
|
|
|
struct hv_page_buffer *pb)
|
|
|
|
{
|
|
|
|
int j = 0;
|
|
|
|
|
|
|
|
/* Deal with compund pages by ignoring unused part
|
|
|
|
* of the page.
|
|
|
|
*/
|
|
|
|
page += (offset >> PAGE_SHIFT);
|
|
|
|
offset &= ~PAGE_MASK;
|
|
|
|
|
|
|
|
while (len > 0) {
|
|
|
|
unsigned long bytes;
|
|
|
|
|
|
|
|
bytes = PAGE_SIZE - offset;
|
|
|
|
if (bytes > len)
|
|
|
|
bytes = len;
|
|
|
|
pb[j].pfn = page_to_pfn(page);
|
|
|
|
pb[j].offset = offset;
|
|
|
|
pb[j].len = bytes;
|
|
|
|
|
|
|
|
offset += bytes;
|
|
|
|
len -= bytes;
|
|
|
|
|
|
|
|
if (offset == PAGE_SIZE && len) {
|
|
|
|
page++;
|
|
|
|
offset = 0;
|
|
|
|
j++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return j + 1;
|
|
|
|
}
|
|
|
|
|
2014-03-09 03:23:14 +00:00
|
|
|
static u32 init_page_array(void *hdr, u32 len, struct sk_buff *skb,
|
2015-12-02 00:43:13 +00:00
|
|
|
struct hv_netvsc_packet *packet,
|
|
|
|
struct hv_page_buffer **page_buf)
|
2014-03-09 03:23:13 +00:00
|
|
|
{
|
2015-12-02 00:43:13 +00:00
|
|
|
struct hv_page_buffer *pb = *page_buf;
|
2014-03-09 03:23:13 +00:00
|
|
|
u32 slots_used = 0;
|
|
|
|
char *data = skb->data;
|
|
|
|
int frags = skb_shinfo(skb)->nr_frags;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
/* The packet is laid out thus:
|
2015-04-13 23:34:35 +00:00
|
|
|
* 1. hdr: RNDIS header and PPI
|
2014-03-09 03:23:13 +00:00
|
|
|
* 2. skb linear data
|
|
|
|
* 3. skb fragment data
|
|
|
|
*/
|
|
|
|
if (hdr != NULL)
|
|
|
|
slots_used += fill_pg_buf(virt_to_page(hdr),
|
|
|
|
offset_in_page(hdr),
|
|
|
|
len, &pb[slots_used]);
|
|
|
|
|
2015-04-13 23:34:35 +00:00
|
|
|
packet->rmsg_size = len;
|
|
|
|
packet->rmsg_pgcnt = slots_used;
|
|
|
|
|
2014-03-09 03:23:13 +00:00
|
|
|
slots_used += fill_pg_buf(virt_to_page(data),
|
|
|
|
offset_in_page(data),
|
|
|
|
skb_headlen(skb), &pb[slots_used]);
|
|
|
|
|
|
|
|
for (i = 0; i < frags; i++) {
|
|
|
|
skb_frag_t *frag = skb_shinfo(skb)->frags + i;
|
|
|
|
|
|
|
|
slots_used += fill_pg_buf(skb_frag_page(frag),
|
|
|
|
frag->page_offset,
|
|
|
|
skb_frag_size(frag), &pb[slots_used]);
|
|
|
|
}
|
2014-03-09 03:23:14 +00:00
|
|
|
return slots_used;
|
2014-03-09 03:23:13 +00:00
|
|
|
}
|
|
|
|
|
2017-06-08 23:21:18 +00:00
|
|
|
/* Estimate number of page buffers neede to transmit
|
|
|
|
* Need at most 2 for RNDIS header plus skb body and fragments.
|
|
|
|
*/
|
|
|
|
static unsigned int netvsc_get_slots(const struct sk_buff *skb)
|
2014-03-09 03:23:13 +00:00
|
|
|
{
|
2017-06-08 23:21:18 +00:00
|
|
|
return PFN_UP(offset_in_page(skb->data) + skb_headlen(skb))
|
|
|
|
+ skb_shinfo(skb)->nr_frags
|
|
|
|
+ 2;
|
2014-03-09 03:23:13 +00:00
|
|
|
}
|
|
|
|
|
2017-01-24 21:05:59 +00:00
|
|
|
static u32 net_checksum_info(struct sk_buff *skb)
|
2014-03-09 03:23:17 +00:00
|
|
|
{
|
2017-01-24 21:05:59 +00:00
|
|
|
if (skb->protocol == htons(ETH_P_IP)) {
|
|
|
|
struct iphdr *ip = ip_hdr(skb);
|
2014-03-09 03:23:17 +00:00
|
|
|
|
2017-01-24 21:05:59 +00:00
|
|
|
if (ip->protocol == IPPROTO_TCP)
|
|
|
|
return TRANSPORT_INFO_IPV4_TCP;
|
|
|
|
else if (ip->protocol == IPPROTO_UDP)
|
|
|
|
return TRANSPORT_INFO_IPV4_UDP;
|
2014-03-09 03:23:17 +00:00
|
|
|
} else {
|
2017-01-24 21:05:59 +00:00
|
|
|
struct ipv6hdr *ip6 = ipv6_hdr(skb);
|
|
|
|
|
|
|
|
if (ip6->nexthdr == IPPROTO_TCP)
|
|
|
|
return TRANSPORT_INFO_IPV6_TCP;
|
2014-03-09 03:23:17 +00:00
|
|
|
else if (ipv6_hdr(skb)->nexthdr == IPPROTO_UDP)
|
2017-01-24 21:05:59 +00:00
|
|
|
return TRANSPORT_INFO_IPV6_UDP;
|
2014-03-09 03:23:17 +00:00
|
|
|
}
|
|
|
|
|
2017-01-24 21:05:59 +00:00
|
|
|
return TRANSPORT_INFO_NOT_IP;
|
2014-03-09 03:23:17 +00:00
|
|
|
}
|
|
|
|
|
2009-09-01 04:09:45 +00:00
|
|
|
static int netvsc_start_xmit(struct sk_buff *skb, struct net_device *net)
|
2009-07-13 22:34:54 +00:00
|
|
|
{
|
|
|
|
struct net_device_context *net_device_ctx = netdev_priv(net);
|
2015-04-08 15:54:05 +00:00
|
|
|
struct hv_netvsc_packet *packet = NULL;
|
2009-09-01 04:09:45 +00:00
|
|
|
int ret;
|
2014-03-09 03:23:14 +00:00
|
|
|
unsigned int num_data_pgs;
|
|
|
|
struct rndis_message *rndis_msg;
|
|
|
|
struct rndis_packet *rndis_pkt;
|
|
|
|
u32 rndis_msg_size;
|
|
|
|
struct rndis_per_packet_info *ppi;
|
2014-05-21 19:55:39 +00:00
|
|
|
u32 hash;
|
2015-03-30 04:08:42 +00:00
|
|
|
struct hv_page_buffer page_buf[MAX_PAGE_BUFFER_COUNT];
|
2015-12-02 00:43:13 +00:00
|
|
|
struct hv_page_buffer *pb = page_buf;
|
2009-07-13 22:34:54 +00:00
|
|
|
|
2017-06-08 23:21:18 +00:00
|
|
|
/* We can only transmit MAX_PAGE_BUFFER_COUNT number
|
2015-04-08 15:54:06 +00:00
|
|
|
* of pages in a single packet. If skb is scattered around
|
|
|
|
* more pages we try linearizing it.
|
2014-03-09 03:23:13 +00:00
|
|
|
*/
|
2017-06-08 23:21:18 +00:00
|
|
|
num_data_pgs = netvsc_get_slots(skb);
|
2016-08-23 19:17:52 +00:00
|
|
|
if (unlikely(num_data_pgs > MAX_PAGE_BUFFER_COUNT)) {
|
2016-08-23 19:17:57 +00:00
|
|
|
++net_device_ctx->eth_stats.tx_scattered;
|
|
|
|
|
|
|
|
if (skb_linearize(skb))
|
|
|
|
goto no_memory;
|
2016-08-23 19:17:52 +00:00
|
|
|
|
2017-06-08 23:21:18 +00:00
|
|
|
num_data_pgs = netvsc_get_slots(skb);
|
2016-08-23 19:17:52 +00:00
|
|
|
if (num_data_pgs > MAX_PAGE_BUFFER_COUNT) {
|
2016-08-23 19:17:57 +00:00
|
|
|
++net_device_ctx->eth_stats.tx_too_big;
|
2016-08-23 19:17:52 +00:00
|
|
|
goto drop;
|
|
|
|
}
|
2014-03-09 03:23:13 +00:00
|
|
|
}
|
2009-07-13 22:34:54 +00:00
|
|
|
|
2015-12-02 00:43:10 +00:00
|
|
|
/*
|
|
|
|
* Place the rndis header in the skb head room and
|
|
|
|
* the skb->cb will be used for hv_netvsc_packet
|
|
|
|
* structure.
|
|
|
|
*/
|
|
|
|
ret = skb_cow_head(skb, RNDIS_AND_PPI_SIZE);
|
2016-08-23 19:17:57 +00:00
|
|
|
if (ret)
|
|
|
|
goto no_memory;
|
|
|
|
|
2015-12-02 00:43:10 +00:00
|
|
|
/* Use the skb control buffer for building up the packet */
|
|
|
|
BUILD_BUG_ON(sizeof(struct hv_netvsc_packet) >
|
|
|
|
FIELD_SIZEOF(struct sk_buff, cb));
|
|
|
|
packet = (struct hv_netvsc_packet *)skb->cb;
|
2009-07-13 22:34:54 +00:00
|
|
|
|
2014-04-21 17:20:28 +00:00
|
|
|
packet->q_idx = skb_get_queue_mapping(skb);
|
|
|
|
|
2011-12-15 21:45:17 +00:00
|
|
|
packet->total_data_buflen = skb->len;
|
2017-01-24 21:06:12 +00:00
|
|
|
packet->total_bytes = skb->len;
|
|
|
|
packet->total_packets = 1;
|
2009-07-13 22:34:54 +00:00
|
|
|
|
2015-12-02 00:43:10 +00:00
|
|
|
rndis_msg = (struct rndis_message *)skb->head;
|
2015-03-30 04:08:42 +00:00
|
|
|
|
2015-12-02 00:43:06 +00:00
|
|
|
memset(rndis_msg, 0, RNDIS_AND_PPI_SIZE);
|
2009-07-13 22:34:54 +00:00
|
|
|
|
2014-03-09 03:23:14 +00:00
|
|
|
/* Add the rndis header */
|
|
|
|
rndis_msg->ndis_msg_type = RNDIS_MSG_PACKET;
|
|
|
|
rndis_msg->msg_len = packet->total_data_buflen;
|
|
|
|
rndis_pkt = &rndis_msg->msg.pkt;
|
|
|
|
rndis_pkt->data_offset = sizeof(struct rndis_packet);
|
|
|
|
rndis_pkt->data_len = packet->total_data_buflen;
|
|
|
|
rndis_pkt->per_pkt_info_offset = sizeof(struct rndis_packet);
|
|
|
|
|
|
|
|
rndis_msg_size = RNDIS_MESSAGE_SIZE(struct rndis_packet);
|
|
|
|
|
2014-05-21 19:55:39 +00:00
|
|
|
hash = skb_get_hash_raw(skb);
|
|
|
|
if (hash != 0 && net->real_num_tx_queues > 1) {
|
|
|
|
rndis_msg_size += NDIS_HASH_PPI_SIZE;
|
|
|
|
ppi = init_ppi_data(rndis_msg, NDIS_HASH_PPI_SIZE,
|
|
|
|
NBL_HASH_VALUE);
|
|
|
|
*(u32 *)((void *)ppi + ppi->ppi_offset) = hash;
|
|
|
|
}
|
|
|
|
|
2016-08-23 19:17:52 +00:00
|
|
|
if (skb_vlan_tag_present(skb)) {
|
2014-03-09 03:23:14 +00:00
|
|
|
struct ndis_pkt_8021q_info *vlan;
|
|
|
|
|
|
|
|
rndis_msg_size += NDIS_VLAN_PPI_SIZE;
|
|
|
|
ppi = init_ppi_data(rndis_msg, NDIS_VLAN_PPI_SIZE,
|
|
|
|
IEEE_8021Q_INFO);
|
|
|
|
vlan = (struct ndis_pkt_8021q_info *)((void *)ppi +
|
|
|
|
ppi->ppi_offset);
|
2015-12-02 00:43:19 +00:00
|
|
|
vlan->vlanid = skb->vlan_tci & VLAN_VID_MASK;
|
|
|
|
vlan->pri = (skb->vlan_tci & VLAN_PRIO_MASK) >>
|
2014-03-09 03:23:14 +00:00
|
|
|
VLAN_PRIO_SHIFT;
|
|
|
|
}
|
|
|
|
|
2017-01-24 21:05:59 +00:00
|
|
|
if (skb_is_gso(skb)) {
|
2016-08-23 19:17:52 +00:00
|
|
|
struct ndis_tcp_lso_info *lso_info;
|
|
|
|
|
|
|
|
rndis_msg_size += NDIS_LSO_PPI_SIZE;
|
|
|
|
ppi = init_ppi_data(rndis_msg, NDIS_LSO_PPI_SIZE,
|
|
|
|
TCP_LARGESEND_PKTINFO);
|
|
|
|
|
|
|
|
lso_info = (struct ndis_tcp_lso_info *)((void *)ppi +
|
|
|
|
ppi->ppi_offset);
|
|
|
|
|
|
|
|
lso_info->lso_v2_transmit.type = NDIS_TCP_LARGE_SEND_OFFLOAD_V2_TYPE;
|
2017-01-24 21:05:59 +00:00
|
|
|
if (skb->protocol == htons(ETH_P_IP)) {
|
2016-08-23 19:17:52 +00:00
|
|
|
lso_info->lso_v2_transmit.ip_version =
|
|
|
|
NDIS_TCP_LARGE_SEND_OFFLOAD_IPV4;
|
|
|
|
ip_hdr(skb)->tot_len = 0;
|
|
|
|
ip_hdr(skb)->check = 0;
|
|
|
|
tcp_hdr(skb)->check =
|
|
|
|
~csum_tcpudp_magic(ip_hdr(skb)->saddr,
|
|
|
|
ip_hdr(skb)->daddr, 0, IPPROTO_TCP, 0);
|
|
|
|
} else {
|
|
|
|
lso_info->lso_v2_transmit.ip_version =
|
|
|
|
NDIS_TCP_LARGE_SEND_OFFLOAD_IPV6;
|
|
|
|
ipv6_hdr(skb)->payload_len = 0;
|
|
|
|
tcp_hdr(skb)->check =
|
|
|
|
~csum_ipv6_magic(&ipv6_hdr(skb)->saddr,
|
|
|
|
&ipv6_hdr(skb)->daddr, 0, IPPROTO_TCP, 0);
|
|
|
|
}
|
2017-01-24 21:05:59 +00:00
|
|
|
lso_info->lso_v2_transmit.tcp_header_offset = skb_transport_offset(skb);
|
2016-08-23 19:17:52 +00:00
|
|
|
lso_info->lso_v2_transmit.mss = skb_shinfo(skb)->gso_size;
|
2016-10-11 21:03:07 +00:00
|
|
|
} else if (skb->ip_summed == CHECKSUM_PARTIAL) {
|
2017-01-24 21:05:59 +00:00
|
|
|
if (net_checksum_info(skb) & net_device_ctx->tx_checksum_mask) {
|
|
|
|
struct ndis_tcp_ip_checksum_info *csum_info;
|
|
|
|
|
2016-10-11 21:03:07 +00:00
|
|
|
rndis_msg_size += NDIS_CSUM_PPI_SIZE;
|
|
|
|
ppi = init_ppi_data(rndis_msg, NDIS_CSUM_PPI_SIZE,
|
|
|
|
TCPIP_CHKSUM_PKTINFO);
|
|
|
|
|
|
|
|
csum_info = (struct ndis_tcp_ip_checksum_info *)((void *)ppi +
|
|
|
|
ppi->ppi_offset);
|
|
|
|
|
2017-01-24 21:05:59 +00:00
|
|
|
csum_info->transmit.tcp_header_offset = skb_transport_offset(skb);
|
|
|
|
|
|
|
|
if (skb->protocol == htons(ETH_P_IP)) {
|
2016-10-11 21:03:07 +00:00
|
|
|
csum_info->transmit.is_ipv4 = 1;
|
2017-01-24 21:05:59 +00:00
|
|
|
|
|
|
|
if (ip_hdr(skb)->protocol == IPPROTO_TCP)
|
|
|
|
csum_info->transmit.tcp_checksum = 1;
|
|
|
|
else
|
|
|
|
csum_info->transmit.udp_checksum = 1;
|
|
|
|
} else {
|
2016-10-11 21:03:07 +00:00
|
|
|
csum_info->transmit.is_ipv6 = 1;
|
|
|
|
|
2017-01-24 21:05:59 +00:00
|
|
|
if (ipv6_hdr(skb)->nexthdr == IPPROTO_TCP)
|
|
|
|
csum_info->transmit.tcp_checksum = 1;
|
|
|
|
else
|
|
|
|
csum_info->transmit.udp_checksum = 1;
|
|
|
|
}
|
2016-10-11 21:03:07 +00:00
|
|
|
} else {
|
2017-01-24 21:05:59 +00:00
|
|
|
/* Can't do offload of this type of checksum */
|
2016-10-11 21:03:07 +00:00
|
|
|
if (skb_checksum_help(skb))
|
|
|
|
goto drop;
|
|
|
|
}
|
2014-03-09 03:23:17 +00:00
|
|
|
}
|
|
|
|
|
2014-03-09 03:23:14 +00:00
|
|
|
/* Start filling in the page buffers with the rndis hdr */
|
|
|
|
rndis_msg->msg_len += rndis_msg_size;
|
2014-10-22 20:47:18 +00:00
|
|
|
packet->total_data_buflen = rndis_msg->msg_len;
|
2014-03-09 03:23:14 +00:00
|
|
|
packet->page_buf_cnt = init_page_array(rndis_msg, rndis_msg_size,
|
2015-12-02 00:43:13 +00:00
|
|
|
skb, packet, &pb);
|
2014-03-09 03:23:14 +00:00
|
|
|
|
2016-02-18 00:43:59 +00:00
|
|
|
/* timestamp packet in software */
|
|
|
|
skb_tx_timestamp(skb);
|
2015-12-02 00:43:14 +00:00
|
|
|
ret = netvsc_send(net_device_ctx->device_ctx, packet,
|
|
|
|
rndis_msg, &pb, skb);
|
2017-01-24 21:06:12 +00:00
|
|
|
if (likely(ret == 0))
|
2016-08-23 19:17:52 +00:00
|
|
|
return NETDEV_TX_OK;
|
2016-08-23 19:17:57 +00:00
|
|
|
|
|
|
|
if (ret == -EAGAIN) {
|
|
|
|
++net_device_ctx->eth_stats.tx_busy;
|
2016-08-23 19:17:52 +00:00
|
|
|
return NETDEV_TX_BUSY;
|
2016-08-23 19:17:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (ret == -ENOSPC)
|
|
|
|
++net_device_ctx->eth_stats.tx_no_space;
|
2016-08-23 19:17:52 +00:00
|
|
|
|
|
|
|
drop:
|
|
|
|
dev_kfree_skb_any(skb);
|
|
|
|
net->stats.tx_dropped++;
|
2009-07-13 22:34:54 +00:00
|
|
|
|
2016-08-23 19:17:52 +00:00
|
|
|
return NETDEV_TX_OK;
|
2016-08-23 19:17:57 +00:00
|
|
|
|
|
|
|
no_memory:
|
|
|
|
++net_device_ctx->eth_stats.tx_no_memory;
|
|
|
|
goto drop;
|
2009-07-13 22:34:54 +00:00
|
|
|
}
|
2010-03-04 22:11:00 +00:00
|
|
|
/*
|
2009-09-01 04:09:45 +00:00
|
|
|
* netvsc_linkstatus_callback - Link up/down notification
|
|
|
|
*/
|
2011-05-13 02:34:50 +00:00
|
|
|
void netvsc_linkstatus_callback(struct hv_device *device_obj,
|
2014-06-20 01:34:36 +00:00
|
|
|
struct rndis_message *resp)
|
2009-07-13 22:34:54 +00:00
|
|
|
{
|
2014-06-20 01:34:36 +00:00
|
|
|
struct rndis_indicate_status *indicate = &resp->msg.indicate_status;
|
2011-09-13 17:59:49 +00:00
|
|
|
struct net_device *net;
|
2011-04-06 22:18:00 +00:00
|
|
|
struct net_device_context *ndev_ctx;
|
2015-11-27 10:39:55 +00:00
|
|
|
struct netvsc_reconfig *event;
|
|
|
|
unsigned long flags;
|
2014-02-13 00:54:27 +00:00
|
|
|
|
2016-08-04 17:42:15 +00:00
|
|
|
net = hv_get_drvdata(device_obj);
|
|
|
|
|
|
|
|
if (!net)
|
|
|
|
return;
|
|
|
|
|
|
|
|
ndev_ctx = netdev_priv(net);
|
|
|
|
|
|
|
|
/* Update the physical link speed when changing to another vSwitch */
|
|
|
|
if (indicate->status == RNDIS_STATUS_LINK_SPEED_CHANGE) {
|
|
|
|
u32 speed;
|
|
|
|
|
|
|
|
speed = *(u32 *)((void *)indicate + indicate->
|
|
|
|
status_buf_offset) / 10000;
|
|
|
|
ndev_ctx->speed = speed;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Handle these link change statuses below */
|
2015-11-27 10:39:55 +00:00
|
|
|
if (indicate->status != RNDIS_STATUS_NETWORK_CHANGE &&
|
|
|
|
indicate->status != RNDIS_STATUS_MEDIA_CONNECT &&
|
|
|
|
indicate->status != RNDIS_STATUS_MEDIA_DISCONNECT)
|
2014-06-20 01:34:36 +00:00
|
|
|
return;
|
2014-02-13 00:54:27 +00:00
|
|
|
|
2016-08-04 17:42:15 +00:00
|
|
|
if (net->reg_state != NETREG_REGISTERED)
|
2009-07-13 22:34:54 +00:00
|
|
|
return;
|
|
|
|
|
2015-11-27 10:39:55 +00:00
|
|
|
event = kzalloc(sizeof(*event), GFP_ATOMIC);
|
|
|
|
if (!event)
|
|
|
|
return;
|
|
|
|
event->event = indicate->status;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&ndev_ctx->lock, flags);
|
|
|
|
list_add_tail(&event->list, &ndev_ctx->reconfig_events);
|
|
|
|
spin_unlock_irqrestore(&ndev_ctx->lock, flags);
|
|
|
|
|
|
|
|
schedule_delayed_work(&ndev_ctx->dwork, 0);
|
2009-07-13 22:34:54 +00:00
|
|
|
}
|
|
|
|
|
2016-04-14 23:31:54 +00:00
|
|
|
static struct sk_buff *netvsc_alloc_recv_skb(struct net_device *net,
|
2017-02-27 18:26:51 +00:00
|
|
|
struct napi_struct *napi,
|
2017-01-24 21:06:08 +00:00
|
|
|
const struct ndis_tcp_ip_checksum_info *csum_info,
|
|
|
|
const struct ndis_pkt_8021q_info *vlan,
|
|
|
|
void *data, u32 buflen)
|
2009-07-13 22:34:54 +00:00
|
|
|
{
|
|
|
|
struct sk_buff *skb;
|
|
|
|
|
2017-02-27 18:26:51 +00:00
|
|
|
skb = napi_alloc_skb(napi, buflen);
|
2016-04-14 23:31:54 +00:00
|
|
|
if (!skb)
|
|
|
|
return skb;
|
2009-07-13 22:34:54 +00:00
|
|
|
|
2009-09-01 04:09:45 +00:00
|
|
|
/*
|
|
|
|
* Copy to skb. This copy is needed here since the memory pointed by
|
|
|
|
* hv_netvsc_packet cannot be deallocated
|
|
|
|
*/
|
2017-01-24 21:06:08 +00:00
|
|
|
memcpy(skb_put(skb, buflen), data, buflen);
|
2009-07-13 22:34:54 +00:00
|
|
|
|
|
|
|
skb->protocol = eth_type_trans(skb, net);
|
2016-10-24 04:32:47 +00:00
|
|
|
|
|
|
|
/* skb is already created with CHECKSUM_NONE */
|
|
|
|
skb_checksum_none_assert(skb);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* In Linux, the IP checksum is always checked.
|
|
|
|
* Do L4 checksum offload if enabled and present.
|
|
|
|
*/
|
|
|
|
if (csum_info && (net->features & NETIF_F_RXCSUM)) {
|
|
|
|
if (csum_info->receive.tcp_checksum_succeeded ||
|
|
|
|
csum_info->receive.udp_checksum_succeeded)
|
2014-03-09 03:23:16 +00:00
|
|
|
skb->ip_summed = CHECKSUM_UNNECESSARY;
|
|
|
|
}
|
|
|
|
|
2017-01-24 21:06:08 +00:00
|
|
|
if (vlan) {
|
|
|
|
u16 vlan_tci = vlan->vlanid | (vlan->pri << VLAN_PRIO_SHIFT);
|
|
|
|
|
2013-06-17 22:36:49 +00:00
|
|
|
__vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q),
|
2015-12-02 00:43:19 +00:00
|
|
|
vlan_tci);
|
2017-01-24 21:06:08 +00:00
|
|
|
}
|
2009-07-13 22:34:54 +00:00
|
|
|
|
2016-04-14 23:31:54 +00:00
|
|
|
return skb;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* netvsc_recv_callback - Callback when we receive a packet from the
|
|
|
|
* "wire" on the specified device.
|
|
|
|
*/
|
2017-01-24 21:06:08 +00:00
|
|
|
int netvsc_recv_callback(struct net_device *net,
|
|
|
|
struct vmbus_channel *channel,
|
|
|
|
void *data, u32 len,
|
|
|
|
const struct ndis_tcp_ip_checksum_info *csum_info,
|
|
|
|
const struct ndis_pkt_8021q_info *vlan)
|
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(net);
|
2017-03-22 21:51:00 +00:00
|
|
|
struct netvsc_device *net_device;
|
2017-02-27 18:26:50 +00:00
|
|
|
u16 q_idx = channel->offermsg.offer.sub_channel_index;
|
2017-03-22 21:51:00 +00:00
|
|
|
struct netvsc_channel *nvchan;
|
2016-09-22 23:56:33 +00:00
|
|
|
struct net_device *vf_netdev;
|
2016-04-14 23:31:54 +00:00
|
|
|
struct sk_buff *skb;
|
|
|
|
struct netvsc_stats *rx_stats;
|
|
|
|
|
2016-09-22 23:56:34 +00:00
|
|
|
if (net->reg_state != NETREG_REGISTERED)
|
2016-04-14 23:31:54 +00:00
|
|
|
return NVSP_STAT_FAIL;
|
|
|
|
|
2016-09-22 23:56:34 +00:00
|
|
|
/*
|
|
|
|
* If necessary, inject this packet into the VF interface.
|
|
|
|
* On Hyper-V, multicast and brodcast packets are only delivered
|
|
|
|
* to the synthetic interface (after subjecting these to
|
|
|
|
* policy filters on the host). Deliver these via the VF
|
|
|
|
* interface in the guest.
|
|
|
|
*/
|
2017-01-11 17:16:32 +00:00
|
|
|
rcu_read_lock();
|
2017-03-22 21:51:00 +00:00
|
|
|
net_device = rcu_dereference(net_device_ctx->nvdev);
|
|
|
|
if (unlikely(!net_device))
|
|
|
|
goto drop;
|
|
|
|
|
|
|
|
nvchan = &net_device->chan_table[q_idx];
|
2016-09-22 23:56:33 +00:00
|
|
|
vf_netdev = rcu_dereference(net_device_ctx->vf_netdev);
|
2016-09-22 23:56:34 +00:00
|
|
|
if (vf_netdev && (vf_netdev->flags & IFF_UP))
|
|
|
|
net = vf_netdev;
|
2016-04-14 23:31:54 +00:00
|
|
|
|
|
|
|
/* Allocate a skb - TODO direct I/O to pages? */
|
2017-02-27 18:26:51 +00:00
|
|
|
skb = netvsc_alloc_recv_skb(net, &nvchan->napi,
|
|
|
|
csum_info, vlan, data, len);
|
2016-04-14 23:31:54 +00:00
|
|
|
if (unlikely(!skb)) {
|
2017-03-22 21:51:00 +00:00
|
|
|
drop:
|
2016-04-14 23:31:54 +00:00
|
|
|
++net->stats.rx_dropped;
|
2017-01-11 17:16:32 +00:00
|
|
|
rcu_read_unlock();
|
2016-04-14 23:31:54 +00:00
|
|
|
return NVSP_STAT_FAIL;
|
|
|
|
}
|
2014-04-21 17:20:28 +00:00
|
|
|
|
2016-09-22 23:56:34 +00:00
|
|
|
if (net != vf_netdev)
|
2017-01-24 21:06:13 +00:00
|
|
|
skb_record_rx_queue(skb, q_idx);
|
2016-09-22 23:56:34 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Even if injecting the packet, record the statistics
|
|
|
|
* on the synthetic device because modifying the VF device
|
|
|
|
* statistics will not work correctly.
|
|
|
|
*/
|
2017-02-27 18:26:50 +00:00
|
|
|
rx_stats = &nvchan->rx_stats;
|
2015-05-15 09:33:03 +00:00
|
|
|
u64_stats_update_begin(&rx_stats->syncp);
|
2015-05-14 08:00:25 +00:00
|
|
|
rx_stats->packets++;
|
2017-01-24 21:06:08 +00:00
|
|
|
rx_stats->bytes += len;
|
2016-09-22 23:56:35 +00:00
|
|
|
|
|
|
|
if (skb->pkt_type == PACKET_BROADCAST)
|
|
|
|
++rx_stats->broadcast;
|
|
|
|
else if (skb->pkt_type == PACKET_MULTICAST)
|
|
|
|
++rx_stats->multicast;
|
2015-05-15 09:33:03 +00:00
|
|
|
u64_stats_update_end(&rx_stats->syncp);
|
2010-03-10 01:42:17 +00:00
|
|
|
|
2017-02-27 18:26:50 +00:00
|
|
|
napi_gro_receive(&nvchan->napi, skb);
|
2017-01-11 17:16:32 +00:00
|
|
|
rcu_read_unlock();
|
2009-07-13 22:34:54 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-05-04 16:58:57 +00:00
|
|
|
static void netvsc_get_drvinfo(struct net_device *net,
|
|
|
|
struct ethtool_drvinfo *info)
|
|
|
|
{
|
2013-01-06 00:44:26 +00:00
|
|
|
strlcpy(info->driver, KBUILD_MODNAME, sizeof(info->driver));
|
|
|
|
strlcpy(info->fw_version, "N/A", sizeof(info->fw_version));
|
2010-05-04 16:58:57 +00:00
|
|
|
}
|
|
|
|
|
2015-02-27 00:27:14 +00:00
|
|
|
static void netvsc_get_channels(struct net_device *net,
|
|
|
|
struct ethtool_channels *channel)
|
|
|
|
{
|
|
|
|
struct net_device_context *net_device_ctx = netdev_priv(net);
|
2017-03-22 21:51:00 +00:00
|
|
|
struct netvsc_device *nvdev = rtnl_dereference(net_device_ctx->nvdev);
|
2015-02-27 00:27:14 +00:00
|
|
|
|
|
|
|
if (nvdev) {
|
|
|
|
channel->max_combined = nvdev->max_chn;
|
|
|
|
channel->combined_count = nvdev->num_chn;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-01-24 21:06:03 +00:00
|
|
|
static int netvsc_set_queues(struct net_device *net, struct hv_device *dev,
|
|
|
|
u32 num_chn)
|
|
|
|
{
|
|
|
|
struct netvsc_device_info device_info;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
memset(&device_info, 0, sizeof(device_info));
|
|
|
|
device_info.num_chn = num_chn;
|
|
|
|
device_info.ring_size = ring_size;
|
|
|
|
device_info.max_num_vrss_chns = num_chn;
|
|
|
|
|
|
|
|
ret = rndis_filter_device_add(dev, &device_info);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
ret = netif_set_real_num_tx_queues(net, num_chn);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
ret = netif_set_real_num_rx_queues(net, num_chn);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2015-08-12 00:14:32 +00:00
|
|
|
static int netvsc_set_channels(struct net_device *net,
|
|
|
|
struct ethtool_channels *channels)
|
|
|
|
{
|
|
|
|
struct net_device_context *net_device_ctx = netdev_priv(net);
|
|
|
|
struct hv_device *dev = net_device_ctx->device_ctx;
|
2017-03-22 21:51:00 +00:00
|
|
|
struct netvsc_device *nvdev = rtnl_dereference(net_device_ctx->nvdev);
|
2017-01-24 21:06:03 +00:00
|
|
|
unsigned int count = channels->combined_count;
|
2017-03-22 21:50:58 +00:00
|
|
|
bool was_running;
|
2017-01-24 21:06:03 +00:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
/* We do not support separate count for rx, tx, or other */
|
|
|
|
if (count == 0 ||
|
|
|
|
channels->rx_count || channels->tx_count || channels->other_count)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (count > net->num_tx_queues || count > net->num_rx_queues)
|
|
|
|
return -EINVAL;
|
2015-08-12 00:14:32 +00:00
|
|
|
|
2017-03-22 21:51:01 +00:00
|
|
|
if (!nvdev || nvdev->destroy)
|
2015-08-12 00:14:32 +00:00
|
|
|
return -ENODEV;
|
|
|
|
|
2017-01-24 21:06:03 +00:00
|
|
|
if (nvdev->nvsp_version < NVSP_PROTOCOL_VERSION_5)
|
2015-08-12 00:14:32 +00:00
|
|
|
return -EINVAL;
|
|
|
|
|
2017-01-24 21:06:03 +00:00
|
|
|
if (count > nvdev->max_chn)
|
2015-08-12 00:14:32 +00:00
|
|
|
return -EINVAL;
|
|
|
|
|
2017-03-22 21:50:58 +00:00
|
|
|
was_running = netif_running(net);
|
|
|
|
if (was_running) {
|
|
|
|
ret = netvsc_close(net);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
}
|
2015-08-12 00:14:32 +00:00
|
|
|
|
2017-01-24 21:06:10 +00:00
|
|
|
rndis_filter_device_remove(dev, nvdev);
|
2015-08-12 00:14:32 +00:00
|
|
|
|
2017-01-24 21:06:03 +00:00
|
|
|
ret = netvsc_set_queues(net, dev, count);
|
|
|
|
if (ret == 0)
|
|
|
|
nvdev->num_chn = count;
|
|
|
|
else
|
|
|
|
netvsc_set_queues(net, dev, nvdev->num_chn);
|
2015-08-12 00:14:32 +00:00
|
|
|
|
2017-03-22 21:50:58 +00:00
|
|
|
if (was_running)
|
|
|
|
ret = netvsc_open(net);
|
|
|
|
|
2016-05-13 11:55:21 +00:00
|
|
|
/* We may have missed link change notifications */
|
|
|
|
schedule_delayed_work(&net_device_ctx->dwork, 0);
|
2015-08-12 00:14:32 +00:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2017-03-08 22:41:04 +00:00
|
|
|
static bool
|
|
|
|
netvsc_validate_ethtool_ss_cmd(const struct ethtool_link_ksettings *cmd)
|
2016-02-25 23:24:08 +00:00
|
|
|
{
|
2017-03-08 22:41:04 +00:00
|
|
|
struct ethtool_link_ksettings diff1 = *cmd;
|
|
|
|
struct ethtool_link_ksettings diff2 = {};
|
2016-02-25 23:24:08 +00:00
|
|
|
|
2017-03-08 22:41:04 +00:00
|
|
|
diff1.base.speed = 0;
|
|
|
|
diff1.base.duplex = 0;
|
2016-02-25 23:24:08 +00:00
|
|
|
/* advertising and cmd are usually set */
|
2017-03-08 22:41:04 +00:00
|
|
|
ethtool_link_ksettings_zero_link_mode(&diff1, advertising);
|
|
|
|
diff1.base.cmd = 0;
|
2016-02-25 23:24:08 +00:00
|
|
|
/* We set port to PORT_OTHER */
|
2017-03-08 22:41:04 +00:00
|
|
|
diff2.base.port = PORT_OTHER;
|
2016-02-25 23:24:08 +00:00
|
|
|
|
|
|
|
return !memcmp(&diff1, &diff2, sizeof(diff1));
|
|
|
|
}
|
|
|
|
|
|
|
|
static void netvsc_init_settings(struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct net_device_context *ndc = netdev_priv(dev);
|
|
|
|
|
|
|
|
ndc->speed = SPEED_UNKNOWN;
|
2017-04-14 21:42:58 +00:00
|
|
|
ndc->duplex = DUPLEX_FULL;
|
2016-02-25 23:24:08 +00:00
|
|
|
}
|
|
|
|
|
2017-03-08 22:41:04 +00:00
|
|
|
static int netvsc_get_link_ksettings(struct net_device *dev,
|
|
|
|
struct ethtool_link_ksettings *cmd)
|
2016-02-25 23:24:08 +00:00
|
|
|
{
|
|
|
|
struct net_device_context *ndc = netdev_priv(dev);
|
|
|
|
|
2017-03-08 22:41:04 +00:00
|
|
|
cmd->base.speed = ndc->speed;
|
|
|
|
cmd->base.duplex = ndc->duplex;
|
|
|
|
cmd->base.port = PORT_OTHER;
|
2016-02-25 23:24:08 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-03-08 22:41:04 +00:00
|
|
|
static int netvsc_set_link_ksettings(struct net_device *dev,
|
|
|
|
const struct ethtool_link_ksettings *cmd)
|
2016-02-25 23:24:08 +00:00
|
|
|
{
|
|
|
|
struct net_device_context *ndc = netdev_priv(dev);
|
|
|
|
u32 speed;
|
|
|
|
|
2017-03-08 22:41:04 +00:00
|
|
|
speed = cmd->base.speed;
|
2016-02-25 23:24:08 +00:00
|
|
|
if (!ethtool_validate_speed(speed) ||
|
2017-03-08 22:41:04 +00:00
|
|
|
!ethtool_validate_duplex(cmd->base.duplex) ||
|
2016-02-25 23:24:08 +00:00
|
|
|
!netvsc_validate_ethtool_ss_cmd(cmd))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
ndc->speed = speed;
|
2017-03-08 22:41:04 +00:00
|
|
|
ndc->duplex = cmd->base.duplex;
|
2016-02-25 23:24:08 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-12-15 21:45:17 +00:00
|
|
|
static int netvsc_change_mtu(struct net_device *ndev, int mtu)
|
|
|
|
{
|
|
|
|
struct net_device_context *ndevctx = netdev_priv(ndev);
|
2017-03-22 21:51:00 +00:00
|
|
|
struct netvsc_device *nvdev = rtnl_dereference(ndevctx->nvdev);
|
2016-05-13 11:55:22 +00:00
|
|
|
struct hv_device *hdev = ndevctx->device_ctx;
|
2011-12-15 21:45:17 +00:00
|
|
|
struct netvsc_device_info device_info;
|
2017-03-22 21:50:58 +00:00
|
|
|
bool was_running;
|
2017-03-25 03:54:37 +00:00
|
|
|
int ret = 0;
|
2011-12-15 21:45:17 +00:00
|
|
|
|
2017-03-22 21:51:01 +00:00
|
|
|
if (!nvdev || nvdev->destroy)
|
2011-12-15 21:45:17 +00:00
|
|
|
return -ENODEV;
|
|
|
|
|
2017-03-22 21:50:58 +00:00
|
|
|
was_running = netif_running(ndev);
|
|
|
|
if (was_running) {
|
|
|
|
ret = netvsc_close(ndev);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
}
|
2015-07-13 20:09:16 +00:00
|
|
|
|
2017-03-02 13:00:53 +00:00
|
|
|
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;
|
|
|
|
|
2017-01-24 21:06:10 +00:00
|
|
|
rndis_filter_device_remove(hdev, nvdev);
|
2011-12-15 21:45:17 +00:00
|
|
|
|
2017-03-02 13:00:53 +00:00
|
|
|
/* 'nvdev' has been freed in rndis_filter_device_remove() ->
|
|
|
|
* netvsc_device_remove () -> free_netvsc_device().
|
|
|
|
* We mustn't access it before it's re-created in
|
|
|
|
* rndis_filter_device_add() -> netvsc_device_add().
|
|
|
|
*/
|
|
|
|
|
2011-12-15 21:45:17 +00:00
|
|
|
ndev->mtu = mtu;
|
|
|
|
|
|
|
|
rndis_filter_device_add(hdev, &device_info);
|
|
|
|
|
2017-03-22 21:50:58 +00:00
|
|
|
if (was_running)
|
|
|
|
ret = netvsc_open(ndev);
|
|
|
|
|
2016-05-13 11:55:21 +00:00
|
|
|
/* We may have missed link change notifications */
|
|
|
|
schedule_delayed_work(&ndevctx->dwork, 0);
|
|
|
|
|
2015-07-13 20:09:16 +00:00
|
|
|
return ret;
|
2011-12-15 21:45:17 +00:00
|
|
|
}
|
|
|
|
|
2017-01-07 03:12:52 +00:00
|
|
|
static void netvsc_get_stats64(struct net_device *net,
|
|
|
|
struct rtnl_link_stats64 *t)
|
2015-05-14 08:00:25 +00:00
|
|
|
{
|
|
|
|
struct net_device_context *ndev_ctx = netdev_priv(net);
|
2017-04-14 21:42:57 +00:00
|
|
|
struct netvsc_device *nvdev = rcu_dereference_rtnl(ndev_ctx->nvdev);
|
2017-01-24 21:06:13 +00:00
|
|
|
int i;
|
|
|
|
|
|
|
|
if (!nvdev)
|
|
|
|
return;
|
|
|
|
|
|
|
|
for (i = 0; i < nvdev->num_chn; i++) {
|
|
|
|
const struct netvsc_channel *nvchan = &nvdev->chan_table[i];
|
|
|
|
const struct netvsc_stats *stats;
|
|
|
|
u64 packets, bytes, multicast;
|
2015-05-14 08:00:25 +00:00
|
|
|
unsigned int start;
|
|
|
|
|
2017-01-24 21:06:13 +00:00
|
|
|
stats = &nvchan->tx_stats;
|
2015-05-14 08:00:25 +00:00
|
|
|
do {
|
2017-01-24 21:06:13 +00:00
|
|
|
start = u64_stats_fetch_begin_irq(&stats->syncp);
|
|
|
|
packets = stats->packets;
|
|
|
|
bytes = stats->bytes;
|
|
|
|
} while (u64_stats_fetch_retry_irq(&stats->syncp, start));
|
|
|
|
|
|
|
|
t->tx_bytes += bytes;
|
|
|
|
t->tx_packets += packets;
|
2015-05-14 08:00:25 +00:00
|
|
|
|
2017-01-24 21:06:13 +00:00
|
|
|
stats = &nvchan->rx_stats;
|
2015-05-14 08:00:25 +00:00
|
|
|
do {
|
2017-01-24 21:06:13 +00:00
|
|
|
start = u64_stats_fetch_begin_irq(&stats->syncp);
|
|
|
|
packets = stats->packets;
|
|
|
|
bytes = stats->bytes;
|
|
|
|
multicast = stats->multicast + stats->broadcast;
|
|
|
|
} while (u64_stats_fetch_retry_irq(&stats->syncp, start));
|
|
|
|
|
|
|
|
t->rx_bytes += bytes;
|
|
|
|
t->rx_packets += packets;
|
|
|
|
t->multicast += multicast;
|
2015-05-14 08:00:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
t->tx_dropped = net->stats.tx_dropped;
|
2017-02-17 19:36:20 +00:00
|
|
|
t->tx_errors = net->stats.tx_errors;
|
2015-05-14 08:00:25 +00:00
|
|
|
|
|
|
|
t->rx_dropped = net->stats.rx_dropped;
|
|
|
|
t->rx_errors = net->stats.rx_errors;
|
|
|
|
}
|
2012-07-10 07:19:22 +00:00
|
|
|
|
|
|
|
static int netvsc_set_mac_addr(struct net_device *ndev, void *p)
|
|
|
|
{
|
|
|
|
struct sockaddr *addr = p;
|
2013-01-18 16:52:09 +00:00
|
|
|
char save_adr[ETH_ALEN];
|
2012-07-10 07:19:22 +00:00
|
|
|
unsigned char save_aatype;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
memcpy(save_adr, ndev->dev_addr, ETH_ALEN);
|
|
|
|
save_aatype = ndev->addr_assign_type;
|
|
|
|
|
|
|
|
err = eth_mac_addr(ndev, p);
|
|
|
|
if (err != 0)
|
|
|
|
return err;
|
|
|
|
|
2016-06-03 15:51:01 +00:00
|
|
|
err = rndis_filter_set_device_mac(ndev, addr->sa_data);
|
2012-07-10 07:19:22 +00:00
|
|
|
if (err != 0) {
|
|
|
|
/* roll back to saved MAC */
|
|
|
|
memcpy(ndev->dev_addr, save_adr, ETH_ALEN);
|
|
|
|
ndev->addr_assign_type = save_aatype;
|
|
|
|
}
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2016-08-23 19:17:57 +00:00
|
|
|
static const struct {
|
|
|
|
char name[ETH_GSTRING_LEN];
|
|
|
|
u16 offset;
|
|
|
|
} netvsc_stats[] = {
|
|
|
|
{ "tx_scattered", offsetof(struct netvsc_ethtool_stats, tx_scattered) },
|
|
|
|
{ "tx_no_memory", offsetof(struct netvsc_ethtool_stats, tx_no_memory) },
|
|
|
|
{ "tx_no_space", offsetof(struct netvsc_ethtool_stats, tx_no_space) },
|
|
|
|
{ "tx_too_big", offsetof(struct netvsc_ethtool_stats, tx_too_big) },
|
|
|
|
{ "tx_busy", offsetof(struct netvsc_ethtool_stats, tx_busy) },
|
|
|
|
};
|
|
|
|
|
2017-01-24 21:06:13 +00:00
|
|
|
#define NETVSC_GLOBAL_STATS_LEN ARRAY_SIZE(netvsc_stats)
|
|
|
|
|
|
|
|
/* 4 statistics per queue (rx/tx packets/bytes) */
|
|
|
|
#define NETVSC_QUEUE_STATS_LEN(dev) ((dev)->num_chn * 4)
|
|
|
|
|
2016-08-23 19:17:57 +00:00
|
|
|
static int netvsc_get_sset_count(struct net_device *dev, int string_set)
|
|
|
|
{
|
2017-01-24 21:06:13 +00:00
|
|
|
struct net_device_context *ndc = netdev_priv(dev);
|
2017-03-22 21:51:00 +00:00
|
|
|
struct netvsc_device *nvdev = rcu_dereference(ndc->nvdev);
|
|
|
|
|
|
|
|
if (!nvdev)
|
|
|
|
return -ENODEV;
|
2017-01-24 21:06:13 +00:00
|
|
|
|
2016-08-23 19:17:57 +00:00
|
|
|
switch (string_set) {
|
|
|
|
case ETH_SS_STATS:
|
2017-01-24 21:06:13 +00:00
|
|
|
return NETVSC_GLOBAL_STATS_LEN + NETVSC_QUEUE_STATS_LEN(nvdev);
|
2016-08-23 19:17:57 +00:00
|
|
|
default:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void netvsc_get_ethtool_stats(struct net_device *dev,
|
|
|
|
struct ethtool_stats *stats, u64 *data)
|
|
|
|
{
|
|
|
|
struct net_device_context *ndc = netdev_priv(dev);
|
2017-03-22 21:51:00 +00:00
|
|
|
struct netvsc_device *nvdev = rcu_dereference(ndc->nvdev);
|
2016-08-23 19:17:57 +00:00
|
|
|
const void *nds = &ndc->eth_stats;
|
2017-01-24 21:06:13 +00:00
|
|
|
const struct netvsc_stats *qstats;
|
|
|
|
unsigned int start;
|
|
|
|
u64 packets, bytes;
|
|
|
|
int i, j;
|
2016-08-23 19:17:57 +00:00
|
|
|
|
2017-03-22 21:51:00 +00:00
|
|
|
if (!nvdev)
|
|
|
|
return;
|
|
|
|
|
2017-01-24 21:06:13 +00:00
|
|
|
for (i = 0; i < NETVSC_GLOBAL_STATS_LEN; i++)
|
2016-08-23 19:17:57 +00:00
|
|
|
data[i] = *(unsigned long *)(nds + netvsc_stats[i].offset);
|
2017-01-24 21:06:13 +00:00
|
|
|
|
|
|
|
for (j = 0; j < nvdev->num_chn; j++) {
|
|
|
|
qstats = &nvdev->chan_table[j].tx_stats;
|
|
|
|
|
|
|
|
do {
|
|
|
|
start = u64_stats_fetch_begin_irq(&qstats->syncp);
|
|
|
|
packets = qstats->packets;
|
|
|
|
bytes = qstats->bytes;
|
|
|
|
} while (u64_stats_fetch_retry_irq(&qstats->syncp, start));
|
|
|
|
data[i++] = packets;
|
|
|
|
data[i++] = bytes;
|
|
|
|
|
|
|
|
qstats = &nvdev->chan_table[j].rx_stats;
|
|
|
|
do {
|
|
|
|
start = u64_stats_fetch_begin_irq(&qstats->syncp);
|
|
|
|
packets = qstats->packets;
|
|
|
|
bytes = qstats->bytes;
|
|
|
|
} while (u64_stats_fetch_retry_irq(&qstats->syncp, start));
|
|
|
|
data[i++] = packets;
|
|
|
|
data[i++] = bytes;
|
|
|
|
}
|
2016-08-23 19:17:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void netvsc_get_strings(struct net_device *dev, u32 stringset, u8 *data)
|
|
|
|
{
|
2017-01-24 21:06:13 +00:00
|
|
|
struct net_device_context *ndc = netdev_priv(dev);
|
2017-03-22 21:51:00 +00:00
|
|
|
struct netvsc_device *nvdev = rcu_dereference(ndc->nvdev);
|
2017-01-24 21:06:13 +00:00
|
|
|
u8 *p = data;
|
2016-08-23 19:17:57 +00:00
|
|
|
int i;
|
|
|
|
|
2017-03-22 21:51:00 +00:00
|
|
|
if (!nvdev)
|
|
|
|
return;
|
|
|
|
|
2016-08-23 19:17:57 +00:00
|
|
|
switch (stringset) {
|
|
|
|
case ETH_SS_STATS:
|
|
|
|
for (i = 0; i < ARRAY_SIZE(netvsc_stats); i++)
|
2017-01-24 21:06:13 +00:00
|
|
|
memcpy(p + i * ETH_GSTRING_LEN,
|
2016-08-23 19:17:57 +00:00
|
|
|
netvsc_stats[i].name, ETH_GSTRING_LEN);
|
2017-01-24 21:06:13 +00:00
|
|
|
|
|
|
|
p += i * ETH_GSTRING_LEN;
|
|
|
|
for (i = 0; i < nvdev->num_chn; i++) {
|
|
|
|
sprintf(p, "tx_queue_%u_packets", i);
|
|
|
|
p += ETH_GSTRING_LEN;
|
|
|
|
sprintf(p, "tx_queue_%u_bytes", i);
|
|
|
|
p += ETH_GSTRING_LEN;
|
|
|
|
sprintf(p, "rx_queue_%u_packets", i);
|
|
|
|
p += ETH_GSTRING_LEN;
|
|
|
|
sprintf(p, "rx_queue_%u_bytes", i);
|
|
|
|
p += ETH_GSTRING_LEN;
|
|
|
|
}
|
|
|
|
|
2016-08-23 19:17:57 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-01-24 21:06:01 +00:00
|
|
|
static int
|
|
|
|
netvsc_get_rss_hash_opts(struct netvsc_device *nvdev,
|
|
|
|
struct ethtool_rxnfc *info)
|
|
|
|
{
|
|
|
|
info->data = RXH_IP_SRC | RXH_IP_DST;
|
|
|
|
|
|
|
|
switch (info->flow_type) {
|
|
|
|
case TCP_V4_FLOW:
|
|
|
|
case TCP_V6_FLOW:
|
|
|
|
info->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3;
|
|
|
|
/* fallthrough */
|
|
|
|
case UDP_V4_FLOW:
|
|
|
|
case UDP_V6_FLOW:
|
|
|
|
case IPV4_FLOW:
|
|
|
|
case IPV6_FLOW:
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
info->data = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-01-24 21:06:00 +00:00
|
|
|
static int
|
|
|
|
netvsc_get_rxnfc(struct net_device *dev, struct ethtool_rxnfc *info,
|
|
|
|
u32 *rules)
|
|
|
|
{
|
|
|
|
struct net_device_context *ndc = netdev_priv(dev);
|
2017-03-22 21:51:00 +00:00
|
|
|
struct netvsc_device *nvdev = rcu_dereference(ndc->nvdev);
|
|
|
|
|
|
|
|
if (!nvdev)
|
|
|
|
return -ENODEV;
|
2017-01-24 21:06:00 +00:00
|
|
|
|
|
|
|
switch (info->cmd) {
|
|
|
|
case ETHTOOL_GRXRINGS:
|
|
|
|
info->data = nvdev->num_chn;
|
|
|
|
return 0;
|
2017-01-24 21:06:01 +00:00
|
|
|
|
|
|
|
case ETHTOOL_GRXFH:
|
|
|
|
return netvsc_get_rss_hash_opts(nvdev, info);
|
2017-01-24 21:06:00 +00:00
|
|
|
}
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
}
|
|
|
|
|
2014-07-09 14:23:59 +00:00
|
|
|
#ifdef CONFIG_NET_POLL_CONTROLLER
|
|
|
|
static void netvsc_poll_controller(struct net_device *net)
|
|
|
|
{
|
|
|
|
/* As netvsc_start_xmit() works synchronous we don't have to
|
|
|
|
* trigger anything here.
|
|
|
|
*/
|
|
|
|
}
|
|
|
|
#endif
|
2012-07-10 07:19:22 +00:00
|
|
|
|
2017-01-24 21:06:02 +00:00
|
|
|
static u32 netvsc_get_rxfh_key_size(struct net_device *dev)
|
|
|
|
{
|
|
|
|
return NETVSC_HASH_KEYLEN;
|
|
|
|
}
|
|
|
|
|
|
|
|
static u32 netvsc_rss_indir_size(struct net_device *dev)
|
|
|
|
{
|
2017-01-24 21:06:04 +00:00
|
|
|
return ITAB_NUM;
|
2017-01-24 21:06:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int netvsc_get_rxfh(struct net_device *dev, u32 *indir, u8 *key,
|
|
|
|
u8 *hfunc)
|
|
|
|
{
|
|
|
|
struct net_device_context *ndc = netdev_priv(dev);
|
2017-03-22 21:51:00 +00:00
|
|
|
struct netvsc_device *ndev = rcu_dereference(ndc->nvdev);
|
2017-03-25 14:26:39 +00:00
|
|
|
struct rndis_device *rndis_dev;
|
2017-01-24 21:06:04 +00:00
|
|
|
int i;
|
2017-01-24 21:06:02 +00:00
|
|
|
|
2017-03-22 21:51:00 +00:00
|
|
|
if (!ndev)
|
|
|
|
return -ENODEV;
|
|
|
|
|
2017-01-24 21:06:02 +00:00
|
|
|
if (hfunc)
|
|
|
|
*hfunc = ETH_RSS_HASH_TOP; /* Toeplitz */
|
|
|
|
|
2017-03-25 14:26:39 +00:00
|
|
|
rndis_dev = ndev->extension;
|
2017-01-24 21:06:04 +00:00
|
|
|
if (indir) {
|
|
|
|
for (i = 0; i < ITAB_NUM; i++)
|
|
|
|
indir[i] = rndis_dev->ind_table[i];
|
|
|
|
}
|
|
|
|
|
2017-01-24 21:06:02 +00:00
|
|
|
if (key)
|
|
|
|
memcpy(key, rndis_dev->rss_key, NETVSC_HASH_KEYLEN);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
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);
|
2017-03-22 21:51:00 +00:00
|
|
|
struct netvsc_device *ndev = rtnl_dereference(ndc->nvdev);
|
2017-03-25 14:26:39 +00:00
|
|
|
struct rndis_device *rndis_dev;
|
2017-01-24 21:06:04 +00:00
|
|
|
int i;
|
2017-01-24 21:06:02 +00:00
|
|
|
|
2017-03-22 21:51:00 +00:00
|
|
|
if (!ndev)
|
|
|
|
return -ENODEV;
|
|
|
|
|
2017-01-24 21:06:02 +00:00
|
|
|
if (hfunc != ETH_RSS_HASH_NO_CHANGE && hfunc != ETH_RSS_HASH_TOP)
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
2017-03-25 14:26:39 +00:00
|
|
|
rndis_dev = ndev->extension;
|
2017-01-24 21:06:04 +00:00
|
|
|
if (indir) {
|
|
|
|
for (i = 0; i < ITAB_NUM; i++)
|
|
|
|
if (indir[i] >= dev->num_rx_queues)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
for (i = 0; i < ITAB_NUM; i++)
|
|
|
|
rndis_dev->ind_table[i] = indir[i];
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!key) {
|
|
|
|
if (!indir)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
key = rndis_dev->rss_key;
|
|
|
|
}
|
2017-01-24 21:06:02 +00:00
|
|
|
|
|
|
|
return rndis_filter_set_rss_param(rndis_dev, key, ndev->num_chn);
|
|
|
|
}
|
|
|
|
|
2010-05-04 16:58:57 +00:00
|
|
|
static const struct ethtool_ops ethtool_ops = {
|
|
|
|
.get_drvinfo = netvsc_get_drvinfo,
|
|
|
|
.get_link = ethtool_op_get_link,
|
2016-08-23 19:17:57 +00:00
|
|
|
.get_ethtool_stats = netvsc_get_ethtool_stats,
|
|
|
|
.get_sset_count = netvsc_get_sset_count,
|
|
|
|
.get_strings = netvsc_get_strings,
|
2015-02-27 00:27:14 +00:00
|
|
|
.get_channels = netvsc_get_channels,
|
2015-08-12 00:14:32 +00:00
|
|
|
.set_channels = netvsc_set_channels,
|
2016-02-18 00:43:59 +00:00
|
|
|
.get_ts_info = ethtool_op_get_ts_info,
|
2017-01-24 21:06:00 +00:00
|
|
|
.get_rxnfc = netvsc_get_rxnfc,
|
2017-01-24 21:06:02 +00:00
|
|
|
.get_rxfh_key_size = netvsc_get_rxfh_key_size,
|
|
|
|
.get_rxfh_indir_size = netvsc_rss_indir_size,
|
|
|
|
.get_rxfh = netvsc_get_rxfh,
|
|
|
|
.set_rxfh = netvsc_set_rxfh,
|
2017-03-08 22:41:04 +00:00
|
|
|
.get_link_ksettings = netvsc_get_link_ksettings,
|
|
|
|
.set_link_ksettings = netvsc_set_link_ksettings,
|
2010-05-04 16:58:57 +00:00
|
|
|
};
|
|
|
|
|
2009-09-01 04:11:12 +00:00
|
|
|
static const struct net_device_ops device_ops = {
|
|
|
|
.ndo_open = netvsc_open,
|
|
|
|
.ndo_stop = netvsc_close,
|
|
|
|
.ndo_start_xmit = netvsc_start_xmit,
|
2011-08-16 06:29:01 +00:00
|
|
|
.ndo_set_rx_mode = netvsc_set_multicast_list,
|
2011-12-15 21:45:17 +00:00
|
|
|
.ndo_change_mtu = netvsc_change_mtu,
|
2010-08-03 19:15:31 +00:00
|
|
|
.ndo_validate_addr = eth_validate_addr,
|
2012-07-10 07:19:22 +00:00
|
|
|
.ndo_set_mac_address = netvsc_set_mac_addr,
|
2014-04-21 17:20:28 +00:00
|
|
|
.ndo_select_queue = netvsc_select_queue,
|
2015-05-14 08:00:25 +00:00
|
|
|
.ndo_get_stats64 = netvsc_get_stats64,
|
2014-07-09 14:23:59 +00:00
|
|
|
#ifdef CONFIG_NET_POLL_CONTROLLER
|
|
|
|
.ndo_poll_controller = netvsc_poll_controller,
|
|
|
|
#endif
|
2009-09-01 04:11:12 +00:00
|
|
|
};
|
|
|
|
|
2011-04-06 22:18:00 +00:00
|
|
|
/*
|
2015-11-27 10:39:55 +00:00
|
|
|
* Handle link status changes. For RNDIS_STATUS_NETWORK_CHANGE emulate link
|
|
|
|
* down/up sequence. In case of RNDIS_STATUS_MEDIA_CONNECT when carrier is
|
|
|
|
* present send GARP packet to network peers with netif_notify_peers().
|
2011-04-06 22:18:00 +00:00
|
|
|
*/
|
2014-02-13 00:54:27 +00:00
|
|
|
static void netvsc_link_change(struct work_struct *w)
|
2011-04-06 22:18:00 +00:00
|
|
|
{
|
2016-05-13 11:55:23 +00:00
|
|
|
struct net_device_context *ndev_ctx =
|
|
|
|
container_of(w, struct net_device_context, dwork.work);
|
|
|
|
struct hv_device *device_obj = ndev_ctx->device_ctx;
|
|
|
|
struct net_device *net = hv_get_drvdata(device_obj);
|
2011-09-13 17:59:49 +00:00
|
|
|
struct netvsc_device *net_device;
|
2014-02-13 00:54:27 +00:00
|
|
|
struct rndis_device *rdev;
|
2015-11-27 10:39:55 +00:00
|
|
|
struct netvsc_reconfig *event = NULL;
|
|
|
|
bool notify = false, reschedule = false;
|
|
|
|
unsigned long flags, next_reconfig, delay;
|
2011-04-06 22:18:00 +00:00
|
|
|
|
2016-05-13 11:55:21 +00:00
|
|
|
rtnl_lock();
|
2017-03-22 21:51:01 +00:00
|
|
|
net_device = rtnl_dereference(ndev_ctx->nvdev);
|
|
|
|
if (!net_device)
|
2016-05-13 11:55:21 +00:00
|
|
|
goto out_unlock;
|
|
|
|
|
2014-02-13 00:54:27 +00:00
|
|
|
rdev = net_device->extension;
|
|
|
|
|
2015-11-27 10:39:55 +00:00
|
|
|
next_reconfig = ndev_ctx->last_reconfig + LINKCHANGE_INT;
|
|
|
|
if (time_is_after_jiffies(next_reconfig)) {
|
|
|
|
/* link_watch only sends one notification with current state
|
|
|
|
* per second, avoid doing reconfig more frequently. Handle
|
|
|
|
* wrap around.
|
|
|
|
*/
|
|
|
|
delay = next_reconfig - jiffies;
|
|
|
|
delay = delay < LINKCHANGE_INT ? delay : LINKCHANGE_INT;
|
|
|
|
schedule_delayed_work(&ndev_ctx->dwork, delay);
|
2016-05-13 11:55:21 +00:00
|
|
|
goto out_unlock;
|
2015-11-27 10:39:55 +00:00
|
|
|
}
|
|
|
|
ndev_ctx->last_reconfig = jiffies;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&ndev_ctx->lock, flags);
|
|
|
|
if (!list_empty(&ndev_ctx->reconfig_events)) {
|
|
|
|
event = list_first_entry(&ndev_ctx->reconfig_events,
|
|
|
|
struct netvsc_reconfig, list);
|
|
|
|
list_del(&event->list);
|
|
|
|
reschedule = !list_empty(&ndev_ctx->reconfig_events);
|
|
|
|
}
|
|
|
|
spin_unlock_irqrestore(&ndev_ctx->lock, flags);
|
|
|
|
|
|
|
|
if (!event)
|
2016-05-13 11:55:21 +00:00
|
|
|
goto out_unlock;
|
2015-11-27 10:39:55 +00:00
|
|
|
|
|
|
|
switch (event->event) {
|
|
|
|
/* Only the following events are possible due to the check in
|
|
|
|
* netvsc_linkstatus_callback()
|
|
|
|
*/
|
|
|
|
case RNDIS_STATUS_MEDIA_CONNECT:
|
|
|
|
if (rdev->link_state) {
|
|
|
|
rdev->link_state = false;
|
|
|
|
netif_carrier_on(net);
|
|
|
|
netif_tx_wake_all_queues(net);
|
|
|
|
} else {
|
|
|
|
notify = true;
|
|
|
|
}
|
|
|
|
kfree(event);
|
|
|
|
break;
|
|
|
|
case RNDIS_STATUS_MEDIA_DISCONNECT:
|
|
|
|
if (!rdev->link_state) {
|
|
|
|
rdev->link_state = true;
|
|
|
|
netif_carrier_off(net);
|
|
|
|
netif_tx_stop_all_queues(net);
|
|
|
|
}
|
|
|
|
kfree(event);
|
|
|
|
break;
|
|
|
|
case RNDIS_STATUS_NETWORK_CHANGE:
|
|
|
|
/* Only makes sense if carrier is present */
|
|
|
|
if (!rdev->link_state) {
|
|
|
|
rdev->link_state = true;
|
|
|
|
netif_carrier_off(net);
|
|
|
|
netif_tx_stop_all_queues(net);
|
|
|
|
event->event = RNDIS_STATUS_MEDIA_CONNECT;
|
|
|
|
spin_lock_irqsave(&ndev_ctx->lock, flags);
|
2016-04-21 23:13:01 +00:00
|
|
|
list_add(&event->list, &ndev_ctx->reconfig_events);
|
2015-11-27 10:39:55 +00:00
|
|
|
spin_unlock_irqrestore(&ndev_ctx->lock, flags);
|
|
|
|
reschedule = true;
|
2014-06-20 01:34:36 +00:00
|
|
|
}
|
2015-11-27 10:39:55 +00:00
|
|
|
break;
|
2014-02-13 00:54:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
rtnl_unlock();
|
|
|
|
|
|
|
|
if (notify)
|
|
|
|
netdev_notify_peers(net);
|
2015-11-27 10:39:55 +00:00
|
|
|
|
|
|
|
/* link_watch only sends one notification with current state per
|
|
|
|
* second, handle next reconfig event in 2 seconds.
|
|
|
|
*/
|
|
|
|
if (reschedule)
|
|
|
|
schedule_delayed_work(&ndev_ctx->dwork, LINKCHANGE_INT);
|
2016-05-13 11:55:21 +00:00
|
|
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
out_unlock:
|
|
|
|
rtnl_unlock();
|
2011-04-06 22:18:00 +00:00
|
|
|
}
|
|
|
|
|
2016-09-22 23:56:32 +00:00
|
|
|
static struct net_device *get_netvsc_bymac(const u8 *mac)
|
2016-04-14 23:31:54 +00:00
|
|
|
{
|
2016-09-22 23:56:32 +00:00
|
|
|
struct net_device *dev;
|
2016-04-14 23:31:54 +00:00
|
|
|
|
2016-08-23 19:17:44 +00:00
|
|
|
ASSERT_RTNL();
|
2016-04-14 23:31:54 +00:00
|
|
|
|
|
|
|
for_each_netdev(&init_net, dev) {
|
2016-09-22 23:56:32 +00:00
|
|
|
if (dev->netdev_ops != &device_ops)
|
|
|
|
continue; /* not a netvsc device */
|
|
|
|
|
|
|
|
if (ether_addr_equal(mac, dev->perm_addr))
|
|
|
|
return dev;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2016-09-22 23:56:33 +00:00
|
|
|
static struct net_device *get_netvsc_byref(struct net_device *vf_netdev)
|
2016-09-22 23:56:32 +00:00
|
|
|
{
|
|
|
|
struct net_device *dev;
|
|
|
|
|
|
|
|
ASSERT_RTNL();
|
|
|
|
|
|
|
|
for_each_netdev(&init_net, dev) {
|
|
|
|
struct net_device_context *net_device_ctx;
|
|
|
|
|
|
|
|
if (dev->netdev_ops != &device_ops)
|
|
|
|
continue; /* not a netvsc device */
|
|
|
|
|
|
|
|
net_device_ctx = netdev_priv(dev);
|
|
|
|
if (net_device_ctx->nvdev == NULL)
|
|
|
|
continue; /* device is removed */
|
|
|
|
|
2016-09-22 23:56:33 +00:00
|
|
|
if (rtnl_dereference(net_device_ctx->vf_netdev) == vf_netdev)
|
2016-09-22 23:56:32 +00:00
|
|
|
return dev; /* a match */
|
2016-04-14 23:31:54 +00:00
|
|
|
}
|
|
|
|
|
2016-09-22 23:56:32 +00:00
|
|
|
return NULL;
|
2016-04-14 23:31:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int netvsc_register_vf(struct net_device *vf_netdev)
|
|
|
|
{
|
2016-05-13 11:55:23 +00:00
|
|
|
struct net_device *ndev;
|
|
|
|
struct net_device_context *net_device_ctx;
|
2016-04-14 23:31:54 +00:00
|
|
|
struct netvsc_device *netvsc_dev;
|
|
|
|
|
2016-09-22 23:56:32 +00:00
|
|
|
if (vf_netdev->addr_len != ETH_ALEN)
|
|
|
|
return NOTIFY_DONE;
|
|
|
|
|
2016-04-14 23:31:54 +00:00
|
|
|
/*
|
|
|
|
* We will use the MAC address to locate the synthetic interface to
|
|
|
|
* associate with the VF interface. If we don't find a matching
|
|
|
|
* synthetic interface, move on.
|
|
|
|
*/
|
2016-09-22 23:56:32 +00:00
|
|
|
ndev = get_netvsc_bymac(vf_netdev->perm_addr);
|
2016-05-13 11:55:23 +00:00
|
|
|
if (!ndev)
|
|
|
|
return NOTIFY_DONE;
|
|
|
|
|
|
|
|
net_device_ctx = netdev_priv(ndev);
|
2017-03-22 21:51:00 +00:00
|
|
|
netvsc_dev = rtnl_dereference(net_device_ctx->nvdev);
|
2016-09-22 23:56:33 +00:00
|
|
|
if (!netvsc_dev || rtnl_dereference(net_device_ctx->vf_netdev))
|
2016-04-14 23:31:54 +00:00
|
|
|
return NOTIFY_DONE;
|
|
|
|
|
2016-05-13 11:55:23 +00:00
|
|
|
netdev_info(ndev, "VF registering: %s\n", vf_netdev->name);
|
2016-04-14 23:31:54 +00:00
|
|
|
/*
|
|
|
|
* Take a reference on the module.
|
|
|
|
*/
|
|
|
|
try_module_get(THIS_MODULE);
|
2016-09-22 23:56:30 +00:00
|
|
|
|
|
|
|
dev_hold(vf_netdev);
|
2016-09-22 23:56:33 +00:00
|
|
|
rcu_assign_pointer(net_device_ctx->vf_netdev, vf_netdev);
|
2016-04-14 23:31:54 +00:00
|
|
|
return NOTIFY_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int netvsc_vf_up(struct net_device *vf_netdev)
|
|
|
|
{
|
2016-05-13 11:55:23 +00:00
|
|
|
struct net_device *ndev;
|
2016-04-14 23:31:54 +00:00
|
|
|
struct netvsc_device *netvsc_dev;
|
|
|
|
struct net_device_context *net_device_ctx;
|
|
|
|
|
2016-09-22 23:56:32 +00:00
|
|
|
ndev = get_netvsc_byref(vf_netdev);
|
2016-05-13 11:55:23 +00:00
|
|
|
if (!ndev)
|
|
|
|
return NOTIFY_DONE;
|
|
|
|
|
|
|
|
net_device_ctx = netdev_priv(ndev);
|
2017-03-22 21:51:00 +00:00
|
|
|
netvsc_dev = rtnl_dereference(net_device_ctx->nvdev);
|
2016-04-14 23:31:54 +00:00
|
|
|
|
2016-05-13 11:55:23 +00:00
|
|
|
netdev_info(ndev, "VF up: %s\n", vf_netdev->name);
|
2016-04-14 23:31:54 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Open the device before switching data path.
|
|
|
|
*/
|
2016-06-03 15:51:00 +00:00
|
|
|
rndis_filter_open(netvsc_dev);
|
2016-04-14 23:31:54 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* notify the host to switch the data path.
|
|
|
|
*/
|
2016-05-13 11:55:23 +00:00
|
|
|
netvsc_switch_datapath(ndev, true);
|
|
|
|
netdev_info(ndev, "Data path switched to VF: %s\n", vf_netdev->name);
|
2016-04-14 23:31:54 +00:00
|
|
|
|
2016-05-13 11:55:23 +00:00
|
|
|
netif_carrier_off(ndev);
|
2016-04-14 23:31:54 +00:00
|
|
|
|
2016-08-15 15:48:40 +00:00
|
|
|
/* Now notify peers through VF device. */
|
|
|
|
call_netdevice_notifiers(NETDEV_NOTIFY_PEERS, vf_netdev);
|
2016-04-14 23:31:54 +00:00
|
|
|
|
|
|
|
return NOTIFY_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int netvsc_vf_down(struct net_device *vf_netdev)
|
|
|
|
{
|
2016-05-13 11:55:23 +00:00
|
|
|
struct net_device *ndev;
|
2016-04-14 23:31:54 +00:00
|
|
|
struct netvsc_device *netvsc_dev;
|
|
|
|
struct net_device_context *net_device_ctx;
|
|
|
|
|
2016-09-22 23:56:32 +00:00
|
|
|
ndev = get_netvsc_byref(vf_netdev);
|
2016-05-13 11:55:23 +00:00
|
|
|
if (!ndev)
|
|
|
|
return NOTIFY_DONE;
|
|
|
|
|
|
|
|
net_device_ctx = netdev_priv(ndev);
|
2017-03-22 21:51:00 +00:00
|
|
|
netvsc_dev = rtnl_dereference(net_device_ctx->nvdev);
|
2016-04-14 23:31:54 +00:00
|
|
|
|
2016-05-13 11:55:23 +00:00
|
|
|
netdev_info(ndev, "VF down: %s\n", vf_netdev->name);
|
|
|
|
netvsc_switch_datapath(ndev, false);
|
|
|
|
netdev_info(ndev, "Data path switched from VF: %s\n", vf_netdev->name);
|
2016-06-03 15:51:00 +00:00
|
|
|
rndis_filter_close(netvsc_dev);
|
2016-05-13 11:55:23 +00:00
|
|
|
netif_carrier_on(ndev);
|
2016-08-15 15:48:40 +00:00
|
|
|
|
|
|
|
/* Now notify peers through netvsc device. */
|
|
|
|
call_netdevice_notifiers(NETDEV_NOTIFY_PEERS, ndev);
|
2016-04-14 23:31:54 +00:00
|
|
|
|
|
|
|
return NOTIFY_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int netvsc_unregister_vf(struct net_device *vf_netdev)
|
|
|
|
{
|
2016-05-13 11:55:23 +00:00
|
|
|
struct net_device *ndev;
|
|
|
|
struct net_device_context *net_device_ctx;
|
2016-04-14 23:31:54 +00:00
|
|
|
|
2016-09-22 23:56:32 +00:00
|
|
|
ndev = get_netvsc_byref(vf_netdev);
|
2016-05-13 11:55:23 +00:00
|
|
|
if (!ndev)
|
|
|
|
return NOTIFY_DONE;
|
|
|
|
|
|
|
|
net_device_ctx = netdev_priv(ndev);
|
2016-09-22 23:56:32 +00:00
|
|
|
|
2016-05-13 11:55:23 +00:00
|
|
|
netdev_info(ndev, "VF unregistering: %s\n", vf_netdev->name);
|
2016-09-22 23:56:33 +00:00
|
|
|
|
|
|
|
RCU_INIT_POINTER(net_device_ctx->vf_netdev, NULL);
|
2016-09-22 23:56:30 +00:00
|
|
|
dev_put(vf_netdev);
|
2016-04-14 23:31:54 +00:00
|
|
|
module_put(THIS_MODULE);
|
|
|
|
return NOTIFY_OK;
|
|
|
|
}
|
|
|
|
|
2011-09-13 17:59:38 +00:00
|
|
|
static int netvsc_probe(struct hv_device *dev,
|
|
|
|
const struct hv_vmbus_device_id *dev_id)
|
2009-09-01 04:11:12 +00:00
|
|
|
{
|
|
|
|
struct net_device *net = NULL;
|
|
|
|
struct net_device_context *net_device_ctx;
|
|
|
|
struct netvsc_device_info device_info;
|
2014-04-21 17:20:28 +00:00
|
|
|
struct netvsc_device *nvdev;
|
2009-09-01 04:11:12 +00:00
|
|
|
int ret;
|
|
|
|
|
2014-04-21 17:20:28 +00:00
|
|
|
net = alloc_etherdev_mq(sizeof(struct net_device_context),
|
2017-01-24 21:06:03 +00:00
|
|
|
VRSS_CHANNEL_MAX);
|
2009-09-01 04:11:12 +00:00
|
|
|
if (!net)
|
2011-08-25 16:49:11 +00:00
|
|
|
return -ENOMEM;
|
2009-09-01 04:11:12 +00:00
|
|
|
|
2014-03-04 22:11:06 +00:00
|
|
|
netif_carrier_off(net);
|
|
|
|
|
2016-08-04 17:42:14 +00:00
|
|
|
netvsc_init_settings(net);
|
|
|
|
|
2009-09-01 04:11:12 +00:00
|
|
|
net_device_ctx = netdev_priv(net);
|
2011-04-29 20:45:10 +00:00
|
|
|
net_device_ctx->device_ctx = dev;
|
2015-04-28 08:05:17 +00:00
|
|
|
net_device_ctx->msg_enable = netif_msg_init(debug, default_msg);
|
|
|
|
if (netif_msg_probe(net_device_ctx))
|
|
|
|
netdev_dbg(net, "netvsc msg_enable: %d\n",
|
|
|
|
net_device_ctx->msg_enable);
|
|
|
|
|
2011-09-13 17:59:49 +00:00
|
|
|
hv_set_drvdata(dev, net);
|
2016-05-13 11:55:20 +00:00
|
|
|
|
2014-02-13 00:54:27 +00:00
|
|
|
INIT_DELAYED_WORK(&net_device_ctx->dwork, netvsc_link_change);
|
2012-04-19 00:39:37 +00:00
|
|
|
INIT_WORK(&net_device_ctx->work, do_set_multicast);
|
2009-09-01 04:11:12 +00:00
|
|
|
|
2015-11-27 10:39:55 +00:00
|
|
|
spin_lock_init(&net_device_ctx->lock);
|
|
|
|
INIT_LIST_HEAD(&net_device_ctx->reconfig_events);
|
|
|
|
|
2009-09-01 04:11:12 +00:00
|
|
|
net->netdev_ops = &device_ops;
|
2014-05-11 00:12:32 +00:00
|
|
|
net->ethtool_ops = ðtool_ops;
|
2011-04-29 20:45:10 +00:00
|
|
|
SET_NETDEV_DEV(net, &dev->device);
|
2009-09-01 04:11:12 +00:00
|
|
|
|
2016-02-05 16:29:08 +00:00
|
|
|
/* We always need headroom for rndis header */
|
|
|
|
net->needed_headroom = RNDIS_AND_PPI_SIZE;
|
|
|
|
|
2011-09-01 19:19:43 +00:00
|
|
|
/* Notify the netvsc driver of the new device */
|
2015-08-12 00:14:31 +00:00
|
|
|
memset(&device_info, 0, sizeof(device_info));
|
2011-09-01 19:19:43 +00:00
|
|
|
device_info.ring_size = ring_size;
|
2017-03-22 21:50:59 +00:00
|
|
|
device_info.num_chn = VRSS_CHANNEL_DEFAULT;
|
2011-09-01 19:19:43 +00:00
|
|
|
ret = rndis_filter_device_add(dev, &device_info);
|
|
|
|
if (ret != 0) {
|
|
|
|
netdev_err(net, "unable to add netvsc device (ret %d)\n", ret);
|
2017-01-24 21:06:13 +00:00
|
|
|
free_netdev(net);
|
2011-09-13 17:59:49 +00:00
|
|
|
hv_set_drvdata(dev, NULL);
|
2011-09-01 19:19:43 +00:00
|
|
|
return ret;
|
2009-09-01 04:11:12 +00:00
|
|
|
}
|
2011-09-01 19:19:43 +00:00
|
|
|
memcpy(net->dev_addr, device_info.mac_adr, ETH_ALEN);
|
|
|
|
|
2017-01-24 21:05:59 +00:00
|
|
|
/* hw_features computed in rndis_filter_device_add */
|
|
|
|
net->features = net->hw_features |
|
|
|
|
NETIF_F_HIGHDMA | NETIF_F_SG |
|
|
|
|
NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_HW_VLAN_CTAG_RX;
|
|
|
|
net->vlan_features = net->features;
|
|
|
|
|
2017-03-22 21:51:00 +00:00
|
|
|
/* RCU not necessary here, device not registered */
|
2016-05-13 11:55:22 +00:00
|
|
|
nvdev = net_device_ctx->nvdev;
|
2014-04-21 17:20:28 +00:00
|
|
|
netif_set_real_num_tx_queues(net, nvdev->num_chn);
|
|
|
|
netif_set_real_num_rx_queues(net, nvdev->num_chn);
|
|
|
|
|
2016-10-20 17:55:21 +00:00
|
|
|
/* MTU range: 68 - 1500 or 65521 */
|
|
|
|
net->min_mtu = NETVSC_MTU_MIN;
|
|
|
|
if (nvdev->nvsp_version >= NVSP_PROTOCOL_VERSION_2)
|
|
|
|
net->max_mtu = NETVSC_MTU - ETH_HLEN;
|
|
|
|
else
|
|
|
|
net->max_mtu = ETH_DATA_LEN;
|
|
|
|
|
2013-12-21 00:52:31 +00:00
|
|
|
ret = register_netdev(net);
|
|
|
|
if (ret != 0) {
|
|
|
|
pr_err("Unable to register netdev.\n");
|
2017-01-24 21:06:10 +00:00
|
|
|
rndis_filter_device_remove(dev, nvdev);
|
2017-01-24 21:06:13 +00:00
|
|
|
free_netdev(net);
|
2013-12-21 00:52:31 +00:00
|
|
|
}
|
|
|
|
|
2009-09-01 04:11:12 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2011-04-29 20:45:12 +00:00
|
|
|
static int netvsc_remove(struct hv_device *dev)
|
2009-09-01 04:11:12 +00:00
|
|
|
{
|
2011-09-13 17:59:49 +00:00
|
|
|
struct net_device *net;
|
2011-05-27 13:21:55 +00:00
|
|
|
struct net_device_context *ndev_ctx;
|
2011-09-13 17:59:49 +00:00
|
|
|
|
2016-05-13 11:55:22 +00:00
|
|
|
net = hv_get_drvdata(dev);
|
2009-09-01 04:11:12 +00:00
|
|
|
|
|
|
|
if (net == NULL) {
|
2011-04-29 20:45:12 +00:00
|
|
|
dev_err(&dev->device, "No net device to remove\n");
|
2009-09-01 04:11:12 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-05-27 13:21:55 +00:00
|
|
|
ndev_ctx = netdev_priv(net);
|
2016-05-13 11:55:22 +00:00
|
|
|
|
2017-03-22 21:51:01 +00:00
|
|
|
netif_device_detach(net);
|
2016-05-13 11:55:20 +00:00
|
|
|
|
2011-05-27 13:21:55 +00:00
|
|
|
cancel_delayed_work_sync(&ndev_ctx->dwork);
|
2012-04-19 00:39:37 +00:00
|
|
|
cancel_work_sync(&ndev_ctx->work);
|
2011-05-27 13:21:55 +00:00
|
|
|
|
2009-09-01 04:11:12 +00:00
|
|
|
/*
|
|
|
|
* Call to the vsc driver to let it know that the device is being
|
2017-03-22 21:51:01 +00:00
|
|
|
* removed. Also blocks mtu and channel changes.
|
2009-09-01 04:11:12 +00:00
|
|
|
*/
|
2017-03-22 21:51:01 +00:00
|
|
|
rtnl_lock();
|
2017-01-24 21:06:10 +00:00
|
|
|
rndis_filter_device_remove(dev, ndev_ctx->nvdev);
|
2017-03-22 21:51:01 +00:00
|
|
|
rtnl_unlock();
|
|
|
|
|
|
|
|
unregister_netdev(net);
|
2009-09-01 04:11:12 +00:00
|
|
|
|
2016-05-13 11:55:22 +00:00
|
|
|
hv_set_drvdata(dev, NULL);
|
|
|
|
|
2017-01-24 21:06:13 +00:00
|
|
|
free_netdev(net);
|
2011-05-23 16:03:47 +00:00
|
|
|
return 0;
|
2009-09-01 04:11:12 +00:00
|
|
|
}
|
|
|
|
|
2011-08-25 16:48:34 +00:00
|
|
|
static const struct hv_vmbus_device_id id_table[] = {
|
2011-08-25 18:41:33 +00:00
|
|
|
/* Network guid */
|
2013-01-24 01:42:42 +00:00
|
|
|
{ HV_NIC_GUID, },
|
2011-08-25 18:41:33 +00:00
|
|
|
{ },
|
2011-08-25 16:48:34 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
MODULE_DEVICE_TABLE(vmbus, id_table);
|
|
|
|
|
2011-05-10 14:55:16 +00:00
|
|
|
/* The one and only one */
|
2011-05-13 02:35:08 +00:00
|
|
|
static struct hv_driver netvsc_drv = {
|
2012-03-07 10:02:00 +00:00
|
|
|
.name = KBUILD_MODNAME,
|
2011-08-25 16:48:34 +00:00
|
|
|
.id_table = id_table,
|
2011-05-13 02:35:08 +00:00
|
|
|
.probe = netvsc_probe,
|
|
|
|
.remove = netvsc_remove,
|
2011-05-10 14:55:17 +00:00
|
|
|
};
|
2011-05-10 14:55:16 +00:00
|
|
|
|
2016-04-14 23:31:54 +00:00
|
|
|
/*
|
|
|
|
* On Hyper-V, every VF interface is matched with a corresponding
|
|
|
|
* synthetic interface. The synthetic interface is presented first
|
|
|
|
* to the guest. When the corresponding VF instance is registered,
|
|
|
|
* we will take care of switching the data path.
|
|
|
|
*/
|
|
|
|
static int netvsc_netdev_event(struct notifier_block *this,
|
|
|
|
unsigned long event, void *ptr)
|
|
|
|
{
|
|
|
|
struct net_device *event_dev = netdev_notifier_info_to_dev(ptr);
|
|
|
|
|
2016-09-22 23:56:31 +00:00
|
|
|
/* Skip our own events */
|
|
|
|
if (event_dev->netdev_ops == &device_ops)
|
|
|
|
return NOTIFY_DONE;
|
|
|
|
|
|
|
|
/* Avoid non-Ethernet type devices */
|
|
|
|
if (event_dev->type != ARPHRD_ETHER)
|
|
|
|
return NOTIFY_DONE;
|
|
|
|
|
2016-08-15 15:48:43 +00:00
|
|
|
/* Avoid Vlan dev with same MAC registering as VF */
|
2017-02-04 17:00:49 +00:00
|
|
|
if (is_vlan_dev(event_dev))
|
2016-08-15 15:48:43 +00:00
|
|
|
return NOTIFY_DONE;
|
|
|
|
|
|
|
|
/* Avoid Bonding master dev with same MAC registering as VF */
|
2016-09-22 23:56:31 +00:00
|
|
|
if ((event_dev->priv_flags & IFF_BONDING) &&
|
|
|
|
(event_dev->flags & IFF_MASTER))
|
2016-06-02 19:02:04 +00:00
|
|
|
return NOTIFY_DONE;
|
|
|
|
|
2016-04-14 23:31:54 +00:00
|
|
|
switch (event) {
|
|
|
|
case NETDEV_REGISTER:
|
|
|
|
return netvsc_register_vf(event_dev);
|
|
|
|
case NETDEV_UNREGISTER:
|
|
|
|
return netvsc_unregister_vf(event_dev);
|
|
|
|
case NETDEV_UP:
|
|
|
|
return netvsc_vf_up(event_dev);
|
|
|
|
case NETDEV_DOWN:
|
|
|
|
return netvsc_vf_down(event_dev);
|
|
|
|
default:
|
|
|
|
return NOTIFY_DONE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct notifier_block netvsc_netdev_notifier = {
|
|
|
|
.notifier_call = netvsc_netdev_event,
|
|
|
|
};
|
|
|
|
|
2011-05-13 02:35:17 +00:00
|
|
|
static void __exit netvsc_drv_exit(void)
|
2009-07-13 22:34:54 +00:00
|
|
|
{
|
2016-04-14 23:31:54 +00:00
|
|
|
unregister_netdevice_notifier(&netvsc_netdev_notifier);
|
2011-08-25 22:07:32 +00:00
|
|
|
vmbus_driver_unregister(&netvsc_drv);
|
2009-07-13 22:34:54 +00:00
|
|
|
}
|
|
|
|
|
2011-05-13 02:35:16 +00:00
|
|
|
static int __init netvsc_drv_init(void)
|
2009-09-01 04:11:12 +00:00
|
|
|
{
|
2016-04-14 23:31:54 +00:00
|
|
|
int ret;
|
|
|
|
|
2012-07-25 08:08:41 +00:00
|
|
|
if (ring_size < RING_SIZE_MIN) {
|
|
|
|
ring_size = RING_SIZE_MIN;
|
|
|
|
pr_info("Increased ring_size to %d (min allowed)\n",
|
|
|
|
ring_size);
|
|
|
|
}
|
2016-04-14 23:31:54 +00:00
|
|
|
ret = vmbus_driver_register(&netvsc_drv);
|
|
|
|
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
register_netdevice_notifier(&netvsc_netdev_notifier);
|
|
|
|
return 0;
|
2009-09-01 04:11:12 +00:00
|
|
|
}
|
|
|
|
|
2010-02-11 23:02:42 +00:00
|
|
|
MODULE_LICENSE("GPL");
|
2010-05-04 16:58:52 +00:00
|
|
|
MODULE_DESCRIPTION("Microsoft Hyper-V network driver");
|
2009-07-13 22:34:54 +00:00
|
|
|
|
2011-05-13 02:35:16 +00:00
|
|
|
module_init(netvsc_drv_init);
|
2011-05-13 02:35:17 +00:00
|
|
|
module_exit(netvsc_drv_exit);
|