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
[smp_processor_id()];
102 * Add to list before we send the request since we may
103 * receive the response before returning from this routine
105 spin_lock_irqsave(&vmbus_connection
.channelmsg_lock
, flags
);
106 list_add_tail(&msginfo
->msglistentry
,
107 &vmbus_connection
.chn_msg_list
);
109 spin_unlock_irqrestore(&vmbus_connection
.channelmsg_lock
, flags
);
111 ret
= vmbus_post_msg(msg
,
112 sizeof(struct vmbus_channel_initiate_contact
),
115 spin_lock_irqsave(&vmbus_connection
.channelmsg_lock
, flags
);
116 list_del(&msginfo
->msglistentry
);
117 spin_unlock_irqrestore(&vmbus_connection
.channelmsg_lock
,
122 /* Wait for the connection response */
123 wait_for_completion(&msginfo
->waitevent
);
125 spin_lock_irqsave(&vmbus_connection
.channelmsg_lock
, flags
);
126 list_del(&msginfo
->msglistentry
);
127 spin_unlock_irqrestore(&vmbus_connection
.channelmsg_lock
, flags
);
129 /* Check if successful */
130 if (msginfo
->response
.version_response
.version_supported
) {
131 vmbus_connection
.conn_state
= CONNECTED
;
133 return -ECONNREFUSED
;
140 * vmbus_connect - Sends a connect request on the partition service connection
142 int vmbus_connect(void)
145 struct vmbus_channel_msginfo
*msginfo
= NULL
;
148 /* Initialize the vmbus connection */
149 vmbus_connection
.conn_state
= CONNECTING
;
150 vmbus_connection
.work_queue
= create_workqueue("hv_vmbus_con");
151 if (!vmbus_connection
.work_queue
) {
156 INIT_LIST_HEAD(&vmbus_connection
.chn_msg_list
);
157 spin_lock_init(&vmbus_connection
.channelmsg_lock
);
159 INIT_LIST_HEAD(&vmbus_connection
.chn_list
);
160 mutex_init(&vmbus_connection
.channel_mutex
);
163 * Setup the vmbus event connection for channel interrupt
166 vmbus_connection
.int_page
=
167 (void *)__get_free_pages(GFP_KERNEL
|__GFP_ZERO
, 0);
168 if (vmbus_connection
.int_page
== NULL
) {
173 vmbus_connection
.recv_int_page
= vmbus_connection
.int_page
;
174 vmbus_connection
.send_int_page
=
175 (void *)((unsigned long)vmbus_connection
.int_page
+
179 * Setup the monitor notification facility. The 1st page for
180 * parent->child and the 2nd page for child->parent
182 vmbus_connection
.monitor_pages
[0] = (void *)__get_free_pages((GFP_KERNEL
|__GFP_ZERO
), 0);
183 vmbus_connection
.monitor_pages
[1] = (void *)__get_free_pages((GFP_KERNEL
|__GFP_ZERO
), 0);
184 if ((vmbus_connection
.monitor_pages
[0] == NULL
) ||
185 (vmbus_connection
.monitor_pages
[1] == NULL
)) {
190 msginfo
= kzalloc(sizeof(*msginfo
) +
191 sizeof(struct vmbus_channel_initiate_contact
),
193 if (msginfo
== NULL
) {
199 * Negotiate a compatible VMBUS version number with the
200 * host. We start with the highest number we can support
201 * and work our way down until we negotiate a compatible
205 version
= VERSION_CURRENT
;
208 ret
= vmbus_negotiate_version(msginfo
, version
);
209 if (ret
== -ETIMEDOUT
)
212 if (vmbus_connection
.conn_state
== CONNECTED
)
215 version
= vmbus_get_next_version(version
);
216 } while (version
!= VERSION_INVAL
);
218 if (version
== VERSION_INVAL
)
221 vmbus_proto_version
= version
;
222 pr_info("Vmbus version:%d.%d\n",
223 version
>> 16, version
& 0xFFFF);
229 pr_err("Unable to connect to host\n");
231 vmbus_connection
.conn_state
= DISCONNECTED
;
239 void vmbus_disconnect(void)
242 * First send the unload request to the host.
244 vmbus_initiate_unload(false);
246 if (vmbus_connection
.work_queue
) {
247 drain_workqueue(vmbus_connection
.work_queue
);
248 destroy_workqueue(vmbus_connection
.work_queue
);
251 if (vmbus_connection
.int_page
) {
252 free_pages((unsigned long)vmbus_connection
.int_page
, 0);
253 vmbus_connection
.int_page
= NULL
;
256 free_pages((unsigned long)vmbus_connection
.monitor_pages
[0], 0);
257 free_pages((unsigned long)vmbus_connection
.monitor_pages
[1], 0);
258 vmbus_connection
.monitor_pages
[0] = NULL
;
259 vmbus_connection
.monitor_pages
[1] = NULL
;
263 * relid2channel - Get the channel object given its
264 * child relative id (ie channel id)
266 struct vmbus_channel
*relid2channel(u32 relid
)
268 struct vmbus_channel
*channel
;
269 struct vmbus_channel
*found_channel
= NULL
;
270 struct list_head
*cur
, *tmp
;
271 struct vmbus_channel
*cur_sc
;
273 BUG_ON(!mutex_is_locked(&vmbus_connection
.channel_mutex
));
275 list_for_each_entry(channel
, &vmbus_connection
.chn_list
, listentry
) {
276 if (channel
->offermsg
.child_relid
== relid
) {
277 found_channel
= channel
;
279 } else if (!list_empty(&channel
->sc_list
)) {
281 * Deal with sub-channels.
283 list_for_each_safe(cur
, tmp
, &channel
->sc_list
) {
284 cur_sc
= list_entry(cur
, struct vmbus_channel
,
286 if (cur_sc
->offermsg
.child_relid
== relid
) {
287 found_channel
= cur_sc
;
294 return found_channel
;
298 * vmbus_on_event - Process a channel event notification
300 * For batched channels (default) optimize host to guest signaling
302 * 1. While reading the channel, we disable interrupts from host.
303 * 2. Ensure that we process all posted messages from the host
304 * before returning from this callback.
305 * 3. Once we return, enable signaling from the host. Once this
306 * state is set we check to see if additional packets are
307 * available to read. In this case we repeat the process.
308 * If this tasklet has been running for a long time
309 * then reschedule ourselves.
311 void vmbus_on_event(unsigned long data
)
313 struct vmbus_channel
*channel
= (void *) data
;
314 unsigned long time_limit
= jiffies
+ 2;
317 void (*callback_fn
)(void *);
319 /* A channel once created is persistent even when
320 * there is no driver handling the device. An
321 * unloading driver sets the onchannel_callback to NULL.
323 callback_fn
= READ_ONCE(channel
->onchannel_callback
);
324 if (unlikely(callback_fn
== NULL
))
327 (*callback_fn
)(channel
->channel_callback_context
);
329 if (channel
->callback_mode
!= HV_CALL_BATCHED
)
332 if (likely(hv_end_read(&channel
->inbound
) == 0))
335 hv_begin_read(&channel
->inbound
);
336 } while (likely(time_before(jiffies
, time_limit
)));
338 /* The time limit (2 jiffies) has been reached */
339 tasklet_schedule(&channel
->callback_event
);
343 * vmbus_post_msg - Send a msg on the vmbus's message connection
345 int vmbus_post_msg(void *buffer
, size_t buflen
, bool can_sleep
)
347 union hv_connection_id conn_id
;
353 conn_id
.u
.id
= VMBUS_MESSAGE_CONNECTION_ID
;
356 * hv_post_message() can have transient failures because of
357 * insufficient resources. Retry the operation a couple of
358 * times before giving up.
360 while (retries
< 100) {
361 ret
= hv_post_message(conn_id
, 1, buffer
, buflen
);
364 case HV_STATUS_INVALID_CONNECTION_ID
:
366 * We could get this if we send messages too
371 case HV_STATUS_INSUFFICIENT_MEMORY
:
372 case HV_STATUS_INSUFFICIENT_BUFFERS
:
375 case HV_STATUS_SUCCESS
:
378 pr_err("hv_post_msg() failed; error code:%d\n", ret
);
383 if (can_sleep
&& usec
> 1000)
385 else if (usec
< MAX_UDELAY_MS
* 1000)
397 * vmbus_set_event - Send an event notification to the parent
399 void vmbus_set_event(struct vmbus_channel
*channel
)
401 u32 child_relid
= channel
->offermsg
.child_relid
;
403 if (!channel
->is_dedicated_interrupt
)
404 vmbus_send_interrupt(child_relid
);
406 hv_do_hypercall(HVCALL_SIGNAL_EVENT
, channel
->sig_event
, NULL
);
408 EXPORT_SYMBOL_GPL(vmbus_set_event
);