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("Vmbus version:%d.%d\n",
225 version
>> 16, version
& 0xFFFF);
231 pr_err("Unable to connect to host\n");
233 vmbus_connection
.conn_state
= DISCONNECTED
;
241 void vmbus_disconnect(void)
244 * First send the unload request to the host.
246 vmbus_initiate_unload(false);
248 if (vmbus_connection
.work_queue
) {
249 drain_workqueue(vmbus_connection
.work_queue
);
250 destroy_workqueue(vmbus_connection
.work_queue
);
253 if (vmbus_connection
.int_page
) {
254 free_pages((unsigned long)vmbus_connection
.int_page
, 0);
255 vmbus_connection
.int_page
= NULL
;
258 free_pages((unsigned long)vmbus_connection
.monitor_pages
[0], 0);
259 free_pages((unsigned long)vmbus_connection
.monitor_pages
[1], 0);
260 vmbus_connection
.monitor_pages
[0] = NULL
;
261 vmbus_connection
.monitor_pages
[1] = NULL
;
265 * Map the given relid to the corresponding channel based on the
266 * per-cpu list of channels that have been affinitized to this CPU.
267 * This will be used in the channel callback path as we can do this
268 * mapping in a lock-free fashion.
270 static struct vmbus_channel
*pcpu_relid2channel(u32 relid
)
272 struct vmbus_channel
*channel
;
273 struct vmbus_channel
*found_channel
= NULL
;
274 int cpu
= smp_processor_id();
275 struct list_head
*pcpu_head
= &hv_context
.percpu_list
[cpu
];
277 list_for_each_entry(channel
, pcpu_head
, percpu_list
) {
278 if (channel
->offermsg
.child_relid
== relid
) {
279 found_channel
= channel
;
284 return found_channel
;
288 * relid2channel - Get the channel object given its
289 * child relative id (ie channel id)
291 struct vmbus_channel
*relid2channel(u32 relid
)
293 struct vmbus_channel
*channel
;
294 struct vmbus_channel
*found_channel
= NULL
;
295 struct list_head
*cur
, *tmp
;
296 struct vmbus_channel
*cur_sc
;
298 BUG_ON(!mutex_is_locked(&vmbus_connection
.channel_mutex
));
300 list_for_each_entry(channel
, &vmbus_connection
.chn_list
, listentry
) {
301 if (channel
->offermsg
.child_relid
== relid
) {
302 found_channel
= channel
;
304 } else if (!list_empty(&channel
->sc_list
)) {
306 * Deal with sub-channels.
308 list_for_each_safe(cur
, tmp
, &channel
->sc_list
) {
309 cur_sc
= list_entry(cur
, struct vmbus_channel
,
311 if (cur_sc
->offermsg
.child_relid
== relid
) {
312 found_channel
= cur_sc
;
319 return found_channel
;
323 * process_chn_event - Process a channel event notification
325 static void process_chn_event(u32 relid
)
327 struct vmbus_channel
*channel
;
333 * Find the channel based on this relid and invokes the
334 * channel callback to process the event
336 channel
= pcpu_relid2channel(relid
);
342 * A channel once created is persistent even when there
343 * is no driver handling the device. An unloading driver
344 * sets the onchannel_callback to NULL on the same CPU
345 * as where this interrupt is handled (in an interrupt context).
346 * Thus, checking and invoking the driver specific callback takes
347 * care of orderly unloading of the driver.
350 if (channel
->onchannel_callback
!= NULL
) {
351 arg
= channel
->channel_callback_context
;
352 read_state
= channel
->batched_reading
;
354 * This callback reads the messages sent by the host.
355 * We can optimize host to guest signaling by ensuring:
356 * 1. While reading the channel, we disable interrupts from
358 * 2. Ensure that we process all posted messages from the host
359 * before returning from this callback.
360 * 3. Once we return, enable signaling from the host. Once this
361 * state is set we check to see if additional packets are
362 * available to read. In this case we repeat the process.
367 hv_begin_read(&channel
->inbound
);
368 channel
->onchannel_callback(arg
);
370 bytes_to_read
= hv_end_read(&channel
->inbound
);
373 } while (read_state
&& (bytes_to_read
!= 0));
378 * vmbus_on_event - Handler for events
380 void vmbus_on_event(unsigned long data
)
386 u32
*recv_int_page
= NULL
;
388 int cpu
= smp_processor_id();
389 union hv_synic_event_flags
*event
;
391 if (vmbus_proto_version
< VERSION_WIN8
) {
392 maxdword
= MAX_NUM_CHANNELS_SUPPORTED
>> 5;
393 recv_int_page
= vmbus_connection
.recv_int_page
;
396 * When the host is win8 and beyond, the event page
397 * can be directly checked to get the id of the channel
398 * that has the interrupt pending.
400 maxdword
= HV_EVENT_FLAGS_DWORD_COUNT
;
401 page_addr
= hv_context
.synic_event_page
[cpu
];
402 event
= (union hv_synic_event_flags
*)page_addr
+
404 recv_int_page
= event
->flags32
;
412 for (dword
= 0; dword
< maxdword
; dword
++) {
413 if (!recv_int_page
[dword
])
415 for (bit
= 0; bit
< 32; bit
++) {
416 if (sync_test_and_clear_bit(bit
,
417 (unsigned long *)&recv_int_page
[dword
])) {
418 relid
= (dword
<< 5) + bit
;
422 * Special case - vmbus
423 * channel protocol msg
427 process_chn_event(relid
);
434 * vmbus_post_msg - Send a msg on the vmbus's message connection
436 int vmbus_post_msg(void *buffer
, size_t buflen
, bool can_sleep
)
438 union hv_connection_id conn_id
;
444 conn_id
.u
.id
= VMBUS_MESSAGE_CONNECTION_ID
;
447 * hv_post_message() can have transient failures because of
448 * insufficient resources. Retry the operation a couple of
449 * times before giving up.
451 while (retries
< 100) {
452 ret
= hv_post_message(conn_id
, 1, buffer
, buflen
);
455 case HV_STATUS_INVALID_CONNECTION_ID
:
457 * We could get this if we send messages too
462 case HV_STATUS_INSUFFICIENT_MEMORY
:
463 case HV_STATUS_INSUFFICIENT_BUFFERS
:
466 case HV_STATUS_SUCCESS
:
469 pr_err("hv_post_msg() failed; error code:%d\n", ret
);
474 if (can_sleep
&& usec
> 1000)
476 else if (usec
< MAX_UDELAY_MS
* 1000)
488 * vmbus_set_event - Send an event notification to the parent
490 void vmbus_set_event(struct vmbus_channel
*channel
)
492 u32 child_relid
= channel
->offermsg
.child_relid
;
494 if (!channel
->is_dedicated_interrupt
) {
495 /* Each u32 represents 32 channels */
496 sync_set_bit(child_relid
& 31,
497 (unsigned long *)vmbus_connection
.send_int_page
+
501 hv_do_hypercall(HVCALL_SIGNAL_EVENT
, channel
->sig_event
, NULL
);
503 EXPORT_SYMBOL_GPL(vmbus_set_event
);