3 * Copyright (c) 2009, Microsoft Corporation.
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms and conditions of the GNU General Public License,
7 * version 2, as published by the Free Software Foundation.
9 * This program is distributed in the hope it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
14 * You should have received a copy of the GNU General Public License along with
15 * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
16 * Place - Suite 330, Boston, MA 02111-1307 USA.
19 * Haiyang Zhang <haiyangz@microsoft.com>
20 * Hank Janssen <hjanssen@microsoft.com>
23 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
25 #include <linux/kernel.h>
26 #include <linux/sched.h>
27 #include <linux/wait.h>
28 #include <linux/delay.h>
30 #include <linux/slab.h>
31 #include <linux/vmalloc.h>
32 #include <linux/hyperv.h>
33 #include <linux/export.h>
34 #include <asm/hyperv.h>
35 #include "hyperv_vmbus.h"
38 struct vmbus_connection vmbus_connection
= {
39 .conn_state
= DISCONNECTED
,
40 .next_gpadl_handle
= ATOMIC_INIT(0xE1E10),
44 * Negotiated protocol version with the host.
46 __u32 vmbus_proto_version
;
47 EXPORT_SYMBOL_GPL(vmbus_proto_version
);
49 static __u32
vmbus_get_next_version(__u32 current_version
)
51 switch (current_version
) {
53 return VERSION_WS2008
;
58 case (VERSION_WIN8_1
):
62 return VERSION_WIN8_1
;
64 case (VERSION_WS2008
):
70 static int vmbus_negotiate_version(struct vmbus_channel_msginfo
*msginfo
,
74 struct vmbus_channel_initiate_contact
*msg
;
77 init_completion(&msginfo
->waitevent
);
79 msg
= (struct vmbus_channel_initiate_contact
*)msginfo
->msg
;
81 msg
->header
.msgtype
= CHANNELMSG_INITIATE_CONTACT
;
82 msg
->vmbus_version_requested
= version
;
83 msg
->interrupt_page
= virt_to_phys(vmbus_connection
.int_page
);
84 msg
->monitor_page1
= virt_to_phys(vmbus_connection
.monitor_pages
[0]);
85 msg
->monitor_page2
= virt_to_phys(vmbus_connection
.monitor_pages
[1]);
87 * We want all channel messages to be delivered on CPU 0.
88 * This has been the behavior pre-win8. This is not
89 * perf issue and having all channel messages delivered on CPU 0
95 * Add to list before we send the request since we may
96 * receive the response before returning from this routine
98 spin_lock_irqsave(&vmbus_connection
.channelmsg_lock
, flags
);
99 list_add_tail(&msginfo
->msglistentry
,
100 &vmbus_connection
.chn_msg_list
);
102 spin_unlock_irqrestore(&vmbus_connection
.channelmsg_lock
, flags
);
104 ret
= vmbus_post_msg(msg
,
105 sizeof(struct vmbus_channel_initiate_contact
));
107 spin_lock_irqsave(&vmbus_connection
.channelmsg_lock
, flags
);
108 list_del(&msginfo
->msglistentry
);
109 spin_unlock_irqrestore(&vmbus_connection
.channelmsg_lock
,
114 /* Wait for the connection response */
115 wait_for_completion(&msginfo
->waitevent
);
117 spin_lock_irqsave(&vmbus_connection
.channelmsg_lock
, flags
);
118 list_del(&msginfo
->msglistentry
);
119 spin_unlock_irqrestore(&vmbus_connection
.channelmsg_lock
, flags
);
121 /* Check if successful */
122 if (msginfo
->response
.version_response
.version_supported
) {
123 vmbus_connection
.conn_state
= CONNECTED
;
125 return -ECONNREFUSED
;
132 * vmbus_connect - Sends a connect request on the partition service connection
134 int vmbus_connect(void)
137 struct vmbus_channel_msginfo
*msginfo
= NULL
;
140 /* Initialize the vmbus connection */
141 vmbus_connection
.conn_state
= CONNECTING
;
142 vmbus_connection
.work_queue
= create_workqueue("hv_vmbus_con");
143 if (!vmbus_connection
.work_queue
) {
148 INIT_LIST_HEAD(&vmbus_connection
.chn_msg_list
);
149 spin_lock_init(&vmbus_connection
.channelmsg_lock
);
151 INIT_LIST_HEAD(&vmbus_connection
.chn_list
);
152 mutex_init(&vmbus_connection
.channel_mutex
);
155 * Setup the vmbus event connection for channel interrupt
158 vmbus_connection
.int_page
=
159 (void *)__get_free_pages(GFP_KERNEL
|__GFP_ZERO
, 0);
160 if (vmbus_connection
.int_page
== NULL
) {
165 vmbus_connection
.recv_int_page
= vmbus_connection
.int_page
;
166 vmbus_connection
.send_int_page
=
167 (void *)((unsigned long)vmbus_connection
.int_page
+
171 * Setup the monitor notification facility. The 1st page for
172 * parent->child and the 2nd page for child->parent
174 vmbus_connection
.monitor_pages
[0] = (void *)__get_free_pages((GFP_KERNEL
|__GFP_ZERO
), 0);
175 vmbus_connection
.monitor_pages
[1] = (void *)__get_free_pages((GFP_KERNEL
|__GFP_ZERO
), 0);
176 if ((vmbus_connection
.monitor_pages
[0] == NULL
) ||
177 (vmbus_connection
.monitor_pages
[1] == NULL
)) {
182 msginfo
= kzalloc(sizeof(*msginfo
) +
183 sizeof(struct vmbus_channel_initiate_contact
),
185 if (msginfo
== NULL
) {
191 * Negotiate a compatible VMBUS version number with the
192 * host. We start with the highest number we can support
193 * and work our way down until we negotiate a compatible
197 version
= VERSION_CURRENT
;
200 ret
= vmbus_negotiate_version(msginfo
, version
);
201 if (ret
== -ETIMEDOUT
)
204 if (vmbus_connection
.conn_state
== CONNECTED
)
207 version
= vmbus_get_next_version(version
);
208 } while (version
!= VERSION_INVAL
);
210 if (version
== VERSION_INVAL
)
213 vmbus_proto_version
= version
;
214 pr_info("Hyper-V Host Build:%d-%d.%d-%d-%d.%d; Vmbus version:%d.%d\n",
215 host_info_eax
, host_info_ebx
>> 16,
216 host_info_ebx
& 0xFFFF, host_info_ecx
,
217 host_info_edx
>> 24, host_info_edx
& 0xFFFFFF,
218 version
>> 16, version
& 0xFFFF);
224 pr_err("Unable to connect to host\n");
226 vmbus_connection
.conn_state
= DISCONNECTED
;
234 void vmbus_disconnect(void)
237 * First send the unload request to the host.
239 vmbus_initiate_unload();
241 if (vmbus_connection
.work_queue
) {
242 drain_workqueue(vmbus_connection
.work_queue
);
243 destroy_workqueue(vmbus_connection
.work_queue
);
246 if (vmbus_connection
.int_page
) {
247 free_pages((unsigned long)vmbus_connection
.int_page
, 0);
248 vmbus_connection
.int_page
= NULL
;
251 free_pages((unsigned long)vmbus_connection
.monitor_pages
[0], 0);
252 free_pages((unsigned long)vmbus_connection
.monitor_pages
[1], 0);
253 vmbus_connection
.monitor_pages
[0] = NULL
;
254 vmbus_connection
.monitor_pages
[1] = NULL
;
258 * Map the given relid to the corresponding channel based on the
259 * per-cpu list of channels that have been affinitized to this CPU.
260 * This will be used in the channel callback path as we can do this
261 * mapping in a lock-free fashion.
263 static struct vmbus_channel
*pcpu_relid2channel(u32 relid
)
265 struct vmbus_channel
*channel
;
266 struct vmbus_channel
*found_channel
= NULL
;
267 int cpu
= smp_processor_id();
268 struct list_head
*pcpu_head
= &hv_context
.percpu_list
[cpu
];
270 list_for_each_entry(channel
, pcpu_head
, percpu_list
) {
271 if (channel
->offermsg
.child_relid
== relid
) {
272 found_channel
= channel
;
277 return found_channel
;
281 * relid2channel - Get the channel object given its
282 * child relative id (ie channel id)
284 struct vmbus_channel
*relid2channel(u32 relid
)
286 struct vmbus_channel
*channel
;
287 struct vmbus_channel
*found_channel
= NULL
;
288 struct list_head
*cur
, *tmp
;
289 struct vmbus_channel
*cur_sc
;
291 mutex_lock(&vmbus_connection
.channel_mutex
);
292 list_for_each_entry(channel
, &vmbus_connection
.chn_list
, listentry
) {
293 if (channel
->offermsg
.child_relid
== relid
) {
294 found_channel
= channel
;
296 } else if (!list_empty(&channel
->sc_list
)) {
298 * Deal with sub-channels.
300 list_for_each_safe(cur
, tmp
, &channel
->sc_list
) {
301 cur_sc
= list_entry(cur
, struct vmbus_channel
,
303 if (cur_sc
->offermsg
.child_relid
== relid
) {
304 found_channel
= cur_sc
;
310 mutex_unlock(&vmbus_connection
.channel_mutex
);
312 return found_channel
;
316 * process_chn_event - Process a channel event notification
318 static void process_chn_event(u32 relid
)
320 struct vmbus_channel
*channel
;
326 * Find the channel based on this relid and invokes the
327 * channel callback to process the event
329 channel
= pcpu_relid2channel(relid
);
335 * A channel once created is persistent even when there
336 * is no driver handling the device. An unloading driver
337 * sets the onchannel_callback to NULL on the same CPU
338 * as where this interrupt is handled (in an interrupt context).
339 * Thus, checking and invoking the driver specific callback takes
340 * care of orderly unloading of the driver.
343 if (channel
->onchannel_callback
!= NULL
) {
344 arg
= channel
->channel_callback_context
;
345 read_state
= channel
->batched_reading
;
347 * This callback reads the messages sent by the host.
348 * We can optimize host to guest signaling by ensuring:
349 * 1. While reading the channel, we disable interrupts from
351 * 2. Ensure that we process all posted messages from the host
352 * before returning from this callback.
353 * 3. Once we return, enable signaling from the host. Once this
354 * state is set we check to see if additional packets are
355 * available to read. In this case we repeat the process.
360 hv_begin_read(&channel
->inbound
);
361 channel
->onchannel_callback(arg
);
363 bytes_to_read
= hv_end_read(&channel
->inbound
);
366 } while (read_state
&& (bytes_to_read
!= 0));
371 * vmbus_on_event - Handler for events
373 void vmbus_on_event(unsigned long data
)
379 u32
*recv_int_page
= NULL
;
381 int cpu
= smp_processor_id();
382 union hv_synic_event_flags
*event
;
384 if (vmbus_proto_version
< VERSION_WIN8
) {
385 maxdword
= MAX_NUM_CHANNELS_SUPPORTED
>> 5;
386 recv_int_page
= vmbus_connection
.recv_int_page
;
389 * When the host is win8 and beyond, the event page
390 * can be directly checked to get the id of the channel
391 * that has the interrupt pending.
393 maxdword
= HV_EVENT_FLAGS_DWORD_COUNT
;
394 page_addr
= hv_context
.synic_event_page
[cpu
];
395 event
= (union hv_synic_event_flags
*)page_addr
+
397 recv_int_page
= event
->flags32
;
405 for (dword
= 0; dword
< maxdword
; dword
++) {
406 if (!recv_int_page
[dword
])
408 for (bit
= 0; bit
< 32; bit
++) {
409 if (sync_test_and_clear_bit(bit
,
410 (unsigned long *)&recv_int_page
[dword
])) {
411 relid
= (dword
<< 5) + bit
;
415 * Special case - vmbus
416 * channel protocol msg
420 process_chn_event(relid
);
427 * vmbus_post_msg - Send a msg on the vmbus's message connection
429 int vmbus_post_msg(void *buffer
, size_t buflen
)
431 union hv_connection_id conn_id
;
437 conn_id
.u
.id
= VMBUS_MESSAGE_CONNECTION_ID
;
440 * hv_post_message() can have transient failures because of
441 * insufficient resources. Retry the operation a couple of
442 * times before giving up.
444 while (retries
< 20) {
445 ret
= hv_post_message(conn_id
, 1, buffer
, buflen
);
448 case HV_STATUS_INVALID_CONNECTION_ID
:
450 * We could get this if we send messages too
455 case HV_STATUS_INSUFFICIENT_MEMORY
:
456 case HV_STATUS_INSUFFICIENT_BUFFERS
:
459 case HV_STATUS_SUCCESS
:
462 pr_err("hv_post_msg() failed; error code:%d\n", ret
);
475 * vmbus_set_event - Send an event notification to the parent
477 int vmbus_set_event(struct vmbus_channel
*channel
)
479 u32 child_relid
= channel
->offermsg
.child_relid
;
481 if (!channel
->is_dedicated_interrupt
) {
482 /* Each u32 represents 32 channels */
483 sync_set_bit(child_relid
& 31,
484 (unsigned long *)vmbus_connection
.send_int_page
+
488 return hv_signal_event(channel
->sig_event
);