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 * VMBUS version is 32 bit entity broken up into
45 * two 16 bit quantities: major_number. minor_number.
47 * 0 . 13 (Windows Server 2008)
52 #define VERSION_WS2008 ((0 << 16) | (13))
53 #define VERSION_WIN7 ((1 << 16) | (1))
54 #define VERSION_WIN8 ((2 << 16) | (4))
56 #define VERSION_INVAL -1
59 * Negotiated protocol version with the host.
61 __u32 vmbus_proto_version;
62 EXPORT_SYMBOL_GPL(vmbus_proto_version);
64 static __u32 vmbus_get_next_version(__u32 current_version)
66 switch (current_version) {
68 return VERSION_WS2008;
73 case (VERSION_WS2008):
79 static int vmbus_negotiate_version(struct vmbus_channel_msginfo *msginfo,
83 struct vmbus_channel_initiate_contact *msg;
87 init_completion(&msginfo->waitevent);
89 msg = (struct vmbus_channel_initiate_contact *)msginfo->msg;
91 msg->header.msgtype = CHANNELMSG_INITIATE_CONTACT;
92 msg->vmbus_version_requested = version;
93 msg->interrupt_page = virt_to_phys(vmbus_connection.int_page);
94 msg->monitor_page1 = virt_to_phys(vmbus_connection.monitor_pages);
95 msg->monitor_page2 = virt_to_phys(
96 (void *)((unsigned long)vmbus_connection.monitor_pages +
100 * Add to list before we send the request since we may
101 * receive the response before returning from this routine
103 spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags);
104 list_add_tail(&msginfo->msglistentry,
105 &vmbus_connection.chn_msg_list);
107 spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock, flags);
109 ret = vmbus_post_msg(msg,
110 sizeof(struct vmbus_channel_initiate_contact));
112 spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags);
113 list_del(&msginfo->msglistentry);
114 spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock,
119 /* Wait for the connection response */
120 t = wait_for_completion_timeout(&msginfo->waitevent, 5*HZ);
122 spin_lock_irqsave(&vmbus_connection.channelmsg_lock,
124 list_del(&msginfo->msglistentry);
125 spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock,
130 spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags);
131 list_del(&msginfo->msglistentry);
132 spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock, flags);
134 /* Check if successful */
135 if (msginfo->response.version_response.version_supported) {
136 vmbus_connection.conn_state = CONNECTED;
138 pr_err("Unable to connect, "
139 "Version %d not supported by Hyper-V\n",
141 return -ECONNREFUSED;
148 * vmbus_connect - Sends a connect request on the partition service connection
150 int vmbus_connect(void)
153 struct vmbus_channel_msginfo *msginfo = NULL;
156 /* Initialize the vmbus connection */
157 vmbus_connection.conn_state = CONNECTING;
158 vmbus_connection.work_queue = create_workqueue("hv_vmbus_con");
159 if (!vmbus_connection.work_queue) {
164 INIT_LIST_HEAD(&vmbus_connection.chn_msg_list);
165 spin_lock_init(&vmbus_connection.channelmsg_lock);
167 INIT_LIST_HEAD(&vmbus_connection.chn_list);
168 spin_lock_init(&vmbus_connection.channel_lock);
171 * Setup the vmbus event connection for channel interrupt
174 vmbus_connection.int_page =
175 (void *)__get_free_pages(GFP_KERNEL|__GFP_ZERO, 0);
176 if (vmbus_connection.int_page == NULL) {
181 vmbus_connection.recv_int_page = vmbus_connection.int_page;
182 vmbus_connection.send_int_page =
183 (void *)((unsigned long)vmbus_connection.int_page +
187 * Setup the monitor notification facility. The 1st page for
188 * parent->child and the 2nd page for child->parent
190 vmbus_connection.monitor_pages =
191 (void *)__get_free_pages((GFP_KERNEL|__GFP_ZERO), 1);
192 if (vmbus_connection.monitor_pages == NULL) {
197 msginfo = kzalloc(sizeof(*msginfo) +
198 sizeof(struct vmbus_channel_initiate_contact),
200 if (msginfo == NULL) {
206 * Negotiate a compatible VMBUS version number with the
207 * host. We start with the highest number we can support
208 * and work our way down until we negotiate a compatible
212 version = VERSION_WS2008;
215 ret = vmbus_negotiate_version(msginfo, version);
219 version = vmbus_get_next_version(version);
220 } while (version != VERSION_INVAL);
222 if (version == VERSION_INVAL)
225 vmbus_proto_version = version;
226 pr_info("Negotiated host information %d\n", version);
231 vmbus_connection.conn_state = DISCONNECTED;
233 if (vmbus_connection.work_queue)
234 destroy_workqueue(vmbus_connection.work_queue);
236 if (vmbus_connection.int_page) {
237 free_pages((unsigned long)vmbus_connection.int_page, 0);
238 vmbus_connection.int_page = NULL;
241 if (vmbus_connection.monitor_pages) {
242 free_pages((unsigned long)vmbus_connection.monitor_pages, 1);
243 vmbus_connection.monitor_pages = NULL;
253 * relid2channel - Get the channel object given its
254 * child relative id (ie channel id)
256 struct vmbus_channel *relid2channel(u32 relid)
258 struct vmbus_channel *channel;
259 struct vmbus_channel *found_channel = NULL;
262 spin_lock_irqsave(&vmbus_connection.channel_lock, flags);
263 list_for_each_entry(channel, &vmbus_connection.chn_list, listentry) {
264 if (channel->offermsg.child_relid == relid) {
265 found_channel = channel;
269 spin_unlock_irqrestore(&vmbus_connection.channel_lock, flags);
271 return found_channel;
275 * process_chn_event - Process a channel event notification
277 static void process_chn_event(u32 relid)
279 struct vmbus_channel *channel;
286 * Find the channel based on this relid and invokes the
287 * channel callback to process the event
289 channel = relid2channel(relid);
292 pr_err("channel not found for relid - %u\n", relid);
297 * A channel once created is persistent even when there
298 * is no driver handling the device. An unloading driver
299 * sets the onchannel_callback to NULL under the
300 * protection of the channel inbound_lock. Thus, checking
301 * and invoking the driver specific callback takes care of
302 * orderly unloading of the driver.
305 spin_lock_irqsave(&channel->inbound_lock, flags);
306 if (channel->onchannel_callback != NULL) {
307 arg = channel->channel_callback_context;
308 read_state = channel->batched_reading;
310 * This callback reads the messages sent by the host.
311 * We can optimize host to guest signaling by ensuring:
312 * 1. While reading the channel, we disable interrupts from
314 * 2. Ensure that we process all posted messages from the host
315 * before returning from this callback.
316 * 3. Once we return, enable signaling from the host. Once this
317 * state is set we check to see if additional packets are
318 * available to read. In this case we repeat the process.
322 hv_begin_read(&channel->inbound);
323 channel->onchannel_callback(arg);
324 bytes_to_read = hv_end_read(&channel->inbound);
325 } while (read_state && (bytes_to_read != 0));
327 pr_err("no channel callback for relid - %u\n", relid);
330 spin_unlock_irqrestore(&channel->inbound_lock, flags);
334 * vmbus_on_event - Handler for events
336 void vmbus_on_event(unsigned long data)
339 u32 maxdword = MAX_NUM_CHANNELS_SUPPORTED >> 5;
342 u32 *recv_int_page = vmbus_connection.recv_int_page;
347 for (dword = 0; dword < maxdword; dword++) {
348 if (!recv_int_page[dword])
350 for (bit = 0; bit < 32; bit++) {
351 if (sync_test_and_clear_bit(bit,
352 (unsigned long *)&recv_int_page[dword])) {
353 relid = (dword << 5) + bit;
357 * Special case - vmbus
358 * channel protocol msg
362 process_chn_event(relid);
369 * vmbus_post_msg - Send a msg on the vmbus's message connection
371 int vmbus_post_msg(void *buffer, size_t buflen)
373 union hv_connection_id conn_id;
378 conn_id.u.id = VMBUS_MESSAGE_CONNECTION_ID;
381 * hv_post_message() can have transient failures because of
382 * insufficient resources. Retry the operation a couple of
383 * times before giving up.
385 while (retries < 3) {
386 ret = hv_post_message(conn_id, 1, buffer, buflen);
387 if (ret != HV_STATUS_INSUFFICIENT_BUFFERS)
396 * vmbus_set_event - Send an event notification to the parent
398 int vmbus_set_event(u32 child_relid)
400 /* Each u32 represents 32 channels */
401 sync_set_bit(child_relid & 31,
402 (unsigned long *)vmbus_connection.send_int_page +
405 return hv_signal_event(hv_context.signal_event_param);