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
) || flow
.n_proto
!= htons(ETH_P_IP
))
199 if (flow
.ip_proto
== IPPROTO_TCP
)
204 *hash
= comp_hash(netvsc_hash_key
, HASH_KEYLEN
, &flow
, data_len
);
209 static u16
netvsc_select_queue(struct net_device
*ndev
, struct sk_buff
*skb
,
210 void *accel_priv
, select_queue_fallback_t fallback
)
212 struct net_device_context
*net_device_ctx
= netdev_priv(ndev
);
213 struct hv_device
*hdev
= net_device_ctx
->device_ctx
;
214 struct netvsc_device
*nvsc_dev
= hv_get_drvdata(hdev
);
218 if (nvsc_dev
== NULL
|| ndev
->real_num_tx_queues
<= 1)
221 if (netvsc_set_hash(&hash
, skb
)) {
222 q_idx
= nvsc_dev
->send_table
[hash
% VRSS_SEND_TAB_SIZE
] %
223 ndev
->real_num_tx_queues
;
224 skb_set_hash(skb
, hash
, PKT_HASH_TYPE_L3
);
230 static void netvsc_xmit_completion(void *context
)
232 struct hv_netvsc_packet
*packet
= (struct hv_netvsc_packet
*)context
;
233 struct sk_buff
*skb
= (struct sk_buff
*)
234 (unsigned long)packet
->send_completion_tid
;
235 u32 index
= packet
->send_buf_index
;
239 if (skb
&& (index
== NETVSC_INVALID_INDEX
))
240 dev_kfree_skb_any(skb
);
243 static u32
fill_pg_buf(struct page
*page
, u32 offset
, u32 len
,
244 struct hv_page_buffer
*pb
)
248 /* Deal with compund pages by ignoring unused part
251 page
+= (offset
>> PAGE_SHIFT
);
252 offset
&= ~PAGE_MASK
;
257 bytes
= PAGE_SIZE
- offset
;
260 pb
[j
].pfn
= page_to_pfn(page
);
261 pb
[j
].offset
= offset
;
267 if (offset
== PAGE_SIZE
&& len
) {
277 static u32
init_page_array(void *hdr
, u32 len
, struct sk_buff
*skb
,
278 struct hv_page_buffer
*pb
)
281 char *data
= skb
->data
;
282 int frags
= skb_shinfo(skb
)->nr_frags
;
285 /* The packet is laid out thus:
288 * 3. skb fragment data
291 slots_used
+= fill_pg_buf(virt_to_page(hdr
),
293 len
, &pb
[slots_used
]);
295 slots_used
+= fill_pg_buf(virt_to_page(data
),
296 offset_in_page(data
),
297 skb_headlen(skb
), &pb
[slots_used
]);
299 for (i
= 0; i
< frags
; i
++) {
300 skb_frag_t
*frag
= skb_shinfo(skb
)->frags
+ i
;
302 slots_used
+= fill_pg_buf(skb_frag_page(frag
),
304 skb_frag_size(frag
), &pb
[slots_used
]);
309 static int count_skb_frag_slots(struct sk_buff
*skb
)
311 int i
, frags
= skb_shinfo(skb
)->nr_frags
;
314 for (i
= 0; i
< frags
; i
++) {
315 skb_frag_t
*frag
= skb_shinfo(skb
)->frags
+ i
;
316 unsigned long size
= skb_frag_size(frag
);
317 unsigned long offset
= frag
->page_offset
;
319 /* Skip unused frames from start of page */
320 offset
&= ~PAGE_MASK
;
321 pages
+= PFN_UP(offset
+ size
);
326 static int netvsc_get_slots(struct sk_buff
*skb
)
328 char *data
= skb
->data
;
329 unsigned int offset
= offset_in_page(data
);
330 unsigned int len
= skb_headlen(skb
);
334 slots
= DIV_ROUND_UP(offset
+ len
, PAGE_SIZE
);
335 frag_slots
= count_skb_frag_slots(skb
);
336 return slots
+ frag_slots
;
339 static u32
get_net_transport_info(struct sk_buff
*skb
, u32
*trans_off
)
341 u32 ret_val
= TRANSPORT_INFO_NOT_IP
;
343 if ((eth_hdr(skb
)->h_proto
!= htons(ETH_P_IP
)) &&
344 (eth_hdr(skb
)->h_proto
!= htons(ETH_P_IPV6
))) {
348 *trans_off
= skb_transport_offset(skb
);
350 if ((eth_hdr(skb
)->h_proto
== htons(ETH_P_IP
))) {
351 struct iphdr
*iphdr
= ip_hdr(skb
);
353 if (iphdr
->protocol
== IPPROTO_TCP
)
354 ret_val
= TRANSPORT_INFO_IPV4_TCP
;
355 else if (iphdr
->protocol
== IPPROTO_UDP
)
356 ret_val
= TRANSPORT_INFO_IPV4_UDP
;
358 if (ipv6_hdr(skb
)->nexthdr
== IPPROTO_TCP
)
359 ret_val
= TRANSPORT_INFO_IPV6_TCP
;
360 else if (ipv6_hdr(skb
)->nexthdr
== IPPROTO_UDP
)
361 ret_val
= TRANSPORT_INFO_IPV6_UDP
;
368 static int netvsc_start_xmit(struct sk_buff
*skb
, struct net_device
*net
)
370 struct net_device_context
*net_device_ctx
= netdev_priv(net
);
371 struct hv_netvsc_packet
*packet
;
373 unsigned int num_data_pgs
;
374 struct rndis_message
*rndis_msg
;
375 struct rndis_packet
*rndis_pkt
;
378 struct rndis_per_packet_info
*ppi
;
379 struct ndis_tcp_ip_checksum_info
*csum_info
;
380 struct ndis_tcp_lso_info
*lso_info
;
384 u32 skb_length
= skb
->len
;
387 /* We will atmost need two pages to describe the rndis
388 * header. We can only transmit MAX_PAGE_BUFFER_COUNT number
389 * of pages in a single packet.
391 num_data_pgs
= netvsc_get_slots(skb
) + 2;
392 if (num_data_pgs
> MAX_PAGE_BUFFER_COUNT
) {
393 netdev_err(net
, "Packet too big: %u\n", skb
->len
);
395 net
->stats
.tx_dropped
++;
399 /* Allocate a netvsc packet based on # of frags. */
400 packet
= kzalloc(sizeof(struct hv_netvsc_packet
) +
401 (num_data_pgs
* sizeof(struct hv_page_buffer
)) +
402 sizeof(struct rndis_message
) +
403 NDIS_VLAN_PPI_SIZE
+ NDIS_CSUM_PPI_SIZE
+
404 NDIS_LSO_PPI_SIZE
+ NDIS_HASH_PPI_SIZE
, GFP_ATOMIC
);
406 /* out of memory, drop packet */
407 netdev_err(net
, "unable to allocate hv_netvsc_packet\n");
410 net
->stats
.tx_dropped
++;
414 packet
->vlan_tci
= skb
->vlan_tci
;
416 packet
->q_idx
= skb_get_queue_mapping(skb
);
418 packet
->is_data_pkt
= true;
419 packet
->total_data_buflen
= skb
->len
;
421 packet
->rndis_msg
= (struct rndis_message
*)((unsigned long)packet
+
422 sizeof(struct hv_netvsc_packet
) +
423 (num_data_pgs
* sizeof(struct hv_page_buffer
)));
425 /* Set the completion routine */
426 packet
->send_completion
= netvsc_xmit_completion
;
427 packet
->send_completion_ctx
= packet
;
428 packet
->send_completion_tid
= (unsigned long)skb
;
430 isvlan
= packet
->vlan_tci
& VLAN_TAG_PRESENT
;
432 /* Add the rndis header */
433 rndis_msg
= packet
->rndis_msg
;
434 rndis_msg
->ndis_msg_type
= RNDIS_MSG_PACKET
;
435 rndis_msg
->msg_len
= packet
->total_data_buflen
;
436 rndis_pkt
= &rndis_msg
->msg
.pkt
;
437 rndis_pkt
->data_offset
= sizeof(struct rndis_packet
);
438 rndis_pkt
->data_len
= packet
->total_data_buflen
;
439 rndis_pkt
->per_pkt_info_offset
= sizeof(struct rndis_packet
);
441 rndis_msg_size
= RNDIS_MESSAGE_SIZE(struct rndis_packet
);
443 hash
= skb_get_hash_raw(skb
);
444 if (hash
!= 0 && net
->real_num_tx_queues
> 1) {
445 rndis_msg_size
+= NDIS_HASH_PPI_SIZE
;
446 ppi
= init_ppi_data(rndis_msg
, NDIS_HASH_PPI_SIZE
,
448 *(u32
*)((void *)ppi
+ ppi
->ppi_offset
) = hash
;
452 struct ndis_pkt_8021q_info
*vlan
;
454 rndis_msg_size
+= NDIS_VLAN_PPI_SIZE
;
455 ppi
= init_ppi_data(rndis_msg
, NDIS_VLAN_PPI_SIZE
,
457 vlan
= (struct ndis_pkt_8021q_info
*)((void *)ppi
+
459 vlan
->vlanid
= packet
->vlan_tci
& VLAN_VID_MASK
;
460 vlan
->pri
= (packet
->vlan_tci
& VLAN_PRIO_MASK
) >>
464 net_trans_info
= get_net_transport_info(skb
, &hdr_offset
);
465 if (net_trans_info
== TRANSPORT_INFO_NOT_IP
)
469 * Setup the sendside checksum offload only if this is not a
475 if ((skb
->ip_summed
== CHECKSUM_NONE
) ||
476 (skb
->ip_summed
== CHECKSUM_UNNECESSARY
))
479 rndis_msg_size
+= NDIS_CSUM_PPI_SIZE
;
480 ppi
= init_ppi_data(rndis_msg
, NDIS_CSUM_PPI_SIZE
,
481 TCPIP_CHKSUM_PKTINFO
);
483 csum_info
= (struct ndis_tcp_ip_checksum_info
*)((void *)ppi
+
486 if (net_trans_info
& (INFO_IPV4
<< 16))
487 csum_info
->transmit
.is_ipv4
= 1;
489 csum_info
->transmit
.is_ipv6
= 1;
491 if (net_trans_info
& INFO_TCP
) {
492 csum_info
->transmit
.tcp_checksum
= 1;
493 csum_info
->transmit
.tcp_header_offset
= hdr_offset
;
494 } else if (net_trans_info
& INFO_UDP
) {
495 /* UDP checksum offload is not supported on ws2008r2.
496 * Furthermore, on ws2012 and ws2012r2, there are some
497 * issues with udp checksum offload from Linux guests.
498 * (these are host issues).
499 * For now compute the checksum here.
504 ret
= skb_cow_head(skb
, 0);
509 udp_len
= ntohs(uh
->len
);
511 uh
->check
= csum_tcpudp_magic(ip_hdr(skb
)->saddr
,
513 udp_len
, IPPROTO_UDP
,
514 csum_partial(uh
, udp_len
, 0));
516 uh
->check
= CSUM_MANGLED_0
;
518 csum_info
->transmit
.udp_checksum
= 0;
523 rndis_msg_size
+= NDIS_LSO_PPI_SIZE
;
524 ppi
= init_ppi_data(rndis_msg
, NDIS_LSO_PPI_SIZE
,
525 TCP_LARGESEND_PKTINFO
);
527 lso_info
= (struct ndis_tcp_lso_info
*)((void *)ppi
+
530 lso_info
->lso_v2_transmit
.type
= NDIS_TCP_LARGE_SEND_OFFLOAD_V2_TYPE
;
531 if (net_trans_info
& (INFO_IPV4
<< 16)) {
532 lso_info
->lso_v2_transmit
.ip_version
=
533 NDIS_TCP_LARGE_SEND_OFFLOAD_IPV4
;
534 ip_hdr(skb
)->tot_len
= 0;
535 ip_hdr(skb
)->check
= 0;
536 tcp_hdr(skb
)->check
=
537 ~csum_tcpudp_magic(ip_hdr(skb
)->saddr
,
538 ip_hdr(skb
)->daddr
, 0, IPPROTO_TCP
, 0);
540 lso_info
->lso_v2_transmit
.ip_version
=
541 NDIS_TCP_LARGE_SEND_OFFLOAD_IPV6
;
542 ipv6_hdr(skb
)->payload_len
= 0;
543 tcp_hdr(skb
)->check
=
544 ~csum_ipv6_magic(&ipv6_hdr(skb
)->saddr
,
545 &ipv6_hdr(skb
)->daddr
, 0, IPPROTO_TCP
, 0);
547 lso_info
->lso_v2_transmit
.tcp_header_offset
= hdr_offset
;
548 lso_info
->lso_v2_transmit
.mss
= skb_shinfo(skb
)->gso_size
;
551 /* Start filling in the page buffers with the rndis hdr */
552 rndis_msg
->msg_len
+= rndis_msg_size
;
553 packet
->total_data_buflen
= rndis_msg
->msg_len
;
554 packet
->page_buf_cnt
= init_page_array(rndis_msg
, rndis_msg_size
,
555 skb
, &packet
->page_buf
[0]);
557 ret
= netvsc_send(net_device_ctx
->device_ctx
, packet
);
561 net
->stats
.tx_bytes
+= skb_length
;
562 net
->stats
.tx_packets
++;
565 if (ret
!= -EAGAIN
) {
566 dev_kfree_skb_any(skb
);
567 net
->stats
.tx_dropped
++;
571 return (ret
== -EAGAIN
) ? NETDEV_TX_BUSY
: NETDEV_TX_OK
;
575 * netvsc_linkstatus_callback - Link up/down notification
577 void netvsc_linkstatus_callback(struct hv_device
*device_obj
,
578 struct rndis_message
*resp
)
580 struct rndis_indicate_status
*indicate
= &resp
->msg
.indicate_status
;
581 struct net_device
*net
;
582 struct net_device_context
*ndev_ctx
;
583 struct netvsc_device
*net_device
;
584 struct rndis_device
*rdev
;
586 net_device
= hv_get_drvdata(device_obj
);
587 rdev
= net_device
->extension
;
589 switch (indicate
->status
) {
590 case RNDIS_STATUS_MEDIA_CONNECT
:
591 rdev
->link_state
= false;
593 case RNDIS_STATUS_MEDIA_DISCONNECT
:
594 rdev
->link_state
= true;
596 case RNDIS_STATUS_NETWORK_CHANGE
:
597 rdev
->link_change
= true;
603 net
= net_device
->ndev
;
605 if (!net
|| net
->reg_state
!= NETREG_REGISTERED
)
608 ndev_ctx
= netdev_priv(net
);
609 if (!rdev
->link_state
) {
610 schedule_delayed_work(&ndev_ctx
->dwork
, 0);
611 schedule_delayed_work(&ndev_ctx
->dwork
, msecs_to_jiffies(20));
613 schedule_delayed_work(&ndev_ctx
->dwork
, 0);
618 * netvsc_recv_callback - Callback when we receive a packet from the
619 * "wire" on the specified device.
621 int netvsc_recv_callback(struct hv_device
*device_obj
,
622 struct hv_netvsc_packet
*packet
,
623 struct ndis_tcp_ip_checksum_info
*csum_info
)
625 struct net_device
*net
;
628 net
= ((struct netvsc_device
*)hv_get_drvdata(device_obj
))->ndev
;
629 if (!net
|| net
->reg_state
!= NETREG_REGISTERED
) {
630 packet
->status
= NVSP_STAT_FAIL
;
634 /* Allocate a skb - TODO direct I/O to pages? */
635 skb
= netdev_alloc_skb_ip_align(net
, packet
->total_data_buflen
);
636 if (unlikely(!skb
)) {
637 ++net
->stats
.rx_dropped
;
638 packet
->status
= NVSP_STAT_FAIL
;
643 * Copy to skb. This copy is needed here since the memory pointed by
644 * hv_netvsc_packet cannot be deallocated
646 memcpy(skb_put(skb
, packet
->total_data_buflen
), packet
->data
,
647 packet
->total_data_buflen
);
649 skb
->protocol
= eth_type_trans(skb
, net
);
651 /* We only look at the IP checksum here.
652 * Should we be dropping the packet if checksum
653 * failed? How do we deal with other checksums - TCP/UDP?
655 if (csum_info
->receive
.ip_checksum_succeeded
)
656 skb
->ip_summed
= CHECKSUM_UNNECESSARY
;
658 skb
->ip_summed
= CHECKSUM_NONE
;
661 if (packet
->vlan_tci
& VLAN_TAG_PRESENT
)
662 __vlan_hwaccel_put_tag(skb
, htons(ETH_P_8021Q
),
665 skb_record_rx_queue(skb
, packet
->channel
->
666 offermsg
.offer
.sub_channel_index
);
668 net
->stats
.rx_packets
++;
669 net
->stats
.rx_bytes
+= packet
->total_data_buflen
;
672 * Pass the skb back up. Network stack will deallocate the skb when it
681 static void netvsc_get_drvinfo(struct net_device
*net
,
682 struct ethtool_drvinfo
*info
)
684 strlcpy(info
->driver
, KBUILD_MODNAME
, sizeof(info
->driver
));
685 strlcpy(info
->fw_version
, "N/A", sizeof(info
->fw_version
));
688 static int netvsc_change_mtu(struct net_device
*ndev
, int mtu
)
690 struct net_device_context
*ndevctx
= netdev_priv(ndev
);
691 struct hv_device
*hdev
= ndevctx
->device_ctx
;
692 struct netvsc_device
*nvdev
= hv_get_drvdata(hdev
);
693 struct netvsc_device_info device_info
;
694 int limit
= ETH_DATA_LEN
;
696 if (nvdev
== NULL
|| nvdev
->destroy
)
699 if (nvdev
->nvsp_version
>= NVSP_PROTOCOL_VERSION_2
)
702 if (mtu
< 68 || mtu
> limit
)
705 nvdev
->start_remove
= true;
706 cancel_work_sync(&ndevctx
->work
);
707 netif_tx_disable(ndev
);
708 rndis_filter_device_remove(hdev
);
712 ndevctx
->device_ctx
= hdev
;
713 hv_set_drvdata(hdev
, ndev
);
714 device_info
.ring_size
= ring_size
;
715 rndis_filter_device_add(hdev
, &device_info
);
716 netif_tx_wake_all_queues(ndev
);
722 static int netvsc_set_mac_addr(struct net_device
*ndev
, void *p
)
724 struct net_device_context
*ndevctx
= netdev_priv(ndev
);
725 struct hv_device
*hdev
= ndevctx
->device_ctx
;
726 struct sockaddr
*addr
= p
;
727 char save_adr
[ETH_ALEN
];
728 unsigned char save_aatype
;
731 memcpy(save_adr
, ndev
->dev_addr
, ETH_ALEN
);
732 save_aatype
= ndev
->addr_assign_type
;
734 err
= eth_mac_addr(ndev
, p
);
738 err
= rndis_filter_set_device_mac(hdev
, addr
->sa_data
);
740 /* roll back to saved MAC */
741 memcpy(ndev
->dev_addr
, save_adr
, ETH_ALEN
);
742 ndev
->addr_assign_type
= save_aatype
;
748 #ifdef CONFIG_NET_POLL_CONTROLLER
749 static void netvsc_poll_controller(struct net_device
*net
)
751 /* As netvsc_start_xmit() works synchronous we don't have to
752 * trigger anything here.
757 static const struct ethtool_ops ethtool_ops
= {
758 .get_drvinfo
= netvsc_get_drvinfo
,
759 .get_link
= ethtool_op_get_link
,
762 static const struct net_device_ops device_ops
= {
763 .ndo_open
= netvsc_open
,
764 .ndo_stop
= netvsc_close
,
765 .ndo_start_xmit
= netvsc_start_xmit
,
766 .ndo_set_rx_mode
= netvsc_set_multicast_list
,
767 .ndo_change_mtu
= netvsc_change_mtu
,
768 .ndo_validate_addr
= eth_validate_addr
,
769 .ndo_set_mac_address
= netvsc_set_mac_addr
,
770 .ndo_select_queue
= netvsc_select_queue
,
771 #ifdef CONFIG_NET_POLL_CONTROLLER
772 .ndo_poll_controller
= netvsc_poll_controller
,
777 * Send GARP packet to network peers after migrations.
778 * After Quick Migration, the network is not immediately operational in the
779 * current context when receiving RNDIS_STATUS_MEDIA_CONNECT event. So, add
780 * another netif_notify_peers() into a delayed work, otherwise GARP packet
781 * will not be sent after quick migration, and cause network disconnection.
782 * Also, we update the carrier status here.
784 static void netvsc_link_change(struct work_struct
*w
)
786 struct net_device_context
*ndev_ctx
;
787 struct net_device
*net
;
788 struct netvsc_device
*net_device
;
789 struct rndis_device
*rdev
;
790 bool notify
, refresh
= false;
791 char *argv
[] = { "/etc/init.d/network", "restart", NULL
};
792 char *envp
[] = { "HOME=/", "PATH=/sbin:/usr/sbin:/bin:/usr/bin", NULL
};
796 ndev_ctx
= container_of(w
, struct net_device_context
, dwork
.work
);
797 net_device
= hv_get_drvdata(ndev_ctx
->device_ctx
);
798 rdev
= net_device
->extension
;
799 net
= net_device
->ndev
;
801 if (rdev
->link_state
) {
802 netif_carrier_off(net
);
805 netif_carrier_on(net
);
807 if (rdev
->link_change
) {
808 rdev
->link_change
= false;
816 call_usermodehelper(argv
[0], argv
, envp
, UMH_WAIT_EXEC
);
819 netdev_notify_peers(net
);
823 static int netvsc_probe(struct hv_device
*dev
,
824 const struct hv_vmbus_device_id
*dev_id
)
826 struct net_device
*net
= NULL
;
827 struct net_device_context
*net_device_ctx
;
828 struct netvsc_device_info device_info
;
829 struct netvsc_device
*nvdev
;
832 net
= alloc_etherdev_mq(sizeof(struct net_device_context
),
837 netif_carrier_off(net
);
839 net_device_ctx
= netdev_priv(net
);
840 net_device_ctx
->device_ctx
= dev
;
841 hv_set_drvdata(dev
, net
);
842 INIT_DELAYED_WORK(&net_device_ctx
->dwork
, netvsc_link_change
);
843 INIT_WORK(&net_device_ctx
->work
, do_set_multicast
);
845 net
->netdev_ops
= &device_ops
;
847 net
->hw_features
= NETIF_F_RXCSUM
| NETIF_F_SG
| NETIF_F_IP_CSUM
|
849 net
->features
= NETIF_F_HW_VLAN_CTAG_TX
| NETIF_F_SG
| NETIF_F_RXCSUM
|
850 NETIF_F_IP_CSUM
| NETIF_F_TSO
;
852 net
->ethtool_ops
= ðtool_ops
;
853 SET_NETDEV_DEV(net
, &dev
->device
);
855 /* Notify the netvsc driver of the new device */
856 device_info
.ring_size
= ring_size
;
857 ret
= rndis_filter_device_add(dev
, &device_info
);
859 netdev_err(net
, "unable to add netvsc device (ret %d)\n", ret
);
861 hv_set_drvdata(dev
, NULL
);
864 memcpy(net
->dev_addr
, device_info
.mac_adr
, ETH_ALEN
);
866 nvdev
= hv_get_drvdata(dev
);
867 netif_set_real_num_tx_queues(net
, nvdev
->num_chn
);
868 netif_set_real_num_rx_queues(net
, nvdev
->num_chn
);
870 ret
= register_netdev(net
);
872 pr_err("Unable to register netdev.\n");
873 rndis_filter_device_remove(dev
);
876 schedule_delayed_work(&net_device_ctx
->dwork
, 0);
882 static int netvsc_remove(struct hv_device
*dev
)
884 struct net_device
*net
;
885 struct net_device_context
*ndev_ctx
;
886 struct netvsc_device
*net_device
;
888 net_device
= hv_get_drvdata(dev
);
889 net
= net_device
->ndev
;
892 dev_err(&dev
->device
, "No net device to remove\n");
896 net_device
->start_remove
= true;
898 ndev_ctx
= netdev_priv(net
);
899 cancel_delayed_work_sync(&ndev_ctx
->dwork
);
900 cancel_work_sync(&ndev_ctx
->work
);
902 /* Stop outbound asap */
903 netif_tx_disable(net
);
905 unregister_netdev(net
);
908 * Call to the vsc driver to let it know that the device is being
911 rndis_filter_device_remove(dev
);
917 static const struct hv_vmbus_device_id id_table
[] = {
923 MODULE_DEVICE_TABLE(vmbus
, id_table
);
925 /* The one and only one */
926 static struct hv_driver netvsc_drv
= {
927 .name
= KBUILD_MODNAME
,
928 .id_table
= id_table
,
929 .probe
= netvsc_probe
,
930 .remove
= netvsc_remove
,
933 static void __exit
netvsc_drv_exit(void)
935 vmbus_driver_unregister(&netvsc_drv
);
938 static int __init
netvsc_drv_init(void)
940 if (ring_size
< RING_SIZE_MIN
) {
941 ring_size
= RING_SIZE_MIN
;
942 pr_info("Increased ring_size to %d (min allowed)\n",
945 return vmbus_driver_register(&netvsc_drv
);
948 MODULE_LICENSE("GPL");
949 MODULE_DESCRIPTION("Microsoft Hyper-V network driver");
951 module_init(netvsc_drv_init
);
952 module_exit(netvsc_drv_exit
);