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),
42 EXPORT_SYMBOL_GPL(vmbus_connection
);
45 * Negotiated protocol version with the host.
47 __u32 vmbus_proto_version
;
48 EXPORT_SYMBOL_GPL(vmbus_proto_version
);
50 static __u32
vmbus_get_next_version(__u32 current_version
)
52 switch (current_version
) {
54 return VERSION_WS2008
;
59 case (VERSION_WIN8_1
):
63 return VERSION_WIN8_1
;
65 case (VERSION_WS2008
):
71 static int vmbus_negotiate_version(struct vmbus_channel_msginfo
*msginfo
,
75 struct vmbus_channel_initiate_contact
*msg
;
78 init_completion(&msginfo
->waitevent
);
80 msg
= (struct vmbus_channel_initiate_contact
*)msginfo
->msg
;
82 msg
->header
.msgtype
= CHANNELMSG_INITIATE_CONTACT
;
83 msg
->vmbus_version_requested
= version
;
84 msg
->interrupt_page
= virt_to_phys(vmbus_connection
.int_page
);
85 msg
->monitor_page1
= virt_to_phys(vmbus_connection
.monitor_pages
[0]);
86 msg
->monitor_page2
= virt_to_phys(vmbus_connection
.monitor_pages
[1]);
88 * We want all channel messages to be delivered on CPU 0.
89 * This has been the behavior pre-win8. This is not
90 * perf issue and having all channel messages delivered on CPU 0
92 * For post win8 hosts, we support receiving channel messagges on
93 * all the CPUs. This is needed for kexec to work correctly where
94 * the CPU attempting to connect may not be CPU 0.
96 if (version
>= VERSION_WIN8_1
) {
97 msg
->target_vcpu
= hv_context
.vp_index
[get_cpu()];
100 msg
->target_vcpu
= 0;
104 * Add to list before we send the request since we may
105 * receive the response before returning from this routine
107 spin_lock_irqsave(&vmbus_connection
.channelmsg_lock
, flags
);
108 list_add_tail(&msginfo
->msglistentry
,
109 &vmbus_connection
.chn_msg_list
);
111 spin_unlock_irqrestore(&vmbus_connection
.channelmsg_lock
, flags
);
113 ret
= vmbus_post_msg(msg
,
114 sizeof(struct vmbus_channel_initiate_contact
),
117 spin_lock_irqsave(&vmbus_connection
.channelmsg_lock
, flags
);
118 list_del(&msginfo
->msglistentry
);
119 spin_unlock_irqrestore(&vmbus_connection
.channelmsg_lock
,
124 /* Wait for the connection response */
125 wait_for_completion(&msginfo
->waitevent
);
127 spin_lock_irqsave(&vmbus_connection
.channelmsg_lock
, flags
);
128 list_del(&msginfo
->msglistentry
);
129 spin_unlock_irqrestore(&vmbus_connection
.channelmsg_lock
, flags
);
131 /* Check if successful */
132 if (msginfo
->response
.version_response
.version_supported
) {
133 vmbus_connection
.conn_state
= CONNECTED
;
135 return -ECONNREFUSED
;
142 * vmbus_connect - Sends a connect request on the partition service connection
144 int vmbus_connect(void)
147 struct vmbus_channel_msginfo
*msginfo
= NULL
;
150 /* Initialize the vmbus connection */
151 vmbus_connection
.conn_state
= CONNECTING
;
152 vmbus_connection
.work_queue
= create_workqueue("hv_vmbus_con");
153 if (!vmbus_connection
.work_queue
) {
158 INIT_LIST_HEAD(&vmbus_connection
.chn_msg_list
);
159 spin_lock_init(&vmbus_connection
.channelmsg_lock
);
161 INIT_LIST_HEAD(&vmbus_connection
.chn_list
);
162 mutex_init(&vmbus_connection
.channel_mutex
);
165 * Setup the vmbus event connection for channel interrupt
168 vmbus_connection
.int_page
=
169 (void *)__get_free_pages(GFP_KERNEL
|__GFP_ZERO
, 0);
170 if (vmbus_connection
.int_page
== NULL
) {
175 vmbus_connection
.recv_int_page
= vmbus_connection
.int_page
;
176 vmbus_connection
.send_int_page
=
177 (void *)((unsigned long)vmbus_connection
.int_page
+
181 * Setup the monitor notification facility. The 1st page for
182 * parent->child and the 2nd page for child->parent
184 vmbus_connection
.monitor_pages
[0] = (void *)__get_free_pages((GFP_KERNEL
|__GFP_ZERO
), 0);
185 vmbus_connection
.monitor_pages
[1] = (void *)__get_free_pages((GFP_KERNEL
|__GFP_ZERO
), 0);
186 if ((vmbus_connection
.monitor_pages
[0] == NULL
) ||
187 (vmbus_connection
.monitor_pages
[1] == NULL
)) {
192 msginfo
= kzalloc(sizeof(*msginfo
) +
193 sizeof(struct vmbus_channel_initiate_contact
),
195 if (msginfo
== NULL
) {
201 * Negotiate a compatible VMBUS version number with the
202 * host. We start with the highest number we can support
203 * and work our way down until we negotiate a compatible
207 version
= VERSION_CURRENT
;
210 ret
= vmbus_negotiate_version(msginfo
, version
);
211 if (ret
== -ETIMEDOUT
)
214 if (vmbus_connection
.conn_state
== CONNECTED
)
217 version
= vmbus_get_next_version(version
);
218 } while (version
!= VERSION_INVAL
);
220 if (version
== VERSION_INVAL
)
223 vmbus_proto_version
= version
;
224 pr_info("Hyper-V Host Build:%d-%d.%d-%d-%d.%d; Vmbus version:%d.%d\n",
225 host_info_eax
, host_info_ebx
>> 16,
226 host_info_ebx
& 0xFFFF, host_info_ecx
,
227 host_info_edx
>> 24, host_info_edx
& 0xFFFFFF,
228 version
>> 16, version
& 0xFFFF);
234 pr_err("Unable to connect to host\n");
236 vmbus_connection
.conn_state
= DISCONNECTED
;
244 void vmbus_disconnect(void)
247 * First send the unload request to the host.
249 vmbus_initiate_unload(false);
251 if (vmbus_connection
.work_queue
) {
252 drain_workqueue(vmbus_connection
.work_queue
);
253 destroy_workqueue(vmbus_connection
.work_queue
);
256 if (vmbus_connection
.int_page
) {
257 free_pages((unsigned long)vmbus_connection
.int_page
, 0);
258 vmbus_connection
.int_page
= NULL
;
261 free_pages((unsigned long)vmbus_connection
.monitor_pages
[0], 0);
262 free_pages((unsigned long)vmbus_connection
.monitor_pages
[1], 0);
263 vmbus_connection
.monitor_pages
[0] = NULL
;
264 vmbus_connection
.monitor_pages
[1] = NULL
;
268 * Map the given relid to the corresponding channel based on the
269 * per-cpu list of channels that have been affinitized to this CPU.
270 * This will be used in the channel callback path as we can do this
271 * mapping in a lock-free fashion.
273 static struct vmbus_channel
*pcpu_relid2channel(u32 relid
)
275 struct vmbus_channel
*channel
;
276 struct vmbus_channel
*found_channel
= NULL
;
277 int cpu
= smp_processor_id();
278 struct list_head
*pcpu_head
= &hv_context
.percpu_list
[cpu
];
280 list_for_each_entry(channel
, pcpu_head
, percpu_list
) {
281 if (channel
->offermsg
.child_relid
== relid
) {
282 found_channel
= channel
;
287 return found_channel
;
291 * relid2channel - Get the channel object given its
292 * child relative id (ie channel id)
294 struct vmbus_channel
*relid2channel(u32 relid
)
296 struct vmbus_channel
*channel
;
297 struct vmbus_channel
*found_channel
= NULL
;
298 struct list_head
*cur
, *tmp
;
299 struct vmbus_channel
*cur_sc
;
301 BUG_ON(!mutex_is_locked(&vmbus_connection
.channel_mutex
));
303 list_for_each_entry(channel
, &vmbus_connection
.chn_list
, listentry
) {
304 if (channel
->offermsg
.child_relid
== relid
) {
305 found_channel
= channel
;
307 } else if (!list_empty(&channel
->sc_list
)) {
309 * Deal with sub-channels.
311 list_for_each_safe(cur
, tmp
, &channel
->sc_list
) {
312 cur_sc
= list_entry(cur
, struct vmbus_channel
,
314 if (cur_sc
->offermsg
.child_relid
== relid
) {
315 found_channel
= cur_sc
;
322 return found_channel
;
326 * process_chn_event - Process a channel event notification
328 static void process_chn_event(u32 relid
)
330 struct vmbus_channel
*channel
;
336 * Find the channel based on this relid and invokes the
337 * channel callback to process the event
339 channel
= pcpu_relid2channel(relid
);
345 * A channel once created is persistent even when there
346 * is no driver handling the device. An unloading driver
347 * sets the onchannel_callback to NULL on the same CPU
348 * as where this interrupt is handled (in an interrupt context).
349 * Thus, checking and invoking the driver specific callback takes
350 * care of orderly unloading of the driver.
353 if (channel
->onchannel_callback
!= NULL
) {
354 arg
= channel
->channel_callback_context
;
355 read_state
= channel
->batched_reading
;
357 * This callback reads the messages sent by the host.
358 * We can optimize host to guest signaling by ensuring:
359 * 1. While reading the channel, we disable interrupts from
361 * 2. Ensure that we process all posted messages from the host
362 * before returning from this callback.
363 * 3. Once we return, enable signaling from the host. Once this
364 * state is set we check to see if additional packets are
365 * available to read. In this case we repeat the process.
370 hv_begin_read(&channel
->inbound
);
371 channel
->onchannel_callback(arg
);
373 bytes_to_read
= hv_end_read(&channel
->inbound
);
376 } while (read_state
&& (bytes_to_read
!= 0));
381 * vmbus_on_event - Handler for events
383 void vmbus_on_event(unsigned long data
)
389 u32
*recv_int_page
= NULL
;
391 int cpu
= smp_processor_id();
392 union hv_synic_event_flags
*event
;
394 if (vmbus_proto_version
< VERSION_WIN8
) {
395 maxdword
= MAX_NUM_CHANNELS_SUPPORTED
>> 5;
396 recv_int_page
= vmbus_connection
.recv_int_page
;
399 * When the host is win8 and beyond, the event page
400 * can be directly checked to get the id of the channel
401 * that has the interrupt pending.
403 maxdword
= HV_EVENT_FLAGS_DWORD_COUNT
;
404 page_addr
= hv_context
.synic_event_page
[cpu
];
405 event
= (union hv_synic_event_flags
*)page_addr
+
407 recv_int_page
= event
->flags32
;
415 for (dword
= 0; dword
< maxdword
; dword
++) {
416 if (!recv_int_page
[dword
])
418 for (bit
= 0; bit
< 32; bit
++) {
419 if (sync_test_and_clear_bit(bit
,
420 (unsigned long *)&recv_int_page
[dword
])) {
421 relid
= (dword
<< 5) + bit
;
425 * Special case - vmbus
426 * channel protocol msg
430 process_chn_event(relid
);
437 * vmbus_post_msg - Send a msg on the vmbus's message connection
439 int vmbus_post_msg(void *buffer
, size_t buflen
, bool can_sleep
)
441 union hv_connection_id conn_id
;
447 conn_id
.u
.id
= VMBUS_MESSAGE_CONNECTION_ID
;
450 * hv_post_message() can have transient failures because of
451 * insufficient resources. Retry the operation a couple of
452 * times before giving up.
454 while (retries
< 100) {
455 ret
= hv_post_message(conn_id
, 1, buffer
, buflen
);
458 case HV_STATUS_INVALID_CONNECTION_ID
:
460 * We could get this if we send messages too
465 case HV_STATUS_INSUFFICIENT_MEMORY
:
466 case HV_STATUS_INSUFFICIENT_BUFFERS
:
469 case HV_STATUS_SUCCESS
:
472 pr_err("hv_post_msg() failed; error code:%d\n", ret
);
477 if (can_sleep
&& usec
> 1000)
479 else if (usec
< MAX_UDELAY_MS
* 1000)
491 * vmbus_set_event - Send an event notification to the parent
493 void vmbus_set_event(struct vmbus_channel
*channel
)
495 u32 child_relid
= channel
->offermsg
.child_relid
;
497 if (!channel
->is_dedicated_interrupt
) {
498 /* Each u32 represents 32 channels */
499 sync_set_bit(child_relid
& 31,
500 (unsigned long *)vmbus_connection
.send_int_page
+
504 hv_do_hypercall(HVCALL_SIGNAL_EVENT
, channel
->sig_event
, NULL
);
506 EXPORT_SYMBOL_GPL(vmbus_set_event
);