blob: a2d1a9612c86c4730c6aa2f0ce038ca06da4f9c5 [file] [log] [blame]
Hank Janssen3e7ee492009-07-13 16:02:34 -07001/*
Hank Janssen3e7ee492009-07-13 16:02:34 -07002 * Copyright (c) 2009, Microsoft Corporation.
3 *
4 * This program is free software; you can redistribute it and/or modify it
5 * under the terms and conditions of the GNU General Public License,
6 * version 2, as published by the Free Software Foundation.
7 *
8 * This program is distributed in the hope it will be useful, but WITHOUT
9 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
11 * more details.
12 *
13 * You should have received a copy of the GNU General Public License along with
14 * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
15 * Place - Suite 330, Boston, MA 02111-1307 USA.
16 *
17 * Authors:
18 * Haiyang Zhang <haiyangz@microsoft.com>
19 * Hank Janssen <hjanssen@microsoft.com>
Hank Janssen3e7ee492009-07-13 16:02:34 -070020 */
Hank Janssen0a466182011-03-29 13:58:47 -070021#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
22
Greg Kroah-Hartmana0086dc2009-08-17 17:22:08 -070023#include <linux/kernel.h>
K. Y. Srinivasan0c3b7b22011-02-11 09:59:43 -080024#include <linux/sched.h>
25#include <linux/wait.h>
Greg Kroah-Hartmana0086dc2009-08-17 17:22:08 -070026#include <linux/mm.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090027#include <linux/slab.h>
Bill Pemberton53af5452009-09-11 21:46:44 -040028#include <linux/list.h>
Hank Janssenc88c4e42010-05-04 15:55:05 -070029#include <linux/module.h>
Haiyang Zhang8b5d6d32010-05-28 23:22:44 +000030#include <linux/completion.h>
Greg Kroah-Hartman46a97192011-10-04 12:29:52 -070031#include <linux/hyperv.h>
K. Y. Srinivasan3f335ea2011-05-12 19:34:15 -070032
K. Y. Srinivasan0f2a6612011-05-12 19:34:28 -070033#include "hyperv_vmbus.h"
Hank Janssen3e7ee492009-07-13 16:02:34 -070034
Greg Kroah-Hartman1d7e9072009-08-28 16:26:11 -070035struct vmbus_channel_message_table_entry {
K. Y. Srinivasancf9dcba2011-05-10 07:55:37 -070036 enum vmbus_channel_message_type message_type;
K. Y. Srinivasanfa90f1d2011-05-10 07:55:36 -070037 void (*message_handler)(struct vmbus_channel_message_header *msg);
Greg Kroah-Hartman1d7e9072009-08-28 16:26:11 -070038};
Hank Janssen3e7ee492009-07-13 16:02:34 -070039
Hank Janssenc88c4e42010-05-04 15:55:05 -070040
41/**
Greg Kroah-Hartmanda0e9632011-10-11 08:42:28 -060042 * vmbus_prep_negotiate_resp() - Create default response for Hyper-V Negotiate message
Hank Janssenc88c4e42010-05-04 15:55:05 -070043 * @icmsghdrp: Pointer to msg header structure
44 * @icmsg_negotiate: Pointer to negotiate message structure
45 * @buf: Raw buffer channel data
46 *
47 * @icmsghdrp is of type &struct icmsg_hdr.
48 * @negop is of type &struct icmsg_negotiate.
K. Y. Srinivasanc836d0a2012-05-12 13:44:58 -070049 * Set up and fill in default negotiate response message.
50 *
K. Y. Srinivasan67413352013-07-02 10:31:30 -070051 * The fw_version specifies the framework version that
52 * we can support and srv_version specifies the service
53 * version we can support.
Hank Janssenc88c4e42010-05-04 15:55:05 -070054 *
55 * Mainly used by Hyper-V drivers.
56 */
K. Y. Srinivasan67413352013-07-02 10:31:30 -070057bool vmbus_prep_negotiate_resp(struct icmsg_hdr *icmsghdrp,
K. Y. Srinivasanc836d0a2012-05-12 13:44:58 -070058 struct icmsg_negotiate *negop, u8 *buf,
K. Y. Srinivasan67413352013-07-02 10:31:30 -070059 int fw_version, int srv_version)
Hank Janssenc88c4e42010-05-04 15:55:05 -070060{
K. Y. Srinivasan67413352013-07-02 10:31:30 -070061 int icframe_major, icframe_minor;
62 int icmsg_major, icmsg_minor;
63 int fw_major, fw_minor;
64 int srv_major, srv_minor;
K. Y. Srinivasanc836d0a2012-05-12 13:44:58 -070065 int i;
K. Y. Srinivasan67413352013-07-02 10:31:30 -070066 bool found_match = false;
K. Y. Srinivasanc836d0a2012-05-12 13:44:58 -070067
K. Y. Srinivasana3605302012-05-12 13:44:57 -070068 icmsghdrp->icmsgsize = 0x10;
K. Y. Srinivasan67413352013-07-02 10:31:30 -070069 fw_major = (fw_version >> 16);
70 fw_minor = (fw_version & 0xFFFF);
71
72 srv_major = (srv_version >> 16);
73 srv_minor = (srv_version & 0xFFFF);
Hank Janssenc88c4e42010-05-04 15:55:05 -070074
K. Y. Srinivasana3605302012-05-12 13:44:57 -070075 negop = (struct icmsg_negotiate *)&buf[
76 sizeof(struct vmbuspipe_hdr) +
77 sizeof(struct icmsg_hdr)];
Hank Janssenc88c4e42010-05-04 15:55:05 -070078
K. Y. Srinivasan67413352013-07-02 10:31:30 -070079 icframe_major = negop->icframe_vercnt;
80 icframe_minor = 0;
81
82 icmsg_major = negop->icmsg_vercnt;
83 icmsg_minor = 0;
K. Y. Srinivasanc836d0a2012-05-12 13:44:58 -070084
85 /*
86 * Select the framework version number we will
87 * support.
88 */
89
90 for (i = 0; i < negop->icframe_vercnt; i++) {
K. Y. Srinivasan67413352013-07-02 10:31:30 -070091 if ((negop->icversion_data[i].major == fw_major) &&
92 (negop->icversion_data[i].minor == fw_minor)) {
93 icframe_major = negop->icversion_data[i].major;
94 icframe_minor = negop->icversion_data[i].minor;
95 found_match = true;
96 }
Hank Janssenc88c4e42010-05-04 15:55:05 -070097 }
K. Y. Srinivasana3605302012-05-12 13:44:57 -070098
K. Y. Srinivasan67413352013-07-02 10:31:30 -070099 if (!found_match)
100 goto fw_error;
101
102 found_match = false;
103
K. Y. Srinivasanc836d0a2012-05-12 13:44:58 -0700104 for (i = negop->icframe_vercnt;
105 (i < negop->icframe_vercnt + negop->icmsg_vercnt); i++) {
K. Y. Srinivasan67413352013-07-02 10:31:30 -0700106 if ((negop->icversion_data[i].major == srv_major) &&
107 (negop->icversion_data[i].minor == srv_minor)) {
108 icmsg_major = negop->icversion_data[i].major;
109 icmsg_minor = negop->icversion_data[i].minor;
110 found_match = true;
111 }
K. Y. Srinivasanc836d0a2012-05-12 13:44:58 -0700112 }
113
114 /*
K. Y. Srinivasan67413352013-07-02 10:31:30 -0700115 * Respond with the framework and service
K. Y. Srinivasanc836d0a2012-05-12 13:44:58 -0700116 * version numbers we can support.
117 */
K. Y. Srinivasan67413352013-07-02 10:31:30 -0700118
119fw_error:
120 if (!found_match) {
121 negop->icframe_vercnt = 0;
122 negop->icmsg_vercnt = 0;
123 } else {
124 negop->icframe_vercnt = 1;
125 negop->icmsg_vercnt = 1;
126 }
127
128 negop->icversion_data[0].major = icframe_major;
129 negop->icversion_data[0].minor = icframe_minor;
130 negop->icversion_data[1].major = icmsg_major;
131 negop->icversion_data[1].minor = icmsg_minor;
132 return found_match;
Hank Janssenc88c4e42010-05-04 15:55:05 -0700133}
K. Y. Srinivasana3605302012-05-12 13:44:57 -0700134
Greg Kroah-Hartmanda0e9632011-10-11 08:42:28 -0600135EXPORT_SYMBOL_GPL(vmbus_prep_negotiate_resp);
Hank Janssenc88c4e42010-05-04 15:55:05 -0700136
Hank Janssen3e189512010-03-04 22:11:00 +0000137/*
Haiyang Zhange98cb272010-10-15 10:14:07 -0700138 * alloc_channel - Allocate and initialize a vmbus channel object
Greg Kroah-Hartmanbd60c332009-08-31 21:47:21 -0700139 */
Greg Kroah-Hartman50fe56d2010-10-20 15:51:57 -0700140static struct vmbus_channel *alloc_channel(void)
Hank Janssen3e7ee492009-07-13 16:02:34 -0700141{
Greg Kroah-Hartmanaded7162009-08-18 15:21:19 -0700142 struct vmbus_channel *channel;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700143
Greg Kroah-Hartmanaded7162009-08-18 15:21:19 -0700144 channel = kzalloc(sizeof(*channel), GFP_ATOMIC);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700145 if (!channel)
Hank Janssen3e7ee492009-07-13 16:02:34 -0700146 return NULL;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700147
Greg Kroah-Hartman54411c42009-07-15 14:48:32 -0700148 spin_lock_init(&channel->inbound_lock);
K. Y. Srinivasane68d2972013-05-23 12:02:32 -0700149 spin_lock_init(&channel->sc_lock);
150
151 INIT_LIST_HEAD(&channel->sc_list);
K. Y. Srinivasan3a28fa32014-04-08 18:45:54 -0700152 INIT_LIST_HEAD(&channel->percpu_list);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700153
Haiyang Zhangc50f7fb2010-11-08 14:04:38 -0800154 channel->controlwq = create_workqueue("hv_vmbus_ctl");
155 if (!channel->controlwq) {
Greg Kroah-Hartman8c69f522009-07-15 12:48:29 -0700156 kfree(channel);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700157 return NULL;
158 }
159
160 return channel;
161}
162
Hank Janssen3e189512010-03-04 22:11:00 +0000163/*
Haiyang Zhange98cb272010-10-15 10:14:07 -0700164 * release_hannel - Release the vmbus channel object itself
Greg Kroah-Hartmanbd60c332009-08-31 21:47:21 -0700165 */
Timo Teräs4b2f9ab2010-12-15 20:48:09 +0200166static void release_channel(struct work_struct *work)
Hank Janssen3e7ee492009-07-13 16:02:34 -0700167{
Timo Teräs4b2f9ab2010-12-15 20:48:09 +0200168 struct vmbus_channel *channel = container_of(work,
169 struct vmbus_channel,
170 work);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700171
Haiyang Zhangc50f7fb2010-11-08 14:04:38 -0800172 destroy_workqueue(channel->controlwq);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700173
Greg Kroah-Hartman8c69f522009-07-15 12:48:29 -0700174 kfree(channel);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700175}
176
Hank Janssen3e189512010-03-04 22:11:00 +0000177/*
Haiyang Zhange98cb272010-10-15 10:14:07 -0700178 * free_channel - Release the resources used by the vmbus channel object
Greg Kroah-Hartmanbd60c332009-08-31 21:47:21 -0700179 */
Greg Kroah-Hartman9f3e28e2011-10-11 09:40:01 -0600180static void free_channel(struct vmbus_channel *channel)
Hank Janssen3e7ee492009-07-13 16:02:34 -0700181{
Hank Janssen3e7ee492009-07-13 16:02:34 -0700182
Greg Kroah-Hartmanbd60c332009-08-31 21:47:21 -0700183 /*
184 * We have to release the channel's workqueue/thread in the vmbus's
185 * workqueue/thread context
186 * ie we can't destroy ourselves.
187 */
Timo Teräs4b2f9ab2010-12-15 20:48:09 +0200188 INIT_WORK(&channel->work, release_channel);
Haiyang Zhangda9fcb72011-01-26 12:12:14 -0800189 queue_work(vmbus_connection.work_queue, &channel->work);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700190}
191
K. Y. Srinivasan3a28fa32014-04-08 18:45:54 -0700192static void percpu_channel_enq(void *arg)
193{
194 struct vmbus_channel *channel = arg;
195 int cpu = smp_processor_id();
Haiyang Zhang8b5d6d32010-05-28 23:22:44 +0000196
K. Y. Srinivasan3a28fa32014-04-08 18:45:54 -0700197 list_add_tail(&channel->percpu_list, &hv_context.percpu_list[cpu]);
198}
199
200static void percpu_channel_deq(void *arg)
201{
202 struct vmbus_channel *channel = arg;
203
204 list_del(&channel->percpu_list);
205}
Haiyang Zhang8b5d6d32010-05-28 23:22:44 +0000206
Timo Teräs4b2f9ab2010-12-15 20:48:09 +0200207/*
208 * vmbus_process_rescind_offer -
209 * Rescind the offer by initiating a device removal
210 */
211static void vmbus_process_rescind_offer(struct work_struct *work)
212{
213 struct vmbus_channel *channel = container_of(work,
214 struct vmbus_channel,
215 work);
K. Y. Srinivasanc8705972013-03-15 12:25:44 -0700216 unsigned long flags;
K. Y. Srinivasane68d2972013-05-23 12:02:32 -0700217 struct vmbus_channel *primary_channel;
K. Y. Srinivasanc8705972013-03-15 12:25:44 -0700218 struct vmbus_channel_relid_released msg;
Timo Teräs4b2f9ab2010-12-15 20:48:09 +0200219
K. Y. Srinivasan565ce642013-10-16 19:27:19 -0700220 if (channel->device_obj)
221 vmbus_device_unregister(channel->device_obj);
K. Y. Srinivasanc8705972013-03-15 12:25:44 -0700222 memset(&msg, 0, sizeof(struct vmbus_channel_relid_released));
223 msg.child_relid = channel->offermsg.child_relid;
224 msg.header.msgtype = CHANNELMSG_RELID_RELEASED;
225 vmbus_post_msg(&msg, sizeof(struct vmbus_channel_relid_released));
226
K. Y. Srinivasan2115b562014-08-28 18:29:53 -0700227 if (channel->target_cpu != get_cpu()) {
228 put_cpu();
K. Y. Srinivasan3a28fa32014-04-08 18:45:54 -0700229 smp_call_function_single(channel->target_cpu,
230 percpu_channel_deq, channel, true);
K. Y. Srinivasan2115b562014-08-28 18:29:53 -0700231 } else {
K. Y. Srinivasan3a28fa32014-04-08 18:45:54 -0700232 percpu_channel_deq(channel);
K. Y. Srinivasan2115b562014-08-28 18:29:53 -0700233 put_cpu();
234 }
K. Y. Srinivasan3a28fa32014-04-08 18:45:54 -0700235
K. Y. Srinivasane68d2972013-05-23 12:02:32 -0700236 if (channel->primary_channel == NULL) {
237 spin_lock_irqsave(&vmbus_connection.channel_lock, flags);
238 list_del(&channel->listentry);
239 spin_unlock_irqrestore(&vmbus_connection.channel_lock, flags);
240 } else {
241 primary_channel = channel->primary_channel;
242 spin_lock_irqsave(&primary_channel->sc_lock, flags);
K. Y. Srinivasan565ce642013-10-16 19:27:19 -0700243 list_del(&channel->sc_list);
K. Y. Srinivasane68d2972013-05-23 12:02:32 -0700244 spin_unlock_irqrestore(&primary_channel->sc_lock, flags);
245 }
K. Y. Srinivasanc8705972013-03-15 12:25:44 -0700246 free_channel(channel);
Timo Teräs4b2f9ab2010-12-15 20:48:09 +0200247}
Haiyang Zhang8b5d6d32010-05-28 23:22:44 +0000248
K. Y. Srinivasan93e5bd02011-12-12 09:29:17 -0800249void vmbus_free_channels(void)
250{
251 struct vmbus_channel *channel;
252
253 list_for_each_entry(channel, &vmbus_connection.chn_list, listentry) {
254 vmbus_device_unregister(channel->device_obj);
255 kfree(channel->device_obj);
256 free_channel(channel);
257 }
258}
259
Hank Janssen3e189512010-03-04 22:11:00 +0000260/*
Haiyang Zhange98cb272010-10-15 10:14:07 -0700261 * vmbus_process_offer - Process the offer by creating a channel/device
Hank Janssenc88c4e42010-05-04 15:55:05 -0700262 * associated with this offer
Greg Kroah-Hartmanbd60c332009-08-31 21:47:21 -0700263 */
Timo Teräs4b2f9ab2010-12-15 20:48:09 +0200264static void vmbus_process_offer(struct work_struct *work)
Hank Janssen3e7ee492009-07-13 16:02:34 -0700265{
Timo Teräs4b2f9ab2010-12-15 20:48:09 +0200266 struct vmbus_channel *newchannel = container_of(work,
267 struct vmbus_channel,
268 work);
Greg Kroah-Hartmanaded7162009-08-18 15:21:19 -0700269 struct vmbus_channel *channel;
Haiyang Zhang188963e2010-10-15 10:14:06 -0700270 bool fnew = true;
K. Y. Srinivasan3a28fa32014-04-08 18:45:54 -0700271 bool enq = false;
Greg Kroah-Hartmanbd60c332009-08-31 21:47:21 -0700272 int ret;
Greg Kroah-Hartman0f5e44c2009-07-15 14:57:16 -0700273 unsigned long flags;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700274
Timo Teräs4b2f9ab2010-12-15 20:48:09 +0200275 /* The next possible work is rescind handling */
276 INIT_WORK(&newchannel->work, vmbus_process_rescind_offer);
277
Bill Pemberton454f18a2009-07-27 16:47:24 -0400278 /* Make sure this is a new offer */
Haiyang Zhang15b2f642011-01-26 12:12:07 -0800279 spin_lock_irqsave(&vmbus_connection.channel_lock, flags);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700280
Haiyang Zhangda9fcb72011-01-26 12:12:14 -0800281 list_for_each_entry(channel, &vmbus_connection.chn_list, listentry) {
K. Y. Srinivasan358d2ee2011-08-25 09:48:28 -0700282 if (!uuid_le_cmp(channel->offermsg.offer.if_type,
283 newchannel->offermsg.offer.if_type) &&
284 !uuid_le_cmp(channel->offermsg.offer.if_instance,
285 newchannel->offermsg.offer.if_instance)) {
Haiyang Zhang188963e2010-10-15 10:14:06 -0700286 fnew = false;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700287 break;
288 }
289 }
290
K. Y. Srinivasan3a28fa32014-04-08 18:45:54 -0700291 if (fnew) {
Haiyang Zhangc50f7fb2010-11-08 14:04:38 -0800292 list_add_tail(&newchannel->listentry,
Haiyang Zhangda9fcb72011-01-26 12:12:14 -0800293 &vmbus_connection.chn_list);
K. Y. Srinivasan3a28fa32014-04-08 18:45:54 -0700294 enq = true;
295 }
Greg Kroah-Hartmanbd60c332009-08-31 21:47:21 -0700296
Haiyang Zhang15b2f642011-01-26 12:12:07 -0800297 spin_unlock_irqrestore(&vmbus_connection.channel_lock, flags);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700298
K. Y. Srinivasan3a28fa32014-04-08 18:45:54 -0700299 if (enq) {
K. Y. Srinivasan2115b562014-08-28 18:29:53 -0700300 if (newchannel->target_cpu != get_cpu()) {
301 put_cpu();
K. Y. Srinivasan3a28fa32014-04-08 18:45:54 -0700302 smp_call_function_single(newchannel->target_cpu,
303 percpu_channel_enq,
304 newchannel, true);
K. Y. Srinivasan2115b562014-08-28 18:29:53 -0700305 } else {
K. Y. Srinivasan3a28fa32014-04-08 18:45:54 -0700306 percpu_channel_enq(newchannel);
K. Y. Srinivasan2115b562014-08-28 18:29:53 -0700307 put_cpu();
308 }
K. Y. Srinivasan3a28fa32014-04-08 18:45:54 -0700309 }
Haiyang Zhang188963e2010-10-15 10:14:06 -0700310 if (!fnew) {
K. Y. Srinivasane68d2972013-05-23 12:02:32 -0700311 /*
312 * Check to see if this is a sub-channel.
313 */
314 if (newchannel->offermsg.offer.sub_channel_index != 0) {
315 /*
316 * Process the sub-channel.
317 */
318 newchannel->primary_channel = channel;
319 spin_lock_irqsave(&channel->sc_lock, flags);
320 list_add_tail(&newchannel->sc_list, &channel->sc_list);
321 spin_unlock_irqrestore(&channel->sc_lock, flags);
K. Y. Srinivasan3a28fa32014-04-08 18:45:54 -0700322
K. Y. Srinivasan2115b562014-08-28 18:29:53 -0700323 if (newchannel->target_cpu != get_cpu()) {
324 put_cpu();
K. Y. Srinivasan3a28fa32014-04-08 18:45:54 -0700325 smp_call_function_single(newchannel->target_cpu,
326 percpu_channel_enq,
327 newchannel, true);
K. Y. Srinivasan2115b562014-08-28 18:29:53 -0700328 } else {
K. Y. Srinivasan3a28fa32014-04-08 18:45:54 -0700329 percpu_channel_enq(newchannel);
K. Y. Srinivasan2115b562014-08-28 18:29:53 -0700330 put_cpu();
331 }
K. Y. Srinivasan3a28fa32014-04-08 18:45:54 -0700332
K. Y. Srinivasane68d2972013-05-23 12:02:32 -0700333 newchannel->state = CHANNEL_OPEN_STATE;
334 if (channel->sc_creation_callback != NULL)
335 channel->sc_creation_callback(newchannel);
336
337 return;
338 }
339
Haiyang Zhange98cb272010-10-15 10:14:07 -0700340 free_channel(newchannel);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700341 return;
342 }
343
Greg Kroah-Hartmanbd60c332009-08-31 21:47:21 -0700344 /*
K. Y. Srinivasan42dceeb2013-08-26 14:08:58 -0700345 * This state is used to indicate a successful open
346 * so that when we do close the channel normally, we
347 * can cleanup properly
348 */
349 newchannel->state = CHANNEL_OPEN_STATE;
350
351 /*
Greg Kroah-Hartmanbd60c332009-08-31 21:47:21 -0700352 * Start the process of binding this offer to the driver
353 * We need to set the DeviceObject field before calling
Haiyang Zhang646f1ea2011-01-26 12:12:10 -0800354 * vmbus_child_dev_add()
Greg Kroah-Hartmanbd60c332009-08-31 21:47:21 -0700355 */
K. Y. Srinivasanf2c73012011-09-08 07:24:12 -0700356 newchannel->device_obj = vmbus_device_create(
Haiyang Zhang767dff62011-01-26 12:12:12 -0800357 &newchannel->offermsg.offer.if_type,
358 &newchannel->offermsg.offer.if_instance,
Haiyang Zhang188963e2010-10-15 10:14:06 -0700359 newchannel);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700360
Bill Pemberton454f18a2009-07-27 16:47:24 -0400361 /*
362 * Add the new device to the bus. This will kick off device-driver
363 * binding which eventually invokes the device driver's AddDevice()
364 * method.
365 */
K. Y. Srinivasan227942812011-09-08 07:24:13 -0700366 ret = vmbus_device_register(newchannel->device_obj);
Greg Kroah-Hartmanbd60c332009-08-31 21:47:21 -0700367 if (ret != 0) {
Hank Janssen0a466182011-03-29 13:58:47 -0700368 pr_err("unable to add child device object (relid %d)\n",
Haiyang Zhangc50f7fb2010-11-08 14:04:38 -0800369 newchannel->offermsg.child_relid);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700370
Haiyang Zhang15b2f642011-01-26 12:12:07 -0800371 spin_lock_irqsave(&vmbus_connection.channel_lock, flags);
Haiyang Zhangc50f7fb2010-11-08 14:04:38 -0800372 list_del(&newchannel->listentry);
Haiyang Zhang15b2f642011-01-26 12:12:07 -0800373 spin_unlock_irqrestore(&vmbus_connection.channel_lock, flags);
K. Y. Srinivasan8b8ee672011-12-12 09:29:16 -0800374 kfree(newchannel->device_obj);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700375
Haiyang Zhange98cb272010-10-15 10:14:07 -0700376 free_channel(newchannel);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700377 }
Hank Janssen3e7ee492009-07-13 16:02:34 -0700378}
379
K. Y. Srinivasana1198452012-12-01 06:46:50 -0800380enum {
381 IDE = 0,
382 SCSI,
383 NIC,
384 MAX_PERF_CHN,
385};
386
387/*
K. Y. Srinivasan7fb96562013-01-23 17:42:40 -0800388 * This is an array of device_ids (device types) that are performance critical.
K. Y. Srinivasana1198452012-12-01 06:46:50 -0800389 * We attempt to distribute the interrupt load for these devices across
390 * all available CPUs.
391 */
K. Y. Srinivasan7fb96562013-01-23 17:42:40 -0800392static const struct hv_vmbus_device_id hp_devs[] = {
K. Y. Srinivasana1198452012-12-01 06:46:50 -0800393 /* IDE */
K. Y. Srinivasan7fb96562013-01-23 17:42:40 -0800394 { HV_IDE_GUID, },
K. Y. Srinivasana1198452012-12-01 06:46:50 -0800395 /* Storage - SCSI */
K. Y. Srinivasan7fb96562013-01-23 17:42:40 -0800396 { HV_SCSI_GUID, },
K. Y. Srinivasana1198452012-12-01 06:46:50 -0800397 /* Network */
K. Y. Srinivasan7fb96562013-01-23 17:42:40 -0800398 { HV_NIC_GUID, },
K. Y. Srinivasana1198452012-12-01 06:46:50 -0800399};
400
401
402/*
403 * We use this state to statically distribute the channel interrupt load.
404 */
405static u32 next_vp;
406
407/*
408 * Starting with Win8, we can statically distribute the incoming
409 * channel interrupt load by binding a channel to VCPU. We
410 * implement here a simple round robin scheme for distributing
411 * the interrupt load.
412 * We will bind channels that are not performance critical to cpu 0 and
413 * performance critical channels (IDE, SCSI and Network) will be uniformly
414 * distributed across all available CPUs.
415 */
Linus Torvaldsf9da4552014-06-12 14:27:40 -0700416static void init_vp_index(struct vmbus_channel *channel, const uuid_le *type_guid)
K. Y. Srinivasana1198452012-12-01 06:46:50 -0800417{
418 u32 cur_cpu;
419 int i;
420 bool perf_chn = false;
421 u32 max_cpus = num_online_cpus();
422
423 for (i = IDE; i < MAX_PERF_CHN; i++) {
K. Y. Srinivasan7fb96562013-01-23 17:42:40 -0800424 if (!memcmp(type_guid->b, hp_devs[i].guid,
K. Y. Srinivasana1198452012-12-01 06:46:50 -0800425 sizeof(uuid_le))) {
426 perf_chn = true;
427 break;
428 }
429 }
430 if ((vmbus_proto_version == VERSION_WS2008) ||
431 (vmbus_proto_version == VERSION_WIN7) || (!perf_chn)) {
432 /*
433 * Prior to win8, all channel interrupts are
434 * delivered on cpu 0.
435 * Also if the channel is not a performance critical
436 * channel, bind it to cpu 0.
437 */
K. Y. Srinivasand3ba7202014-04-08 18:45:53 -0700438 channel->target_cpu = 0;
439 channel->target_vp = 0;
440 return;
K. Y. Srinivasana1198452012-12-01 06:46:50 -0800441 }
442 cur_cpu = (++next_vp % max_cpus);
K. Y. Srinivasand3ba7202014-04-08 18:45:53 -0700443 channel->target_cpu = cur_cpu;
444 channel->target_vp = hv_context.vp_index[cur_cpu];
K. Y. Srinivasana1198452012-12-01 06:46:50 -0800445}
446
Hank Janssen3e189512010-03-04 22:11:00 +0000447/*
Haiyang Zhange98cb272010-10-15 10:14:07 -0700448 * vmbus_onoffer - Handler for channel offers from vmbus in parent partition.
Greg Kroah-Hartmanbd60c332009-08-31 21:47:21 -0700449 *
Greg Kroah-Hartmanbd60c332009-08-31 21:47:21 -0700450 */
Haiyang Zhange98cb272010-10-15 10:14:07 -0700451static void vmbus_onoffer(struct vmbus_channel_message_header *hdr)
Hank Janssen3e7ee492009-07-13 16:02:34 -0700452{
Greg Kroah-Hartmanbd60c332009-08-31 21:47:21 -0700453 struct vmbus_channel_offer_channel *offer;
Haiyang Zhang188963e2010-10-15 10:14:06 -0700454 struct vmbus_channel *newchannel;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700455
Greg Kroah-Hartmanbd60c332009-08-31 21:47:21 -0700456 offer = (struct vmbus_channel_offer_channel *)hdr;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700457
Bill Pemberton454f18a2009-07-27 16:47:24 -0400458 /* Allocate the channel object and save this offer. */
Haiyang Zhange98cb272010-10-15 10:14:07 -0700459 newchannel = alloc_channel();
Haiyang Zhang188963e2010-10-15 10:14:06 -0700460 if (!newchannel) {
Hank Janssen0a466182011-03-29 13:58:47 -0700461 pr_err("Unable to allocate channel object\n");
Hank Janssen3e7ee492009-07-13 16:02:34 -0700462 return;
463 }
464
K. Y. Srinivasan132368b2012-12-01 06:46:33 -0800465 /*
466 * By default we setup state to enable batched
467 * reading. A specific service can choose to
468 * disable this prior to opening the channel.
469 */
470 newchannel->batched_reading = true;
471
K. Y. Srinivasanb3bf60c2012-12-01 06:46:45 -0800472 /*
473 * Setup state for signalling the host.
474 */
475 newchannel->sig_event = (struct hv_input_signal_event *)
476 (ALIGN((unsigned long)
477 &newchannel->sig_buf,
478 HV_HYPERCALL_PARAM_ALIGN));
479
480 newchannel->sig_event->connectionid.asu32 = 0;
481 newchannel->sig_event->connectionid.u.id = VMBUS_EVENT_CONNECTION_ID;
482 newchannel->sig_event->flag_number = 0;
483 newchannel->sig_event->rsvdz = 0;
484
485 if (vmbus_proto_version != VERSION_WS2008) {
486 newchannel->is_dedicated_interrupt =
487 (offer->is_dedicated_interrupt != 0);
488 newchannel->sig_event->connectionid.u.id =
489 offer->connection_id;
490 }
491
K. Y. Srinivasand3ba7202014-04-08 18:45:53 -0700492 init_vp_index(newchannel, &offer->offer.if_type);
K. Y. Srinivasanabbf3b22012-12-01 06:46:48 -0800493
Haiyang Zhangc50f7fb2010-11-08 14:04:38 -0800494 memcpy(&newchannel->offermsg, offer,
Greg Kroah-Hartmanbd60c332009-08-31 21:47:21 -0700495 sizeof(struct vmbus_channel_offer_channel));
Haiyang Zhangc50f7fb2010-11-08 14:04:38 -0800496 newchannel->monitor_grp = (u8)offer->monitorid / 32;
497 newchannel->monitor_bit = (u8)offer->monitorid % 32;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700498
Timo Teräs4b2f9ab2010-12-15 20:48:09 +0200499 INIT_WORK(&newchannel->work, vmbus_process_offer);
500 queue_work(newchannel->controlwq, &newchannel->work);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700501}
502
Hank Janssen3e189512010-03-04 22:11:00 +0000503/*
Haiyang Zhange98cb272010-10-15 10:14:07 -0700504 * vmbus_onoffer_rescind - Rescind offer handler.
Greg Kroah-Hartmanbd60c332009-08-31 21:47:21 -0700505 *
506 * We queue a work item to process this offer synchronously
507 */
Haiyang Zhange98cb272010-10-15 10:14:07 -0700508static void vmbus_onoffer_rescind(struct vmbus_channel_message_header *hdr)
Hank Janssen3e7ee492009-07-13 16:02:34 -0700509{
Greg Kroah-Hartmanbd60c332009-08-31 21:47:21 -0700510 struct vmbus_channel_rescind_offer *rescind;
Greg Kroah-Hartmanaded7162009-08-18 15:21:19 -0700511 struct vmbus_channel *channel;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700512
Greg Kroah-Hartmanbd60c332009-08-31 21:47:21 -0700513 rescind = (struct vmbus_channel_rescind_offer *)hdr;
Haiyang Zhangc6977672011-01-26 12:12:08 -0800514 channel = relid2channel(rescind->child_relid);
Hank Janssen98e08702011-03-29 13:58:44 -0700515
516 if (channel == NULL)
517 /* Just return here, no channel found */
Hank Janssen3e7ee492009-07-13 16:02:34 -0700518 return;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700519
Timo Teräs4b2f9ab2010-12-15 20:48:09 +0200520 /* work is initialized for vmbus_process_rescind_offer() from
521 * vmbus_process_offer() where the channel got created */
522 queue_work(channel->controlwq, &channel->work);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700523}
524
Hank Janssen3e189512010-03-04 22:11:00 +0000525/*
Haiyang Zhange98cb272010-10-15 10:14:07 -0700526 * vmbus_onoffers_delivered -
527 * This is invoked when all offers have been delivered.
Greg Kroah-Hartmanbd60c332009-08-31 21:47:21 -0700528 *
529 * Nothing to do here.
530 */
Haiyang Zhange98cb272010-10-15 10:14:07 -0700531static void vmbus_onoffers_delivered(
Greg Kroah-Hartmanbd60c332009-08-31 21:47:21 -0700532 struct vmbus_channel_message_header *hdr)
Hank Janssen3e7ee492009-07-13 16:02:34 -0700533{
Hank Janssen3e7ee492009-07-13 16:02:34 -0700534}
535
Hank Janssen3e189512010-03-04 22:11:00 +0000536/*
Haiyang Zhange98cb272010-10-15 10:14:07 -0700537 * vmbus_onopen_result - Open result handler.
Greg Kroah-Hartmanbd60c332009-08-31 21:47:21 -0700538 *
539 * This is invoked when we received a response to our channel open request.
540 * Find the matching request, copy the response and signal the requesting
541 * thread.
542 */
Haiyang Zhange98cb272010-10-15 10:14:07 -0700543static void vmbus_onopen_result(struct vmbus_channel_message_header *hdr)
Hank Janssen3e7ee492009-07-13 16:02:34 -0700544{
Greg Kroah-Hartmanbd60c332009-08-31 21:47:21 -0700545 struct vmbus_channel_open_result *result;
Haiyang Zhang188963e2010-10-15 10:14:06 -0700546 struct vmbus_channel_msginfo *msginfo;
547 struct vmbus_channel_message_header *requestheader;
548 struct vmbus_channel_open_channel *openmsg;
Greg Kroah-Hartmandd0813b2009-07-15 14:56:45 -0700549 unsigned long flags;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700550
Greg Kroah-Hartmanbd60c332009-08-31 21:47:21 -0700551 result = (struct vmbus_channel_open_result *)hdr;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700552
Greg Kroah-Hartmanbd60c332009-08-31 21:47:21 -0700553 /*
554 * Find the open msg, copy the result and signal/unblock the wait event
555 */
Haiyang Zhang15b2f642011-01-26 12:12:07 -0800556 spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700557
Hank Janssenebb61e52011-02-18 12:39:57 -0800558 list_for_each_entry(msginfo, &vmbus_connection.chn_msg_list,
559 msglistentry) {
Haiyang Zhang188963e2010-10-15 10:14:06 -0700560 requestheader =
Haiyang Zhangc50f7fb2010-11-08 14:04:38 -0800561 (struct vmbus_channel_message_header *)msginfo->msg;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700562
Haiyang Zhangc50f7fb2010-11-08 14:04:38 -0800563 if (requestheader->msgtype == CHANNELMSG_OPENCHANNEL) {
Haiyang Zhang188963e2010-10-15 10:14:06 -0700564 openmsg =
Haiyang Zhangc50f7fb2010-11-08 14:04:38 -0800565 (struct vmbus_channel_open_channel *)msginfo->msg;
566 if (openmsg->child_relid == result->child_relid &&
567 openmsg->openid == result->openid) {
568 memcpy(&msginfo->response.open_result,
Greg Kroah-Hartmanbd60c332009-08-31 21:47:21 -0700569 result,
K. Y. Srinivasan9568a192011-05-10 07:55:39 -0700570 sizeof(
571 struct vmbus_channel_open_result));
572 complete(&msginfo->waitevent);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700573 break;
574 }
575 }
576 }
Haiyang Zhang15b2f642011-01-26 12:12:07 -0800577 spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock, flags);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700578}
579
Hank Janssen3e189512010-03-04 22:11:00 +0000580/*
Haiyang Zhange98cb272010-10-15 10:14:07 -0700581 * vmbus_ongpadl_created - GPADL created handler.
Greg Kroah-Hartmanbd60c332009-08-31 21:47:21 -0700582 *
583 * This is invoked when we received a response to our gpadl create request.
584 * Find the matching request, copy the response and signal the requesting
585 * thread.
586 */
Haiyang Zhange98cb272010-10-15 10:14:07 -0700587static void vmbus_ongpadl_created(struct vmbus_channel_message_header *hdr)
Hank Janssen3e7ee492009-07-13 16:02:34 -0700588{
Haiyang Zhang188963e2010-10-15 10:14:06 -0700589 struct vmbus_channel_gpadl_created *gpadlcreated;
Haiyang Zhang188963e2010-10-15 10:14:06 -0700590 struct vmbus_channel_msginfo *msginfo;
591 struct vmbus_channel_message_header *requestheader;
592 struct vmbus_channel_gpadl_header *gpadlheader;
Greg Kroah-Hartmandd0813b2009-07-15 14:56:45 -0700593 unsigned long flags;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700594
Haiyang Zhang188963e2010-10-15 10:14:06 -0700595 gpadlcreated = (struct vmbus_channel_gpadl_created *)hdr;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700596
Greg Kroah-Hartmanbd60c332009-08-31 21:47:21 -0700597 /*
598 * Find the establish msg, copy the result and signal/unblock the wait
599 * event
600 */
Haiyang Zhang15b2f642011-01-26 12:12:07 -0800601 spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700602
Hank Janssenebb61e52011-02-18 12:39:57 -0800603 list_for_each_entry(msginfo, &vmbus_connection.chn_msg_list,
604 msglistentry) {
Haiyang Zhang188963e2010-10-15 10:14:06 -0700605 requestheader =
Haiyang Zhangc50f7fb2010-11-08 14:04:38 -0800606 (struct vmbus_channel_message_header *)msginfo->msg;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700607
Haiyang Zhangc50f7fb2010-11-08 14:04:38 -0800608 if (requestheader->msgtype == CHANNELMSG_GPADL_HEADER) {
Haiyang Zhang188963e2010-10-15 10:14:06 -0700609 gpadlheader =
610 (struct vmbus_channel_gpadl_header *)requestheader;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700611
Haiyang Zhangc50f7fb2010-11-08 14:04:38 -0800612 if ((gpadlcreated->child_relid ==
613 gpadlheader->child_relid) &&
614 (gpadlcreated->gpadl == gpadlheader->gpadl)) {
615 memcpy(&msginfo->response.gpadl_created,
Haiyang Zhang188963e2010-10-15 10:14:06 -0700616 gpadlcreated,
K. Y. Srinivasan9568a192011-05-10 07:55:39 -0700617 sizeof(
618 struct vmbus_channel_gpadl_created));
619 complete(&msginfo->waitevent);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700620 break;
621 }
622 }
623 }
Haiyang Zhang15b2f642011-01-26 12:12:07 -0800624 spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock, flags);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700625}
626
Hank Janssen3e189512010-03-04 22:11:00 +0000627/*
Haiyang Zhange98cb272010-10-15 10:14:07 -0700628 * vmbus_ongpadl_torndown - GPADL torndown handler.
Greg Kroah-Hartmanbd60c332009-08-31 21:47:21 -0700629 *
630 * This is invoked when we received a response to our gpadl teardown request.
631 * Find the matching request, copy the response and signal the requesting
632 * thread.
633 */
Haiyang Zhange98cb272010-10-15 10:14:07 -0700634static void vmbus_ongpadl_torndown(
Greg Kroah-Hartmanbd60c332009-08-31 21:47:21 -0700635 struct vmbus_channel_message_header *hdr)
Hank Janssen3e7ee492009-07-13 16:02:34 -0700636{
Haiyang Zhang188963e2010-10-15 10:14:06 -0700637 struct vmbus_channel_gpadl_torndown *gpadl_torndown;
Haiyang Zhang188963e2010-10-15 10:14:06 -0700638 struct vmbus_channel_msginfo *msginfo;
639 struct vmbus_channel_message_header *requestheader;
640 struct vmbus_channel_gpadl_teardown *gpadl_teardown;
Greg Kroah-Hartmandd0813b2009-07-15 14:56:45 -0700641 unsigned long flags;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700642
Haiyang Zhang188963e2010-10-15 10:14:06 -0700643 gpadl_torndown = (struct vmbus_channel_gpadl_torndown *)hdr;
Greg Kroah-Hartmanbd60c332009-08-31 21:47:21 -0700644
645 /*
646 * Find the open msg, copy the result and signal/unblock the wait event
647 */
Haiyang Zhang15b2f642011-01-26 12:12:07 -0800648 spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700649
Hank Janssenebb61e52011-02-18 12:39:57 -0800650 list_for_each_entry(msginfo, &vmbus_connection.chn_msg_list,
651 msglistentry) {
Haiyang Zhang188963e2010-10-15 10:14:06 -0700652 requestheader =
Haiyang Zhangc50f7fb2010-11-08 14:04:38 -0800653 (struct vmbus_channel_message_header *)msginfo->msg;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700654
Haiyang Zhangc50f7fb2010-11-08 14:04:38 -0800655 if (requestheader->msgtype == CHANNELMSG_GPADL_TEARDOWN) {
Haiyang Zhang188963e2010-10-15 10:14:06 -0700656 gpadl_teardown =
657 (struct vmbus_channel_gpadl_teardown *)requestheader;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700658
Haiyang Zhangc50f7fb2010-11-08 14:04:38 -0800659 if (gpadl_torndown->gpadl == gpadl_teardown->gpadl) {
660 memcpy(&msginfo->response.gpadl_torndown,
Haiyang Zhang188963e2010-10-15 10:14:06 -0700661 gpadl_torndown,
K. Y. Srinivasan9568a192011-05-10 07:55:39 -0700662 sizeof(
663 struct vmbus_channel_gpadl_torndown));
664 complete(&msginfo->waitevent);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700665 break;
666 }
667 }
668 }
Haiyang Zhang15b2f642011-01-26 12:12:07 -0800669 spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock, flags);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700670}
671
Hank Janssen3e189512010-03-04 22:11:00 +0000672/*
Haiyang Zhange98cb272010-10-15 10:14:07 -0700673 * vmbus_onversion_response - Version response handler
Greg Kroah-Hartmanbd60c332009-08-31 21:47:21 -0700674 *
675 * This is invoked when we received a response to our initiate contact request.
676 * Find the matching request, copy the response and signal the requesting
677 * thread.
678 */
Haiyang Zhange98cb272010-10-15 10:14:07 -0700679static void vmbus_onversion_response(
Greg Kroah-Hartmanbd60c332009-08-31 21:47:21 -0700680 struct vmbus_channel_message_header *hdr)
Hank Janssen3e7ee492009-07-13 16:02:34 -0700681{
Haiyang Zhang188963e2010-10-15 10:14:06 -0700682 struct vmbus_channel_msginfo *msginfo;
683 struct vmbus_channel_message_header *requestheader;
Haiyang Zhang188963e2010-10-15 10:14:06 -0700684 struct vmbus_channel_version_response *version_response;
Greg Kroah-Hartmandd0813b2009-07-15 14:56:45 -0700685 unsigned long flags;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700686
Haiyang Zhang188963e2010-10-15 10:14:06 -0700687 version_response = (struct vmbus_channel_version_response *)hdr;
Haiyang Zhang15b2f642011-01-26 12:12:07 -0800688 spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700689
Hank Janssenebb61e52011-02-18 12:39:57 -0800690 list_for_each_entry(msginfo, &vmbus_connection.chn_msg_list,
691 msglistentry) {
Haiyang Zhang188963e2010-10-15 10:14:06 -0700692 requestheader =
Haiyang Zhangc50f7fb2010-11-08 14:04:38 -0800693 (struct vmbus_channel_message_header *)msginfo->msg;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700694
Haiyang Zhangc50f7fb2010-11-08 14:04:38 -0800695 if (requestheader->msgtype ==
696 CHANNELMSG_INITIATE_CONTACT) {
Haiyang Zhangc50f7fb2010-11-08 14:04:38 -0800697 memcpy(&msginfo->response.version_response,
Haiyang Zhang188963e2010-10-15 10:14:06 -0700698 version_response,
Greg Kroah-Hartmanbd60c332009-08-31 21:47:21 -0700699 sizeof(struct vmbus_channel_version_response));
K. Y. Srinivasan9568a192011-05-10 07:55:39 -0700700 complete(&msginfo->waitevent);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700701 }
702 }
Haiyang Zhang15b2f642011-01-26 12:12:07 -0800703 spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock, flags);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700704}
705
Greg Kroah-Hartmanc8212f02009-08-31 21:51:50 -0700706/* Channel message dispatch table */
707static struct vmbus_channel_message_table_entry
K. Y. Srinivasanb7c6b022011-05-10 07:55:38 -0700708 channel_message_table[CHANNELMSG_COUNT] = {
Haiyang Zhangc50f7fb2010-11-08 14:04:38 -0800709 {CHANNELMSG_INVALID, NULL},
710 {CHANNELMSG_OFFERCHANNEL, vmbus_onoffer},
711 {CHANNELMSG_RESCIND_CHANNELOFFER, vmbus_onoffer_rescind},
712 {CHANNELMSG_REQUESTOFFERS, NULL},
713 {CHANNELMSG_ALLOFFERS_DELIVERED, vmbus_onoffers_delivered},
714 {CHANNELMSG_OPENCHANNEL, NULL},
715 {CHANNELMSG_OPENCHANNEL_RESULT, vmbus_onopen_result},
716 {CHANNELMSG_CLOSECHANNEL, NULL},
717 {CHANNELMSG_GPADL_HEADER, NULL},
718 {CHANNELMSG_GPADL_BODY, NULL},
719 {CHANNELMSG_GPADL_CREATED, vmbus_ongpadl_created},
720 {CHANNELMSG_GPADL_TEARDOWN, NULL},
721 {CHANNELMSG_GPADL_TORNDOWN, vmbus_ongpadl_torndown},
722 {CHANNELMSG_RELID_RELEASED, NULL},
723 {CHANNELMSG_INITIATE_CONTACT, NULL},
724 {CHANNELMSG_VERSION_RESPONSE, vmbus_onversion_response},
725 {CHANNELMSG_UNLOAD, NULL},
Greg Kroah-Hartmanc8212f02009-08-31 21:51:50 -0700726};
727
Hank Janssen3e189512010-03-04 22:11:00 +0000728/*
Haiyang Zhange98cb272010-10-15 10:14:07 -0700729 * vmbus_onmessage - Handler for channel protocol messages.
Greg Kroah-Hartmanbd60c332009-08-31 21:47:21 -0700730 *
731 * This is invoked in the vmbus worker thread context.
732 */
Haiyang Zhange98cb272010-10-15 10:14:07 -0700733void vmbus_onmessage(void *context)
Hank Janssen3e7ee492009-07-13 16:02:34 -0700734{
Haiyang Zhang188963e2010-10-15 10:14:06 -0700735 struct hv_message *msg = context;
Greg Kroah-Hartman82250212009-08-26 15:16:04 -0700736 struct vmbus_channel_message_header *hdr;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700737 int size;
738
Haiyang Zhangf6feebe2010-11-08 14:04:39 -0800739 hdr = (struct vmbus_channel_message_header *)msg->u.payload;
740 size = msg->header.payload_size;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700741
Haiyang Zhangc50f7fb2010-11-08 14:04:38 -0800742 if (hdr->msgtype >= CHANNELMSG_COUNT) {
Hank Janssen0a466182011-03-29 13:58:47 -0700743 pr_err("Received invalid channel message type %d size %d\n",
Haiyang Zhangc50f7fb2010-11-08 14:04:38 -0800744 hdr->msgtype, size);
Greg Kroah-Hartman04f50c42009-07-16 12:35:37 -0700745 print_hex_dump_bytes("", DUMP_PREFIX_NONE,
Haiyang Zhangf6feebe2010-11-08 14:04:39 -0800746 (unsigned char *)msg->u.payload, size);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700747 return;
748 }
749
K. Y. Srinivasanb7c6b022011-05-10 07:55:38 -0700750 if (channel_message_table[hdr->msgtype].message_handler)
751 channel_message_table[hdr->msgtype].message_handler(hdr);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700752 else
Hank Janssen0a466182011-03-29 13:58:47 -0700753 pr_err("Unhandled channel message type %d\n", hdr->msgtype);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700754}
755
Hank Janssen3e189512010-03-04 22:11:00 +0000756/*
Haiyang Zhange98cb272010-10-15 10:14:07 -0700757 * vmbus_request_offers - Send a request to get all our pending offers.
Greg Kroah-Hartmanbd60c332009-08-31 21:47:21 -0700758 */
Haiyang Zhange98cb272010-10-15 10:14:07 -0700759int vmbus_request_offers(void)
Hank Janssen3e7ee492009-07-13 16:02:34 -0700760{
Greg Kroah-Hartman82250212009-08-26 15:16:04 -0700761 struct vmbus_channel_message_header *msg;
Haiyang Zhang188963e2010-10-15 10:14:06 -0700762 struct vmbus_channel_msginfo *msginfo;
K. Y. Srinivasan9568a192011-05-10 07:55:39 -0700763 int ret, t;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700764
Haiyang Zhang188963e2010-10-15 10:14:06 -0700765 msginfo = kmalloc(sizeof(*msginfo) +
Greg Kroah-Hartmanbd60c332009-08-31 21:47:21 -0700766 sizeof(struct vmbus_channel_message_header),
767 GFP_KERNEL);
Haiyang Zhang188963e2010-10-15 10:14:06 -0700768 if (!msginfo)
Bill Pemberton75910f22010-05-05 15:27:31 -0400769 return -ENOMEM;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700770
K. Y. Srinivasan9568a192011-05-10 07:55:39 -0700771 init_completion(&msginfo->waitevent);
Bill Pemberton75910f22010-05-05 15:27:31 -0400772
Haiyang Zhangc50f7fb2010-11-08 14:04:38 -0800773 msg = (struct vmbus_channel_message_header *)msginfo->msg;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700774
Haiyang Zhangc50f7fb2010-11-08 14:04:38 -0800775 msg->msgtype = CHANNELMSG_REQUESTOFFERS;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700776
Hank Janssen3e7ee492009-07-13 16:02:34 -0700777
Haiyang Zhangc6977672011-01-26 12:12:08 -0800778 ret = vmbus_post_msg(msg,
Greg Kroah-Hartmanbd60c332009-08-31 21:47:21 -0700779 sizeof(struct vmbus_channel_message_header));
780 if (ret != 0) {
Hank Janssen0a466182011-03-29 13:58:47 -0700781 pr_err("Unable to request offers - %d\n", ret);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700782
K. Y. Srinivasan0c3b7b22011-02-11 09:59:43 -0800783 goto cleanup;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700784 }
Hank Janssen3e7ee492009-07-13 16:02:34 -0700785
K. Y. Srinivasan2dfde962011-06-16 13:16:34 -0700786 t = wait_for_completion_timeout(&msginfo->waitevent, 5*HZ);
K. Y. Srinivasan9568a192011-05-10 07:55:39 -0700787 if (t == 0) {
K. Y. Srinivasan0c3b7b22011-02-11 09:59:43 -0800788 ret = -ETIMEDOUT;
789 goto cleanup;
790 }
Hank Janssen3e7ee492009-07-13 16:02:34 -0700791
792
K. Y. Srinivasan0c3b7b22011-02-11 09:59:43 -0800793
794cleanup:
Ilia Mirkindd9b15d2011-03-13 00:29:00 -0500795 kfree(msginfo);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700796
Hank Janssen3e7ee492009-07-13 16:02:34 -0700797 return ret;
798}
799
K. Y. Srinivasane68d2972013-05-23 12:02:32 -0700800/*
801 * Retrieve the (sub) channel on which to send an outgoing request.
802 * When a primary channel has multiple sub-channels, we choose a
803 * channel whose VCPU binding is closest to the VCPU on which
804 * this call is being made.
805 */
806struct vmbus_channel *vmbus_get_outgoing_channel(struct vmbus_channel *primary)
807{
808 struct list_head *cur, *tmp;
809 int cur_cpu = hv_context.vp_index[smp_processor_id()];
810 struct vmbus_channel *cur_channel;
811 struct vmbus_channel *outgoing_channel = primary;
812 int cpu_distance, new_cpu_distance;
813
814 if (list_empty(&primary->sc_list))
815 return outgoing_channel;
816
817 list_for_each_safe(cur, tmp, &primary->sc_list) {
818 cur_channel = list_entry(cur, struct vmbus_channel, sc_list);
819 if (cur_channel->state != CHANNEL_OPENED_STATE)
820 continue;
821
822 if (cur_channel->target_vp == cur_cpu)
823 return cur_channel;
824
825 cpu_distance = ((outgoing_channel->target_vp > cur_cpu) ?
826 (outgoing_channel->target_vp - cur_cpu) :
827 (cur_cpu - outgoing_channel->target_vp));
828
829 new_cpu_distance = ((cur_channel->target_vp > cur_cpu) ?
830 (cur_channel->target_vp - cur_cpu) :
831 (cur_cpu - cur_channel->target_vp));
832
833 if (cpu_distance < new_cpu_distance)
834 continue;
835
836 outgoing_channel = cur_channel;
837 }
838
839 return outgoing_channel;
840}
841EXPORT_SYMBOL_GPL(vmbus_get_outgoing_channel);
842
843static void invoke_sc_cb(struct vmbus_channel *primary_channel)
844{
845 struct list_head *cur, *tmp;
846 struct vmbus_channel *cur_channel;
847
848 if (primary_channel->sc_creation_callback == NULL)
849 return;
850
851 list_for_each_safe(cur, tmp, &primary_channel->sc_list) {
852 cur_channel = list_entry(cur, struct vmbus_channel, sc_list);
853
854 primary_channel->sc_creation_callback(cur_channel);
855 }
856}
857
858void vmbus_set_sc_create_callback(struct vmbus_channel *primary_channel,
859 void (*sc_cr_cb)(struct vmbus_channel *new_sc))
860{
861 primary_channel->sc_creation_callback = sc_cr_cb;
862}
863EXPORT_SYMBOL_GPL(vmbus_set_sc_create_callback);
864
865bool vmbus_are_subchannels_present(struct vmbus_channel *primary)
866{
867 bool ret;
868
869 ret = !list_empty(&primary->sc_list);
870
871 if (ret) {
872 /*
873 * Invoke the callback on sub-channel creation.
874 * This will present a uniform interface to the
875 * clients.
876 */
877 invoke_sc_cb(primary);
878 }
879
880 return ret;
881}
882EXPORT_SYMBOL_GPL(vmbus_are_subchannels_present);