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 <asm/mshyperv.h>
37 #include "hyperv_vmbus.h"
40 struct vmbus_connection vmbus_connection
= {
41 .conn_state
= DISCONNECTED
,
42 .next_gpadl_handle
= ATOMIC_INIT(0xE1E10),
44 EXPORT_SYMBOL_GPL(vmbus_connection
);
47 * Negotiated protocol version with the host.
49 __u32 vmbus_proto_version
;
50 EXPORT_SYMBOL_GPL(vmbus_proto_version
);
52 static __u32
vmbus_get_next_version(__u32 current_version
)
54 switch (current_version
) {
56 return VERSION_WS2008
;
61 case (VERSION_WIN8_1
):
65 return VERSION_WIN8_1
;
67 case (VERSION_WS2008
):
73 static int vmbus_negotiate_version(struct vmbus_channel_msginfo
*msginfo
,
78 struct vmbus_channel_initiate_contact
*msg
;
81 init_completion(&msginfo
->waitevent
);
83 msg
= (struct vmbus_channel_initiate_contact
*)msginfo
->msg
;
85 msg
->header
.msgtype
= CHANNELMSG_INITIATE_CONTACT
;
86 msg
->vmbus_version_requested
= version
;
87 msg
->interrupt_page
= virt_to_phys(vmbus_connection
.int_page
);
88 msg
->monitor_page1
= virt_to_phys(vmbus_connection
.monitor_pages
[0]);
89 msg
->monitor_page2
= virt_to_phys(vmbus_connection
.monitor_pages
[1]);
91 * We want all channel messages to be delivered on CPU 0.
92 * This has been the behavior pre-win8. This is not
93 * perf issue and having all channel messages delivered on CPU 0
95 * For post win8 hosts, we support receiving channel messagges on
96 * all the CPUs. This is needed for kexec to work correctly where
97 * the CPU attempting to connect may not be CPU 0.
99 if (version
>= VERSION_WIN8_1
) {
101 msg
->target_vcpu
= hv_cpu_number_to_vp_number(cur_cpu
);
102 vmbus_connection
.connect_cpu
= cur_cpu
;
105 msg
->target_vcpu
= 0;
106 vmbus_connection
.connect_cpu
= 0;
110 * Add to list before we send the request since we may
111 * receive the response before returning from this routine
113 spin_lock_irqsave(&vmbus_connection
.channelmsg_lock
, flags
);
114 list_add_tail(&msginfo
->msglistentry
,
115 &vmbus_connection
.chn_msg_list
);
117 spin_unlock_irqrestore(&vmbus_connection
.channelmsg_lock
, flags
);
119 ret
= vmbus_post_msg(msg
,
120 sizeof(struct vmbus_channel_initiate_contact
),
123 trace_vmbus_negotiate_version(msg
, ret
);
126 spin_lock_irqsave(&vmbus_connection
.channelmsg_lock
, flags
);
127 list_del(&msginfo
->msglistentry
);
128 spin_unlock_irqrestore(&vmbus_connection
.channelmsg_lock
,
133 /* Wait for the connection response */
134 wait_for_completion(&msginfo
->waitevent
);
136 spin_lock_irqsave(&vmbus_connection
.channelmsg_lock
, flags
);
137 list_del(&msginfo
->msglistentry
);
138 spin_unlock_irqrestore(&vmbus_connection
.channelmsg_lock
, flags
);
140 /* Check if successful */
141 if (msginfo
->response
.version_response
.version_supported
) {
142 vmbus_connection
.conn_state
= CONNECTED
;
144 return -ECONNREFUSED
;
151 * vmbus_connect - Sends a connect request on the partition service connection
153 int vmbus_connect(void)
156 struct vmbus_channel_msginfo
*msginfo
= NULL
;
159 /* Initialize the vmbus connection */
160 vmbus_connection
.conn_state
= CONNECTING
;
161 vmbus_connection
.work_queue
= create_workqueue("hv_vmbus_con");
162 if (!vmbus_connection
.work_queue
) {
167 vmbus_connection
.handle_primary_chan_wq
=
168 create_workqueue("hv_pri_chan");
169 if (!vmbus_connection
.handle_primary_chan_wq
) {
174 vmbus_connection
.handle_sub_chan_wq
=
175 create_workqueue("hv_sub_chan");
176 if (!vmbus_connection
.handle_sub_chan_wq
) {
181 INIT_LIST_HEAD(&vmbus_connection
.chn_msg_list
);
182 spin_lock_init(&vmbus_connection
.channelmsg_lock
);
184 INIT_LIST_HEAD(&vmbus_connection
.chn_list
);
185 mutex_init(&vmbus_connection
.channel_mutex
);
188 * Setup the vmbus event connection for channel interrupt
191 vmbus_connection
.int_page
=
192 (void *)__get_free_pages(GFP_KERNEL
|__GFP_ZERO
, 0);
193 if (vmbus_connection
.int_page
== NULL
) {
198 vmbus_connection
.recv_int_page
= vmbus_connection
.int_page
;
199 vmbus_connection
.send_int_page
=
200 (void *)((unsigned long)vmbus_connection
.int_page
+
204 * Setup the monitor notification facility. The 1st page for
205 * parent->child and the 2nd page for child->parent
207 vmbus_connection
.monitor_pages
[0] = (void *)__get_free_pages((GFP_KERNEL
|__GFP_ZERO
), 0);
208 vmbus_connection
.monitor_pages
[1] = (void *)__get_free_pages((GFP_KERNEL
|__GFP_ZERO
), 0);
209 if ((vmbus_connection
.monitor_pages
[0] == NULL
) ||
210 (vmbus_connection
.monitor_pages
[1] == NULL
)) {
215 msginfo
= kzalloc(sizeof(*msginfo
) +
216 sizeof(struct vmbus_channel_initiate_contact
),
218 if (msginfo
== NULL
) {
224 * Negotiate a compatible VMBUS version number with the
225 * host. We start with the highest number we can support
226 * and work our way down until we negotiate a compatible
230 version
= VERSION_CURRENT
;
233 ret
= vmbus_negotiate_version(msginfo
, version
);
234 if (ret
== -ETIMEDOUT
)
237 if (vmbus_connection
.conn_state
== CONNECTED
)
240 version
= vmbus_get_next_version(version
);
241 } while (version
!= VERSION_INVAL
);
243 if (version
== VERSION_INVAL
)
246 vmbus_proto_version
= version
;
247 pr_info("Vmbus version:%d.%d\n",
248 version
>> 16, version
& 0xFFFF);
254 pr_err("Unable to connect to host\n");
256 vmbus_connection
.conn_state
= DISCONNECTED
;
264 void vmbus_disconnect(void)
267 * First send the unload request to the host.
269 vmbus_initiate_unload(false);
271 if (vmbus_connection
.handle_sub_chan_wq
)
272 destroy_workqueue(vmbus_connection
.handle_sub_chan_wq
);
274 if (vmbus_connection
.handle_primary_chan_wq
)
275 destroy_workqueue(vmbus_connection
.handle_primary_chan_wq
);
277 if (vmbus_connection
.work_queue
)
278 destroy_workqueue(vmbus_connection
.work_queue
);
280 if (vmbus_connection
.int_page
) {
281 free_pages((unsigned long)vmbus_connection
.int_page
, 0);
282 vmbus_connection
.int_page
= NULL
;
285 free_pages((unsigned long)vmbus_connection
.monitor_pages
[0], 0);
286 free_pages((unsigned long)vmbus_connection
.monitor_pages
[1], 0);
287 vmbus_connection
.monitor_pages
[0] = NULL
;
288 vmbus_connection
.monitor_pages
[1] = NULL
;
292 * relid2channel - Get the channel object given its
293 * child relative id (ie channel id)
295 struct vmbus_channel
*relid2channel(u32 relid
)
297 struct vmbus_channel
*channel
;
298 struct vmbus_channel
*found_channel
= NULL
;
299 struct list_head
*cur
, *tmp
;
300 struct vmbus_channel
*cur_sc
;
302 BUG_ON(!mutex_is_locked(&vmbus_connection
.channel_mutex
));
304 list_for_each_entry(channel
, &vmbus_connection
.chn_list
, listentry
) {
305 if (channel
->offermsg
.child_relid
== relid
) {
306 found_channel
= channel
;
308 } else if (!list_empty(&channel
->sc_list
)) {
310 * Deal with sub-channels.
312 list_for_each_safe(cur
, tmp
, &channel
->sc_list
) {
313 cur_sc
= list_entry(cur
, struct vmbus_channel
,
315 if (cur_sc
->offermsg
.child_relid
== relid
) {
316 found_channel
= cur_sc
;
323 return found_channel
;
327 * vmbus_on_event - Process a channel event notification
329 * For batched channels (default) optimize host to guest signaling
331 * 1. While reading the channel, we disable interrupts from host.
332 * 2. Ensure that we process all posted messages from the host
333 * before returning from this callback.
334 * 3. Once we return, enable signaling from the host. Once this
335 * state is set we check to see if additional packets are
336 * available to read. In this case we repeat the process.
337 * If this tasklet has been running for a long time
338 * then reschedule ourselves.
340 void vmbus_on_event(unsigned long data
)
342 struct vmbus_channel
*channel
= (void *) data
;
343 unsigned long time_limit
= jiffies
+ 2;
345 trace_vmbus_on_event(channel
);
348 void (*callback_fn
)(void *);
350 /* A channel once created is persistent even when
351 * there is no driver handling the device. An
352 * unloading driver sets the onchannel_callback to NULL.
354 callback_fn
= READ_ONCE(channel
->onchannel_callback
);
355 if (unlikely(callback_fn
== NULL
))
358 (*callback_fn
)(channel
->channel_callback_context
);
360 if (channel
->callback_mode
!= HV_CALL_BATCHED
)
363 if (likely(hv_end_read(&channel
->inbound
) == 0))
366 hv_begin_read(&channel
->inbound
);
367 } while (likely(time_before(jiffies
, time_limit
)));
369 /* The time limit (2 jiffies) has been reached */
370 tasklet_schedule(&channel
->callback_event
);
374 * vmbus_post_msg - Send a msg on the vmbus's message connection
376 int vmbus_post_msg(void *buffer
, size_t buflen
, bool can_sleep
)
378 union hv_connection_id conn_id
;
384 conn_id
.u
.id
= VMBUS_MESSAGE_CONNECTION_ID
;
387 * hv_post_message() can have transient failures because of
388 * insufficient resources. Retry the operation a couple of
389 * times before giving up.
391 while (retries
< 100) {
392 ret
= hv_post_message(conn_id
, 1, buffer
, buflen
);
395 case HV_STATUS_INVALID_CONNECTION_ID
:
397 * We could get this if we send messages too
402 case HV_STATUS_INSUFFICIENT_MEMORY
:
403 case HV_STATUS_INSUFFICIENT_BUFFERS
:
406 case HV_STATUS_SUCCESS
:
409 pr_err("hv_post_msg() failed; error code:%d\n", ret
);
414 if (can_sleep
&& usec
> 1000)
416 else if (usec
< MAX_UDELAY_MS
* 1000)
428 * vmbus_set_event - Send an event notification to the parent
430 void vmbus_set_event(struct vmbus_channel
*channel
)
432 u32 child_relid
= channel
->offermsg
.child_relid
;
434 if (!channel
->is_dedicated_interrupt
)
435 vmbus_send_interrupt(child_relid
);
437 ++channel
->sig_events
;
439 hv_do_fast_hypercall8(HVCALL_SIGNAL_EVENT
, channel
->sig_event
);
441 EXPORT_SYMBOL_GPL(vmbus_set_event
);