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"
44 #define RING_SIZE_MIN 64
45 #define LINKCHANGE_INT (2 * HZ)
46 #define NETVSC_HW_FEATURES (NETIF_F_RXCSUM | \
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 int max_num_vrss_chns
= 8;
57 static const u32 default_msg
= NETIF_MSG_DRV
| NETIF_MSG_PROBE
|
58 NETIF_MSG_LINK
| NETIF_MSG_IFUP
|
59 NETIF_MSG_IFDOWN
| NETIF_MSG_RX_ERR
|
62 static int debug
= -1;
63 module_param(debug
, int, S_IRUGO
);
64 MODULE_PARM_DESC(debug
, "Debug level (0=none,...,16=all)");
66 static void do_set_multicast(struct work_struct
*w
)
68 struct net_device_context
*ndevctx
=
69 container_of(w
, struct net_device_context
, work
);
70 struct hv_device
*device_obj
= ndevctx
->device_ctx
;
71 struct net_device
*ndev
= hv_get_drvdata(device_obj
);
72 struct netvsc_device
*nvdev
= ndevctx
->nvdev
;
73 struct rndis_device
*rdev
;
78 rdev
= nvdev
->extension
;
82 if (ndev
->flags
& IFF_PROMISC
)
83 rndis_filter_set_packet_filter(rdev
,
84 NDIS_PACKET_TYPE_PROMISCUOUS
);
86 rndis_filter_set_packet_filter(rdev
,
87 NDIS_PACKET_TYPE_BROADCAST
|
88 NDIS_PACKET_TYPE_ALL_MULTICAST
|
89 NDIS_PACKET_TYPE_DIRECTED
);
92 static void netvsc_set_multicast_list(struct net_device
*net
)
94 struct net_device_context
*net_device_ctx
= netdev_priv(net
);
96 schedule_work(&net_device_ctx
->work
);
99 static int netvsc_open(struct net_device
*net
)
101 struct net_device_context
*net_device_ctx
= netdev_priv(net
);
102 struct hv_device
*device_obj
= net_device_ctx
->device_ctx
;
103 struct netvsc_device
*nvdev
= net_device_ctx
->nvdev
;
104 struct rndis_device
*rdev
;
107 netif_carrier_off(net
);
109 /* Open up the device */
110 ret
= rndis_filter_open(device_obj
);
112 netdev_err(net
, "unable to open device (ret %d).\n", ret
);
116 netif_tx_wake_all_queues(net
);
118 rdev
= nvdev
->extension
;
119 if (!rdev
->link_state
)
120 netif_carrier_on(net
);
125 static int netvsc_close(struct net_device
*net
)
127 struct net_device_context
*net_device_ctx
= netdev_priv(net
);
128 struct hv_device
*device_obj
= net_device_ctx
->device_ctx
;
129 struct netvsc_device
*nvdev
= net_device_ctx
->nvdev
;
131 u32 aread
, awrite
, i
, msec
= 10, retry
= 0, retry_max
= 20;
132 struct vmbus_channel
*chn
;
134 netif_tx_disable(net
);
136 /* Make sure netvsc_set_multicast_list doesn't re-enable filter! */
137 cancel_work_sync(&net_device_ctx
->work
);
138 ret
= rndis_filter_close(device_obj
);
140 netdev_err(net
, "unable to close device (ret %d).\n", ret
);
144 /* Ensure pending bytes in ring are read */
147 for (i
= 0; i
< nvdev
->num_chn
; i
++) {
148 chn
= nvdev
->chn_table
[i
];
152 hv_get_ringbuffer_availbytes(&chn
->inbound
, &aread
,
158 hv_get_ringbuffer_availbytes(&chn
->outbound
, &aread
,
166 if (retry
> retry_max
|| aread
== 0)
176 netdev_err(net
, "Ring buffer not empty after closing rndis\n");
183 static void *init_ppi_data(struct rndis_message
*msg
, u32 ppi_size
,
186 struct rndis_packet
*rndis_pkt
;
187 struct rndis_per_packet_info
*ppi
;
189 rndis_pkt
= &msg
->msg
.pkt
;
190 rndis_pkt
->data_offset
+= ppi_size
;
192 ppi
= (struct rndis_per_packet_info
*)((void *)rndis_pkt
+
193 rndis_pkt
->per_pkt_info_offset
+ rndis_pkt
->per_pkt_info_len
);
195 ppi
->size
= ppi_size
;
196 ppi
->type
= pkt_type
;
197 ppi
->ppi_offset
= sizeof(struct rndis_per_packet_info
);
199 rndis_pkt
->per_pkt_info_len
+= ppi_size
;
204 static u16
netvsc_select_queue(struct net_device
*ndev
, struct sk_buff
*skb
,
205 void *accel_priv
, select_queue_fallback_t fallback
)
207 struct net_device_context
*net_device_ctx
= netdev_priv(ndev
);
208 struct netvsc_device
*nvsc_dev
= net_device_ctx
->nvdev
;
212 if (nvsc_dev
== NULL
|| ndev
->real_num_tx_queues
<= 1)
215 hash
= skb_get_hash(skb
);
216 q_idx
= nvsc_dev
->send_table
[hash
% VRSS_SEND_TAB_SIZE
] %
217 ndev
->real_num_tx_queues
;
219 if (!nvsc_dev
->chn_table
[q_idx
])
225 static u32
fill_pg_buf(struct page
*page
, u32 offset
, u32 len
,
226 struct hv_page_buffer
*pb
)
230 /* Deal with compund pages by ignoring unused part
233 page
+= (offset
>> PAGE_SHIFT
);
234 offset
&= ~PAGE_MASK
;
239 bytes
= PAGE_SIZE
- offset
;
242 pb
[j
].pfn
= page_to_pfn(page
);
243 pb
[j
].offset
= offset
;
249 if (offset
== PAGE_SIZE
&& len
) {
259 static u32
init_page_array(void *hdr
, u32 len
, struct sk_buff
*skb
,
260 struct hv_netvsc_packet
*packet
,
261 struct hv_page_buffer
**page_buf
)
263 struct hv_page_buffer
*pb
= *page_buf
;
265 char *data
= skb
->data
;
266 int frags
= skb_shinfo(skb
)->nr_frags
;
269 /* The packet is laid out thus:
270 * 1. hdr: RNDIS header and PPI
272 * 3. skb fragment data
275 slots_used
+= fill_pg_buf(virt_to_page(hdr
),
277 len
, &pb
[slots_used
]);
279 packet
->rmsg_size
= len
;
280 packet
->rmsg_pgcnt
= slots_used
;
282 slots_used
+= fill_pg_buf(virt_to_page(data
),
283 offset_in_page(data
),
284 skb_headlen(skb
), &pb
[slots_used
]);
286 for (i
= 0; i
< frags
; i
++) {
287 skb_frag_t
*frag
= skb_shinfo(skb
)->frags
+ i
;
289 slots_used
+= fill_pg_buf(skb_frag_page(frag
),
291 skb_frag_size(frag
), &pb
[slots_used
]);
296 static int count_skb_frag_slots(struct sk_buff
*skb
)
298 int i
, frags
= skb_shinfo(skb
)->nr_frags
;
301 for (i
= 0; i
< frags
; i
++) {
302 skb_frag_t
*frag
= skb_shinfo(skb
)->frags
+ i
;
303 unsigned long size
= skb_frag_size(frag
);
304 unsigned long offset
= frag
->page_offset
;
306 /* Skip unused frames from start of page */
307 offset
&= ~PAGE_MASK
;
308 pages
+= PFN_UP(offset
+ size
);
313 static int netvsc_get_slots(struct sk_buff
*skb
)
315 char *data
= skb
->data
;
316 unsigned int offset
= offset_in_page(data
);
317 unsigned int len
= skb_headlen(skb
);
321 slots
= DIV_ROUND_UP(offset
+ len
, PAGE_SIZE
);
322 frag_slots
= count_skb_frag_slots(skb
);
323 return slots
+ frag_slots
;
326 static u32
get_net_transport_info(struct sk_buff
*skb
, u32
*trans_off
)
328 u32 ret_val
= TRANSPORT_INFO_NOT_IP
;
330 if ((eth_hdr(skb
)->h_proto
!= htons(ETH_P_IP
)) &&
331 (eth_hdr(skb
)->h_proto
!= htons(ETH_P_IPV6
))) {
335 *trans_off
= skb_transport_offset(skb
);
337 if ((eth_hdr(skb
)->h_proto
== htons(ETH_P_IP
))) {
338 struct iphdr
*iphdr
= ip_hdr(skb
);
340 if (iphdr
->protocol
== IPPROTO_TCP
)
341 ret_val
= TRANSPORT_INFO_IPV4_TCP
;
342 else if (iphdr
->protocol
== IPPROTO_UDP
)
343 ret_val
= TRANSPORT_INFO_IPV4_UDP
;
345 if (ipv6_hdr(skb
)->nexthdr
== IPPROTO_TCP
)
346 ret_val
= TRANSPORT_INFO_IPV6_TCP
;
347 else if (ipv6_hdr(skb
)->nexthdr
== IPPROTO_UDP
)
348 ret_val
= TRANSPORT_INFO_IPV6_UDP
;
355 static int netvsc_start_xmit(struct sk_buff
*skb
, struct net_device
*net
)
357 struct net_device_context
*net_device_ctx
= netdev_priv(net
);
358 struct hv_netvsc_packet
*packet
= NULL
;
360 unsigned int num_data_pgs
;
361 struct rndis_message
*rndis_msg
;
362 struct rndis_packet
*rndis_pkt
;
366 struct rndis_per_packet_info
*ppi
;
367 struct ndis_tcp_ip_checksum_info
*csum_info
;
368 struct ndis_tcp_lso_info
*lso_info
;
373 struct hv_page_buffer page_buf
[MAX_PAGE_BUFFER_COUNT
];
374 struct hv_page_buffer
*pb
= page_buf
;
375 struct netvsc_stats
*tx_stats
= this_cpu_ptr(net_device_ctx
->tx_stats
);
377 /* We will atmost need two pages to describe the rndis
378 * header. We can only transmit MAX_PAGE_BUFFER_COUNT number
379 * of pages in a single packet. If skb is scattered around
380 * more pages we try linearizing it.
384 skb_length
= skb
->len
;
385 num_data_pgs
= netvsc_get_slots(skb
) + 2;
386 if (num_data_pgs
> MAX_PAGE_BUFFER_COUNT
&& linear
) {
387 net_alert_ratelimited("packet too big: %u pages (%u bytes)\n",
388 num_data_pgs
, skb
->len
);
391 } else if (num_data_pgs
> MAX_PAGE_BUFFER_COUNT
) {
392 if (skb_linearize(skb
)) {
393 net_alert_ratelimited("failed to linearize skb\n");
402 * Place the rndis header in the skb head room and
403 * the skb->cb will be used for hv_netvsc_packet
406 ret
= skb_cow_head(skb
, RNDIS_AND_PPI_SIZE
);
408 netdev_err(net
, "unable to alloc hv_netvsc_packet\n");
412 /* Use the skb control buffer for building up the packet */
413 BUILD_BUG_ON(sizeof(struct hv_netvsc_packet
) >
414 FIELD_SIZEOF(struct sk_buff
, cb
));
415 packet
= (struct hv_netvsc_packet
*)skb
->cb
;
418 packet
->q_idx
= skb_get_queue_mapping(skb
);
420 packet
->total_data_buflen
= skb
->len
;
422 rndis_msg
= (struct rndis_message
*)skb
->head
;
424 memset(rndis_msg
, 0, RNDIS_AND_PPI_SIZE
);
426 isvlan
= skb
->vlan_tci
& VLAN_TAG_PRESENT
;
428 /* Add the rndis header */
429 rndis_msg
->ndis_msg_type
= RNDIS_MSG_PACKET
;
430 rndis_msg
->msg_len
= packet
->total_data_buflen
;
431 rndis_pkt
= &rndis_msg
->msg
.pkt
;
432 rndis_pkt
->data_offset
= sizeof(struct rndis_packet
);
433 rndis_pkt
->data_len
= packet
->total_data_buflen
;
434 rndis_pkt
->per_pkt_info_offset
= sizeof(struct rndis_packet
);
436 rndis_msg_size
= RNDIS_MESSAGE_SIZE(struct rndis_packet
);
438 hash
= skb_get_hash_raw(skb
);
439 if (hash
!= 0 && net
->real_num_tx_queues
> 1) {
440 rndis_msg_size
+= NDIS_HASH_PPI_SIZE
;
441 ppi
= init_ppi_data(rndis_msg
, NDIS_HASH_PPI_SIZE
,
443 *(u32
*)((void *)ppi
+ ppi
->ppi_offset
) = hash
;
447 struct ndis_pkt_8021q_info
*vlan
;
449 rndis_msg_size
+= NDIS_VLAN_PPI_SIZE
;
450 ppi
= init_ppi_data(rndis_msg
, NDIS_VLAN_PPI_SIZE
,
452 vlan
= (struct ndis_pkt_8021q_info
*)((void *)ppi
+
454 vlan
->vlanid
= skb
->vlan_tci
& VLAN_VID_MASK
;
455 vlan
->pri
= (skb
->vlan_tci
& VLAN_PRIO_MASK
) >>
459 net_trans_info
= get_net_transport_info(skb
, &hdr_offset
);
460 if (net_trans_info
== TRANSPORT_INFO_NOT_IP
)
464 * Setup the sendside checksum offload only if this is not a
470 if ((skb
->ip_summed
== CHECKSUM_NONE
) ||
471 (skb
->ip_summed
== CHECKSUM_UNNECESSARY
))
474 rndis_msg_size
+= NDIS_CSUM_PPI_SIZE
;
475 ppi
= init_ppi_data(rndis_msg
, NDIS_CSUM_PPI_SIZE
,
476 TCPIP_CHKSUM_PKTINFO
);
478 csum_info
= (struct ndis_tcp_ip_checksum_info
*)((void *)ppi
+
481 if (net_trans_info
& (INFO_IPV4
<< 16))
482 csum_info
->transmit
.is_ipv4
= 1;
484 csum_info
->transmit
.is_ipv6
= 1;
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
) {
490 /* 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.
499 ret
= skb_cow_head(skb
, 0);
504 udp_len
= ntohs(uh
->len
);
506 uh
->check
= csum_tcpudp_magic(ip_hdr(skb
)->saddr
,
508 udp_len
, IPPROTO_UDP
,
509 csum_partial(uh
, udp_len
, 0));
511 uh
->check
= CSUM_MANGLED_0
;
513 csum_info
->transmit
.udp_checksum
= 0;
518 rndis_msg_size
+= NDIS_LSO_PPI_SIZE
;
519 ppi
= init_ppi_data(rndis_msg
, NDIS_LSO_PPI_SIZE
,
520 TCP_LARGESEND_PKTINFO
);
522 lso_info
= (struct ndis_tcp_lso_info
*)((void *)ppi
+
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);
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);
542 lso_info
->lso_v2_transmit
.tcp_header_offset
= hdr_offset
;
543 lso_info
->lso_v2_transmit
.mss
= skb_shinfo(skb
)->gso_size
;
546 /* Start filling in the page buffers with the rndis hdr */
547 rndis_msg
->msg_len
+= rndis_msg_size
;
548 packet
->total_data_buflen
= rndis_msg
->msg_len
;
549 packet
->page_buf_cnt
= init_page_array(rndis_msg
, rndis_msg_size
,
552 /* timestamp packet in software */
553 skb_tx_timestamp(skb
);
554 ret
= netvsc_send(net_device_ctx
->device_ctx
, packet
,
555 rndis_msg
, &pb
, skb
);
559 u64_stats_update_begin(&tx_stats
->syncp
);
561 tx_stats
->bytes
+= skb_length
;
562 u64_stats_update_end(&tx_stats
->syncp
);
564 if (ret
!= -EAGAIN
) {
565 dev_kfree_skb_any(skb
);
566 net
->stats
.tx_dropped
++;
570 return (ret
== -EAGAIN
) ? NETDEV_TX_BUSY
: NETDEV_TX_OK
;
574 * netvsc_linkstatus_callback - Link up/down notification
576 void netvsc_linkstatus_callback(struct hv_device
*device_obj
,
577 struct rndis_message
*resp
)
579 struct rndis_indicate_status
*indicate
= &resp
->msg
.indicate_status
;
580 struct net_device
*net
;
581 struct net_device_context
*ndev_ctx
;
582 struct netvsc_reconfig
*event
;
585 /* Handle link change statuses only */
586 if (indicate
->status
!= RNDIS_STATUS_NETWORK_CHANGE
&&
587 indicate
->status
!= RNDIS_STATUS_MEDIA_CONNECT
&&
588 indicate
->status
!= RNDIS_STATUS_MEDIA_DISCONNECT
)
591 net
= hv_get_drvdata(device_obj
);
593 if (!net
|| net
->reg_state
!= NETREG_REGISTERED
)
596 ndev_ctx
= netdev_priv(net
);
598 event
= kzalloc(sizeof(*event
), GFP_ATOMIC
);
601 event
->event
= indicate
->status
;
603 spin_lock_irqsave(&ndev_ctx
->lock
, flags
);
604 list_add_tail(&event
->list
, &ndev_ctx
->reconfig_events
);
605 spin_unlock_irqrestore(&ndev_ctx
->lock
, flags
);
607 schedule_delayed_work(&ndev_ctx
->dwork
, 0);
611 static struct sk_buff
*netvsc_alloc_recv_skb(struct net_device
*net
,
612 struct hv_netvsc_packet
*packet
,
613 struct ndis_tcp_ip_checksum_info
*csum_info
,
614 void *data
, u16 vlan_tci
)
618 skb
= netdev_alloc_skb_ip_align(net
, packet
->total_data_buflen
);
623 * Copy to skb. This copy is needed here since the memory pointed by
624 * hv_netvsc_packet cannot be deallocated
626 memcpy(skb_put(skb
, packet
->total_data_buflen
), data
,
627 packet
->total_data_buflen
);
629 skb
->protocol
= eth_type_trans(skb
, net
);
631 /* We only look at the IP checksum here.
632 * Should we be dropping the packet if checksum
633 * failed? How do we deal with other checksums - TCP/UDP?
635 if (csum_info
->receive
.ip_checksum_succeeded
)
636 skb
->ip_summed
= CHECKSUM_UNNECESSARY
;
638 skb
->ip_summed
= CHECKSUM_NONE
;
641 if (vlan_tci
& VLAN_TAG_PRESENT
)
642 __vlan_hwaccel_put_tag(skb
, htons(ETH_P_8021Q
),
649 * netvsc_recv_callback - Callback when we receive a packet from the
650 * "wire" on the specified device.
652 int netvsc_recv_callback(struct hv_device
*device_obj
,
653 struct hv_netvsc_packet
*packet
,
655 struct ndis_tcp_ip_checksum_info
*csum_info
,
656 struct vmbus_channel
*channel
,
659 struct net_device
*net
= hv_get_drvdata(device_obj
);
660 struct net_device_context
*net_device_ctx
= netdev_priv(net
);
662 struct sk_buff
*vf_skb
;
663 struct netvsc_stats
*rx_stats
;
664 struct netvsc_device
*netvsc_dev
= net_device_ctx
->nvdev
;
665 u32 bytes_recvd
= packet
->total_data_buflen
;
668 if (!net
|| net
->reg_state
!= NETREG_REGISTERED
)
669 return NVSP_STAT_FAIL
;
671 if (READ_ONCE(netvsc_dev
->vf_inject
)) {
672 atomic_inc(&netvsc_dev
->vf_use_cnt
);
673 if (!READ_ONCE(netvsc_dev
->vf_inject
)) {
675 * We raced; just move on.
677 atomic_dec(&netvsc_dev
->vf_use_cnt
);
678 goto vf_injection_done
;
682 * Inject this packet into the VF inerface.
683 * On Hyper-V, multicast and brodcast packets
684 * are only delivered on the synthetic interface
685 * (after subjecting these to policy filters on
686 * the host). Deliver these via the VF interface
689 vf_skb
= netvsc_alloc_recv_skb(netvsc_dev
->vf_netdev
, packet
,
690 csum_info
, *data
, vlan_tci
);
691 if (vf_skb
!= NULL
) {
692 ++netvsc_dev
->vf_netdev
->stats
.rx_packets
;
693 netvsc_dev
->vf_netdev
->stats
.rx_bytes
+= bytes_recvd
;
694 netif_receive_skb(vf_skb
);
696 ++net
->stats
.rx_dropped
;
697 ret
= NVSP_STAT_FAIL
;
699 atomic_dec(&netvsc_dev
->vf_use_cnt
);
704 net_device_ctx
= netdev_priv(net
);
705 rx_stats
= this_cpu_ptr(net_device_ctx
->rx_stats
);
707 /* Allocate a skb - TODO direct I/O to pages? */
708 skb
= netvsc_alloc_recv_skb(net
, packet
, csum_info
, *data
, vlan_tci
);
709 if (unlikely(!skb
)) {
710 ++net
->stats
.rx_dropped
;
711 return NVSP_STAT_FAIL
;
713 skb_record_rx_queue(skb
, channel
->
714 offermsg
.offer
.sub_channel_index
);
716 u64_stats_update_begin(&rx_stats
->syncp
);
718 rx_stats
->bytes
+= packet
->total_data_buflen
;
719 u64_stats_update_end(&rx_stats
->syncp
);
722 * Pass the skb back up. Network stack will deallocate the skb when it
731 static void netvsc_get_drvinfo(struct net_device
*net
,
732 struct ethtool_drvinfo
*info
)
734 strlcpy(info
->driver
, KBUILD_MODNAME
, sizeof(info
->driver
));
735 strlcpy(info
->fw_version
, "N/A", sizeof(info
->fw_version
));
738 static void netvsc_get_channels(struct net_device
*net
,
739 struct ethtool_channels
*channel
)
741 struct net_device_context
*net_device_ctx
= netdev_priv(net
);
742 struct netvsc_device
*nvdev
= net_device_ctx
->nvdev
;
745 channel
->max_combined
= nvdev
->max_chn
;
746 channel
->combined_count
= nvdev
->num_chn
;
750 static int netvsc_set_channels(struct net_device
*net
,
751 struct ethtool_channels
*channels
)
753 struct net_device_context
*net_device_ctx
= netdev_priv(net
);
754 struct hv_device
*dev
= net_device_ctx
->device_ctx
;
755 struct netvsc_device
*nvdev
= net_device_ctx
->nvdev
;
756 struct netvsc_device_info device_info
;
760 bool recovering
= false;
762 if (net_device_ctx
->start_remove
|| !nvdev
|| nvdev
->destroy
)
765 num_chn
= nvdev
->num_chn
;
766 max_chn
= min_t(u32
, nvdev
->max_chn
, num_online_cpus());
768 if (nvdev
->nvsp_version
< NVSP_PROTOCOL_VERSION_5
) {
769 pr_info("vRSS unsupported before NVSP Version 5\n");
773 /* We do not support rx, tx, or other */
775 channels
->rx_count
||
776 channels
->tx_count
||
777 channels
->other_count
||
778 (channels
->combined_count
< 1))
781 if (channels
->combined_count
> max_chn
) {
782 pr_info("combined channels too high, using %d\n", max_chn
);
783 channels
->combined_count
= max_chn
;
786 ret
= netvsc_close(net
);
791 net_device_ctx
->start_remove
= true;
792 rndis_filter_device_remove(dev
);
794 nvdev
->num_chn
= channels
->combined_count
;
796 memset(&device_info
, 0, sizeof(device_info
));
797 device_info
.num_chn
= nvdev
->num_chn
; /* passed to RNDIS */
798 device_info
.ring_size
= ring_size
;
799 device_info
.max_num_vrss_chns
= max_num_vrss_chns
;
801 ret
= rndis_filter_device_add(dev
, &device_info
);
804 netdev_err(net
, "unable to add netvsc device (ret %d)\n", ret
);
810 nvdev
= net_device_ctx
->nvdev
;
812 ret
= netif_set_real_num_tx_queues(net
, nvdev
->num_chn
);
815 netdev_err(net
, "could not set tx queue count (ret %d)\n", ret
);
821 ret
= netif_set_real_num_rx_queues(net
, nvdev
->num_chn
);
824 netdev_err(net
, "could not set rx queue count (ret %d)\n", ret
);
832 net_device_ctx
->start_remove
= false;
833 /* We may have missed link change notifications */
834 schedule_delayed_work(&net_device_ctx
->dwork
, 0);
839 /* If the above failed, we attempt to recover through the same
840 * process but with the original number of channels.
842 netdev_err(net
, "could not set channels, recovering\n");
844 channels
->combined_count
= num_chn
;
848 static bool netvsc_validate_ethtool_ss_cmd(const struct ethtool_cmd
*cmd
)
850 struct ethtool_cmd diff1
= *cmd
;
851 struct ethtool_cmd diff2
= {};
853 ethtool_cmd_speed_set(&diff1
, 0);
855 /* advertising and cmd are usually set */
856 diff1
.advertising
= 0;
858 /* We set port to PORT_OTHER */
859 diff2
.port
= PORT_OTHER
;
861 return !memcmp(&diff1
, &diff2
, sizeof(diff1
));
864 static void netvsc_init_settings(struct net_device
*dev
)
866 struct net_device_context
*ndc
= netdev_priv(dev
);
868 ndc
->speed
= SPEED_UNKNOWN
;
869 ndc
->duplex
= DUPLEX_UNKNOWN
;
872 static int netvsc_get_settings(struct net_device
*dev
, struct ethtool_cmd
*cmd
)
874 struct net_device_context
*ndc
= netdev_priv(dev
);
876 ethtool_cmd_speed_set(cmd
, ndc
->speed
);
877 cmd
->duplex
= ndc
->duplex
;
878 cmd
->port
= PORT_OTHER
;
883 static int netvsc_set_settings(struct net_device
*dev
, struct ethtool_cmd
*cmd
)
885 struct net_device_context
*ndc
= netdev_priv(dev
);
888 speed
= ethtool_cmd_speed(cmd
);
889 if (!ethtool_validate_speed(speed
) ||
890 !ethtool_validate_duplex(cmd
->duplex
) ||
891 !netvsc_validate_ethtool_ss_cmd(cmd
))
895 ndc
->duplex
= cmd
->duplex
;
900 static int netvsc_change_mtu(struct net_device
*ndev
, int mtu
)
902 struct net_device_context
*ndevctx
= netdev_priv(ndev
);
903 struct netvsc_device
*nvdev
= ndevctx
->nvdev
;
904 struct hv_device
*hdev
= ndevctx
->device_ctx
;
905 struct netvsc_device_info device_info
;
906 int limit
= ETH_DATA_LEN
;
910 if (ndevctx
->start_remove
|| !nvdev
|| nvdev
->destroy
)
913 if (nvdev
->nvsp_version
>= NVSP_PROTOCOL_VERSION_2
)
914 limit
= NETVSC_MTU
- ETH_HLEN
;
916 if (mtu
< NETVSC_MTU_MIN
|| mtu
> limit
)
919 ret
= netvsc_close(ndev
);
923 num_chn
= nvdev
->num_chn
;
925 ndevctx
->start_remove
= true;
926 rndis_filter_device_remove(hdev
);
930 memset(&device_info
, 0, sizeof(device_info
));
931 device_info
.ring_size
= ring_size
;
932 device_info
.num_chn
= num_chn
;
933 device_info
.max_num_vrss_chns
= max_num_vrss_chns
;
934 rndis_filter_device_add(hdev
, &device_info
);
938 ndevctx
->start_remove
= false;
940 /* We may have missed link change notifications */
941 schedule_delayed_work(&ndevctx
->dwork
, 0);
946 static struct rtnl_link_stats64
*netvsc_get_stats64(struct net_device
*net
,
947 struct rtnl_link_stats64
*t
)
949 struct net_device_context
*ndev_ctx
= netdev_priv(net
);
952 for_each_possible_cpu(cpu
) {
953 struct netvsc_stats
*tx_stats
= per_cpu_ptr(ndev_ctx
->tx_stats
,
955 struct netvsc_stats
*rx_stats
= per_cpu_ptr(ndev_ctx
->rx_stats
,
957 u64 tx_packets
, tx_bytes
, rx_packets
, rx_bytes
;
961 start
= u64_stats_fetch_begin_irq(&tx_stats
->syncp
);
962 tx_packets
= tx_stats
->packets
;
963 tx_bytes
= tx_stats
->bytes
;
964 } while (u64_stats_fetch_retry_irq(&tx_stats
->syncp
, start
));
967 start
= u64_stats_fetch_begin_irq(&rx_stats
->syncp
);
968 rx_packets
= rx_stats
->packets
;
969 rx_bytes
= rx_stats
->bytes
;
970 } while (u64_stats_fetch_retry_irq(&rx_stats
->syncp
, start
));
972 t
->tx_bytes
+= tx_bytes
;
973 t
->tx_packets
+= tx_packets
;
974 t
->rx_bytes
+= rx_bytes
;
975 t
->rx_packets
+= rx_packets
;
978 t
->tx_dropped
= net
->stats
.tx_dropped
;
979 t
->tx_errors
= net
->stats
.tx_dropped
;
981 t
->rx_dropped
= net
->stats
.rx_dropped
;
982 t
->rx_errors
= net
->stats
.rx_errors
;
987 static int netvsc_set_mac_addr(struct net_device
*ndev
, void *p
)
989 struct net_device_context
*ndevctx
= netdev_priv(ndev
);
990 struct hv_device
*hdev
= ndevctx
->device_ctx
;
991 struct sockaddr
*addr
= p
;
992 char save_adr
[ETH_ALEN
];
993 unsigned char save_aatype
;
996 memcpy(save_adr
, ndev
->dev_addr
, ETH_ALEN
);
997 save_aatype
= ndev
->addr_assign_type
;
999 err
= eth_mac_addr(ndev
, p
);
1003 err
= rndis_filter_set_device_mac(hdev
, addr
->sa_data
);
1005 /* roll back to saved MAC */
1006 memcpy(ndev
->dev_addr
, save_adr
, ETH_ALEN
);
1007 ndev
->addr_assign_type
= save_aatype
;
1013 #ifdef CONFIG_NET_POLL_CONTROLLER
1014 static void netvsc_poll_controller(struct net_device
*net
)
1016 /* As netvsc_start_xmit() works synchronous we don't have to
1017 * trigger anything here.
1022 static const struct ethtool_ops ethtool_ops
= {
1023 .get_drvinfo
= netvsc_get_drvinfo
,
1024 .get_link
= ethtool_op_get_link
,
1025 .get_channels
= netvsc_get_channels
,
1026 .set_channels
= netvsc_set_channels
,
1027 .get_ts_info
= ethtool_op_get_ts_info
,
1028 .get_settings
= netvsc_get_settings
,
1029 .set_settings
= netvsc_set_settings
,
1032 static const struct net_device_ops device_ops
= {
1033 .ndo_open
= netvsc_open
,
1034 .ndo_stop
= netvsc_close
,
1035 .ndo_start_xmit
= netvsc_start_xmit
,
1036 .ndo_set_rx_mode
= netvsc_set_multicast_list
,
1037 .ndo_change_mtu
= netvsc_change_mtu
,
1038 .ndo_validate_addr
= eth_validate_addr
,
1039 .ndo_set_mac_address
= netvsc_set_mac_addr
,
1040 .ndo_select_queue
= netvsc_select_queue
,
1041 .ndo_get_stats64
= netvsc_get_stats64
,
1042 #ifdef CONFIG_NET_POLL_CONTROLLER
1043 .ndo_poll_controller
= netvsc_poll_controller
,
1048 * Handle link status changes. For RNDIS_STATUS_NETWORK_CHANGE emulate link
1049 * down/up sequence. In case of RNDIS_STATUS_MEDIA_CONNECT when carrier is
1050 * present send GARP packet to network peers with netif_notify_peers().
1052 static void netvsc_link_change(struct work_struct
*w
)
1054 struct net_device_context
*ndev_ctx
=
1055 container_of(w
, struct net_device_context
, dwork
.work
);
1056 struct hv_device
*device_obj
= ndev_ctx
->device_ctx
;
1057 struct net_device
*net
= hv_get_drvdata(device_obj
);
1058 struct netvsc_device
*net_device
;
1059 struct rndis_device
*rdev
;
1060 struct netvsc_reconfig
*event
= NULL
;
1061 bool notify
= false, reschedule
= false;
1062 unsigned long flags
, next_reconfig
, delay
;
1065 if (ndev_ctx
->start_remove
)
1068 net_device
= ndev_ctx
->nvdev
;
1069 rdev
= net_device
->extension
;
1071 next_reconfig
= ndev_ctx
->last_reconfig
+ LINKCHANGE_INT
;
1072 if (time_is_after_jiffies(next_reconfig
)) {
1073 /* link_watch only sends one notification with current state
1074 * per second, avoid doing reconfig more frequently. Handle
1077 delay
= next_reconfig
- jiffies
;
1078 delay
= delay
< LINKCHANGE_INT
? delay
: LINKCHANGE_INT
;
1079 schedule_delayed_work(&ndev_ctx
->dwork
, delay
);
1082 ndev_ctx
->last_reconfig
= jiffies
;
1084 spin_lock_irqsave(&ndev_ctx
->lock
, flags
);
1085 if (!list_empty(&ndev_ctx
->reconfig_events
)) {
1086 event
= list_first_entry(&ndev_ctx
->reconfig_events
,
1087 struct netvsc_reconfig
, list
);
1088 list_del(&event
->list
);
1089 reschedule
= !list_empty(&ndev_ctx
->reconfig_events
);
1091 spin_unlock_irqrestore(&ndev_ctx
->lock
, flags
);
1096 switch (event
->event
) {
1097 /* Only the following events are possible due to the check in
1098 * netvsc_linkstatus_callback()
1100 case RNDIS_STATUS_MEDIA_CONNECT
:
1101 if (rdev
->link_state
) {
1102 rdev
->link_state
= false;
1103 netif_carrier_on(net
);
1104 netif_tx_wake_all_queues(net
);
1110 case RNDIS_STATUS_MEDIA_DISCONNECT
:
1111 if (!rdev
->link_state
) {
1112 rdev
->link_state
= true;
1113 netif_carrier_off(net
);
1114 netif_tx_stop_all_queues(net
);
1118 case RNDIS_STATUS_NETWORK_CHANGE
:
1119 /* Only makes sense if carrier is present */
1120 if (!rdev
->link_state
) {
1121 rdev
->link_state
= true;
1122 netif_carrier_off(net
);
1123 netif_tx_stop_all_queues(net
);
1124 event
->event
= RNDIS_STATUS_MEDIA_CONNECT
;
1125 spin_lock_irqsave(&ndev_ctx
->lock
, flags
);
1126 list_add(&event
->list
, &ndev_ctx
->reconfig_events
);
1127 spin_unlock_irqrestore(&ndev_ctx
->lock
, flags
);
1136 netdev_notify_peers(net
);
1138 /* link_watch only sends one notification with current state per
1139 * second, handle next reconfig event in 2 seconds.
1142 schedule_delayed_work(&ndev_ctx
->dwork
, LINKCHANGE_INT
);
1150 static void netvsc_free_netdev(struct net_device
*netdev
)
1152 struct net_device_context
*net_device_ctx
= netdev_priv(netdev
);
1154 free_percpu(net_device_ctx
->tx_stats
);
1155 free_percpu(net_device_ctx
->rx_stats
);
1156 free_netdev(netdev
);
1159 static void netvsc_notify_peers(struct work_struct
*wrk
)
1161 struct garp_wrk
*gwrk
;
1163 gwrk
= container_of(wrk
, struct garp_wrk
, dwrk
);
1165 netdev_notify_peers(gwrk
->netdev
);
1167 atomic_dec(&gwrk
->netvsc_dev
->vf_use_cnt
);
1170 static struct net_device
*get_netvsc_net_device(char *mac
)
1172 struct net_device
*dev
, *found
= NULL
;
1175 rtnl_locked
= rtnl_trylock();
1177 for_each_netdev(&init_net
, dev
) {
1178 if (memcmp(dev
->dev_addr
, mac
, ETH_ALEN
) == 0) {
1179 if (dev
->netdev_ops
!= &device_ops
)
1191 static int netvsc_register_vf(struct net_device
*vf_netdev
)
1193 struct net_device
*ndev
;
1194 struct net_device_context
*net_device_ctx
;
1195 struct netvsc_device
*netvsc_dev
;
1196 const struct ethtool_ops
*eth_ops
= vf_netdev
->ethtool_ops
;
1198 if (eth_ops
== NULL
|| eth_ops
== ðtool_ops
)
1202 * We will use the MAC address to locate the synthetic interface to
1203 * associate with the VF interface. If we don't find a matching
1204 * synthetic interface, move on.
1206 ndev
= get_netvsc_net_device(vf_netdev
->dev_addr
);
1210 net_device_ctx
= netdev_priv(ndev
);
1211 netvsc_dev
= net_device_ctx
->nvdev
;
1212 if (netvsc_dev
== NULL
)
1215 netdev_info(ndev
, "VF registering: %s\n", vf_netdev
->name
);
1217 * Take a reference on the module.
1219 try_module_get(THIS_MODULE
);
1220 netvsc_dev
->vf_netdev
= vf_netdev
;
1225 static int netvsc_vf_up(struct net_device
*vf_netdev
)
1227 struct net_device
*ndev
;
1228 struct netvsc_device
*netvsc_dev
;
1229 const struct ethtool_ops
*eth_ops
= vf_netdev
->ethtool_ops
;
1230 struct net_device_context
*net_device_ctx
;
1232 if (eth_ops
== ðtool_ops
)
1235 ndev
= get_netvsc_net_device(vf_netdev
->dev_addr
);
1239 net_device_ctx
= netdev_priv(ndev
);
1240 netvsc_dev
= net_device_ctx
->nvdev
;
1242 if ((netvsc_dev
== NULL
) || (netvsc_dev
->vf_netdev
== NULL
))
1245 netdev_info(ndev
, "VF up: %s\n", vf_netdev
->name
);
1246 netvsc_dev
->vf_inject
= true;
1249 * Open the device before switching data path.
1251 rndis_filter_open(net_device_ctx
->device_ctx
);
1254 * notify the host to switch the data path.
1256 netvsc_switch_datapath(ndev
, true);
1257 netdev_info(ndev
, "Data path switched to VF: %s\n", vf_netdev
->name
);
1259 netif_carrier_off(ndev
);
1262 * Now notify peers. We are scheduling work to
1263 * notify peers; take a reference to prevent
1264 * the VF interface from vanishing.
1266 atomic_inc(&netvsc_dev
->vf_use_cnt
);
1267 net_device_ctx
->gwrk
.netdev
= vf_netdev
;
1268 net_device_ctx
->gwrk
.netvsc_dev
= netvsc_dev
;
1269 schedule_work(&net_device_ctx
->gwrk
.dwrk
);
1275 static int netvsc_vf_down(struct net_device
*vf_netdev
)
1277 struct net_device
*ndev
;
1278 struct netvsc_device
*netvsc_dev
;
1279 struct net_device_context
*net_device_ctx
;
1280 const struct ethtool_ops
*eth_ops
= vf_netdev
->ethtool_ops
;
1282 if (eth_ops
== ðtool_ops
)
1285 ndev
= get_netvsc_net_device(vf_netdev
->dev_addr
);
1289 net_device_ctx
= netdev_priv(ndev
);
1290 netvsc_dev
= net_device_ctx
->nvdev
;
1292 if ((netvsc_dev
== NULL
) || (netvsc_dev
->vf_netdev
== NULL
))
1295 netdev_info(ndev
, "VF down: %s\n", vf_netdev
->name
);
1296 netvsc_dev
->vf_inject
= false;
1298 * Wait for currently active users to
1302 while (atomic_read(&netvsc_dev
->vf_use_cnt
) != 0)
1304 netvsc_switch_datapath(ndev
, false);
1305 netdev_info(ndev
, "Data path switched from VF: %s\n", vf_netdev
->name
);
1306 rndis_filter_close(net_device_ctx
->device_ctx
);
1307 netif_carrier_on(ndev
);
1311 atomic_inc(&netvsc_dev
->vf_use_cnt
);
1312 net_device_ctx
->gwrk
.netdev
= ndev
;
1313 net_device_ctx
->gwrk
.netvsc_dev
= netvsc_dev
;
1314 schedule_work(&net_device_ctx
->gwrk
.dwrk
);
1320 static int netvsc_unregister_vf(struct net_device
*vf_netdev
)
1322 struct net_device
*ndev
;
1323 struct netvsc_device
*netvsc_dev
;
1324 const struct ethtool_ops
*eth_ops
= vf_netdev
->ethtool_ops
;
1325 struct net_device_context
*net_device_ctx
;
1327 if (eth_ops
== ðtool_ops
)
1330 ndev
= get_netvsc_net_device(vf_netdev
->dev_addr
);
1334 net_device_ctx
= netdev_priv(ndev
);
1335 netvsc_dev
= net_device_ctx
->nvdev
;
1336 if (netvsc_dev
== NULL
)
1338 netdev_info(ndev
, "VF unregistering: %s\n", vf_netdev
->name
);
1340 netvsc_dev
->vf_netdev
= NULL
;
1341 module_put(THIS_MODULE
);
1345 static int netvsc_probe(struct hv_device
*dev
,
1346 const struct hv_vmbus_device_id
*dev_id
)
1348 struct net_device
*net
= NULL
;
1349 struct net_device_context
*net_device_ctx
;
1350 struct netvsc_device_info device_info
;
1351 struct netvsc_device
*nvdev
;
1354 net
= alloc_etherdev_mq(sizeof(struct net_device_context
),
1359 netif_carrier_off(net
);
1361 net_device_ctx
= netdev_priv(net
);
1362 net_device_ctx
->device_ctx
= dev
;
1363 net_device_ctx
->msg_enable
= netif_msg_init(debug
, default_msg
);
1364 if (netif_msg_probe(net_device_ctx
))
1365 netdev_dbg(net
, "netvsc msg_enable: %d\n",
1366 net_device_ctx
->msg_enable
);
1368 net_device_ctx
->tx_stats
= netdev_alloc_pcpu_stats(struct netvsc_stats
);
1369 if (!net_device_ctx
->tx_stats
) {
1373 net_device_ctx
->rx_stats
= netdev_alloc_pcpu_stats(struct netvsc_stats
);
1374 if (!net_device_ctx
->rx_stats
) {
1375 free_percpu(net_device_ctx
->tx_stats
);
1380 hv_set_drvdata(dev
, net
);
1382 net_device_ctx
->start_remove
= false;
1384 INIT_DELAYED_WORK(&net_device_ctx
->dwork
, netvsc_link_change
);
1385 INIT_WORK(&net_device_ctx
->work
, do_set_multicast
);
1386 INIT_WORK(&net_device_ctx
->gwrk
.dwrk
, netvsc_notify_peers
);
1388 spin_lock_init(&net_device_ctx
->lock
);
1389 INIT_LIST_HEAD(&net_device_ctx
->reconfig_events
);
1391 net
->netdev_ops
= &device_ops
;
1393 net
->hw_features
= NETVSC_HW_FEATURES
;
1394 net
->features
= NETVSC_HW_FEATURES
| NETIF_F_HW_VLAN_CTAG_TX
;
1396 net
->ethtool_ops
= ðtool_ops
;
1397 SET_NETDEV_DEV(net
, &dev
->device
);
1399 /* We always need headroom for rndis header */
1400 net
->needed_headroom
= RNDIS_AND_PPI_SIZE
;
1402 /* Notify the netvsc driver of the new device */
1403 memset(&device_info
, 0, sizeof(device_info
));
1404 device_info
.ring_size
= ring_size
;
1405 device_info
.max_num_vrss_chns
= max_num_vrss_chns
;
1406 ret
= rndis_filter_device_add(dev
, &device_info
);
1408 netdev_err(net
, "unable to add netvsc device (ret %d)\n", ret
);
1409 netvsc_free_netdev(net
);
1410 hv_set_drvdata(dev
, NULL
);
1413 memcpy(net
->dev_addr
, device_info
.mac_adr
, ETH_ALEN
);
1415 nvdev
= net_device_ctx
->nvdev
;
1416 netif_set_real_num_tx_queues(net
, nvdev
->num_chn
);
1417 netif_set_real_num_rx_queues(net
, nvdev
->num_chn
);
1419 netvsc_init_settings(net
);
1421 ret
= register_netdev(net
);
1423 pr_err("Unable to register netdev.\n");
1424 rndis_filter_device_remove(dev
);
1425 netvsc_free_netdev(net
);
1431 static int netvsc_remove(struct hv_device
*dev
)
1433 struct net_device
*net
;
1434 struct net_device_context
*ndev_ctx
;
1435 struct netvsc_device
*net_device
;
1437 net
= hv_get_drvdata(dev
);
1440 dev_err(&dev
->device
, "No net device to remove\n");
1445 ndev_ctx
= netdev_priv(net
);
1446 net_device
= ndev_ctx
->nvdev
;
1448 /* Avoid racing with netvsc_change_mtu()/netvsc_set_channels()
1449 * removing the device.
1452 ndev_ctx
->start_remove
= true;
1455 cancel_delayed_work_sync(&ndev_ctx
->dwork
);
1456 cancel_work_sync(&ndev_ctx
->work
);
1458 /* Stop outbound asap */
1459 netif_tx_disable(net
);
1461 unregister_netdev(net
);
1464 * Call to the vsc driver to let it know that the device is being
1467 rndis_filter_device_remove(dev
);
1469 hv_set_drvdata(dev
, NULL
);
1471 netvsc_free_netdev(net
);
1475 static const struct hv_vmbus_device_id id_table
[] = {
1481 MODULE_DEVICE_TABLE(vmbus
, id_table
);
1483 /* The one and only one */
1484 static struct hv_driver netvsc_drv
= {
1485 .name
= KBUILD_MODNAME
,
1486 .id_table
= id_table
,
1487 .probe
= netvsc_probe
,
1488 .remove
= netvsc_remove
,
1493 * On Hyper-V, every VF interface is matched with a corresponding
1494 * synthetic interface. The synthetic interface is presented first
1495 * to the guest. When the corresponding VF instance is registered,
1496 * we will take care of switching the data path.
1498 static int netvsc_netdev_event(struct notifier_block
*this,
1499 unsigned long event
, void *ptr
)
1501 struct net_device
*event_dev
= netdev_notifier_info_to_dev(ptr
);
1504 case NETDEV_REGISTER
:
1505 return netvsc_register_vf(event_dev
);
1506 case NETDEV_UNREGISTER
:
1507 return netvsc_unregister_vf(event_dev
);
1509 return netvsc_vf_up(event_dev
);
1511 return netvsc_vf_down(event_dev
);
1517 static struct notifier_block netvsc_netdev_notifier
= {
1518 .notifier_call
= netvsc_netdev_event
,
1521 static void __exit
netvsc_drv_exit(void)
1523 unregister_netdevice_notifier(&netvsc_netdev_notifier
);
1524 vmbus_driver_unregister(&netvsc_drv
);
1527 static int __init
netvsc_drv_init(void)
1531 if (ring_size
< RING_SIZE_MIN
) {
1532 ring_size
= RING_SIZE_MIN
;
1533 pr_info("Increased ring_size to %d (min allowed)\n",
1536 ret
= vmbus_driver_register(&netvsc_drv
);
1541 register_netdevice_notifier(&netvsc_netdev_notifier
);
1545 MODULE_LICENSE("GPL");
1546 MODULE_DESCRIPTION("Microsoft Hyper-V network driver");
1548 module_init(netvsc_drv_init
);
1549 module_exit(netvsc_drv_exit
);