2009-07-13 17:02:34 -06:00
|
|
|
/*
|
|
|
|
* Copyright (c) 2009, Microsoft Corporation.
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify it
|
|
|
|
* under the terms and conditions of the GNU General Public License,
|
|
|
|
* version 2, as published by the Free Software Foundation.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope it will be useful, but WITHOUT
|
|
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
|
|
|
|
* more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License along with
|
|
|
|
* this program; if not, write to the Free Software Foundation, Inc., 59 Temple
|
|
|
|
* Place - Suite 330, Boston, MA 02111-1307 USA.
|
|
|
|
*
|
|
|
|
* Authors:
|
|
|
|
* Haiyang Zhang <haiyangz@microsoft.com>
|
|
|
|
* Hank Janssen <hjanssen@microsoft.com>
|
|
|
|
*/
|
2011-03-29 14:58:47 -06:00
|
|
|
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
|
|
|
|
|
2009-08-17 18:22:08 -06:00
|
|
|
#include <linux/kernel.h>
|
2011-02-11 10:59:43 -07:00
|
|
|
#include <linux/sched.h>
|
|
|
|
#include <linux/wait.h>
|
2009-08-17 18:22:08 -06:00
|
|
|
#include <linux/mm.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 02:04:11 -06:00
|
|
|
#include <linux/slab.h>
|
2009-09-11 19:46:44 -06:00
|
|
|
#include <linux/list.h>
|
2010-05-04 16:55:05 -06:00
|
|
|
#include <linux/module.h>
|
2010-05-28 17:22:44 -06:00
|
|
|
#include <linux/completion.h>
|
2011-05-12 20:34:15 -06:00
|
|
|
|
|
|
|
#include "hyperv.h"
|
2011-05-12 20:34:28 -06:00
|
|
|
#include "hyperv_vmbus.h"
|
2009-07-13 17:02:34 -06:00
|
|
|
|
2009-08-28 17:26:11 -06:00
|
|
|
struct vmbus_channel_message_table_entry {
|
2011-05-10 08:55:37 -06:00
|
|
|
enum vmbus_channel_message_type message_type;
|
2011-05-10 08:55:36 -06:00
|
|
|
void (*message_handler)(struct vmbus_channel_message_header *msg);
|
2009-08-28 17:26:11 -06:00
|
|
|
};
|
2009-07-13 17:02:34 -06:00
|
|
|
|
2010-12-16 18:54:16 -07:00
|
|
|
#define MAX_MSG_TYPES 4
|
|
|
|
#define MAX_NUM_DEVICE_CLASSES_SUPPORTED 8
|
2010-05-04 16:55:05 -06:00
|
|
|
|
2011-08-25 10:48:28 -06:00
|
|
|
static const uuid_le
|
2011-05-10 08:55:35 -06:00
|
|
|
supported_device_classes[MAX_NUM_DEVICE_CLASSES_SUPPORTED] = {
|
2009-07-27 14:47:24 -06:00
|
|
|
/* {ba6163d9-04a1-4d29-b605-72e2ffb1dc7f} */
|
2009-08-19 17:17:03 -06:00
|
|
|
/* Storage - SCSI */
|
|
|
|
{
|
2011-08-25 10:48:28 -06:00
|
|
|
.b = {
|
2009-08-19 17:17:03 -06:00
|
|
|
0xd9, 0x63, 0x61, 0xba, 0xa1, 0x04, 0x29, 0x4d,
|
|
|
|
0xb6, 0x05, 0x72, 0xe2, 0xff, 0xb1, 0xdc, 0x7f
|
|
|
|
}
|
|
|
|
},
|
|
|
|
|
2009-07-27 14:47:24 -06:00
|
|
|
/* {F8615163-DF3E-46c5-913F-F2D2F965ED0E} */
|
2009-08-19 17:17:03 -06:00
|
|
|
/* Network */
|
|
|
|
{
|
2011-08-25 10:48:28 -06:00
|
|
|
.b = {
|
2009-08-19 17:17:03 -06:00
|
|
|
0x63, 0x51, 0x61, 0xF8, 0x3E, 0xDF, 0xc5, 0x46,
|
|
|
|
0x91, 0x3F, 0xF2, 0xD2, 0xF9, 0x65, 0xED, 0x0E
|
|
|
|
}
|
|
|
|
},
|
|
|
|
|
2009-07-27 14:47:24 -06:00
|
|
|
/* {CFA8B69E-5B4A-4cc0-B98B-8BA1A1F3F95A} */
|
2009-08-19 17:17:03 -06:00
|
|
|
/* Input */
|
|
|
|
{
|
2011-08-25 10:48:28 -06:00
|
|
|
.b = {
|
2009-08-19 17:17:03 -06:00
|
|
|
0x9E, 0xB6, 0xA8, 0xCF, 0x4A, 0x5B, 0xc0, 0x4c,
|
|
|
|
0xB9, 0x8B, 0x8B, 0xA1, 0xA1, 0xF3, 0xF9, 0x5A
|
|
|
|
}
|
|
|
|
},
|
2009-07-13 17:02:34 -06:00
|
|
|
|
2009-08-19 17:17:03 -06:00
|
|
|
/* {32412632-86cb-44a2-9b5c-50d1417354f5} */
|
|
|
|
/* IDE */
|
|
|
|
{
|
2011-08-25 10:48:28 -06:00
|
|
|
.b = {
|
2009-08-19 17:17:03 -06:00
|
|
|
0x32, 0x26, 0x41, 0x32, 0xcb, 0x86, 0xa2, 0x44,
|
|
|
|
0x9b, 0x5c, 0x50, 0xd1, 0x41, 0x73, 0x54, 0xf5
|
|
|
|
}
|
|
|
|
},
|
2010-05-04 16:55:05 -06:00
|
|
|
/* 0E0B6031-5213-4934-818B-38D90CED39DB */
|
|
|
|
/* Shutdown */
|
|
|
|
{
|
2011-08-25 10:48:28 -06:00
|
|
|
.b = {
|
2010-05-04 16:55:05 -06:00
|
|
|
0x31, 0x60, 0x0B, 0X0E, 0x13, 0x52, 0x34, 0x49,
|
|
|
|
0x81, 0x8B, 0x38, 0XD9, 0x0C, 0xED, 0x39, 0xDB
|
|
|
|
}
|
|
|
|
},
|
2010-05-05 13:23:46 -06:00
|
|
|
/* {9527E630-D0AE-497b-ADCE-E80AB0175CAF} */
|
|
|
|
/* TimeSync */
|
|
|
|
{
|
2011-08-25 10:48:28 -06:00
|
|
|
.b = {
|
2010-05-05 13:23:46 -06:00
|
|
|
0x30, 0xe6, 0x27, 0x95, 0xae, 0xd0, 0x7b, 0x49,
|
|
|
|
0xad, 0xce, 0xe8, 0x0a, 0xb0, 0x17, 0x5c, 0xaf
|
|
|
|
}
|
|
|
|
},
|
2010-05-15 15:39:58 -06:00
|
|
|
/* {57164f39-9115-4e78-ab55-382f3bd5422d} */
|
|
|
|
/* Heartbeat */
|
|
|
|
{
|
2011-08-25 10:48:28 -06:00
|
|
|
.b = {
|
2010-05-15 15:39:58 -06:00
|
|
|
0x39, 0x4f, 0x16, 0x57, 0x15, 0x91, 0x78, 0x4e,
|
|
|
|
0xab, 0x55, 0x38, 0x2f, 0x3b, 0xd5, 0x42, 0x2d
|
|
|
|
}
|
|
|
|
},
|
2010-12-16 18:54:16 -07:00
|
|
|
/* {A9A0F4E7-5A45-4d96-B827-8A841E8C03E6} */
|
|
|
|
/* KVP */
|
|
|
|
{
|
2011-08-25 10:48:28 -06:00
|
|
|
.b = {
|
2010-12-16 18:54:16 -07:00
|
|
|
0xe7, 0xf4, 0xa0, 0xa9, 0x45, 0x5a, 0x96, 0x4d,
|
|
|
|
0xb8, 0x27, 0x8a, 0x84, 0x1e, 0x8c, 0x3, 0xe6
|
|
|
|
}
|
|
|
|
},
|
|
|
|
|
2009-07-13 17:02:34 -06:00
|
|
|
};
|
|
|
|
|
2010-05-04 16:55:05 -06:00
|
|
|
|
|
|
|
/**
|
|
|
|
* prep_negotiate_resp() - Create default response for Hyper-V Negotiate message
|
|
|
|
* @icmsghdrp: Pointer to msg header structure
|
|
|
|
* @icmsg_negotiate: Pointer to negotiate message structure
|
|
|
|
* @buf: Raw buffer channel data
|
|
|
|
*
|
|
|
|
* @icmsghdrp is of type &struct icmsg_hdr.
|
|
|
|
* @negop is of type &struct icmsg_negotiate.
|
|
|
|
* Set up and fill in default negotiate response message. This response can
|
|
|
|
* come from both the vmbus driver and the hv_utils driver. The current api
|
|
|
|
* will respond properly to both Windows 2008 and Windows 2008-R2 operating
|
|
|
|
* systems.
|
|
|
|
*
|
|
|
|
* Mainly used by Hyper-V drivers.
|
|
|
|
*/
|
|
|
|
void prep_negotiate_resp(struct icmsg_hdr *icmsghdrp,
|
|
|
|
struct icmsg_negotiate *negop,
|
|
|
|
u8 *buf)
|
|
|
|
{
|
|
|
|
if (icmsghdrp->icmsgtype == ICMSGTYPE_NEGOTIATE) {
|
|
|
|
icmsghdrp->icmsgsize = 0x10;
|
|
|
|
|
|
|
|
negop = (struct icmsg_negotiate *)&buf[
|
|
|
|
sizeof(struct vmbuspipe_hdr) +
|
|
|
|
sizeof(struct icmsg_hdr)];
|
|
|
|
|
|
|
|
if (negop->icframe_vercnt == 2 &&
|
|
|
|
negop->icversion_data[1].major == 3) {
|
|
|
|
negop->icversion_data[0].major = 3;
|
|
|
|
negop->icversion_data[0].minor = 0;
|
|
|
|
negop->icversion_data[1].major = 3;
|
|
|
|
negop->icversion_data[1].minor = 0;
|
|
|
|
} else {
|
|
|
|
negop->icversion_data[0].major = 1;
|
|
|
|
negop->icversion_data[0].minor = 0;
|
|
|
|
negop->icversion_data[1].major = 1;
|
|
|
|
negop->icversion_data[1].minor = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
negop->icframe_vercnt = 1;
|
|
|
|
negop->icmsg_vercnt = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(prep_negotiate_resp);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* chn_cb_negotiate() - Default handler for non IDE/SCSI/NETWORK
|
|
|
|
* Hyper-V requests
|
|
|
|
* @context: Pointer to argument structure.
|
|
|
|
*
|
|
|
|
* Set up the default handler for non device driver specific requests
|
|
|
|
* from Hyper-V. This stub responds to the default negotiate messages
|
|
|
|
* that come in for every non IDE/SCSI/Network request.
|
|
|
|
* This behavior is normally overwritten in the hv_utils driver. That
|
2011-03-30 19:57:33 -06:00
|
|
|
* driver handles requests like graceful shutdown, heartbeats etc.
|
2010-05-04 16:55:05 -06:00
|
|
|
*
|
|
|
|
* Mainly used by Hyper-V drivers.
|
|
|
|
*/
|
|
|
|
void chn_cb_negotiate(void *context)
|
|
|
|
{
|
|
|
|
struct vmbus_channel *channel = context;
|
|
|
|
u8 *buf;
|
|
|
|
u32 buflen, recvlen;
|
|
|
|
u64 requestid;
|
|
|
|
|
|
|
|
struct icmsg_hdr *icmsghdrp;
|
|
|
|
struct icmsg_negotiate *negop = NULL;
|
|
|
|
|
2011-05-16 07:44:36 -06:00
|
|
|
if (channel->util_index >= 0) {
|
|
|
|
/*
|
|
|
|
* This is a properly initialized util channel.
|
|
|
|
* Route this callback appropriately and setup state
|
|
|
|
* so that we don't need to reroute again.
|
|
|
|
*/
|
|
|
|
if (hv_cb_utils[channel->util_index].callback != NULL) {
|
|
|
|
/*
|
|
|
|
* The util driver has established a handler for
|
|
|
|
* this service; do the magic.
|
|
|
|
*/
|
|
|
|
channel->onchannel_callback =
|
|
|
|
hv_cb_utils[channel->util_index].callback;
|
|
|
|
(hv_cb_utils[channel->util_index].callback)(channel);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-05-04 16:55:05 -06:00
|
|
|
buflen = PAGE_SIZE;
|
|
|
|
buf = kmalloc(buflen, GFP_ATOMIC);
|
|
|
|
|
2010-10-07 12:40:08 -06:00
|
|
|
vmbus_recvpacket(channel, buf, buflen, &recvlen, &requestid);
|
2010-05-04 16:55:05 -06:00
|
|
|
|
|
|
|
if (recvlen > 0) {
|
|
|
|
icmsghdrp = (struct icmsg_hdr *)&buf[
|
|
|
|
sizeof(struct vmbuspipe_hdr)];
|
|
|
|
|
|
|
|
prep_negotiate_resp(icmsghdrp, negop, buf);
|
|
|
|
|
|
|
|
icmsghdrp->icflags = ICMSGHDRFLAG_TRANSACTION
|
|
|
|
| ICMSGHDRFLAG_RESPONSE;
|
|
|
|
|
2010-10-07 12:40:08 -06:00
|
|
|
vmbus_sendpacket(channel, buf,
|
2010-05-04 16:55:05 -06:00
|
|
|
recvlen, requestid,
|
2011-01-26 13:12:13 -07:00
|
|
|
VM_PKT_DATA_INBAND, 0);
|
2010-05-04 16:55:05 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
kfree(buf);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(chn_cb_negotiate);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Function table used for message responses for non IDE/SCSI/Network type
|
|
|
|
* messages. (Such as KVP/Shutdown etc)
|
|
|
|
*/
|
|
|
|
struct hyperv_service_callback hv_cb_utils[MAX_MSG_TYPES] = {
|
|
|
|
/* 0E0B6031-5213-4934-818B-38D90CED39DB */
|
|
|
|
/* Shutdown */
|
|
|
|
{
|
|
|
|
.msg_type = HV_SHUTDOWN_MSG,
|
2011-08-25 10:48:28 -06:00
|
|
|
.data.b = {
|
2010-05-04 16:55:05 -06:00
|
|
|
0x31, 0x60, 0x0B, 0X0E, 0x13, 0x52, 0x34, 0x49,
|
|
|
|
0x81, 0x8B, 0x38, 0XD9, 0x0C, 0xED, 0x39, 0xDB
|
|
|
|
},
|
|
|
|
.log_msg = "Shutdown channel functionality initialized"
|
|
|
|
},
|
2010-05-05 13:23:46 -06:00
|
|
|
|
|
|
|
/* {9527E630-D0AE-497b-ADCE-E80AB0175CAF} */
|
|
|
|
/* TimeSync */
|
|
|
|
{
|
|
|
|
.msg_type = HV_TIMESYNC_MSG,
|
2011-08-25 10:48:28 -06:00
|
|
|
.data.b = {
|
2010-05-05 13:23:46 -06:00
|
|
|
0x30, 0xe6, 0x27, 0x95, 0xae, 0xd0, 0x7b, 0x49,
|
|
|
|
0xad, 0xce, 0xe8, 0x0a, 0xb0, 0x17, 0x5c, 0xaf
|
|
|
|
},
|
|
|
|
.log_msg = "Timesync channel functionality initialized"
|
|
|
|
},
|
2010-05-15 15:39:58 -06:00
|
|
|
/* {57164f39-9115-4e78-ab55-382f3bd5422d} */
|
|
|
|
/* Heartbeat */
|
|
|
|
{
|
|
|
|
.msg_type = HV_HEARTBEAT_MSG,
|
2011-08-25 10:48:28 -06:00
|
|
|
.data.b = {
|
2010-05-15 15:39:58 -06:00
|
|
|
0x39, 0x4f, 0x16, 0x57, 0x15, 0x91, 0x78, 0x4e,
|
|
|
|
0xab, 0x55, 0x38, 0x2f, 0x3b, 0xd5, 0x42, 0x2d
|
|
|
|
},
|
|
|
|
.log_msg = "Heartbeat channel functionality initialized"
|
|
|
|
},
|
2010-12-16 18:54:16 -07:00
|
|
|
/* {A9A0F4E7-5A45-4d96-B827-8A841E8C03E6} */
|
|
|
|
/* KVP */
|
|
|
|
{
|
2011-08-25 10:48:28 -06:00
|
|
|
.data.b = {
|
2010-12-16 18:54:16 -07:00
|
|
|
0xe7, 0xf4, 0xa0, 0xa9, 0x45, 0x5a, 0x96, 0x4d,
|
|
|
|
0xb8, 0x27, 0x8a, 0x84, 0x1e, 0x8c, 0x3, 0xe6
|
|
|
|
},
|
|
|
|
.log_msg = "KVP channel functionality initialized"
|
|
|
|
},
|
2010-05-04 16:55:05 -06:00
|
|
|
};
|
|
|
|
EXPORT_SYMBOL(hv_cb_utils);
|
|
|
|
|
2010-03-04 15:11:00 -07:00
|
|
|
/*
|
2010-10-15 11:14:07 -06:00
|
|
|
* alloc_channel - Allocate and initialize a vmbus channel object
|
2009-08-31 22:47:21 -06:00
|
|
|
*/
|
2010-10-20 16:51:57 -06:00
|
|
|
static struct vmbus_channel *alloc_channel(void)
|
2009-07-13 17:02:34 -06:00
|
|
|
{
|
2009-08-18 16:21:19 -06:00
|
|
|
struct vmbus_channel *channel;
|
2009-07-13 17:02:34 -06:00
|
|
|
|
2009-08-18 16:21:19 -06:00
|
|
|
channel = kzalloc(sizeof(*channel), GFP_ATOMIC);
|
2009-07-13 17:02:34 -06:00
|
|
|
if (!channel)
|
|
|
|
return NULL;
|
|
|
|
|
2009-07-15 15:48:32 -06:00
|
|
|
spin_lock_init(&channel->inbound_lock);
|
2009-07-13 17:02:34 -06:00
|
|
|
|
2010-11-08 15:04:38 -07:00
|
|
|
channel->controlwq = create_workqueue("hv_vmbus_ctl");
|
|
|
|
if (!channel->controlwq) {
|
2009-07-15 13:48:29 -06:00
|
|
|
kfree(channel);
|
2009-07-13 17:02:34 -06:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return channel;
|
|
|
|
}
|
|
|
|
|
2010-03-04 15:11:00 -07:00
|
|
|
/*
|
2010-10-15 11:14:07 -06:00
|
|
|
* release_hannel - Release the vmbus channel object itself
|
2009-08-31 22:47:21 -06:00
|
|
|
*/
|
2010-12-15 11:48:09 -07:00
|
|
|
static void release_channel(struct work_struct *work)
|
2009-07-13 17:02:34 -06:00
|
|
|
{
|
2010-12-15 11:48:09 -07:00
|
|
|
struct vmbus_channel *channel = container_of(work,
|
|
|
|
struct vmbus_channel,
|
|
|
|
work);
|
2009-07-13 17:02:34 -06:00
|
|
|
|
2010-11-08 15:04:38 -07:00
|
|
|
destroy_workqueue(channel->controlwq);
|
2009-07-13 17:02:34 -06:00
|
|
|
|
2009-07-15 13:48:29 -06:00
|
|
|
kfree(channel);
|
2009-07-13 17:02:34 -06:00
|
|
|
}
|
|
|
|
|
2010-03-04 15:11:00 -07:00
|
|
|
/*
|
2010-10-15 11:14:07 -06:00
|
|
|
* free_channel - Release the resources used by the vmbus channel object
|
2009-08-31 22:47:21 -06:00
|
|
|
*/
|
2010-10-15 11:14:07 -06:00
|
|
|
void free_channel(struct vmbus_channel *channel)
|
2009-07-13 17:02:34 -06:00
|
|
|
{
|
|
|
|
|
2009-08-31 22:47:21 -06:00
|
|
|
/*
|
|
|
|
* We have to release the channel's workqueue/thread in the vmbus's
|
|
|
|
* workqueue/thread context
|
|
|
|
* ie we can't destroy ourselves.
|
|
|
|
*/
|
2010-12-15 11:48:09 -07:00
|
|
|
INIT_WORK(&channel->work, release_channel);
|
2011-01-26 13:12:14 -07:00
|
|
|
queue_work(vmbus_connection.work_queue, &channel->work);
|
2009-07-13 17:02:34 -06:00
|
|
|
}
|
|
|
|
|
2010-05-28 17:22:44 -06:00
|
|
|
|
|
|
|
|
2010-12-15 11:48:09 -07:00
|
|
|
/*
|
|
|
|
* vmbus_process_rescind_offer -
|
|
|
|
* Rescind the offer by initiating a device removal
|
|
|
|
*/
|
|
|
|
static void vmbus_process_rescind_offer(struct work_struct *work)
|
|
|
|
{
|
|
|
|
struct vmbus_channel *channel = container_of(work,
|
|
|
|
struct vmbus_channel,
|
|
|
|
work);
|
|
|
|
|
|
|
|
vmbus_child_device_unregister(channel->device_obj);
|
|
|
|
}
|
2010-05-28 17:22:44 -06:00
|
|
|
|
2010-03-04 15:11:00 -07:00
|
|
|
/*
|
2010-10-15 11:14:07 -06:00
|
|
|
* vmbus_process_offer - Process the offer by creating a channel/device
|
2010-05-04 16:55:05 -06:00
|
|
|
* associated with this offer
|
2009-08-31 22:47:21 -06:00
|
|
|
*/
|
2010-12-15 11:48:09 -07:00
|
|
|
static void vmbus_process_offer(struct work_struct *work)
|
2009-07-13 17:02:34 -06:00
|
|
|
{
|
2010-12-15 11:48:09 -07:00
|
|
|
struct vmbus_channel *newchannel = container_of(work,
|
|
|
|
struct vmbus_channel,
|
|
|
|
work);
|
2009-08-18 16:21:19 -06:00
|
|
|
struct vmbus_channel *channel;
|
2010-10-15 11:14:06 -06:00
|
|
|
bool fnew = true;
|
2009-08-31 22:47:21 -06:00
|
|
|
int ret;
|
2010-05-04 16:55:05 -06:00
|
|
|
int cnt;
|
2009-07-15 15:57:16 -06:00
|
|
|
unsigned long flags;
|
2009-07-13 17:02:34 -06:00
|
|
|
|
2010-12-15 11:48:09 -07:00
|
|
|
/* The next possible work is rescind handling */
|
|
|
|
INIT_WORK(&newchannel->work, vmbus_process_rescind_offer);
|
|
|
|
|
2009-07-27 14:47:24 -06:00
|
|
|
/* Make sure this is a new offer */
|
2011-01-26 13:12:07 -07:00
|
|
|
spin_lock_irqsave(&vmbus_connection.channel_lock, flags);
|
2009-07-13 17:02:34 -06:00
|
|
|
|
2011-01-26 13:12:14 -07:00
|
|
|
list_for_each_entry(channel, &vmbus_connection.chn_list, listentry) {
|
2011-08-25 10:48:28 -06:00
|
|
|
if (!uuid_le_cmp(channel->offermsg.offer.if_type,
|
|
|
|
newchannel->offermsg.offer.if_type) &&
|
|
|
|
!uuid_le_cmp(channel->offermsg.offer.if_instance,
|
|
|
|
newchannel->offermsg.offer.if_instance)) {
|
2010-10-15 11:14:06 -06:00
|
|
|
fnew = false;
|
2009-07-13 17:02:34 -06:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-10-15 11:14:06 -06:00
|
|
|
if (fnew)
|
2010-11-08 15:04:38 -07:00
|
|
|
list_add_tail(&newchannel->listentry,
|
2011-01-26 13:12:14 -07:00
|
|
|
&vmbus_connection.chn_list);
|
2009-08-31 22:47:21 -06:00
|
|
|
|
2011-01-26 13:12:07 -07:00
|
|
|
spin_unlock_irqrestore(&vmbus_connection.channel_lock, flags);
|
2009-07-13 17:02:34 -06:00
|
|
|
|
2010-10-15 11:14:06 -06:00
|
|
|
if (!fnew) {
|
2010-10-15 11:14:07 -06:00
|
|
|
free_channel(newchannel);
|
2009-07-13 17:02:34 -06:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2009-08-31 22:47:21 -06:00
|
|
|
/*
|
|
|
|
* Start the process of binding this offer to the driver
|
|
|
|
* We need to set the DeviceObject field before calling
|
2011-01-26 13:12:10 -07:00
|
|
|
* vmbus_child_dev_add()
|
2009-08-31 22:47:21 -06:00
|
|
|
*/
|
2011-09-08 08:24:12 -06:00
|
|
|
newchannel->device_obj = vmbus_device_create(
|
2011-01-26 13:12:12 -07:00
|
|
|
&newchannel->offermsg.offer.if_type,
|
|
|
|
&newchannel->offermsg.offer.if_instance,
|
2010-10-15 11:14:06 -06:00
|
|
|
newchannel);
|
2009-07-13 17:02:34 -06:00
|
|
|
|
2009-07-27 14:47:24 -06:00
|
|
|
/*
|
|
|
|
* Add the new device to the bus. This will kick off device-driver
|
|
|
|
* binding which eventually invokes the device driver's AddDevice()
|
|
|
|
* method.
|
|
|
|
*/
|
2011-09-08 08:24:13 -06:00
|
|
|
ret = vmbus_device_register(newchannel->device_obj);
|
2009-08-31 22:47:21 -06:00
|
|
|
if (ret != 0) {
|
2011-03-29 14:58:47 -06:00
|
|
|
pr_err("unable to add child device object (relid %d)\n",
|
2010-11-08 15:04:38 -07:00
|
|
|
newchannel->offermsg.child_relid);
|
2009-07-13 17:02:34 -06:00
|
|
|
|
2011-01-26 13:12:07 -07:00
|
|
|
spin_lock_irqsave(&vmbus_connection.channel_lock, flags);
|
2010-11-08 15:04:38 -07:00
|
|
|
list_del(&newchannel->listentry);
|
2011-01-26 13:12:07 -07:00
|
|
|
spin_unlock_irqrestore(&vmbus_connection.channel_lock, flags);
|
2009-07-13 17:02:34 -06:00
|
|
|
|
2010-10-15 11:14:07 -06:00
|
|
|
free_channel(newchannel);
|
2009-08-31 22:47:21 -06:00
|
|
|
} else {
|
2009-07-27 14:47:24 -06:00
|
|
|
/*
|
|
|
|
* This state is used to indicate a successful open
|
|
|
|
* so that when we do close the channel normally, we
|
|
|
|
* can cleanup properly
|
|
|
|
*/
|
2010-11-08 15:04:38 -07:00
|
|
|
newchannel->state = CHANNEL_OPEN_STATE;
|
2011-05-16 07:44:35 -06:00
|
|
|
newchannel->util_index = -1; /* Invalid index */
|
2010-05-04 16:55:05 -06:00
|
|
|
|
2010-05-28 17:22:44 -06:00
|
|
|
/* Open IC channels */
|
|
|
|
for (cnt = 0; cnt < MAX_MSG_TYPES; cnt++) {
|
2011-08-25 10:48:28 -06:00
|
|
|
if (!uuid_le_cmp(newchannel->offermsg.offer.if_type,
|
|
|
|
hv_cb_utils[cnt].data) &&
|
2010-10-15 11:14:06 -06:00
|
|
|
vmbus_open(newchannel, 2 * PAGE_SIZE,
|
2010-05-28 17:22:44 -06:00
|
|
|
2 * PAGE_SIZE, NULL, 0,
|
2011-05-16 07:44:36 -06:00
|
|
|
chn_cb_negotiate,
|
2010-10-15 11:14:06 -06:00
|
|
|
newchannel) == 0) {
|
|
|
|
hv_cb_utils[cnt].channel = newchannel;
|
2011-05-16 07:44:35 -06:00
|
|
|
newchannel->util_index = cnt;
|
2011-03-29 14:58:47 -06:00
|
|
|
|
|
|
|
pr_info("%s\n", hv_cb_utils[cnt].log_msg);
|
|
|
|
|
2010-05-04 16:55:05 -06:00
|
|
|
}
|
|
|
|
}
|
2009-07-13 17:02:34 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-03-04 15:11:00 -07:00
|
|
|
/*
|
2010-10-15 11:14:07 -06:00
|
|
|
* vmbus_onoffer - Handler for channel offers from vmbus in parent partition.
|
2009-08-31 22:47:21 -06:00
|
|
|
*
|
|
|
|
* We ignore all offers except network and storage offers. For each network and
|
|
|
|
* storage offers, we create a channel object and queue a work item to the
|
|
|
|
* channel object to process the offer synchronously
|
|
|
|
*/
|
2010-10-15 11:14:07 -06:00
|
|
|
static void vmbus_onoffer(struct vmbus_channel_message_header *hdr)
|
2009-07-13 17:02:34 -06:00
|
|
|
{
|
2009-08-31 22:47:21 -06:00
|
|
|
struct vmbus_channel_offer_channel *offer;
|
2010-10-15 11:14:06 -06:00
|
|
|
struct vmbus_channel *newchannel;
|
2011-08-25 10:48:28 -06:00
|
|
|
uuid_le *guidtype;
|
|
|
|
uuid_le *guidinstance;
|
2009-07-13 17:02:34 -06:00
|
|
|
int i;
|
2010-10-15 11:14:06 -06:00
|
|
|
int fsupported = 0;
|
2009-07-13 17:02:34 -06:00
|
|
|
|
2009-08-31 22:47:21 -06:00
|
|
|
offer = (struct vmbus_channel_offer_channel *)hdr;
|
|
|
|
for (i = 0; i < MAX_NUM_DEVICE_CLASSES_SUPPORTED; i++) {
|
2011-08-25 10:48:28 -06:00
|
|
|
if (!uuid_le_cmp(offer->offer.if_type,
|
|
|
|
supported_device_classes[i])) {
|
2010-10-15 11:14:06 -06:00
|
|
|
fsupported = 1;
|
2009-07-13 17:02:34 -06:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-03-29 14:58:44 -06:00
|
|
|
if (!fsupported)
|
2009-07-13 17:02:34 -06:00
|
|
|
return;
|
|
|
|
|
2011-01-26 13:12:12 -07:00
|
|
|
guidtype = &offer->offer.if_type;
|
|
|
|
guidinstance = &offer->offer.if_instance;
|
2009-07-13 17:02:34 -06:00
|
|
|
|
2009-07-27 14:47:24 -06:00
|
|
|
/* Allocate the channel object and save this offer. */
|
2010-10-15 11:14:07 -06:00
|
|
|
newchannel = alloc_channel();
|
2010-10-15 11:14:06 -06:00
|
|
|
if (!newchannel) {
|
2011-03-29 14:58:47 -06:00
|
|
|
pr_err("Unable to allocate channel object\n");
|
2009-07-13 17:02:34 -06:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2010-11-08 15:04:38 -07:00
|
|
|
memcpy(&newchannel->offermsg, offer,
|
2009-08-31 22:47:21 -06:00
|
|
|
sizeof(struct vmbus_channel_offer_channel));
|
2010-11-08 15:04:38 -07:00
|
|
|
newchannel->monitor_grp = (u8)offer->monitorid / 32;
|
|
|
|
newchannel->monitor_bit = (u8)offer->monitorid % 32;
|
2009-07-13 17:02:34 -06:00
|
|
|
|
2010-12-15 11:48:09 -07:00
|
|
|
INIT_WORK(&newchannel->work, vmbus_process_offer);
|
|
|
|
queue_work(newchannel->controlwq, &newchannel->work);
|
2009-07-13 17:02:34 -06:00
|
|
|
}
|
|
|
|
|
2010-03-04 15:11:00 -07:00
|
|
|
/*
|
2010-10-15 11:14:07 -06:00
|
|
|
* vmbus_onoffer_rescind - Rescind offer handler.
|
2009-08-31 22:47:21 -06:00
|
|
|
*
|
|
|
|
* We queue a work item to process this offer synchronously
|
|
|
|
*/
|
2010-10-15 11:14:07 -06:00
|
|
|
static void vmbus_onoffer_rescind(struct vmbus_channel_message_header *hdr)
|
2009-07-13 17:02:34 -06:00
|
|
|
{
|
2009-08-31 22:47:21 -06:00
|
|
|
struct vmbus_channel_rescind_offer *rescind;
|
2009-08-18 16:21:19 -06:00
|
|
|
struct vmbus_channel *channel;
|
2009-07-13 17:02:34 -06:00
|
|
|
|
2009-08-31 22:47:21 -06:00
|
|
|
rescind = (struct vmbus_channel_rescind_offer *)hdr;
|
2011-01-26 13:12:08 -07:00
|
|
|
channel = relid2channel(rescind->child_relid);
|
2011-03-29 14:58:44 -06:00
|
|
|
|
|
|
|
if (channel == NULL)
|
|
|
|
/* Just return here, no channel found */
|
2009-07-13 17:02:34 -06:00
|
|
|
return;
|
|
|
|
|
2010-12-15 11:48:09 -07:00
|
|
|
/* work is initialized for vmbus_process_rescind_offer() from
|
|
|
|
* vmbus_process_offer() where the channel got created */
|
|
|
|
queue_work(channel->controlwq, &channel->work);
|
2009-07-13 17:02:34 -06:00
|
|
|
}
|
|
|
|
|
2010-03-04 15:11:00 -07:00
|
|
|
/*
|
2010-10-15 11:14:07 -06:00
|
|
|
* vmbus_onoffers_delivered -
|
|
|
|
* This is invoked when all offers have been delivered.
|
2009-08-31 22:47:21 -06:00
|
|
|
*
|
|
|
|
* Nothing to do here.
|
|
|
|
*/
|
2010-10-15 11:14:07 -06:00
|
|
|
static void vmbus_onoffers_delivered(
|
2009-08-31 22:47:21 -06:00
|
|
|
struct vmbus_channel_message_header *hdr)
|
2009-07-13 17:02:34 -06:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2010-03-04 15:11:00 -07:00
|
|
|
/*
|
2010-10-15 11:14:07 -06:00
|
|
|
* vmbus_onopen_result - Open result handler.
|
2009-08-31 22:47:21 -06:00
|
|
|
*
|
|
|
|
* This is invoked when we received a response to our channel open request.
|
|
|
|
* Find the matching request, copy the response and signal the requesting
|
|
|
|
* thread.
|
|
|
|
*/
|
2010-10-15 11:14:07 -06:00
|
|
|
static void vmbus_onopen_result(struct vmbus_channel_message_header *hdr)
|
2009-07-13 17:02:34 -06:00
|
|
|
{
|
2009-08-31 22:47:21 -06:00
|
|
|
struct vmbus_channel_open_result *result;
|
2010-10-15 11:14:06 -06:00
|
|
|
struct vmbus_channel_msginfo *msginfo;
|
|
|
|
struct vmbus_channel_message_header *requestheader;
|
|
|
|
struct vmbus_channel_open_channel *openmsg;
|
2009-07-15 15:56:45 -06:00
|
|
|
unsigned long flags;
|
2009-07-13 17:02:34 -06:00
|
|
|
|
2009-08-31 22:47:21 -06:00
|
|
|
result = (struct vmbus_channel_open_result *)hdr;
|
2009-07-13 17:02:34 -06:00
|
|
|
|
2009-08-31 22:47:21 -06:00
|
|
|
/*
|
|
|
|
* Find the open msg, copy the result and signal/unblock the wait event
|
|
|
|
*/
|
2011-01-26 13:12:07 -07:00
|
|
|
spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags);
|
2009-07-13 17:02:34 -06:00
|
|
|
|
2011-02-18 13:39:57 -07:00
|
|
|
list_for_each_entry(msginfo, &vmbus_connection.chn_msg_list,
|
|
|
|
msglistentry) {
|
2010-10-15 11:14:06 -06:00
|
|
|
requestheader =
|
2010-11-08 15:04:38 -07:00
|
|
|
(struct vmbus_channel_message_header *)msginfo->msg;
|
2010-10-15 11:14:06 -06:00
|
|
|
|
2010-11-08 15:04:38 -07:00
|
|
|
if (requestheader->msgtype == CHANNELMSG_OPENCHANNEL) {
|
2010-10-15 11:14:06 -06:00
|
|
|
openmsg =
|
2010-11-08 15:04:38 -07:00
|
|
|
(struct vmbus_channel_open_channel *)msginfo->msg;
|
|
|
|
if (openmsg->child_relid == result->child_relid &&
|
|
|
|
openmsg->openid == result->openid) {
|
|
|
|
memcpy(&msginfo->response.open_result,
|
2009-08-31 22:47:21 -06:00
|
|
|
result,
|
2011-05-10 08:55:39 -06:00
|
|
|
sizeof(
|
|
|
|
struct vmbus_channel_open_result));
|
|
|
|
complete(&msginfo->waitevent);
|
2009-07-13 17:02:34 -06:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2011-01-26 13:12:07 -07:00
|
|
|
spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock, flags);
|
2009-07-13 17:02:34 -06:00
|
|
|
}
|
|
|
|
|
2010-03-04 15:11:00 -07:00
|
|
|
/*
|
2010-10-15 11:14:07 -06:00
|
|
|
* vmbus_ongpadl_created - GPADL created handler.
|
2009-08-31 22:47:21 -06:00
|
|
|
*
|
|
|
|
* This is invoked when we received a response to our gpadl create request.
|
|
|
|
* Find the matching request, copy the response and signal the requesting
|
|
|
|
* thread.
|
|
|
|
*/
|
2010-10-15 11:14:07 -06:00
|
|
|
static void vmbus_ongpadl_created(struct vmbus_channel_message_header *hdr)
|
2009-07-13 17:02:34 -06:00
|
|
|
{
|
2010-10-15 11:14:06 -06:00
|
|
|
struct vmbus_channel_gpadl_created *gpadlcreated;
|
|
|
|
struct vmbus_channel_msginfo *msginfo;
|
|
|
|
struct vmbus_channel_message_header *requestheader;
|
|
|
|
struct vmbus_channel_gpadl_header *gpadlheader;
|
2009-07-15 15:56:45 -06:00
|
|
|
unsigned long flags;
|
2009-07-13 17:02:34 -06:00
|
|
|
|
2010-10-15 11:14:06 -06:00
|
|
|
gpadlcreated = (struct vmbus_channel_gpadl_created *)hdr;
|
2009-07-13 17:02:34 -06:00
|
|
|
|
2009-08-31 22:47:21 -06:00
|
|
|
/*
|
|
|
|
* Find the establish msg, copy the result and signal/unblock the wait
|
|
|
|
* event
|
|
|
|
*/
|
2011-01-26 13:12:07 -07:00
|
|
|
spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags);
|
2009-07-13 17:02:34 -06:00
|
|
|
|
2011-02-18 13:39:57 -07:00
|
|
|
list_for_each_entry(msginfo, &vmbus_connection.chn_msg_list,
|
|
|
|
msglistentry) {
|
2010-10-15 11:14:06 -06:00
|
|
|
requestheader =
|
2010-11-08 15:04:38 -07:00
|
|
|
(struct vmbus_channel_message_header *)msginfo->msg;
|
2010-10-15 11:14:06 -06:00
|
|
|
|
2010-11-08 15:04:38 -07:00
|
|
|
if (requestheader->msgtype == CHANNELMSG_GPADL_HEADER) {
|
2010-10-15 11:14:06 -06:00
|
|
|
gpadlheader =
|
|
|
|
(struct vmbus_channel_gpadl_header *)requestheader;
|
|
|
|
|
2010-11-08 15:04:38 -07:00
|
|
|
if ((gpadlcreated->child_relid ==
|
|
|
|
gpadlheader->child_relid) &&
|
|
|
|
(gpadlcreated->gpadl == gpadlheader->gpadl)) {
|
|
|
|
memcpy(&msginfo->response.gpadl_created,
|
2010-10-15 11:14:06 -06:00
|
|
|
gpadlcreated,
|
2011-05-10 08:55:39 -06:00
|
|
|
sizeof(
|
|
|
|
struct vmbus_channel_gpadl_created));
|
|
|
|
complete(&msginfo->waitevent);
|
2009-07-13 17:02:34 -06:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2011-01-26 13:12:07 -07:00
|
|
|
spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock, flags);
|
2009-07-13 17:02:34 -06:00
|
|
|
}
|
|
|
|
|
2010-03-04 15:11:00 -07:00
|
|
|
/*
|
2010-10-15 11:14:07 -06:00
|
|
|
* vmbus_ongpadl_torndown - GPADL torndown handler.
|
2009-08-31 22:47:21 -06:00
|
|
|
*
|
|
|
|
* This is invoked when we received a response to our gpadl teardown request.
|
|
|
|
* Find the matching request, copy the response and signal the requesting
|
|
|
|
* thread.
|
|
|
|
*/
|
2010-10-15 11:14:07 -06:00
|
|
|
static void vmbus_ongpadl_torndown(
|
2009-08-31 22:47:21 -06:00
|
|
|
struct vmbus_channel_message_header *hdr)
|
2009-07-13 17:02:34 -06:00
|
|
|
{
|
2010-10-15 11:14:06 -06:00
|
|
|
struct vmbus_channel_gpadl_torndown *gpadl_torndown;
|
|
|
|
struct vmbus_channel_msginfo *msginfo;
|
|
|
|
struct vmbus_channel_message_header *requestheader;
|
|
|
|
struct vmbus_channel_gpadl_teardown *gpadl_teardown;
|
2009-07-15 15:56:45 -06:00
|
|
|
unsigned long flags;
|
2009-07-13 17:02:34 -06:00
|
|
|
|
2010-10-15 11:14:06 -06:00
|
|
|
gpadl_torndown = (struct vmbus_channel_gpadl_torndown *)hdr;
|
2009-08-31 22:47:21 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Find the open msg, copy the result and signal/unblock the wait event
|
|
|
|
*/
|
2011-01-26 13:12:07 -07:00
|
|
|
spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags);
|
2009-07-13 17:02:34 -06:00
|
|
|
|
2011-02-18 13:39:57 -07:00
|
|
|
list_for_each_entry(msginfo, &vmbus_connection.chn_msg_list,
|
|
|
|
msglistentry) {
|
2010-10-15 11:14:06 -06:00
|
|
|
requestheader =
|
2010-11-08 15:04:38 -07:00
|
|
|
(struct vmbus_channel_message_header *)msginfo->msg;
|
2009-07-13 17:02:34 -06:00
|
|
|
|
2010-11-08 15:04:38 -07:00
|
|
|
if (requestheader->msgtype == CHANNELMSG_GPADL_TEARDOWN) {
|
2010-10-15 11:14:06 -06:00
|
|
|
gpadl_teardown =
|
|
|
|
(struct vmbus_channel_gpadl_teardown *)requestheader;
|
2009-07-13 17:02:34 -06:00
|
|
|
|
2010-11-08 15:04:38 -07:00
|
|
|
if (gpadl_torndown->gpadl == gpadl_teardown->gpadl) {
|
|
|
|
memcpy(&msginfo->response.gpadl_torndown,
|
2010-10-15 11:14:06 -06:00
|
|
|
gpadl_torndown,
|
2011-05-10 08:55:39 -06:00
|
|
|
sizeof(
|
|
|
|
struct vmbus_channel_gpadl_torndown));
|
|
|
|
complete(&msginfo->waitevent);
|
2009-07-13 17:02:34 -06:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2011-01-26 13:12:07 -07:00
|
|
|
spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock, flags);
|
2009-07-13 17:02:34 -06:00
|
|
|
}
|
|
|
|
|
2010-03-04 15:11:00 -07:00
|
|
|
/*
|
2010-10-15 11:14:07 -06:00
|
|
|
* vmbus_onversion_response - Version response handler
|
2009-08-31 22:47:21 -06:00
|
|
|
*
|
|
|
|
* This is invoked when we received a response to our initiate contact request.
|
|
|
|
* Find the matching request, copy the response and signal the requesting
|
|
|
|
* thread.
|
|
|
|
*/
|
2010-10-15 11:14:07 -06:00
|
|
|
static void vmbus_onversion_response(
|
2009-08-31 22:47:21 -06:00
|
|
|
struct vmbus_channel_message_header *hdr)
|
2009-07-13 17:02:34 -06:00
|
|
|
{
|
2010-10-15 11:14:06 -06:00
|
|
|
struct vmbus_channel_msginfo *msginfo;
|
|
|
|
struct vmbus_channel_message_header *requestheader;
|
2009-08-26 16:16:04 -06:00
|
|
|
struct vmbus_channel_initiate_contact *initiate;
|
2010-10-15 11:14:06 -06:00
|
|
|
struct vmbus_channel_version_response *version_response;
|
2009-07-15 15:56:45 -06:00
|
|
|
unsigned long flags;
|
2009-07-13 17:02:34 -06:00
|
|
|
|
2010-10-15 11:14:06 -06:00
|
|
|
version_response = (struct vmbus_channel_version_response *)hdr;
|
2011-01-26 13:12:07 -07:00
|
|
|
spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags);
|
2009-07-13 17:02:34 -06:00
|
|
|
|
2011-02-18 13:39:57 -07:00
|
|
|
list_for_each_entry(msginfo, &vmbus_connection.chn_msg_list,
|
|
|
|
msglistentry) {
|
2010-10-15 11:14:06 -06:00
|
|
|
requestheader =
|
2010-11-08 15:04:38 -07:00
|
|
|
(struct vmbus_channel_message_header *)msginfo->msg;
|
2009-07-13 17:02:34 -06:00
|
|
|
|
2010-11-08 15:04:38 -07:00
|
|
|
if (requestheader->msgtype ==
|
|
|
|
CHANNELMSG_INITIATE_CONTACT) {
|
2010-10-15 11:14:06 -06:00
|
|
|
initiate =
|
|
|
|
(struct vmbus_channel_initiate_contact *)requestheader;
|
2010-11-08 15:04:38 -07:00
|
|
|
memcpy(&msginfo->response.version_response,
|
2010-10-15 11:14:06 -06:00
|
|
|
version_response,
|
2009-08-31 22:47:21 -06:00
|
|
|
sizeof(struct vmbus_channel_version_response));
|
2011-05-10 08:55:39 -06:00
|
|
|
complete(&msginfo->waitevent);
|
2009-07-13 17:02:34 -06:00
|
|
|
}
|
|
|
|
}
|
2011-01-26 13:12:07 -07:00
|
|
|
spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock, flags);
|
2009-07-13 17:02:34 -06:00
|
|
|
}
|
|
|
|
|
2009-08-31 22:51:50 -06:00
|
|
|
/* Channel message dispatch table */
|
|
|
|
static struct vmbus_channel_message_table_entry
|
2011-05-10 08:55:38 -06:00
|
|
|
channel_message_table[CHANNELMSG_COUNT] = {
|
2010-11-08 15:04:38 -07:00
|
|
|
{CHANNELMSG_INVALID, NULL},
|
|
|
|
{CHANNELMSG_OFFERCHANNEL, vmbus_onoffer},
|
|
|
|
{CHANNELMSG_RESCIND_CHANNELOFFER, vmbus_onoffer_rescind},
|
|
|
|
{CHANNELMSG_REQUESTOFFERS, NULL},
|
|
|
|
{CHANNELMSG_ALLOFFERS_DELIVERED, vmbus_onoffers_delivered},
|
|
|
|
{CHANNELMSG_OPENCHANNEL, NULL},
|
|
|
|
{CHANNELMSG_OPENCHANNEL_RESULT, vmbus_onopen_result},
|
|
|
|
{CHANNELMSG_CLOSECHANNEL, NULL},
|
|
|
|
{CHANNELMSG_GPADL_HEADER, NULL},
|
|
|
|
{CHANNELMSG_GPADL_BODY, NULL},
|
|
|
|
{CHANNELMSG_GPADL_CREATED, vmbus_ongpadl_created},
|
|
|
|
{CHANNELMSG_GPADL_TEARDOWN, NULL},
|
|
|
|
{CHANNELMSG_GPADL_TORNDOWN, vmbus_ongpadl_torndown},
|
|
|
|
{CHANNELMSG_RELID_RELEASED, NULL},
|
|
|
|
{CHANNELMSG_INITIATE_CONTACT, NULL},
|
|
|
|
{CHANNELMSG_VERSION_RESPONSE, vmbus_onversion_response},
|
|
|
|
{CHANNELMSG_UNLOAD, NULL},
|
2009-08-31 22:51:50 -06:00
|
|
|
};
|
|
|
|
|
2010-03-04 15:11:00 -07:00
|
|
|
/*
|
2010-10-15 11:14:07 -06:00
|
|
|
* vmbus_onmessage - Handler for channel protocol messages.
|
2009-08-31 22:47:21 -06:00
|
|
|
*
|
|
|
|
* This is invoked in the vmbus worker thread context.
|
|
|
|
*/
|
2010-10-15 11:14:07 -06:00
|
|
|
void vmbus_onmessage(void *context)
|
2009-07-13 17:02:34 -06:00
|
|
|
{
|
2010-10-15 11:14:06 -06:00
|
|
|
struct hv_message *msg = context;
|
2009-08-26 16:16:04 -06:00
|
|
|
struct vmbus_channel_message_header *hdr;
|
2009-07-13 17:02:34 -06:00
|
|
|
int size;
|
|
|
|
|
2010-11-08 15:04:39 -07:00
|
|
|
hdr = (struct vmbus_channel_message_header *)msg->u.payload;
|
|
|
|
size = msg->header.payload_size;
|
2009-07-13 17:02:34 -06:00
|
|
|
|
2010-11-08 15:04:38 -07:00
|
|
|
if (hdr->msgtype >= CHANNELMSG_COUNT) {
|
2011-03-29 14:58:47 -06:00
|
|
|
pr_err("Received invalid channel message type %d size %d\n",
|
2010-11-08 15:04:38 -07:00
|
|
|
hdr->msgtype, size);
|
2009-07-16 13:35:37 -06:00
|
|
|
print_hex_dump_bytes("", DUMP_PREFIX_NONE,
|
2010-11-08 15:04:39 -07:00
|
|
|
(unsigned char *)msg->u.payload, size);
|
2009-07-13 17:02:34 -06:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2011-05-10 08:55:38 -06:00
|
|
|
if (channel_message_table[hdr->msgtype].message_handler)
|
|
|
|
channel_message_table[hdr->msgtype].message_handler(hdr);
|
2009-07-13 17:02:34 -06:00
|
|
|
else
|
2011-03-29 14:58:47 -06:00
|
|
|
pr_err("Unhandled channel message type %d\n", hdr->msgtype);
|
2009-07-13 17:02:34 -06:00
|
|
|
}
|
|
|
|
|
2010-03-04 15:11:00 -07:00
|
|
|
/*
|
2010-10-15 11:14:07 -06:00
|
|
|
* vmbus_request_offers - Send a request to get all our pending offers.
|
2009-08-31 22:47:21 -06:00
|
|
|
*/
|
2010-10-15 11:14:07 -06:00
|
|
|
int vmbus_request_offers(void)
|
2009-07-13 17:02:34 -06:00
|
|
|
{
|
2009-08-26 16:16:04 -06:00
|
|
|
struct vmbus_channel_message_header *msg;
|
2010-10-15 11:14:06 -06:00
|
|
|
struct vmbus_channel_msginfo *msginfo;
|
2011-05-10 08:55:39 -06:00
|
|
|
int ret, t;
|
2009-07-13 17:02:34 -06:00
|
|
|
|
2010-10-15 11:14:06 -06:00
|
|
|
msginfo = kmalloc(sizeof(*msginfo) +
|
2009-08-31 22:47:21 -06:00
|
|
|
sizeof(struct vmbus_channel_message_header),
|
|
|
|
GFP_KERNEL);
|
2010-10-15 11:14:06 -06:00
|
|
|
if (!msginfo)
|
2010-05-05 13:27:31 -06:00
|
|
|
return -ENOMEM;
|
2009-07-13 17:02:34 -06:00
|
|
|
|
2011-05-10 08:55:39 -06:00
|
|
|
init_completion(&msginfo->waitevent);
|
2010-05-05 13:27:31 -06:00
|
|
|
|
2010-11-08 15:04:38 -07:00
|
|
|
msg = (struct vmbus_channel_message_header *)msginfo->msg;
|
2009-07-13 17:02:34 -06:00
|
|
|
|
2010-11-08 15:04:38 -07:00
|
|
|
msg->msgtype = CHANNELMSG_REQUESTOFFERS;
|
2009-07-13 17:02:34 -06:00
|
|
|
|
|
|
|
|
2011-01-26 13:12:08 -07:00
|
|
|
ret = vmbus_post_msg(msg,
|
2009-08-31 22:47:21 -06:00
|
|
|
sizeof(struct vmbus_channel_message_header));
|
|
|
|
if (ret != 0) {
|
2011-03-29 14:58:47 -06:00
|
|
|
pr_err("Unable to request offers - %d\n", ret);
|
2009-07-13 17:02:34 -06:00
|
|
|
|
2011-02-11 10:59:43 -07:00
|
|
|
goto cleanup;
|
|
|
|
}
|
2009-07-13 17:02:34 -06:00
|
|
|
|
2011-06-16 14:16:34 -06:00
|
|
|
t = wait_for_completion_timeout(&msginfo->waitevent, 5*HZ);
|
2011-05-10 08:55:39 -06:00
|
|
|
if (t == 0) {
|
2011-02-11 10:59:43 -07:00
|
|
|
ret = -ETIMEDOUT;
|
|
|
|
goto cleanup;
|
2009-07-13 17:02:34 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
2011-02-11 10:59:43 -07:00
|
|
|
cleanup:
|
2011-03-12 22:29:00 -07:00
|
|
|
kfree(msginfo);
|
2009-07-13 17:02:34 -06:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2009-07-27 14:47:24 -06:00
|
|
|
/* eof */
|