2 * Copyright (c) 2009, Microsoft Corporation.
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.
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
13 * You should have received a copy of the GNU General Public License along with
14 * this program; if not, see <http://www.gnu.org/licenses/>.
17 * Haiyang Zhang <haiyangz@microsoft.com>
18 * Hank Janssen <hjanssen@microsoft.com>
20 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
22 #include <linux/init.h>
23 #include <linux/atomic.h>
24 #include <linux/module.h>
25 #include <linux/highmem.h>
26 #include <linux/device.h>
28 #include <linux/delay.h>
29 #include <linux/netdevice.h>
30 #include <linux/inetdevice.h>
31 #include <linux/etherdevice.h>
32 #include <linux/skbuff.h>
33 #include <linux/if_vlan.h>
35 #include <linux/slab.h>
37 #include <net/route.h>
39 #include <net/pkt_sched.h>
41 #include "hyperv_net.h"
43 struct net_device_context
{
44 /* point back to our device context */
45 struct hv_device
*device_ctx
;
46 struct delayed_work dwork
;
47 struct work_struct work
;
50 #define RING_SIZE_MIN 64
51 static int ring_size
= 128;
52 module_param(ring_size
, int, S_IRUGO
);
53 MODULE_PARM_DESC(ring_size
, "Ring buffer size (# of pages)");
55 static void do_set_multicast(struct work_struct
*w
)
57 struct net_device_context
*ndevctx
=
58 container_of(w
, struct net_device_context
, work
);
59 struct netvsc_device
*nvdev
;
60 struct rndis_device
*rdev
;
62 nvdev
= hv_get_drvdata(ndevctx
->device_ctx
);
63 if (nvdev
== NULL
|| nvdev
->ndev
== NULL
)
66 rdev
= nvdev
->extension
;
70 if (nvdev
->ndev
->flags
& IFF_PROMISC
)
71 rndis_filter_set_packet_filter(rdev
,
72 NDIS_PACKET_TYPE_PROMISCUOUS
);
74 rndis_filter_set_packet_filter(rdev
,
75 NDIS_PACKET_TYPE_BROADCAST
|
76 NDIS_PACKET_TYPE_ALL_MULTICAST
|
77 NDIS_PACKET_TYPE_DIRECTED
);
80 static void netvsc_set_multicast_list(struct net_device
*net
)
82 struct net_device_context
*net_device_ctx
= netdev_priv(net
);
84 schedule_work(&net_device_ctx
->work
);
87 static int netvsc_open(struct net_device
*net
)
89 struct net_device_context
*net_device_ctx
= netdev_priv(net
);
90 struct hv_device
*device_obj
= net_device_ctx
->device_ctx
;
91 struct netvsc_device
*nvdev
;
92 struct rndis_device
*rdev
;
95 netif_carrier_off(net
);
97 /* Open up the device */
98 ret
= rndis_filter_open(device_obj
);
100 netdev_err(net
, "unable to open device (ret %d).\n", ret
);
104 netif_tx_start_all_queues(net
);
106 nvdev
= hv_get_drvdata(device_obj
);
107 rdev
= nvdev
->extension
;
108 if (!rdev
->link_state
)
109 netif_carrier_on(net
);
114 static int netvsc_close(struct net_device
*net
)
116 struct net_device_context
*net_device_ctx
= netdev_priv(net
);
117 struct hv_device
*device_obj
= net_device_ctx
->device_ctx
;
120 netif_tx_disable(net
);
122 /* Make sure netvsc_set_multicast_list doesn't re-enable filter! */
123 cancel_work_sync(&net_device_ctx
->work
);
124 ret
= rndis_filter_close(device_obj
);
126 netdev_err(net
, "unable to close device (ret %d).\n", ret
);
131 static void *init_ppi_data(struct rndis_message
*msg
, u32 ppi_size
,
134 struct rndis_packet
*rndis_pkt
;
135 struct rndis_per_packet_info
*ppi
;
137 rndis_pkt
= &msg
->msg
.pkt
;
138 rndis_pkt
->data_offset
+= ppi_size
;
140 ppi
= (struct rndis_per_packet_info
*)((void *)rndis_pkt
+
141 rndis_pkt
->per_pkt_info_offset
+ rndis_pkt
->per_pkt_info_len
);
143 ppi
->size
= ppi_size
;
144 ppi
->type
= pkt_type
;
145 ppi
->ppi_offset
= sizeof(struct rndis_per_packet_info
);
147 rndis_pkt
->per_pkt_info_len
+= ppi_size
;
161 /* Toeplitz hash function
162 * data: network byte order
163 * return: host byte order
165 static u32
comp_hash(u8
*key
, int klen
, void *data
, int dlen
)
174 subk
.ka
= ntohl(*(u32
*)key
);
176 for (i
= 0; i
< dlen
; i
++) {
177 subk
.kb
= key
[k_next
];
178 k_next
= (k_next
+ 1) % klen
;
179 dt
= ((u8
*)data
)[i
];
180 for (j
= 0; j
< 8; j
++) {
191 static bool netvsc_set_hash(u32
*hash
, struct sk_buff
*skb
)
193 struct flow_keys flow
;
196 if (!skb_flow_dissect(skb
, &flow
) ||
197 !(flow
.n_proto
== htons(ETH_P_IP
) ||
198 flow
.n_proto
== htons(ETH_P_IPV6
)))
201 if (flow
.ip_proto
== IPPROTO_TCP
)
206 *hash
= comp_hash(netvsc_hash_key
, HASH_KEYLEN
, &flow
, data_len
);
211 static u16
netvsc_select_queue(struct net_device
*ndev
, struct sk_buff
*skb
,
212 void *accel_priv
, select_queue_fallback_t fallback
)
214 struct net_device_context
*net_device_ctx
= netdev_priv(ndev
);
215 struct hv_device
*hdev
= net_device_ctx
->device_ctx
;
216 struct netvsc_device
*nvsc_dev
= hv_get_drvdata(hdev
);
220 if (nvsc_dev
== NULL
|| ndev
->real_num_tx_queues
<= 1)
223 if (netvsc_set_hash(&hash
, skb
)) {
224 q_idx
= nvsc_dev
->send_table
[hash
% VRSS_SEND_TAB_SIZE
] %
225 ndev
->real_num_tx_queues
;
226 skb_set_hash(skb
, hash
, PKT_HASH_TYPE_L3
);
232 static void netvsc_xmit_completion(void *context
)
234 struct hv_netvsc_packet
*packet
= (struct hv_netvsc_packet
*)context
;
235 struct sk_buff
*skb
= (struct sk_buff
*)
236 (unsigned long)packet
->send_completion_tid
;
237 u32 index
= packet
->send_buf_index
;
241 if (skb
&& (index
== NETVSC_INVALID_INDEX
))
242 dev_kfree_skb_any(skb
);
245 static u32
fill_pg_buf(struct page
*page
, u32 offset
, u32 len
,
246 struct hv_page_buffer
*pb
)
250 /* Deal with compund pages by ignoring unused part
253 page
+= (offset
>> PAGE_SHIFT
);
254 offset
&= ~PAGE_MASK
;
259 bytes
= PAGE_SIZE
- offset
;
262 pb
[j
].pfn
= page_to_pfn(page
);
263 pb
[j
].offset
= offset
;
269 if (offset
== PAGE_SIZE
&& len
) {
279 static u32
init_page_array(void *hdr
, u32 len
, struct sk_buff
*skb
,
280 struct hv_page_buffer
*pb
)
283 char *data
= skb
->data
;
284 int frags
= skb_shinfo(skb
)->nr_frags
;
287 /* The packet is laid out thus:
290 * 3. skb fragment data
293 slots_used
+= fill_pg_buf(virt_to_page(hdr
),
295 len
, &pb
[slots_used
]);
297 slots_used
+= fill_pg_buf(virt_to_page(data
),
298 offset_in_page(data
),
299 skb_headlen(skb
), &pb
[slots_used
]);
301 for (i
= 0; i
< frags
; i
++) {
302 skb_frag_t
*frag
= skb_shinfo(skb
)->frags
+ i
;
304 slots_used
+= fill_pg_buf(skb_frag_page(frag
),
306 skb_frag_size(frag
), &pb
[slots_used
]);
311 static int count_skb_frag_slots(struct sk_buff
*skb
)
313 int i
, frags
= skb_shinfo(skb
)->nr_frags
;
316 for (i
= 0; i
< frags
; i
++) {
317 skb_frag_t
*frag
= skb_shinfo(skb
)->frags
+ i
;
318 unsigned long size
= skb_frag_size(frag
);
319 unsigned long offset
= frag
->page_offset
;
321 /* Skip unused frames from start of page */
322 offset
&= ~PAGE_MASK
;
323 pages
+= PFN_UP(offset
+ size
);
328 static int netvsc_get_slots(struct sk_buff
*skb
)
330 char *data
= skb
->data
;
331 unsigned int offset
= offset_in_page(data
);
332 unsigned int len
= skb_headlen(skb
);
336 slots
= DIV_ROUND_UP(offset
+ len
, PAGE_SIZE
);
337 frag_slots
= count_skb_frag_slots(skb
);
338 return slots
+ frag_slots
;
341 static u32
get_net_transport_info(struct sk_buff
*skb
, u32
*trans_off
)
343 u32 ret_val
= TRANSPORT_INFO_NOT_IP
;
345 if ((eth_hdr(skb
)->h_proto
!= htons(ETH_P_IP
)) &&
346 (eth_hdr(skb
)->h_proto
!= htons(ETH_P_IPV6
))) {
350 *trans_off
= skb_transport_offset(skb
);
352 if ((eth_hdr(skb
)->h_proto
== htons(ETH_P_IP
))) {
353 struct iphdr
*iphdr
= ip_hdr(skb
);
355 if (iphdr
->protocol
== IPPROTO_TCP
)
356 ret_val
= TRANSPORT_INFO_IPV4_TCP
;
357 else if (iphdr
->protocol
== IPPROTO_UDP
)
358 ret_val
= TRANSPORT_INFO_IPV4_UDP
;
360 if (ipv6_hdr(skb
)->nexthdr
== IPPROTO_TCP
)
361 ret_val
= TRANSPORT_INFO_IPV6_TCP
;
362 else if (ipv6_hdr(skb
)->nexthdr
== IPPROTO_UDP
)
363 ret_val
= TRANSPORT_INFO_IPV6_UDP
;
370 static int netvsc_start_xmit(struct sk_buff
*skb
, struct net_device
*net
)
372 struct net_device_context
*net_device_ctx
= netdev_priv(net
);
373 struct hv_netvsc_packet
*packet
;
375 unsigned int num_data_pgs
;
376 struct rndis_message
*rndis_msg
;
377 struct rndis_packet
*rndis_pkt
;
380 struct rndis_per_packet_info
*ppi
;
381 struct ndis_tcp_ip_checksum_info
*csum_info
;
382 struct ndis_tcp_lso_info
*lso_info
;
386 u32 skb_length
= skb
->len
;
389 /* 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.
393 num_data_pgs
= netvsc_get_slots(skb
) + 2;
394 if (num_data_pgs
> MAX_PAGE_BUFFER_COUNT
) {
395 netdev_err(net
, "Packet too big: %u\n", skb
->len
);
397 net
->stats
.tx_dropped
++;
401 /* Allocate a netvsc packet based on # of frags. */
402 packet
= kzalloc(sizeof(struct hv_netvsc_packet
) +
403 (num_data_pgs
* sizeof(struct hv_page_buffer
)) +
404 sizeof(struct rndis_message
) +
405 NDIS_VLAN_PPI_SIZE
+ NDIS_CSUM_PPI_SIZE
+
406 NDIS_LSO_PPI_SIZE
+ NDIS_HASH_PPI_SIZE
, GFP_ATOMIC
);
408 /* out of memory, drop packet */
409 netdev_err(net
, "unable to allocate hv_netvsc_packet\n");
412 net
->stats
.tx_dropped
++;
416 packet
->xmit_more
= skb
->xmit_more
;
418 packet
->vlan_tci
= skb
->vlan_tci
;
420 packet
->q_idx
= skb_get_queue_mapping(skb
);
422 packet
->is_data_pkt
= true;
423 packet
->total_data_buflen
= skb
->len
;
425 packet
->rndis_msg
= (struct rndis_message
*)((unsigned long)packet
+
426 sizeof(struct hv_netvsc_packet
) +
427 (num_data_pgs
* sizeof(struct hv_page_buffer
)));
429 /* Set the completion routine */
430 packet
->send_completion
= netvsc_xmit_completion
;
431 packet
->send_completion_ctx
= packet
;
432 packet
->send_completion_tid
= (unsigned long)skb
;
434 isvlan
= packet
->vlan_tci
& VLAN_TAG_PRESENT
;
436 /* Add the rndis header */
437 rndis_msg
= packet
->rndis_msg
;
438 rndis_msg
->ndis_msg_type
= RNDIS_MSG_PACKET
;
439 rndis_msg
->msg_len
= packet
->total_data_buflen
;
440 rndis_pkt
= &rndis_msg
->msg
.pkt
;
441 rndis_pkt
->data_offset
= sizeof(struct rndis_packet
);
442 rndis_pkt
->data_len
= packet
->total_data_buflen
;
443 rndis_pkt
->per_pkt_info_offset
= sizeof(struct rndis_packet
);
445 rndis_msg_size
= RNDIS_MESSAGE_SIZE(struct rndis_packet
);
447 hash
= skb_get_hash_raw(skb
);
448 if (hash
!= 0 && net
->real_num_tx_queues
> 1) {
449 rndis_msg_size
+= NDIS_HASH_PPI_SIZE
;
450 ppi
= init_ppi_data(rndis_msg
, NDIS_HASH_PPI_SIZE
,
452 *(u32
*)((void *)ppi
+ ppi
->ppi_offset
) = hash
;
456 struct ndis_pkt_8021q_info
*vlan
;
458 rndis_msg_size
+= NDIS_VLAN_PPI_SIZE
;
459 ppi
= init_ppi_data(rndis_msg
, NDIS_VLAN_PPI_SIZE
,
461 vlan
= (struct ndis_pkt_8021q_info
*)((void *)ppi
+
463 vlan
->vlanid
= packet
->vlan_tci
& VLAN_VID_MASK
;
464 vlan
->pri
= (packet
->vlan_tci
& VLAN_PRIO_MASK
) >>
468 net_trans_info
= get_net_transport_info(skb
, &hdr_offset
);
469 if (net_trans_info
== TRANSPORT_INFO_NOT_IP
)
473 * Setup the sendside checksum offload only if this is not a
479 if ((skb
->ip_summed
== CHECKSUM_NONE
) ||
480 (skb
->ip_summed
== CHECKSUM_UNNECESSARY
))
483 rndis_msg_size
+= NDIS_CSUM_PPI_SIZE
;
484 ppi
= init_ppi_data(rndis_msg
, NDIS_CSUM_PPI_SIZE
,
485 TCPIP_CHKSUM_PKTINFO
);
487 csum_info
= (struct ndis_tcp_ip_checksum_info
*)((void *)ppi
+
490 if (net_trans_info
& (INFO_IPV4
<< 16))
491 csum_info
->transmit
.is_ipv4
= 1;
493 csum_info
->transmit
.is_ipv6
= 1;
495 if (net_trans_info
& INFO_TCP
) {
496 csum_info
->transmit
.tcp_checksum
= 1;
497 csum_info
->transmit
.tcp_header_offset
= hdr_offset
;
498 } else if (net_trans_info
& INFO_UDP
) {
499 /* UDP checksum offload is not supported on ws2008r2.
500 * Furthermore, on ws2012 and ws2012r2, there are some
501 * issues with udp checksum offload from Linux guests.
502 * (these are host issues).
503 * For now compute the checksum here.
508 ret
= skb_cow_head(skb
, 0);
513 udp_len
= ntohs(uh
->len
);
515 uh
->check
= csum_tcpudp_magic(ip_hdr(skb
)->saddr
,
517 udp_len
, IPPROTO_UDP
,
518 csum_partial(uh
, udp_len
, 0));
520 uh
->check
= CSUM_MANGLED_0
;
522 csum_info
->transmit
.udp_checksum
= 0;
527 rndis_msg_size
+= NDIS_LSO_PPI_SIZE
;
528 ppi
= init_ppi_data(rndis_msg
, NDIS_LSO_PPI_SIZE
,
529 TCP_LARGESEND_PKTINFO
);
531 lso_info
= (struct ndis_tcp_lso_info
*)((void *)ppi
+
534 lso_info
->lso_v2_transmit
.type
= NDIS_TCP_LARGE_SEND_OFFLOAD_V2_TYPE
;
535 if (net_trans_info
& (INFO_IPV4
<< 16)) {
536 lso_info
->lso_v2_transmit
.ip_version
=
537 NDIS_TCP_LARGE_SEND_OFFLOAD_IPV4
;
538 ip_hdr(skb
)->tot_len
= 0;
539 ip_hdr(skb
)->check
= 0;
540 tcp_hdr(skb
)->check
=
541 ~csum_tcpudp_magic(ip_hdr(skb
)->saddr
,
542 ip_hdr(skb
)->daddr
, 0, IPPROTO_TCP
, 0);
544 lso_info
->lso_v2_transmit
.ip_version
=
545 NDIS_TCP_LARGE_SEND_OFFLOAD_IPV6
;
546 ipv6_hdr(skb
)->payload_len
= 0;
547 tcp_hdr(skb
)->check
=
548 ~csum_ipv6_magic(&ipv6_hdr(skb
)->saddr
,
549 &ipv6_hdr(skb
)->daddr
, 0, IPPROTO_TCP
, 0);
551 lso_info
->lso_v2_transmit
.tcp_header_offset
= hdr_offset
;
552 lso_info
->lso_v2_transmit
.mss
= skb_shinfo(skb
)->gso_size
;
555 /* Start filling in the page buffers with the rndis hdr */
556 rndis_msg
->msg_len
+= rndis_msg_size
;
557 packet
->total_data_buflen
= rndis_msg
->msg_len
;
558 packet
->page_buf_cnt
= init_page_array(rndis_msg
, rndis_msg_size
,
559 skb
, &packet
->page_buf
[0]);
561 ret
= netvsc_send(net_device_ctx
->device_ctx
, packet
);
565 net
->stats
.tx_bytes
+= skb_length
;
566 net
->stats
.tx_packets
++;
569 if (ret
!= -EAGAIN
) {
570 dev_kfree_skb_any(skb
);
571 net
->stats
.tx_dropped
++;
575 return (ret
== -EAGAIN
) ? NETDEV_TX_BUSY
: NETDEV_TX_OK
;
579 * netvsc_linkstatus_callback - Link up/down notification
581 void netvsc_linkstatus_callback(struct hv_device
*device_obj
,
582 struct rndis_message
*resp
)
584 struct rndis_indicate_status
*indicate
= &resp
->msg
.indicate_status
;
585 struct net_device
*net
;
586 struct net_device_context
*ndev_ctx
;
587 struct netvsc_device
*net_device
;
588 struct rndis_device
*rdev
;
590 net_device
= hv_get_drvdata(device_obj
);
591 rdev
= net_device
->extension
;
593 switch (indicate
->status
) {
594 case RNDIS_STATUS_MEDIA_CONNECT
:
595 rdev
->link_state
= false;
597 case RNDIS_STATUS_MEDIA_DISCONNECT
:
598 rdev
->link_state
= true;
600 case RNDIS_STATUS_NETWORK_CHANGE
:
601 rdev
->link_change
= true;
607 net
= net_device
->ndev
;
609 if (!net
|| net
->reg_state
!= NETREG_REGISTERED
)
612 ndev_ctx
= netdev_priv(net
);
613 if (!rdev
->link_state
) {
614 schedule_delayed_work(&ndev_ctx
->dwork
, 0);
615 schedule_delayed_work(&ndev_ctx
->dwork
, msecs_to_jiffies(20));
617 schedule_delayed_work(&ndev_ctx
->dwork
, 0);
622 * netvsc_recv_callback - Callback when we receive a packet from the
623 * "wire" on the specified device.
625 int netvsc_recv_callback(struct hv_device
*device_obj
,
626 struct hv_netvsc_packet
*packet
,
627 struct ndis_tcp_ip_checksum_info
*csum_info
)
629 struct net_device
*net
;
632 net
= ((struct netvsc_device
*)hv_get_drvdata(device_obj
))->ndev
;
633 if (!net
|| net
->reg_state
!= NETREG_REGISTERED
) {
634 packet
->status
= NVSP_STAT_FAIL
;
638 /* Allocate a skb - TODO direct I/O to pages? */
639 skb
= netdev_alloc_skb_ip_align(net
, packet
->total_data_buflen
);
640 if (unlikely(!skb
)) {
641 ++net
->stats
.rx_dropped
;
642 packet
->status
= NVSP_STAT_FAIL
;
647 * Copy to skb. This copy is needed here since the memory pointed by
648 * hv_netvsc_packet cannot be deallocated
650 memcpy(skb_put(skb
, packet
->total_data_buflen
), packet
->data
,
651 packet
->total_data_buflen
);
653 skb
->protocol
= eth_type_trans(skb
, net
);
655 /* We only look at the IP checksum here.
656 * Should we be dropping the packet if checksum
657 * failed? How do we deal with other checksums - TCP/UDP?
659 if (csum_info
->receive
.ip_checksum_succeeded
)
660 skb
->ip_summed
= CHECKSUM_UNNECESSARY
;
662 skb
->ip_summed
= CHECKSUM_NONE
;
665 if (packet
->vlan_tci
& VLAN_TAG_PRESENT
)
666 __vlan_hwaccel_put_tag(skb
, htons(ETH_P_8021Q
),
669 skb_record_rx_queue(skb
, packet
->channel
->
670 offermsg
.offer
.sub_channel_index
);
672 net
->stats
.rx_packets
++;
673 net
->stats
.rx_bytes
+= packet
->total_data_buflen
;
676 * Pass the skb back up. Network stack will deallocate the skb when it
685 static void netvsc_get_drvinfo(struct net_device
*net
,
686 struct ethtool_drvinfo
*info
)
688 strlcpy(info
->driver
, KBUILD_MODNAME
, sizeof(info
->driver
));
689 strlcpy(info
->fw_version
, "N/A", sizeof(info
->fw_version
));
692 static void netvsc_get_channels(struct net_device
*net
,
693 struct ethtool_channels
*channel
)
695 struct net_device_context
*net_device_ctx
= netdev_priv(net
);
696 struct hv_device
*dev
= net_device_ctx
->device_ctx
;
697 struct netvsc_device
*nvdev
= hv_get_drvdata(dev
);
700 channel
->max_combined
= nvdev
->max_chn
;
701 channel
->combined_count
= nvdev
->num_chn
;
705 static int netvsc_change_mtu(struct net_device
*ndev
, int mtu
)
707 struct net_device_context
*ndevctx
= netdev_priv(ndev
);
708 struct hv_device
*hdev
= ndevctx
->device_ctx
;
709 struct netvsc_device
*nvdev
= hv_get_drvdata(hdev
);
710 struct netvsc_device_info device_info
;
711 int limit
= ETH_DATA_LEN
;
713 if (nvdev
== NULL
|| nvdev
->destroy
)
716 if (nvdev
->nvsp_version
>= NVSP_PROTOCOL_VERSION_2
)
717 limit
= NETVSC_MTU
- ETH_HLEN
;
719 /* Hyper-V hosts don't support MTU < ETH_DATA_LEN (1500) */
720 if (mtu
< ETH_DATA_LEN
|| mtu
> limit
)
723 nvdev
->start_remove
= true;
724 cancel_work_sync(&ndevctx
->work
);
725 netif_tx_disable(ndev
);
726 rndis_filter_device_remove(hdev
);
730 ndevctx
->device_ctx
= hdev
;
731 hv_set_drvdata(hdev
, ndev
);
732 device_info
.ring_size
= ring_size
;
733 rndis_filter_device_add(hdev
, &device_info
);
734 netif_tx_wake_all_queues(ndev
);
740 static int netvsc_set_mac_addr(struct net_device
*ndev
, void *p
)
742 struct net_device_context
*ndevctx
= netdev_priv(ndev
);
743 struct hv_device
*hdev
= ndevctx
->device_ctx
;
744 struct sockaddr
*addr
= p
;
745 char save_adr
[ETH_ALEN
];
746 unsigned char save_aatype
;
749 memcpy(save_adr
, ndev
->dev_addr
, ETH_ALEN
);
750 save_aatype
= ndev
->addr_assign_type
;
752 err
= eth_mac_addr(ndev
, p
);
756 err
= rndis_filter_set_device_mac(hdev
, addr
->sa_data
);
758 /* roll back to saved MAC */
759 memcpy(ndev
->dev_addr
, save_adr
, ETH_ALEN
);
760 ndev
->addr_assign_type
= save_aatype
;
766 #ifdef CONFIG_NET_POLL_CONTROLLER
767 static void netvsc_poll_controller(struct net_device
*net
)
769 /* As netvsc_start_xmit() works synchronous we don't have to
770 * trigger anything here.
775 static const struct ethtool_ops ethtool_ops
= {
776 .get_drvinfo
= netvsc_get_drvinfo
,
777 .get_link
= ethtool_op_get_link
,
778 .get_channels
= netvsc_get_channels
,
781 static const struct net_device_ops device_ops
= {
782 .ndo_open
= netvsc_open
,
783 .ndo_stop
= netvsc_close
,
784 .ndo_start_xmit
= netvsc_start_xmit
,
785 .ndo_set_rx_mode
= netvsc_set_multicast_list
,
786 .ndo_change_mtu
= netvsc_change_mtu
,
787 .ndo_validate_addr
= eth_validate_addr
,
788 .ndo_set_mac_address
= netvsc_set_mac_addr
,
789 .ndo_select_queue
= netvsc_select_queue
,
790 #ifdef CONFIG_NET_POLL_CONTROLLER
791 .ndo_poll_controller
= netvsc_poll_controller
,
796 * Send GARP packet to network peers after migrations.
797 * After Quick Migration, the network is not immediately operational in the
798 * current context when receiving RNDIS_STATUS_MEDIA_CONNECT event. So, add
799 * another netif_notify_peers() into a delayed work, otherwise GARP packet
800 * will not be sent after quick migration, and cause network disconnection.
801 * Also, we update the carrier status here.
803 static void netvsc_link_change(struct work_struct
*w
)
805 struct net_device_context
*ndev_ctx
;
806 struct net_device
*net
;
807 struct netvsc_device
*net_device
;
808 struct rndis_device
*rdev
;
809 bool notify
, refresh
= false;
810 char *argv
[] = { "/etc/init.d/network", "restart", NULL
};
811 char *envp
[] = { "HOME=/", "PATH=/sbin:/usr/sbin:/bin:/usr/bin", NULL
};
815 ndev_ctx
= container_of(w
, struct net_device_context
, dwork
.work
);
816 net_device
= hv_get_drvdata(ndev_ctx
->device_ctx
);
817 rdev
= net_device
->extension
;
818 net
= net_device
->ndev
;
820 if (rdev
->link_state
) {
821 netif_carrier_off(net
);
824 netif_carrier_on(net
);
826 if (rdev
->link_change
) {
827 rdev
->link_change
= false;
835 call_usermodehelper(argv
[0], argv
, envp
, UMH_WAIT_EXEC
);
838 netdev_notify_peers(net
);
842 static int netvsc_probe(struct hv_device
*dev
,
843 const struct hv_vmbus_device_id
*dev_id
)
845 struct net_device
*net
= NULL
;
846 struct net_device_context
*net_device_ctx
;
847 struct netvsc_device_info device_info
;
848 struct netvsc_device
*nvdev
;
851 net
= alloc_etherdev_mq(sizeof(struct net_device_context
),
856 netif_carrier_off(net
);
858 net_device_ctx
= netdev_priv(net
);
859 net_device_ctx
->device_ctx
= dev
;
860 hv_set_drvdata(dev
, net
);
861 INIT_DELAYED_WORK(&net_device_ctx
->dwork
, netvsc_link_change
);
862 INIT_WORK(&net_device_ctx
->work
, do_set_multicast
);
864 net
->netdev_ops
= &device_ops
;
866 net
->hw_features
= NETIF_F_RXCSUM
| NETIF_F_SG
| NETIF_F_IP_CSUM
|
868 net
->features
= NETIF_F_HW_VLAN_CTAG_TX
| NETIF_F_SG
| NETIF_F_RXCSUM
|
869 NETIF_F_IP_CSUM
| NETIF_F_TSO
;
871 net
->ethtool_ops
= ðtool_ops
;
872 SET_NETDEV_DEV(net
, &dev
->device
);
874 /* Notify the netvsc driver of the new device */
875 device_info
.ring_size
= ring_size
;
876 ret
= rndis_filter_device_add(dev
, &device_info
);
878 netdev_err(net
, "unable to add netvsc device (ret %d)\n", ret
);
880 hv_set_drvdata(dev
, NULL
);
883 memcpy(net
->dev_addr
, device_info
.mac_adr
, ETH_ALEN
);
885 nvdev
= hv_get_drvdata(dev
);
886 netif_set_real_num_tx_queues(net
, nvdev
->num_chn
);
887 netif_set_real_num_rx_queues(net
, nvdev
->num_chn
);
889 ret
= register_netdev(net
);
891 pr_err("Unable to register netdev.\n");
892 rndis_filter_device_remove(dev
);
895 schedule_delayed_work(&net_device_ctx
->dwork
, 0);
901 static int netvsc_remove(struct hv_device
*dev
)
903 struct net_device
*net
;
904 struct net_device_context
*ndev_ctx
;
905 struct netvsc_device
*net_device
;
907 net_device
= hv_get_drvdata(dev
);
908 net
= net_device
->ndev
;
911 dev_err(&dev
->device
, "No net device to remove\n");
915 net_device
->start_remove
= true;
917 ndev_ctx
= netdev_priv(net
);
918 cancel_delayed_work_sync(&ndev_ctx
->dwork
);
919 cancel_work_sync(&ndev_ctx
->work
);
921 /* Stop outbound asap */
922 netif_tx_disable(net
);
924 unregister_netdev(net
);
927 * Call to the vsc driver to let it know that the device is being
930 rndis_filter_device_remove(dev
);
936 static const struct hv_vmbus_device_id id_table
[] = {
942 MODULE_DEVICE_TABLE(vmbus
, id_table
);
944 /* The one and only one */
945 static struct hv_driver netvsc_drv
= {
946 .name
= KBUILD_MODNAME
,
947 .id_table
= id_table
,
948 .probe
= netvsc_probe
,
949 .remove
= netvsc_remove
,
952 static void __exit
netvsc_drv_exit(void)
954 vmbus_driver_unregister(&netvsc_drv
);
957 static int __init
netvsc_drv_init(void)
959 if (ring_size
< RING_SIZE_MIN
) {
960 ring_size
= RING_SIZE_MIN
;
961 pr_info("Increased ring_size to %d (min allowed)\n",
964 return vmbus_driver_register(&netvsc_drv
);
967 MODULE_LICENSE("GPL");
968 MODULE_DESCRIPTION("Microsoft Hyper-V network driver");
970 module_init(netvsc_drv_init
);
971 module_exit(netvsc_drv_exit
);