Merge 3.12-rc3 into char-misc-next
[deliverable/linux.git] / drivers / hv / connection.c
CommitLineData
3e7ee490
HJ
1/*
2 *
3 * Copyright (c) 2009, Microsoft Corporation.
4 *
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.
8 *
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
12 * more details.
13 *
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.
17 *
18 * Authors:
19 * Haiyang Zhang <haiyangz@microsoft.com>
20 * Hank Janssen <hjanssen@microsoft.com>
21 *
22 */
0a46618d
HJ
23#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
24
a0086dc5 25#include <linux/kernel.h>
0c3b7b2f
S
26#include <linux/sched.h>
27#include <linux/wait.h>
5289d3d1 28#include <linux/delay.h>
a0086dc5 29#include <linux/mm.h>
5a0e3ad6 30#include <linux/slab.h>
a0086dc5 31#include <linux/vmalloc.h>
46a97191 32#include <linux/hyperv.h>
37f7278b 33#include <linux/export.h>
407dd164 34#include <asm/hyperv.h>
0f2a6619 35#include "hyperv_vmbus.h"
3e7ee490 36
3e7ee490 37
da9fcb72
HZ
38struct vmbus_connection vmbus_connection = {
39 .conn_state = DISCONNECTED,
40 .next_gpadl_handle = ATOMIC_INIT(0xE1E10),
3e7ee490
HJ
41};
42
37f7278b
S
43/*
44 * Negotiated protocol version with the host.
45 */
46__u32 vmbus_proto_version;
47EXPORT_SYMBOL_GPL(vmbus_proto_version);
48
610071c3
S
49static __u32 vmbus_get_next_version(__u32 current_version)
50{
51 switch (current_version) {
52 case (VERSION_WIN7):
53 return VERSION_WS2008;
54
55 case (VERSION_WIN8):
56 return VERSION_WIN7;
57
58 case (VERSION_WS2008):
59 default:
60 return VERSION_INVAL;
61 }
62}
63
64static int vmbus_negotiate_version(struct vmbus_channel_msginfo *msginfo,
65 __u32 version)
66{
67 int ret = 0;
68 struct vmbus_channel_initiate_contact *msg;
69 unsigned long flags;
70 int t;
71
72 init_completion(&msginfo->waitevent);
73
74 msg = (struct vmbus_channel_initiate_contact *)msginfo->msg;
75
76 msg->header.msgtype = CHANNELMSG_INITIATE_CONTACT;
77 msg->vmbus_version_requested = version;
78 msg->interrupt_page = virt_to_phys(vmbus_connection.int_page);
8681db44
GKH
79 msg->monitor_page1 = virt_to_phys(vmbus_connection.monitor_pages[0]);
80 msg->monitor_page2 = virt_to_phys(vmbus_connection.monitor_pages[1]);
610071c3
S
81
82 /*
83 * Add to list before we send the request since we may
84 * receive the response before returning from this routine
85 */
86 spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags);
87 list_add_tail(&msginfo->msglistentry,
88 &vmbus_connection.chn_msg_list);
89
90 spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock, flags);
91
92 ret = vmbus_post_msg(msg,
93 sizeof(struct vmbus_channel_initiate_contact));
94 if (ret != 0) {
95 spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags);
96 list_del(&msginfo->msglistentry);
97 spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock,
98 flags);
99 return ret;
100 }
101
102 /* Wait for the connection response */
103 t = wait_for_completion_timeout(&msginfo->waitevent, 5*HZ);
104 if (t == 0) {
105 spin_lock_irqsave(&vmbus_connection.channelmsg_lock,
106 flags);
107 list_del(&msginfo->msglistentry);
108 spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock,
109 flags);
110 return -ETIMEDOUT;
111 }
112
113 spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags);
114 list_del(&msginfo->msglistentry);
115 spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock, flags);
116
117 /* Check if successful */
118 if (msginfo->response.version_response.version_supported) {
119 vmbus_connection.conn_state = CONNECTED;
120 } else {
610071c3
S
121 return -ECONNREFUSED;
122 }
123
124 return ret;
125}
126
3e189519 127/*
c6977677 128 * vmbus_connect - Sends a connect request on the partition service connection
fd8b85ea 129 */
c6977677 130int vmbus_connect(void)
3e7ee490 131{
fd8b85ea 132 int ret = 0;
15b2f647 133 struct vmbus_channel_msginfo *msginfo = NULL;
610071c3 134 __u32 version;
3e7ee490 135
454f18a9 136 /* Initialize the vmbus connection */
da9fcb72
HZ
137 vmbus_connection.conn_state = CONNECTING;
138 vmbus_connection.work_queue = create_workqueue("hv_vmbus_con");
139 if (!vmbus_connection.work_queue) {
3a7546d9 140 ret = -ENOMEM;
b0043863 141 goto cleanup;
de65a384 142 }
3e7ee490 143
da9fcb72 144 INIT_LIST_HEAD(&vmbus_connection.chn_msg_list);
15b2f647 145 spin_lock_init(&vmbus_connection.channelmsg_lock);
3e7ee490 146
da9fcb72 147 INIT_LIST_HEAD(&vmbus_connection.chn_list);
15b2f647 148 spin_lock_init(&vmbus_connection.channel_lock);
3e7ee490 149
454f18a9
BP
150 /*
151 * Setup the vmbus event connection for channel interrupt
152 * abstraction stuff
153 */
df3493e0
S
154 vmbus_connection.int_page =
155 (void *)__get_free_pages(GFP_KERNEL|__GFP_ZERO, 0);
da9fcb72 156 if (vmbus_connection.int_page == NULL) {
3a7546d9 157 ret = -ENOMEM;
b0043863 158 goto cleanup;
3e7ee490
HJ
159 }
160
da9fcb72
HZ
161 vmbus_connection.recv_int_page = vmbus_connection.int_page;
162 vmbus_connection.send_int_page =
163 (void *)((unsigned long)vmbus_connection.int_page +
fd8b85ea 164 (PAGE_SIZE >> 1));
3e7ee490 165
fd8b85ea
GKH
166 /*
167 * Setup the monitor notification facility. The 1st page for
168 * parent->child and the 2nd page for child->parent
454f18a9 169 */
8681db44
GKH
170 vmbus_connection.monitor_pages[0] = (void *)__get_free_pages((GFP_KERNEL|__GFP_ZERO), 0);
171 vmbus_connection.monitor_pages[1] = (void *)__get_free_pages((GFP_KERNEL|__GFP_ZERO), 0);
172 if ((vmbus_connection.monitor_pages[0] == NULL) ||
173 (vmbus_connection.monitor_pages[1] == NULL)) {
3a7546d9 174 ret = -ENOMEM;
b0043863 175 goto cleanup;
3e7ee490
HJ
176 }
177
15b2f647 178 msginfo = kzalloc(sizeof(*msginfo) +
fd8b85ea
GKH
179 sizeof(struct vmbus_channel_initiate_contact),
180 GFP_KERNEL);
15b2f647 181 if (msginfo == NULL) {
8cad0af9 182 ret = -ENOMEM;
b0043863 183 goto cleanup;
3e7ee490
HJ
184 }
185
454f18a9 186 /*
610071c3
S
187 * Negotiate a compatible VMBUS version number with the
188 * host. We start with the highest number we can support
189 * and work our way down until we negotiate a compatible
190 * version.
454f18a9 191 */
3e7ee490 192
2a5c43a8 193 version = VERSION_CURRENT;
3e7ee490 194
610071c3
S
195 do {
196 ret = vmbus_negotiate_version(msginfo, version);
8bbf9f44 197 if (ret == -ETIMEDOUT)
666b9adc
S
198 goto cleanup;
199
200 if (vmbus_connection.conn_state == CONNECTED)
610071c3 201 break;
3e7ee490 202
610071c3
S
203 version = vmbus_get_next_version(version);
204 } while (version != VERSION_INVAL);
3e7ee490 205
610071c3 206 if (version == VERSION_INVAL)
b0043863 207 goto cleanup;
3e7ee490 208
37f7278b 209 vmbus_proto_version = version;
3bacaf0c
S
210 pr_info("Hyper-V Host Build:%d-%d.%d-%d-%d.%d; Vmbus version:%d.%d\n",
211 host_info_eax, host_info_ebx >> 16,
212 host_info_ebx & 0xFFFF, host_info_ecx,
213 host_info_edx >> 24, host_info_edx & 0xFFFFFF,
214 version >> 16, version & 0xFFFF);
215
15b2f647 216 kfree(msginfo);
3e7ee490
HJ
217 return 0;
218
b0043863 219cleanup:
3bacaf0c 220 pr_err("Unable to connect to host\n");
da9fcb72 221 vmbus_connection.conn_state = DISCONNECTED;
3e7ee490 222
da9fcb72
HZ
223 if (vmbus_connection.work_queue)
224 destroy_workqueue(vmbus_connection.work_queue);
3e7ee490 225
da9fcb72 226 if (vmbus_connection.int_page) {
df3493e0 227 free_pages((unsigned long)vmbus_connection.int_page, 0);
da9fcb72 228 vmbus_connection.int_page = NULL;
3e7ee490
HJ
229 }
230
8681db44
GKH
231 free_pages((unsigned long)vmbus_connection.monitor_pages[0], 1);
232 free_pages((unsigned long)vmbus_connection.monitor_pages[1], 1);
233 vmbus_connection.monitor_pages[0] = NULL;
234 vmbus_connection.monitor_pages[1] = NULL;
3e7ee490 235
dd9b15dc 236 kfree(msginfo);
3e7ee490 237
3e7ee490
HJ
238 return ret;
239}
240
3e7ee490 241
3e189519 242/*
c6977677
HZ
243 * relid2channel - Get the channel object given its
244 * child relative id (ie channel id)
fd8b85ea 245 */
c6977677 246struct vmbus_channel *relid2channel(u32 relid)
3e7ee490 247{
aded7165 248 struct vmbus_channel *channel;
15b2f647 249 struct vmbus_channel *found_channel = NULL;
0f5e44ca 250 unsigned long flags;
e68d2971
S
251 struct list_head *cur, *tmp;
252 struct vmbus_channel *cur_sc;
3e7ee490 253
15b2f647 254 spin_lock_irqsave(&vmbus_connection.channel_lock, flags);
da9fcb72 255 list_for_each_entry(channel, &vmbus_connection.chn_list, listentry) {
15b2f647
HZ
256 if (channel->offermsg.child_relid == relid) {
257 found_channel = channel;
3e7ee490 258 break;
e68d2971
S
259 } else if (!list_empty(&channel->sc_list)) {
260 /*
261 * Deal with sub-channels.
262 */
263 list_for_each_safe(cur, tmp, &channel->sc_list) {
264 cur_sc = list_entry(cur, struct vmbus_channel,
265 sc_list);
266 if (cur_sc->offermsg.child_relid == relid) {
267 found_channel = cur_sc;
268 break;
269 }
270 }
3e7ee490
HJ
271 }
272 }
15b2f647 273 spin_unlock_irqrestore(&vmbus_connection.channel_lock, flags);
3e7ee490 274
15b2f647 275 return found_channel;
3e7ee490
HJ
276}
277
3e189519 278/*
c6977677 279 * process_chn_event - Process a channel event notification
fd8b85ea 280 */
35436487 281static void process_chn_event(u32 relid)
3e7ee490 282{
aded7165 283 struct vmbus_channel *channel;
dad76bf7 284 unsigned long flags;
f878f3d5
S
285 void *arg;
286 bool read_state;
287 u32 bytes_to_read;
3e7ee490 288
454f18a9
BP
289 /*
290 * Find the channel based on this relid and invokes the
291 * channel callback to process the event
292 */
c6977677 293 channel = relid2channel(relid);
3e7ee490 294
24326039
S
295 if (!channel) {
296 pr_err("channel not found for relid - %u\n", relid);
297 return;
298 }
299
300 /*
301 * A channel once created is persistent even when there
302 * is no driver handling the device. An unloading driver
303 * sets the onchannel_callback to NULL under the
304 * protection of the channel inbound_lock. Thus, checking
305 * and invoking the driver specific callback takes care of
306 * orderly unloading of the driver.
307 */
308
dad76bf7 309 spin_lock_irqsave(&channel->inbound_lock, flags);
f878f3d5
S
310 if (channel->onchannel_callback != NULL) {
311 arg = channel->channel_callback_context;
312 read_state = channel->batched_reading;
313 /*
314 * This callback reads the messages sent by the host.
315 * We can optimize host to guest signaling by ensuring:
316 * 1. While reading the channel, we disable interrupts from
317 * host.
318 * 2. Ensure that we process all posted messages from the host
319 * before returning from this callback.
320 * 3. Once we return, enable signaling from the host. Once this
321 * state is set we check to see if additional packets are
322 * available to read. In this case we repeat the process.
323 */
324
325 do {
326 hv_begin_read(&channel->inbound);
327 channel->onchannel_callback(arg);
328 bytes_to_read = hv_end_read(&channel->inbound);
329 } while (read_state && (bytes_to_read != 0));
330 } else {
24326039 331 pr_err("no channel callback for relid - %u\n", relid);
f878f3d5 332 }
d9add43b 333
dad76bf7 334 spin_unlock_irqrestore(&channel->inbound_lock, flags);
3e7ee490
HJ
335}
336
3e189519 337/*
c6977677 338 * vmbus_on_event - Handler for events
fd8b85ea 339 */
6de3d6aa 340void vmbus_on_event(unsigned long data)
3e7ee490 341{
35436487 342 u32 dword;
6552ecd7 343 u32 maxdword;
3e7ee490 344 int bit;
35436487 345 u32 relid;
6552ecd7
S
346 u32 *recv_int_page = NULL;
347 void *page_addr;
348 int cpu = smp_processor_id();
349 union hv_synic_event_flags *event;
350
351 if ((vmbus_proto_version == VERSION_WS2008) ||
352 (vmbus_proto_version == VERSION_WIN7)) {
353 maxdword = MAX_NUM_CHANNELS_SUPPORTED >> 5;
354 recv_int_page = vmbus_connection.recv_int_page;
355 } else {
356 /*
357 * When the host is win8 and beyond, the event page
358 * can be directly checked to get the id of the channel
359 * that has the interrupt pending.
360 */
361 maxdword = HV_EVENT_FLAGS_DWORD_COUNT;
362 page_addr = hv_context.synic_event_page[cpu];
363 event = (union hv_synic_event_flags *)page_addr +
364 VMBUS_MESSAGE_SINT;
365 recv_int_page = event->flags32;
366 }
367
368
3e7ee490 369
454f18a9 370 /* Check events */
242b45aa
OH
371 if (!recv_int_page)
372 return;
373 for (dword = 0; dword < maxdword; dword++) {
374 if (!recv_int_page[dword])
375 continue;
376 for (bit = 0; bit < 32; bit++) {
d9add43b
S
377 if (sync_test_and_clear_bit(bit,
378 (unsigned long *)&recv_int_page[dword])) {
242b45aa
OH
379 relid = (dword << 5) + bit;
380
d9add43b 381 if (relid == 0)
6d81d330
S
382 /*
383 * Special case - vmbus
384 * channel protocol msg
385 */
242b45aa 386 continue;
d9add43b 387
35436487 388 process_chn_event(relid);
3e7ee490 389 }
242b45aa 390 }
3e7ee490 391 }
3e7ee490
HJ
392}
393
3e189519 394/*
c6977677 395 * vmbus_post_msg - Send a msg on the vmbus's message connection
fd8b85ea 396 */
c6977677 397int vmbus_post_msg(void *buffer, size_t buflen)
3e7ee490 398{
15b2f647 399 union hv_connection_id conn_id;
5289d3d1
S
400 int ret = 0;
401 int retries = 0;
3e7ee490 402
15b2f647
HZ
403 conn_id.asu32 = 0;
404 conn_id.u.id = VMBUS_MESSAGE_CONNECTION_ID;
5289d3d1
S
405
406 /*
407 * hv_post_message() can have transient failures because of
408 * insufficient resources. Retry the operation a couple of
409 * times before giving up.
410 */
411 while (retries < 3) {
412 ret = hv_post_message(conn_id, 1, buffer, buflen);
413 if (ret != HV_STATUS_INSUFFICIENT_BUFFERS)
414 return ret;
415 retries++;
416 msleep(100);
417 }
418 return ret;
3e7ee490
HJ
419}
420
3e189519 421/*
c6977677 422 * vmbus_set_event - Send an event notification to the parent
fd8b85ea 423 */
21c3bef5 424int vmbus_set_event(struct vmbus_channel *channel)
3e7ee490 425{
21c3bef5 426 u32 child_relid = channel->offermsg.child_relid;
7c369f40 427
3be77774
S
428 if (!channel->is_dedicated_interrupt) {
429 /* Each u32 represents 32 channels */
430 sync_set_bit(child_relid & 31,
431 (unsigned long *)vmbus_connection.send_int_page +
432 (child_relid >> 5));
433 }
434
435 return hv_signal_event(channel->sig_event);
3e7ee490 436}
This page took 0.376023 seconds and 5 git commands to generate.