blob: 1de3ef5dd5d2ac0fdf57d963d19b32689753b424 [file] [log] [blame]
Hank Janssenfceaf242009-07-13 15:34:54 -07001/*
Hank Janssenfceaf242009-07-13 15:34:54 -07002 * Copyright (c) 2009, Microsoft Corporation.
3 *
4 * This program is free software; you can redistribute it and/or modify it
5 * under the terms and conditions of the GNU General Public License,
6 * version 2, as published by the Free Software Foundation.
7 *
8 * This program is distributed in the hope it will be useful, but WITHOUT
9 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
11 * more details.
12 *
13 * You should have received a copy of the GNU General Public License along with
Jeff Kirsheradf8d3f2013-12-06 06:28:47 -080014 * this program; if not, see <http://www.gnu.org/licenses/>.
Hank Janssenfceaf242009-07-13 15:34:54 -070015 *
16 * Authors:
Haiyang Zhangd0e94d12009-11-23 17:00:22 +000017 * Haiyang Zhang <haiyangz@microsoft.com>
Hank Janssenfceaf242009-07-13 15:34:54 -070018 * Hank Janssen <hjanssen@microsoft.com>
Hank Janssenfceaf242009-07-13 15:34:54 -070019 */
Hank Jansseneb335bc2011-03-29 13:58:48 -070020#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
21
Hank Janssenfceaf242009-07-13 15:34:54 -070022#include <linux/init.h>
K. Y. Srinivasan9079ce62011-06-16 13:16:37 -070023#include <linux/atomic.h>
Hank Janssenfceaf242009-07-13 15:34:54 -070024#include <linux/module.h>
25#include <linux/highmem.h>
26#include <linux/device.h>
Hank Janssenfceaf242009-07-13 15:34:54 -070027#include <linux/io.h>
Hank Janssenfceaf242009-07-13 15:34:54 -070028#include <linux/delay.h>
29#include <linux/netdevice.h>
30#include <linux/inetdevice.h>
31#include <linux/etherdevice.h>
32#include <linux/skbuff.h>
Haiyang Zhangc802db12013-05-28 06:15:56 +000033#include <linux/if_vlan.h>
Hank Janssenfceaf242009-07-13 15:34:54 -070034#include <linux/in.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090035#include <linux/slab.h>
Hank Janssenfceaf242009-07-13 15:34:54 -070036#include <net/arp.h>
37#include <net/route.h>
38#include <net/sock.h>
39#include <net/pkt_sched.h>
K. Y. Srinivasan3f335ea2011-05-12 19:34:15 -070040
K. Y. Srinivasan5ca72522011-05-12 19:34:37 -070041#include "hyperv_net.h"
Hank Janssenfceaf242009-07-13 15:34:54 -070042
Hank Janssenfceaf242009-07-13 15:34:54 -070043struct net_device_context {
Greg Kroah-Hartman02fafbc2009-08-31 21:09:45 -070044 /* point back to our device context */
K. Y. Srinivasan6bad88da2011-03-07 13:35:48 -080045 struct hv_device *device_ctx;
Haiyang Zhang122a5f62011-05-27 06:21:55 -070046 struct delayed_work dwork;
Wenqi Ma792df872012-04-19 00:39:37 +000047 struct work_struct work;
Hank Janssenfceaf242009-07-13 15:34:54 -070048};
49
Haiyang Zhangfa85a6c2012-07-25 08:08:41 +000050#define RING_SIZE_MIN 64
Hank Janssen99c8da02010-10-12 10:45:23 -070051static int ring_size = 128;
Stephen Hemminger450d7a42010-05-04 09:58:53 -070052module_param(ring_size, int, S_IRUGO);
53MODULE_PARM_DESC(ring_size, "Ring buffer size (# of pages)");
Hank Janssenfceaf242009-07-13 15:34:54 -070054
Haiyang Zhangd426b2e2011-11-30 07:19:08 -080055static void do_set_multicast(struct work_struct *w)
56{
Wenqi Ma792df872012-04-19 00:39:37 +000057 struct net_device_context *ndevctx =
58 container_of(w, struct net_device_context, work);
Haiyang Zhangd426b2e2011-11-30 07:19:08 -080059 struct netvsc_device *nvdev;
60 struct rndis_device *rdev;
61
62 nvdev = hv_get_drvdata(ndevctx->device_ctx);
Wenqi Ma792df872012-04-19 00:39:37 +000063 if (nvdev == NULL || nvdev->ndev == NULL)
64 return;
Haiyang Zhangd426b2e2011-11-30 07:19:08 -080065
66 rdev = nvdev->extension;
67 if (rdev == NULL)
Wenqi Ma792df872012-04-19 00:39:37 +000068 return;
Haiyang Zhangd426b2e2011-11-30 07:19:08 -080069
Wenqi Ma792df872012-04-19 00:39:37 +000070 if (nvdev->ndev->flags & IFF_PROMISC)
Haiyang Zhangd426b2e2011-11-30 07:19:08 -080071 rndis_filter_set_packet_filter(rdev,
72 NDIS_PACKET_TYPE_PROMISCUOUS);
73 else
74 rndis_filter_set_packet_filter(rdev,
75 NDIS_PACKET_TYPE_BROADCAST |
76 NDIS_PACKET_TYPE_ALL_MULTICAST |
77 NDIS_PACKET_TYPE_DIRECTED);
Haiyang Zhangd426b2e2011-11-30 07:19:08 -080078}
79
Greg Kroah-Hartman4e9bfef2009-07-15 12:45:20 -070080static void netvsc_set_multicast_list(struct net_device *net)
Hank Janssenfceaf242009-07-13 15:34:54 -070081{
Wenqi Ma792df872012-04-19 00:39:37 +000082 struct net_device_context *net_device_ctx = netdev_priv(net);
Haiyang Zhangd426b2e2011-11-30 07:19:08 -080083
Wenqi Ma792df872012-04-19 00:39:37 +000084 schedule_work(&net_device_ctx->work);
Hank Janssenfceaf242009-07-13 15:34:54 -070085}
86
Hank Janssenfceaf242009-07-13 15:34:54 -070087static int netvsc_open(struct net_device *net)
88{
Hank Janssenfceaf242009-07-13 15:34:54 -070089 struct net_device_context *net_device_ctx = netdev_priv(net);
K. Y. Srinivasan6bad88da2011-03-07 13:35:48 -080090 struct hv_device *device_obj = net_device_ctx->device_ctx;
Haiyang Zhang891de742014-02-12 16:54:27 -080091 struct netvsc_device *nvdev;
92 struct rndis_device *rdev;
Greg Kroah-Hartman02fafbc2009-08-31 21:09:45 -070093 int ret = 0;
Hank Janssenfceaf242009-07-13 15:34:54 -070094
Haiyang Zhang891de742014-02-12 16:54:27 -080095 netif_carrier_off(net);
96
Haiyang Zhangd515d0f2011-09-28 13:24:15 -070097 /* Open up the device */
98 ret = rndis_filter_open(device_obj);
99 if (ret != 0) {
100 netdev_err(net, "unable to open device (ret %d).\n", ret);
101 return ret;
Hank Janssenfceaf242009-07-13 15:34:54 -0700102 }
103
Haiyang Zhang5b54dac2014-04-21 10:20:28 -0700104 netif_tx_start_all_queues(net);
Haiyang Zhangd515d0f2011-09-28 13:24:15 -0700105
Haiyang Zhang891de742014-02-12 16:54:27 -0800106 nvdev = hv_get_drvdata(device_obj);
107 rdev = nvdev->extension;
108 if (!rdev->link_state)
109 netif_carrier_on(net);
110
Hank Janssenfceaf242009-07-13 15:34:54 -0700111 return ret;
112}
113
Hank Janssenfceaf242009-07-13 15:34:54 -0700114static int netvsc_close(struct net_device *net)
115{
Hank Janssenfceaf242009-07-13 15:34:54 -0700116 struct net_device_context *net_device_ctx = netdev_priv(net);
K. Y. Srinivasan6bad88da2011-03-07 13:35:48 -0800117 struct hv_device *device_obj = net_device_ctx->device_ctx;
Greg Kroah-Hartman02fafbc2009-08-31 21:09:45 -0700118 int ret;
Hank Janssenfceaf242009-07-13 15:34:54 -0700119
Haiyang Zhang0a282532012-02-02 07:17:59 +0000120 netif_tx_disable(net);
Hank Janssenfceaf242009-07-13 15:34:54 -0700121
Wenqi Ma792df872012-04-19 00:39:37 +0000122 /* Make sure netvsc_set_multicast_list doesn't re-enable filter! */
123 cancel_work_sync(&net_device_ctx->work);
Haiyang Zhang9c26aa02010-12-10 12:03:57 -0800124 ret = rndis_filter_close(device_obj);
Hank Janssenfceaf242009-07-13 15:34:54 -0700125 if (ret != 0)
Hank Jansseneb335bc2011-03-29 13:58:48 -0700126 netdev_err(net, "unable to close device (ret %d).\n", ret);
Hank Janssenfceaf242009-07-13 15:34:54 -0700127
Hank Janssenfceaf242009-07-13 15:34:54 -0700128 return ret;
129}
130
KY Srinivasan8a002512014-03-08 19:23:14 -0800131static void *init_ppi_data(struct rndis_message *msg, u32 ppi_size,
132 int pkt_type)
133{
134 struct rndis_packet *rndis_pkt;
135 struct rndis_per_packet_info *ppi;
136
137 rndis_pkt = &msg->msg.pkt;
138 rndis_pkt->data_offset += ppi_size;
139
140 ppi = (struct rndis_per_packet_info *)((void *)rndis_pkt +
141 rndis_pkt->per_pkt_info_offset + rndis_pkt->per_pkt_info_len);
142
143 ppi->size = ppi_size;
144 ppi->type = pkt_type;
145 ppi->ppi_offset = sizeof(struct rndis_per_packet_info);
146
147 rndis_pkt->per_pkt_info_len += ppi_size;
148
149 return ppi;
150}
151
Haiyang Zhang5b54dac2014-04-21 10:20:28 -0700152union sub_key {
153 u64 k;
154 struct {
155 u8 pad[3];
156 u8 kb;
157 u32 ka;
158 };
159};
160
161/* Toeplitz hash function
162 * data: network byte order
163 * return: host byte order
164 */
165static u32 comp_hash(u8 *key, int klen, u8 *data, int dlen)
166{
167 union sub_key subk;
168 int k_next = 4;
169 u8 dt;
170 int i, j;
171 u32 ret = 0;
172
173 subk.k = 0;
174 subk.ka = ntohl(*(u32 *)key);
175
176 for (i = 0; i < dlen; i++) {
177 subk.kb = key[k_next];
178 k_next = (k_next + 1) % klen;
179 dt = data[i];
180 for (j = 0; j < 8; j++) {
181 if (dt & 0x80)
182 ret ^= subk.ka;
183 dt <<= 1;
184 subk.k <<= 1;
185 }
186 }
187
188 return ret;
189}
190
191static bool netvsc_set_hash(u32 *hash, struct sk_buff *skb)
192{
193 struct iphdr *iphdr;
194 int data_len;
195 bool ret = false;
196
197 if (eth_hdr(skb)->h_proto != htons(ETH_P_IP))
198 return false;
199
200 iphdr = ip_hdr(skb);
201
202 if (iphdr->version == 4) {
203 if (iphdr->protocol == IPPROTO_TCP)
204 data_len = 12;
205 else
206 data_len = 8;
207 *hash = comp_hash(netvsc_hash_key, HASH_KEYLEN,
208 (u8 *)&iphdr->saddr, data_len);
209 ret = true;
210 }
211
212 return ret;
213}
214
215static u16 netvsc_select_queue(struct net_device *ndev, struct sk_buff *skb,
216 void *accel_priv, select_queue_fallback_t fallback)
217{
218 struct net_device_context *net_device_ctx = netdev_priv(ndev);
219 struct hv_device *hdev = net_device_ctx->device_ctx;
220 struct netvsc_device *nvsc_dev = hv_get_drvdata(hdev);
221 u32 hash;
222 u16 q_idx = 0;
223
224 if (nvsc_dev == NULL || ndev->real_num_tx_queues <= 1)
225 return 0;
226
227 if (netvsc_set_hash(&hash, skb))
228 q_idx = nvsc_dev->send_table[hash % VRSS_SEND_TAB_SIZE] %
229 ndev->real_num_tx_queues;
230
231 return q_idx;
232}
233
Hank Janssenfceaf242009-07-13 15:34:54 -0700234static void netvsc_xmit_completion(void *context)
235{
Nicolas Palix4193d4f2009-07-29 14:10:10 +0200236 struct hv_netvsc_packet *packet = (struct hv_netvsc_packet *)context;
Greg Kroah-Hartman02fafbc2009-08-31 21:09:45 -0700237 struct sk_buff *skb = (struct sk_buff *)
Haiyang Zhang893f6622014-04-21 14:54:44 -0700238 (unsigned long)packet->send_completion_tid;
KY Srinivasanc25aaf82014-04-30 10:14:31 -0700239 u32 index = packet->send_buf_index;
Hank Janssenfceaf242009-07-13 15:34:54 -0700240
Hank Janssenfceaf242009-07-13 15:34:54 -0700241 kfree(packet);
242
KY Srinivasanc25aaf82014-04-30 10:14:31 -0700243 if (skb && (index == NETVSC_INVALID_INDEX))
Hank Janssenfceaf242009-07-13 15:34:54 -0700244 dev_kfree_skb_any(skb);
Hank Janssenfceaf242009-07-13 15:34:54 -0700245}
246
KY Srinivasan54a73572014-03-08 19:23:13 -0800247static u32 fill_pg_buf(struct page *page, u32 offset, u32 len,
248 struct hv_page_buffer *pb)
249{
250 int j = 0;
251
252 /* Deal with compund pages by ignoring unused part
253 * of the page.
254 */
255 page += (offset >> PAGE_SHIFT);
256 offset &= ~PAGE_MASK;
257
258 while (len > 0) {
259 unsigned long bytes;
260
261 bytes = PAGE_SIZE - offset;
262 if (bytes > len)
263 bytes = len;
264 pb[j].pfn = page_to_pfn(page);
265 pb[j].offset = offset;
266 pb[j].len = bytes;
267
268 offset += bytes;
269 len -= bytes;
270
271 if (offset == PAGE_SIZE && len) {
272 page++;
273 offset = 0;
274 j++;
275 }
276 }
277
278 return j + 1;
279}
280
KY Srinivasan8a002512014-03-08 19:23:14 -0800281static u32 init_page_array(void *hdr, u32 len, struct sk_buff *skb,
282 struct hv_page_buffer *pb)
KY Srinivasan54a73572014-03-08 19:23:13 -0800283{
284 u32 slots_used = 0;
285 char *data = skb->data;
286 int frags = skb_shinfo(skb)->nr_frags;
287 int i;
288
289 /* The packet is laid out thus:
290 * 1. hdr
291 * 2. skb linear data
292 * 3. skb fragment data
293 */
294 if (hdr != NULL)
295 slots_used += fill_pg_buf(virt_to_page(hdr),
296 offset_in_page(hdr),
297 len, &pb[slots_used]);
298
299 slots_used += fill_pg_buf(virt_to_page(data),
300 offset_in_page(data),
301 skb_headlen(skb), &pb[slots_used]);
302
303 for (i = 0; i < frags; i++) {
304 skb_frag_t *frag = skb_shinfo(skb)->frags + i;
305
306 slots_used += fill_pg_buf(skb_frag_page(frag),
307 frag->page_offset,
308 skb_frag_size(frag), &pb[slots_used]);
309 }
KY Srinivasan8a002512014-03-08 19:23:14 -0800310 return slots_used;
KY Srinivasan54a73572014-03-08 19:23:13 -0800311}
312
313static int count_skb_frag_slots(struct sk_buff *skb)
314{
315 int i, frags = skb_shinfo(skb)->nr_frags;
316 int pages = 0;
317
318 for (i = 0; i < frags; i++) {
319 skb_frag_t *frag = skb_shinfo(skb)->frags + i;
320 unsigned long size = skb_frag_size(frag);
321 unsigned long offset = frag->page_offset;
322
323 /* Skip unused frames from start of page */
324 offset &= ~PAGE_MASK;
325 pages += PFN_UP(offset + size);
326 }
327 return pages;
328}
329
330static int netvsc_get_slots(struct sk_buff *skb)
331{
332 char *data = skb->data;
333 unsigned int offset = offset_in_page(data);
334 unsigned int len = skb_headlen(skb);
335 int slots;
336 int frag_slots;
337
338 slots = DIV_ROUND_UP(offset + len, PAGE_SIZE);
339 frag_slots = count_skb_frag_slots(skb);
340 return slots + frag_slots;
341}
342
KY Srinivasan08cd04b2014-03-08 19:23:17 -0800343static u32 get_net_transport_info(struct sk_buff *skb, u32 *trans_off)
344{
345 u32 ret_val = TRANSPORT_INFO_NOT_IP;
346
347 if ((eth_hdr(skb)->h_proto != htons(ETH_P_IP)) &&
348 (eth_hdr(skb)->h_proto != htons(ETH_P_IPV6))) {
349 goto not_ip;
350 }
351
352 *trans_off = skb_transport_offset(skb);
353
354 if ((eth_hdr(skb)->h_proto == htons(ETH_P_IP))) {
355 struct iphdr *iphdr = ip_hdr(skb);
356
357 if (iphdr->protocol == IPPROTO_TCP)
358 ret_val = TRANSPORT_INFO_IPV4_TCP;
359 else if (iphdr->protocol == IPPROTO_UDP)
360 ret_val = TRANSPORT_INFO_IPV4_UDP;
361 } else {
362 if (ipv6_hdr(skb)->nexthdr == IPPROTO_TCP)
363 ret_val = TRANSPORT_INFO_IPV6_TCP;
364 else if (ipv6_hdr(skb)->nexthdr == IPPROTO_UDP)
365 ret_val = TRANSPORT_INFO_IPV6_UDP;
366 }
367
368not_ip:
369 return ret_val;
370}
371
Greg Kroah-Hartman02fafbc2009-08-31 21:09:45 -0700372static int netvsc_start_xmit(struct sk_buff *skb, struct net_device *net)
Hank Janssenfceaf242009-07-13 15:34:54 -0700373{
Hank Janssenfceaf242009-07-13 15:34:54 -0700374 struct net_device_context *net_device_ctx = netdev_priv(net);
Nicolas Palix4193d4f2009-07-29 14:10:10 +0200375 struct hv_netvsc_packet *packet;
Greg Kroah-Hartman02fafbc2009-08-31 21:09:45 -0700376 int ret;
KY Srinivasan8a002512014-03-08 19:23:14 -0800377 unsigned int num_data_pgs;
378 struct rndis_message *rndis_msg;
379 struct rndis_packet *rndis_pkt;
380 u32 rndis_msg_size;
381 bool isvlan;
382 struct rndis_per_packet_info *ppi;
KY Srinivasan08cd04b2014-03-08 19:23:17 -0800383 struct ndis_tcp_ip_checksum_info *csum_info;
KY Srinivasan77bf5482014-03-08 19:23:18 -0800384 struct ndis_tcp_lso_info *lso_info;
KY Srinivasan08cd04b2014-03-08 19:23:17 -0800385 int hdr_offset;
386 u32 net_trans_info;
387
Hank Janssenfceaf242009-07-13 15:34:54 -0700388
KY Srinivasan54a73572014-03-08 19:23:13 -0800389 /* We will atmost need two pages to describe the rndis
390 * header. We can only transmit MAX_PAGE_BUFFER_COUNT number
391 * of pages in a single packet.
392 */
KY Srinivasan8a002512014-03-08 19:23:14 -0800393 num_data_pgs = netvsc_get_slots(skb) + 2;
394 if (num_data_pgs > MAX_PAGE_BUFFER_COUNT) {
KY Srinivasan54a73572014-03-08 19:23:13 -0800395 netdev_err(net, "Packet too big: %u\n", skb->len);
396 dev_kfree_skb(skb);
397 net->stats.tx_dropped++;
398 return NETDEV_TX_OK;
399 }
Hank Janssenfceaf242009-07-13 15:34:54 -0700400
Bill Pemberton454f18a2009-07-27 16:47:24 -0400401 /* Allocate a netvsc packet based on # of frags. */
Greg Kroah-Hartman02fafbc2009-08-31 21:09:45 -0700402 packet = kzalloc(sizeof(struct hv_netvsc_packet) +
KY Srinivasan8a002512014-03-08 19:23:14 -0800403 (num_data_pgs * sizeof(struct hv_page_buffer)) +
KY Srinivasan86eedac2014-02-16 16:38:43 -0800404 sizeof(struct rndis_message) +
KY Srinivasan42763722014-04-09 15:00:45 -0700405 NDIS_VLAN_PPI_SIZE +
406 NDIS_CSUM_PPI_SIZE +
407 NDIS_LSO_PPI_SIZE, GFP_ATOMIC);
Greg Kroah-Hartman02fafbc2009-08-31 21:09:45 -0700408 if (!packet) {
Haiyang Zhangbf769372011-09-01 12:19:46 -0700409 /* out of memory, drop packet */
Hank Jansseneb335bc2011-03-29 13:58:48 -0700410 netdev_err(net, "unable to allocate hv_netvsc_packet\n");
Stephen Hemmingerb220f5f2010-05-04 09:58:56 -0700411
412 dev_kfree_skb(skb);
413 net->stats.tx_dropped++;
Eric Dumazetbb6d5e72012-03-14 08:53:34 +0000414 return NETDEV_TX_OK;
Hank Janssenfceaf242009-07-13 15:34:54 -0700415 }
416
Haiyang Zhang1f5f3a72012-03-12 10:20:50 +0000417 packet->vlan_tci = skb->vlan_tci;
418
Haiyang Zhang5b54dac2014-04-21 10:20:28 -0700419 packet->q_idx = skb_get_queue_mapping(skb);
420
KY Srinivasan8a002512014-03-08 19:23:14 -0800421 packet->is_data_pkt = true;
Haiyang Zhang4d447c92011-12-15 13:45:17 -0800422 packet->total_data_buflen = skb->len;
Hank Janssenfceaf242009-07-13 15:34:54 -0700423
KY Srinivasan8a002512014-03-08 19:23:14 -0800424 packet->rndis_msg = (struct rndis_message *)((unsigned long)packet +
425 sizeof(struct hv_netvsc_packet) +
426 (num_data_pgs * sizeof(struct hv_page_buffer)));
Hank Janssenfceaf242009-07-13 15:34:54 -0700427
Bill Pemberton454f18a2009-07-27 16:47:24 -0400428 /* Set the completion routine */
Haiyang Zhang893f6622014-04-21 14:54:44 -0700429 packet->send_completion = netvsc_xmit_completion;
430 packet->send_completion_ctx = packet;
431 packet->send_completion_tid = (unsigned long)skb;
Hank Janssenfceaf242009-07-13 15:34:54 -0700432
KY Srinivasan8a002512014-03-08 19:23:14 -0800433 isvlan = packet->vlan_tci & VLAN_TAG_PRESENT;
434
435 /* Add the rndis header */
436 rndis_msg = packet->rndis_msg;
437 rndis_msg->ndis_msg_type = RNDIS_MSG_PACKET;
438 rndis_msg->msg_len = packet->total_data_buflen;
439 rndis_pkt = &rndis_msg->msg.pkt;
440 rndis_pkt->data_offset = sizeof(struct rndis_packet);
441 rndis_pkt->data_len = packet->total_data_buflen;
442 rndis_pkt->per_pkt_info_offset = sizeof(struct rndis_packet);
443
444 rndis_msg_size = RNDIS_MESSAGE_SIZE(struct rndis_packet);
445
446 if (isvlan) {
447 struct ndis_pkt_8021q_info *vlan;
448
449 rndis_msg_size += NDIS_VLAN_PPI_SIZE;
450 ppi = init_ppi_data(rndis_msg, NDIS_VLAN_PPI_SIZE,
451 IEEE_8021Q_INFO);
452 vlan = (struct ndis_pkt_8021q_info *)((void *)ppi +
453 ppi->ppi_offset);
454 vlan->vlanid = packet->vlan_tci & VLAN_VID_MASK;
455 vlan->pri = (packet->vlan_tci & VLAN_PRIO_MASK) >>
456 VLAN_PRIO_SHIFT;
457 }
458
KY Srinivasan08cd04b2014-03-08 19:23:17 -0800459 net_trans_info = get_net_transport_info(skb, &hdr_offset);
460 if (net_trans_info == TRANSPORT_INFO_NOT_IP)
461 goto do_send;
462
463 /*
464 * Setup the sendside checksum offload only if this is not a
465 * GSO packet.
466 */
467 if (skb_is_gso(skb))
KY Srinivasan77bf5482014-03-08 19:23:18 -0800468 goto do_lso;
KY Srinivasan08cd04b2014-03-08 19:23:17 -0800469
KY Srinivasan22041fb2014-04-30 11:58:25 -0700470 if ((skb->ip_summed == CHECKSUM_NONE) ||
471 (skb->ip_summed == CHECKSUM_UNNECESSARY))
472 goto do_send;
473
KY Srinivasan08cd04b2014-03-08 19:23:17 -0800474 rndis_msg_size += NDIS_CSUM_PPI_SIZE;
475 ppi = init_ppi_data(rndis_msg, NDIS_CSUM_PPI_SIZE,
476 TCPIP_CHKSUM_PKTINFO);
477
478 csum_info = (struct ndis_tcp_ip_checksum_info *)((void *)ppi +
479 ppi->ppi_offset);
480
481 if (net_trans_info & (INFO_IPV4 << 16))
482 csum_info->transmit.is_ipv4 = 1;
483 else
484 csum_info->transmit.is_ipv6 = 1;
485
486 if (net_trans_info & INFO_TCP) {
487 csum_info->transmit.tcp_checksum = 1;
488 csum_info->transmit.tcp_header_offset = hdr_offset;
489 } else if (net_trans_info & INFO_UDP) {
KY Srinivasanaf9893a2014-04-09 15:00:47 -0700490 /* UDP checksum offload is not supported on ws2008r2.
491 * Furthermore, on ws2012 and ws2012r2, there are some
492 * issues with udp checksum offload from Linux guests.
493 * (these are host issues).
494 * For now compute the checksum here.
495 */
496 struct udphdr *uh;
497 u16 udp_len;
498
499 ret = skb_cow_head(skb, 0);
500 if (ret)
501 goto drop;
502
503 uh = udp_hdr(skb);
504 udp_len = ntohs(uh->len);
505 uh->check = 0;
506 uh->check = csum_tcpudp_magic(ip_hdr(skb)->saddr,
507 ip_hdr(skb)->daddr,
508 udp_len, IPPROTO_UDP,
509 csum_partial(uh, udp_len, 0));
510 if (uh->check == 0)
511 uh->check = CSUM_MANGLED_0;
512
513 csum_info->transmit.udp_checksum = 0;
KY Srinivasan08cd04b2014-03-08 19:23:17 -0800514 }
KY Srinivasan77bf5482014-03-08 19:23:18 -0800515 goto do_send;
516
517do_lso:
518 rndis_msg_size += NDIS_LSO_PPI_SIZE;
519 ppi = init_ppi_data(rndis_msg, NDIS_LSO_PPI_SIZE,
520 TCP_LARGESEND_PKTINFO);
521
522 lso_info = (struct ndis_tcp_lso_info *)((void *)ppi +
523 ppi->ppi_offset);
524
525 lso_info->lso_v2_transmit.type = NDIS_TCP_LARGE_SEND_OFFLOAD_V2_TYPE;
526 if (net_trans_info & (INFO_IPV4 << 16)) {
527 lso_info->lso_v2_transmit.ip_version =
528 NDIS_TCP_LARGE_SEND_OFFLOAD_IPV4;
529 ip_hdr(skb)->tot_len = 0;
530 ip_hdr(skb)->check = 0;
531 tcp_hdr(skb)->check =
532 ~csum_tcpudp_magic(ip_hdr(skb)->saddr,
533 ip_hdr(skb)->daddr, 0, IPPROTO_TCP, 0);
534 } else {
535 lso_info->lso_v2_transmit.ip_version =
536 NDIS_TCP_LARGE_SEND_OFFLOAD_IPV6;
537 ipv6_hdr(skb)->payload_len = 0;
538 tcp_hdr(skb)->check =
539 ~csum_ipv6_magic(&ipv6_hdr(skb)->saddr,
540 &ipv6_hdr(skb)->daddr, 0, IPPROTO_TCP, 0);
541 }
542 lso_info->lso_v2_transmit.tcp_header_offset = hdr_offset;
543 lso_info->lso_v2_transmit.mss = skb_shinfo(skb)->gso_size;
KY Srinivasan08cd04b2014-03-08 19:23:17 -0800544
545do_send:
KY Srinivasan8a002512014-03-08 19:23:14 -0800546 /* Start filling in the page buffers with the rndis hdr */
547 rndis_msg->msg_len += rndis_msg_size;
548 packet->page_buf_cnt = init_page_array(rndis_msg, rndis_msg_size,
549 skb, &packet->page_buf[0]);
550
551 ret = netvsc_send(net_device_ctx->device_ctx, packet);
552
KY Srinivasanaf9893a2014-04-09 15:00:47 -0700553drop:
Greg Kroah-Hartman02fafbc2009-08-31 21:09:45 -0700554 if (ret == 0) {
Stephen Hemmingerb852fdc2010-03-09 17:42:33 -0800555 net->stats.tx_bytes += skb->len;
556 net->stats.tx_packets++;
Greg Kroah-Hartman02fafbc2009-08-31 21:09:45 -0700557 } else {
Haiyang Zhang8a5f9ed2011-09-01 12:19:45 -0700558 kfree(packet);
Haiyang Zhang33be96e2012-03-27 13:20:45 +0000559 if (ret != -EAGAIN) {
560 dev_kfree_skb_any(skb);
561 net->stats.tx_dropped++;
562 }
Hank Janssenfceaf242009-07-13 15:34:54 -0700563 }
564
Haiyang Zhang33be96e2012-03-27 13:20:45 +0000565 return (ret == -EAGAIN) ? NETDEV_TX_BUSY : NETDEV_TX_OK;
Hank Janssenfceaf242009-07-13 15:34:54 -0700566}
567
Hank Janssen3e189512010-03-04 22:11:00 +0000568/*
Greg Kroah-Hartman02fafbc2009-08-31 21:09:45 -0700569 * netvsc_linkstatus_callback - Link up/down notification
570 */
K. Y. Srinivasan90ef1172011-05-12 19:34:50 -0700571void netvsc_linkstatus_callback(struct hv_device *device_obj,
Greg Kroah-Hartman02fafbc2009-08-31 21:09:45 -0700572 unsigned int status)
Hank Janssenfceaf242009-07-13 15:34:54 -0700573{
K. Y. Srinivasan2ddd5e52011-09-13 10:59:49 -0700574 struct net_device *net;
Haiyang Zhangc996edc2011-04-06 15:18:00 -0700575 struct net_device_context *ndev_ctx;
K. Y. Srinivasan2ddd5e52011-09-13 10:59:49 -0700576 struct netvsc_device *net_device;
Haiyang Zhang891de742014-02-12 16:54:27 -0800577 struct rndis_device *rdev;
K. Y. Srinivasan2ddd5e52011-09-13 10:59:49 -0700578
579 net_device = hv_get_drvdata(device_obj);
Haiyang Zhang891de742014-02-12 16:54:27 -0800580 rdev = net_device->extension;
581
582 rdev->link_state = status != 1;
583
K. Y. Srinivasan2ddd5e52011-09-13 10:59:49 -0700584 net = net_device->ndev;
Hank Janssenfceaf242009-07-13 15:34:54 -0700585
Haiyang Zhang891de742014-02-12 16:54:27 -0800586 if (!net || net->reg_state != NETREG_REGISTERED)
Hank Janssenfceaf242009-07-13 15:34:54 -0700587 return;
Hank Janssenfceaf242009-07-13 15:34:54 -0700588
Haiyang Zhang891de742014-02-12 16:54:27 -0800589 ndev_ctx = netdev_priv(net);
Greg Kroah-Hartman02fafbc2009-08-31 21:09:45 -0700590 if (status == 1) {
Haiyang Zhangc4b6a2e2011-09-01 12:19:42 -0700591 schedule_delayed_work(&ndev_ctx->dwork, 0);
Haiyang Zhang122a5f62011-05-27 06:21:55 -0700592 schedule_delayed_work(&ndev_ctx->dwork, msecs_to_jiffies(20));
Greg Kroah-Hartman02fafbc2009-08-31 21:09:45 -0700593 } else {
Haiyang Zhang891de742014-02-12 16:54:27 -0800594 schedule_delayed_work(&ndev_ctx->dwork, 0);
Hank Janssenfceaf242009-07-13 15:34:54 -0700595 }
Hank Janssenfceaf242009-07-13 15:34:54 -0700596}
597
Hank Janssen3e189512010-03-04 22:11:00 +0000598/*
599 * netvsc_recv_callback - Callback when we receive a packet from the
600 * "wire" on the specified device.
Greg Kroah-Hartman02fafbc2009-08-31 21:09:45 -0700601 */
K. Y. Srinivasanf79adf82011-05-12 19:34:51 -0700602int netvsc_recv_callback(struct hv_device *device_obj,
KY Srinivasane3d605e2014-03-08 19:23:16 -0800603 struct hv_netvsc_packet *packet,
604 struct ndis_tcp_ip_checksum_info *csum_info)
Hank Janssenfceaf242009-07-13 15:34:54 -0700605{
Haiyang Zhang6f4c4442012-02-05 12:13:09 +0000606 struct net_device *net;
Hank Janssenfceaf242009-07-13 15:34:54 -0700607 struct sk_buff *skb;
K. Y. Srinivasan2ddd5e52011-09-13 10:59:49 -0700608
Haiyang Zhang6f4c4442012-02-05 12:13:09 +0000609 net = ((struct netvsc_device *)hv_get_drvdata(device_obj))->ndev;
Haiyang Zhanga68f9612013-12-20 16:52:31 -0800610 if (!net || net->reg_state != NETREG_REGISTERED) {
Haiyang Zhang63f69212012-10-02 05:30:23 +0000611 packet->status = NVSP_STAT_FAIL;
Hank Janssenfceaf242009-07-13 15:34:54 -0700612 return 0;
613 }
614
Stephen Hemminger9495c282010-03-09 17:42:17 -0800615 /* Allocate a skb - TODO direct I/O to pages? */
Haiyang Zhang72a2f5b2010-12-10 12:03:58 -0800616 skb = netdev_alloc_skb_ip_align(net, packet->total_data_buflen);
Stephen Hemminger9495c282010-03-09 17:42:17 -0800617 if (unlikely(!skb)) {
618 ++net->stats.rx_dropped;
Haiyang Zhang63f69212012-10-02 05:30:23 +0000619 packet->status = NVSP_STAT_FAIL;
Stephen Hemminger9495c282010-03-09 17:42:17 -0800620 return 0;
621 }
Hank Janssenfceaf242009-07-13 15:34:54 -0700622
Greg Kroah-Hartman02fafbc2009-08-31 21:09:45 -0700623 /*
624 * Copy to skb. This copy is needed here since the memory pointed by
625 * hv_netvsc_packet cannot be deallocated
626 */
Haiyang Zhang45326342011-12-15 13:45:15 -0800627 memcpy(skb_put(skb, packet->total_data_buflen), packet->data,
628 packet->total_data_buflen);
Hank Janssenfceaf242009-07-13 15:34:54 -0700629
630 skb->protocol = eth_type_trans(skb, net);
KY Srinivasane3d605e2014-03-08 19:23:16 -0800631 if (csum_info) {
632 /* We only look at the IP checksum here.
633 * Should we be dropping the packet if checksum
634 * failed? How do we deal with other checksums - TCP/UDP?
635 */
636 if (csum_info->receive.ip_checksum_succeeded)
637 skb->ip_summed = CHECKSUM_UNNECESSARY;
638 else
639 skb->ip_summed = CHECKSUM_NONE;
640 }
641
Haiyang Zhang93725cb2013-06-17 15:36:49 -0700642 if (packet->vlan_tci & VLAN_TAG_PRESENT)
643 __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q),
644 packet->vlan_tci);
Hank Janssenfceaf242009-07-13 15:34:54 -0700645
Haiyang Zhang4baab262014-04-21 14:54:43 -0700646 skb_record_rx_queue(skb, packet->channel->
Haiyang Zhange565e802014-05-08 15:14:10 -0700647 offermsg.offer.sub_channel_index);
Haiyang Zhang5b54dac2014-04-21 10:20:28 -0700648
Stephen Hemminger9495c282010-03-09 17:42:17 -0800649 net->stats.rx_packets++;
Wei Yongjun48c38832012-01-29 22:14:02 +0000650 net->stats.rx_bytes += packet->total_data_buflen;
Stephen Hemminger9495c282010-03-09 17:42:17 -0800651
Greg Kroah-Hartman02fafbc2009-08-31 21:09:45 -0700652 /*
653 * Pass the skb back up. Network stack will deallocate the skb when it
Stephen Hemminger9495c282010-03-09 17:42:17 -0800654 * is done.
655 * TODO - use NAPI?
Greg Kroah-Hartman02fafbc2009-08-31 21:09:45 -0700656 */
Stephen Hemminger9495c282010-03-09 17:42:17 -0800657 netif_rx(skb);
Hank Janssenfceaf242009-07-13 15:34:54 -0700658
Hank Janssenfceaf242009-07-13 15:34:54 -0700659 return 0;
660}
661
Stephen Hemmingerf82f4ad2010-05-04 09:58:57 -0700662static void netvsc_get_drvinfo(struct net_device *net,
663 struct ethtool_drvinfo *info)
664{
Jiri Pirko7826d432013-01-06 00:44:26 +0000665 strlcpy(info->driver, KBUILD_MODNAME, sizeof(info->driver));
Jiri Pirko7826d432013-01-06 00:44:26 +0000666 strlcpy(info->fw_version, "N/A", sizeof(info->fw_version));
Stephen Hemmingerf82f4ad2010-05-04 09:58:57 -0700667}
668
Haiyang Zhang4d447c92011-12-15 13:45:17 -0800669static int netvsc_change_mtu(struct net_device *ndev, int mtu)
670{
671 struct net_device_context *ndevctx = netdev_priv(ndev);
672 struct hv_device *hdev = ndevctx->device_ctx;
673 struct netvsc_device *nvdev = hv_get_drvdata(hdev);
674 struct netvsc_device_info device_info;
675 int limit = ETH_DATA_LEN;
676
677 if (nvdev == NULL || nvdev->destroy)
678 return -ENODEV;
679
Haiyang Zhanga1eabb02014-02-19 15:49:45 -0800680 if (nvdev->nvsp_version >= NVSP_PROTOCOL_VERSION_2)
Haiyang Zhang4d447c92011-12-15 13:45:17 -0800681 limit = NETVSC_MTU;
682
683 if (mtu < 68 || mtu > limit)
684 return -EINVAL;
685
686 nvdev->start_remove = true;
Wenqi Ma792df872012-04-19 00:39:37 +0000687 cancel_work_sync(&ndevctx->work);
Haiyang Zhang0a282532012-02-02 07:17:59 +0000688 netif_tx_disable(ndev);
Haiyang Zhang4d447c92011-12-15 13:45:17 -0800689 rndis_filter_device_remove(hdev);
690
691 ndev->mtu = mtu;
692
693 ndevctx->device_ctx = hdev;
694 hv_set_drvdata(hdev, ndev);
695 device_info.ring_size = ring_size;
696 rndis_filter_device_add(hdev, &device_info);
Haiyang Zhang5b54dac2014-04-21 10:20:28 -0700697 netif_tx_wake_all_queues(ndev);
Haiyang Zhang4d447c92011-12-15 13:45:17 -0800698
699 return 0;
700}
701
Haiyang Zhang1ce09e82012-07-10 07:19:22 +0000702
703static int netvsc_set_mac_addr(struct net_device *ndev, void *p)
704{
705 struct net_device_context *ndevctx = netdev_priv(ndev);
706 struct hv_device *hdev = ndevctx->device_ctx;
707 struct sockaddr *addr = p;
Jianjun Kong9a4c8312013-01-18 16:52:09 +0000708 char save_adr[ETH_ALEN];
Haiyang Zhang1ce09e82012-07-10 07:19:22 +0000709 unsigned char save_aatype;
710 int err;
711
712 memcpy(save_adr, ndev->dev_addr, ETH_ALEN);
713 save_aatype = ndev->addr_assign_type;
714
715 err = eth_mac_addr(ndev, p);
716 if (err != 0)
717 return err;
718
719 err = rndis_filter_set_device_mac(hdev, addr->sa_data);
720 if (err != 0) {
721 /* roll back to saved MAC */
722 memcpy(ndev->dev_addr, save_adr, ETH_ALEN);
723 ndev->addr_assign_type = save_aatype;
724 }
725
726 return err;
727}
728
729
Stephen Hemmingerf82f4ad2010-05-04 09:58:57 -0700730static const struct ethtool_ops ethtool_ops = {
731 .get_drvinfo = netvsc_get_drvinfo,
Stephen Hemmingerf82f4ad2010-05-04 09:58:57 -0700732 .get_link = ethtool_op_get_link,
733};
734
Greg Kroah-Hartmandf2fff22009-08-31 21:11:12 -0700735static const struct net_device_ops device_ops = {
736 .ndo_open = netvsc_open,
737 .ndo_stop = netvsc_close,
738 .ndo_start_xmit = netvsc_start_xmit,
Jiri Pirkoafc4b132011-08-16 06:29:01 +0000739 .ndo_set_rx_mode = netvsc_set_multicast_list,
Haiyang Zhang4d447c92011-12-15 13:45:17 -0800740 .ndo_change_mtu = netvsc_change_mtu,
Haiyang Zhangb681b582010-08-03 19:15:31 +0000741 .ndo_validate_addr = eth_validate_addr,
Haiyang Zhang1ce09e82012-07-10 07:19:22 +0000742 .ndo_set_mac_address = netvsc_set_mac_addr,
Haiyang Zhang5b54dac2014-04-21 10:20:28 -0700743 .ndo_select_queue = netvsc_select_queue,
Greg Kroah-Hartmandf2fff22009-08-31 21:11:12 -0700744};
745
Haiyang Zhangc996edc2011-04-06 15:18:00 -0700746/*
747 * Send GARP packet to network peers after migrations.
748 * After Quick Migration, the network is not immediately operational in the
749 * current context when receiving RNDIS_STATUS_MEDIA_CONNECT event. So, add
Haiyang Zhang122a5f62011-05-27 06:21:55 -0700750 * another netif_notify_peers() into a delayed work, otherwise GARP packet
Haiyang Zhangc996edc2011-04-06 15:18:00 -0700751 * will not be sent after quick migration, and cause network disconnection.
Haiyang Zhang891de742014-02-12 16:54:27 -0800752 * Also, we update the carrier status here.
Haiyang Zhangc996edc2011-04-06 15:18:00 -0700753 */
Haiyang Zhang891de742014-02-12 16:54:27 -0800754static void netvsc_link_change(struct work_struct *w)
Haiyang Zhangc996edc2011-04-06 15:18:00 -0700755{
756 struct net_device_context *ndev_ctx;
757 struct net_device *net;
K. Y. Srinivasan2ddd5e52011-09-13 10:59:49 -0700758 struct netvsc_device *net_device;
Haiyang Zhang891de742014-02-12 16:54:27 -0800759 struct rndis_device *rdev;
760 bool notify;
761
762 rtnl_lock();
Haiyang Zhangc996edc2011-04-06 15:18:00 -0700763
Haiyang Zhang122a5f62011-05-27 06:21:55 -0700764 ndev_ctx = container_of(w, struct net_device_context, dwork.work);
K. Y. Srinivasan2ddd5e52011-09-13 10:59:49 -0700765 net_device = hv_get_drvdata(ndev_ctx->device_ctx);
Haiyang Zhang891de742014-02-12 16:54:27 -0800766 rdev = net_device->extension;
K. Y. Srinivasan2ddd5e52011-09-13 10:59:49 -0700767 net = net_device->ndev;
Haiyang Zhang891de742014-02-12 16:54:27 -0800768
769 if (rdev->link_state) {
770 netif_carrier_off(net);
771 notify = false;
772 } else {
773 netif_carrier_on(net);
774 notify = true;
775 }
776
777 rtnl_unlock();
778
779 if (notify)
780 netdev_notify_peers(net);
Haiyang Zhangc996edc2011-04-06 15:18:00 -0700781}
782
783
K. Y. Srinivasan84946892011-09-13 10:59:38 -0700784static int netvsc_probe(struct hv_device *dev,
785 const struct hv_vmbus_device_id *dev_id)
Greg Kroah-Hartmandf2fff22009-08-31 21:11:12 -0700786{
Greg Kroah-Hartmandf2fff22009-08-31 21:11:12 -0700787 struct net_device *net = NULL;
788 struct net_device_context *net_device_ctx;
789 struct netvsc_device_info device_info;
Haiyang Zhang5b54dac2014-04-21 10:20:28 -0700790 struct netvsc_device *nvdev;
Greg Kroah-Hartmandf2fff22009-08-31 21:11:12 -0700791 int ret;
792
Haiyang Zhang5b54dac2014-04-21 10:20:28 -0700793 net = alloc_etherdev_mq(sizeof(struct net_device_context),
794 num_online_cpus());
Greg Kroah-Hartmandf2fff22009-08-31 21:11:12 -0700795 if (!net)
K. Y. Srinivasan51a805d2011-08-25 09:49:11 -0700796 return -ENOMEM;
Greg Kroah-Hartmandf2fff22009-08-31 21:11:12 -0700797
Haiyang Zhang1b07da52014-03-04 14:11:06 -0800798 netif_carrier_off(net);
799
Greg Kroah-Hartmandf2fff22009-08-31 21:11:12 -0700800 net_device_ctx = netdev_priv(net);
K. Y. Srinivasan9efd21e2011-04-29 13:45:10 -0700801 net_device_ctx->device_ctx = dev;
K. Y. Srinivasan2ddd5e52011-09-13 10:59:49 -0700802 hv_set_drvdata(dev, net);
Haiyang Zhang891de742014-02-12 16:54:27 -0800803 INIT_DELAYED_WORK(&net_device_ctx->dwork, netvsc_link_change);
Wenqi Ma792df872012-04-19 00:39:37 +0000804 INIT_WORK(&net_device_ctx->work, do_set_multicast);
Greg Kroah-Hartmandf2fff22009-08-31 21:11:12 -0700805
Greg Kroah-Hartmandf2fff22009-08-31 21:11:12 -0700806 net->netdev_ops = &device_ops;
807
KY Srinivasan77bf5482014-03-08 19:23:18 -0800808 net->hw_features = NETIF_F_RXCSUM | NETIF_F_SG | NETIF_F_IP_CSUM |
809 NETIF_F_TSO;
KY Srinivasan08cd04b2014-03-08 19:23:17 -0800810 net->features = NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_SG | NETIF_F_RXCSUM |
KY Srinivasan77bf5482014-03-08 19:23:18 -0800811 NETIF_F_IP_CSUM | NETIF_F_TSO;
Stephen Hemminger60487182010-05-04 09:58:55 -0700812
Stephen Hemmingerf82f4ad2010-05-04 09:58:57 -0700813 SET_ETHTOOL_OPS(net, &ethtool_ops);
K. Y. Srinivasan9efd21e2011-04-29 13:45:10 -0700814 SET_NETDEV_DEV(net, &dev->device);
Greg Kroah-Hartmandf2fff22009-08-31 21:11:12 -0700815
Haiyang Zhang692e0842011-09-01 12:19:43 -0700816 /* Notify the netvsc driver of the new device */
817 device_info.ring_size = ring_size;
818 ret = rndis_filter_device_add(dev, &device_info);
819 if (ret != 0) {
820 netdev_err(net, "unable to add netvsc device (ret %d)\n", ret);
Haiyang Zhang692e0842011-09-01 12:19:43 -0700821 free_netdev(net);
K. Y. Srinivasan2ddd5e52011-09-13 10:59:49 -0700822 hv_set_drvdata(dev, NULL);
Haiyang Zhang692e0842011-09-01 12:19:43 -0700823 return ret;
824 }
825 memcpy(net->dev_addr, device_info.mac_adr, ETH_ALEN);
826
Haiyang Zhang5b54dac2014-04-21 10:20:28 -0700827 nvdev = hv_get_drvdata(dev);
828 netif_set_real_num_tx_queues(net, nvdev->num_chn);
829 netif_set_real_num_rx_queues(net, nvdev->num_chn);
Haiyang Zhang5b54dac2014-04-21 10:20:28 -0700830
Haiyang Zhanga68f9612013-12-20 16:52:31 -0800831 ret = register_netdev(net);
832 if (ret != 0) {
833 pr_err("Unable to register netdev.\n");
834 rndis_filter_device_remove(dev);
835 free_netdev(net);
Haiyang Zhang1b07da52014-03-04 14:11:06 -0800836 } else {
837 schedule_delayed_work(&net_device_ctx->dwork, 0);
Haiyang Zhanga68f9612013-12-20 16:52:31 -0800838 }
839
Greg Kroah-Hartmandf2fff22009-08-31 21:11:12 -0700840 return ret;
841}
842
K. Y. Srinivasan415b0232011-04-29 13:45:12 -0700843static int netvsc_remove(struct hv_device *dev)
Greg Kroah-Hartmandf2fff22009-08-31 21:11:12 -0700844{
K. Y. Srinivasan2ddd5e52011-09-13 10:59:49 -0700845 struct net_device *net;
Haiyang Zhang122a5f62011-05-27 06:21:55 -0700846 struct net_device_context *ndev_ctx;
K. Y. Srinivasan2ddd5e52011-09-13 10:59:49 -0700847 struct netvsc_device *net_device;
848
849 net_device = hv_get_drvdata(dev);
850 net = net_device->ndev;
Greg Kroah-Hartmandf2fff22009-08-31 21:11:12 -0700851
Greg Kroah-Hartmandf2fff22009-08-31 21:11:12 -0700852 if (net == NULL) {
K. Y. Srinivasan415b0232011-04-29 13:45:12 -0700853 dev_err(&dev->device, "No net device to remove\n");
Greg Kroah-Hartmandf2fff22009-08-31 21:11:12 -0700854 return 0;
855 }
856
Haiyang Zhang4d447c92011-12-15 13:45:17 -0800857 net_device->start_remove = true;
858
Haiyang Zhang122a5f62011-05-27 06:21:55 -0700859 ndev_ctx = netdev_priv(net);
860 cancel_delayed_work_sync(&ndev_ctx->dwork);
Wenqi Ma792df872012-04-19 00:39:37 +0000861 cancel_work_sync(&ndev_ctx->work);
Haiyang Zhang122a5f62011-05-27 06:21:55 -0700862
Greg Kroah-Hartmandf2fff22009-08-31 21:11:12 -0700863 /* Stop outbound asap */
Haiyang Zhang0a282532012-02-02 07:17:59 +0000864 netif_tx_disable(net);
Greg Kroah-Hartmandf2fff22009-08-31 21:11:12 -0700865
866 unregister_netdev(net);
867
868 /*
869 * Call to the vsc driver to let it know that the device is being
870 * removed
871 */
Haiyang Zhangdf06bcf2011-05-23 09:03:47 -0700872 rndis_filter_device_remove(dev);
Greg Kroah-Hartmandf2fff22009-08-31 21:11:12 -0700873
874 free_netdev(net);
Haiyang Zhangdf06bcf2011-05-23 09:03:47 -0700875 return 0;
Greg Kroah-Hartmandf2fff22009-08-31 21:11:12 -0700876}
877
K. Y. Srinivasan345c4cc2011-08-25 09:48:34 -0700878static const struct hv_vmbus_device_id id_table[] = {
Greg Kroah-Hartmanc45cf2d2011-08-25 11:41:33 -0700879 /* Network guid */
K. Y. Srinivasan8f505942013-01-23 17:42:42 -0800880 { HV_NIC_GUID, },
Greg Kroah-Hartmanc45cf2d2011-08-25 11:41:33 -0700881 { },
K. Y. Srinivasan345c4cc2011-08-25 09:48:34 -0700882};
883
884MODULE_DEVICE_TABLE(vmbus, id_table);
885
K. Y. Srinivasanf1542a62011-05-10 07:55:16 -0700886/* The one and only one */
K. Y. Srinivasanfde0ef92011-05-12 19:35:08 -0700887static struct hv_driver netvsc_drv = {
Haiyang Zhangd31b20f2012-03-07 10:02:00 +0000888 .name = KBUILD_MODNAME,
K. Y. Srinivasan345c4cc2011-08-25 09:48:34 -0700889 .id_table = id_table,
K. Y. Srinivasanfde0ef92011-05-12 19:35:08 -0700890 .probe = netvsc_probe,
891 .remove = netvsc_remove,
K. Y. Srinivasand4890972011-05-10 07:55:17 -0700892};
K. Y. Srinivasanf1542a62011-05-10 07:55:16 -0700893
K. Y. Srinivasana9869c92011-05-12 19:35:17 -0700894static void __exit netvsc_drv_exit(void)
Hank Janssenfceaf242009-07-13 15:34:54 -0700895{
Greg Kroah-Hartman768fa212011-08-25 15:07:32 -0700896 vmbus_driver_unregister(&netvsc_drv);
Hank Janssenfceaf242009-07-13 15:34:54 -0700897}
898
K. Y. Srinivasan1fde28c2011-05-12 19:35:16 -0700899static int __init netvsc_drv_init(void)
Greg Kroah-Hartmandf2fff22009-08-31 21:11:12 -0700900{
Haiyang Zhangfa85a6c2012-07-25 08:08:41 +0000901 if (ring_size < RING_SIZE_MIN) {
902 ring_size = RING_SIZE_MIN;
903 pr_info("Increased ring_size to %d (min allowed)\n",
904 ring_size);
905 }
Greg Kroah-Hartman768fa212011-08-25 15:07:32 -0700906 return vmbus_driver_register(&netvsc_drv);
Greg Kroah-Hartmandf2fff22009-08-31 21:11:12 -0700907}
908
Hank Janssen26c14cc2010-02-11 23:02:42 +0000909MODULE_LICENSE("GPL");
Stephen Hemminger7880fc52010-05-04 09:58:52 -0700910MODULE_DESCRIPTION("Microsoft Hyper-V network driver");
Hank Janssenfceaf242009-07-13 15:34:54 -0700911
K. Y. Srinivasan1fde28c2011-05-12 19:35:16 -0700912module_init(netvsc_drv_init);
K. Y. Srinivasana9869c92011-05-12 19:35:17 -0700913module_exit(netvsc_drv_exit);