[linux.git] / drivers / hv / hv_kvp.c

/*
 * An implementation of key value pair (KVP) functionality for Linux.
 *
 *
 * Copyright (C) 2010, Novell, Inc.
 * Author : K. Y. Srinivasan <[email protected]>
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 as published
 * by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
 * NON INFRINGEMENT.  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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 */
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include <linux/net.h>
#include <linux/nls.h>
#include <linux/connector.h>
#include <linux/workqueue.h>
#include <linux/hyperv.h>


/*
 * Pre win8 version numbers used in ws2008 and ws 2008 r2 (win7)
 */
#define WIN7_SRV_MAJOR   3
#define WIN7_SRV_MINOR   0
#define WIN7_SRV_MAJOR_MINOR     (WIN7_SRV_MAJOR << 16 | WIN7_SRV_MINOR)

#define WIN8_SRV_MAJOR   4
#define WIN8_SRV_MINOR   0
#define WIN8_SRV_MAJOR_MINOR     (WIN8_SRV_MAJOR << 16 | WIN8_SRV_MINOR)

/*
 * Global state maintained for transaction that is being processed.
 * Note that only one transaction can be active at any point in time.
 *
 * This state is set when we receive a request from the host; we
 * cleanup this state when the transaction is completed - when we respond
 * to the host with the key value.
 */

static struct {
	bool active; /* transaction status - active or not */
	int recv_len; /* number of bytes received. */
	struct hv_kvp_msg  *kvp_msg; /* current message */
	struct vmbus_channel *recv_channel; /* chn we got the request */
	u64 recv_req_id; /* request ID. */
	void *kvp_context; /* for the channel callback */
} kvp_transaction;

/*
 * Before we can accept KVP messages from the host, we need
 * to handshake with the user level daemon. This state tracks
 * if we are in the handshake phase.
 */
static bool in_hand_shake = true;

/*
 * This state maintains the version number registered by the daemon.
 */
static int dm_reg_value;

static void kvp_send_key(struct work_struct *dummy);


static void kvp_respond_to_host(struct hv_kvp_msg *msg, int error);
static void kvp_work_func(struct work_struct *dummy);
static void kvp_register(int);

static DECLARE_DELAYED_WORK(kvp_work, kvp_work_func);
static DECLARE_WORK(kvp_sendkey_work, kvp_send_key);

static struct cb_id kvp_id = { CN_KVP_IDX, CN_KVP_VAL };
static const char kvp_name[] = "kvp_kernel_module";
static u8 *recv_buffer;
/*
 * Register the kernel component with the user-level daemon.
 * As part of this registration, pass the LIC version number.
 * This number has no meaning, it satisfies the registration protocol.
 */
#define HV_DRV_VERSION           "3.1"

static void
kvp_register(int reg_value)
{

	struct cn_msg *msg;
	struct hv_kvp_msg *kvp_msg;
	char *version;

	msg = kzalloc(sizeof(*msg) + sizeof(struct hv_kvp_msg), GFP_ATOMIC);

	if (msg) {
		kvp_msg = (struct hv_kvp_msg *)msg->data;
		version = kvp_msg->body.kvp_register.version;
		msg->id.idx =  CN_KVP_IDX;
		msg->id.val = CN_KVP_VAL;

		kvp_msg->kvp_hdr.operation = reg_value;
		strcpy(version, HV_DRV_VERSION);
		msg->len = sizeof(struct hv_kvp_msg);
		cn_netlink_send(msg, 0, GFP_ATOMIC);
		kfree(msg);
	}
}
static void
kvp_work_func(struct work_struct *dummy)
{
	/*
	 * If the timer fires, the user-mode component has not responded;
	 * process the pending transaction.
	 */
	kvp_respond_to_host(NULL, HV_E_FAIL);
}

static int kvp_handle_handshake(struct hv_kvp_msg *msg)
{
	int ret = 1;

	switch (msg->kvp_hdr.operation) {
	case KVP_OP_REGISTER:
		dm_reg_value = KVP_OP_REGISTER;
		pr_info("KVP: IP injection functionality not available\n");
		pr_info("KVP: Upgrade the KVP daemon\n");
		break;
	case KVP_OP_REGISTER1:
		dm_reg_value = KVP_OP_REGISTER1;
		break;
	default:
		pr_info("KVP: incompatible daemon\n");
		pr_info("KVP: KVP version: %d, Daemon version: %d\n",
			KVP_OP_REGISTER1, msg->kvp_hdr.operation);
		ret = 0;
	}

	if (ret) {
		/*
		 * We have a compatible daemon; complete the handshake.
		 */
		pr_info("KVP: user-mode registering done.\n");
		kvp_register(dm_reg_value);
		kvp_transaction.active = false;
		if (kvp_transaction.kvp_context)
			hv_kvp_onchannelcallback(kvp_transaction.kvp_context);
	}
	return ret;
}


/*
 * Callback when data is received from user mode.
 */

static void
kvp_cn_callback(struct cn_msg *msg, struct netlink_skb_parms *nsp)
{
	struct hv_kvp_msg *message;
	struct hv_kvp_msg_enumerate *data;
	int	error = 0;

	message = (struct hv_kvp_msg *)msg->data;

	/*
	 * If we are negotiating the version information
	 * with the daemon; handle that first.
	 */

	if (in_hand_shake) {
		if (kvp_handle_handshake(message))
			in_hand_shake = false;
		return;
	}

	/*
	 * Based on the version of the daemon, we propagate errors from the
	 * daemon differently.
	 */

	data = &message->body.kvp_enum_data;

	switch (dm_reg_value) {
	case KVP_OP_REGISTER:
		/*
		 * Null string is used to pass back error condition.
		 */
		if (data->data.key[0] == 0)
			error = HV_S_CONT;
		break;

	case KVP_OP_REGISTER1:
		/*
		 * We use the message header information from
		 * the user level daemon to transmit errors.
		 */
		error = message->error;
		break;
	}

	/*
	 * Complete the transaction by forwarding the key value
	 * to the host. But first, cancel the timeout.
	 */
	if (cancel_delayed_work_sync(&kvp_work))
		kvp_respond_to_host(message, error);
}


static int process_ob_ipinfo(void *in_msg, void *out_msg, int op)
{
	struct hv_kvp_msg *in = in_msg;
	struct hv_kvp_ip_msg *out = out_msg;
	int len;

	switch (op) {
	case KVP_OP_GET_IP_INFO:
		/*
		 * Transform all parameters into utf16 encoding.
		 */
		len = utf8s_to_utf16s((char *)in->body.kvp_ip_val.ip_addr,
				strlen((char *)in->body.kvp_ip_val.ip_addr),
				UTF16_HOST_ENDIAN,
				(wchar_t *)out->kvp_ip_val.ip_addr,
				MAX_IP_ADDR_SIZE);
		if (len < 0)
			return len;

		len = utf8s_to_utf16s((char *)in->body.kvp_ip_val.sub_net,
				strlen((char *)in->body.kvp_ip_val.sub_net),
				UTF16_HOST_ENDIAN,
				(wchar_t *)out->kvp_ip_val.sub_net,
				MAX_IP_ADDR_SIZE);
		if (len < 0)
			return len;

		len = utf8s_to_utf16s((char *)in->body.kvp_ip_val.gate_way,
				strlen((char *)in->body.kvp_ip_val.gate_way),
				UTF16_HOST_ENDIAN,
				(wchar_t *)out->kvp_ip_val.gate_way,
				MAX_GATEWAY_SIZE);
		if (len < 0)
			return len;

		len = utf8s_to_utf16s((char *)in->body.kvp_ip_val.dns_addr,
				strlen((char *)in->body.kvp_ip_val.dns_addr),
				UTF16_HOST_ENDIAN,
				(wchar_t *)out->kvp_ip_val.dns_addr,
				MAX_IP_ADDR_SIZE);
		if (len < 0)
			return len;

		len = utf8s_to_utf16s((char *)in->body.kvp_ip_val.adapter_id,
				strlen((char *)in->body.kvp_ip_val.adapter_id),
				UTF16_HOST_ENDIAN,
				(wchar_t *)out->kvp_ip_val.adapter_id,
				MAX_IP_ADDR_SIZE);
		if (len < 0)
			return len;

		out->kvp_ip_val.dhcp_enabled =
			in->body.kvp_ip_val.dhcp_enabled;
		out->kvp_ip_val.addr_family =
			in->body.kvp_ip_val.addr_family;
	}

	return 0;
}

static void process_ib_ipinfo(void *in_msg, void *out_msg, int op)
{
	struct hv_kvp_ip_msg *in = in_msg;
	struct hv_kvp_msg *out = out_msg;

	switch (op) {
	case KVP_OP_SET_IP_INFO:
		/*
		 * Transform all parameters into utf8 encoding.
		 */
		utf16s_to_utf8s((wchar_t *)in->kvp_ip_val.ip_addr,
				MAX_IP_ADDR_SIZE,
				UTF16_LITTLE_ENDIAN,
				(__u8 *)out->body.kvp_ip_val.ip_addr,
				MAX_IP_ADDR_SIZE);

		utf16s_to_utf8s((wchar_t *)in->kvp_ip_val.sub_net,
				MAX_IP_ADDR_SIZE,
				UTF16_LITTLE_ENDIAN,
				(__u8 *)out->body.kvp_ip_val.sub_net,
				MAX_IP_ADDR_SIZE);

		utf16s_to_utf8s((wchar_t *)in->kvp_ip_val.gate_way,
				MAX_GATEWAY_SIZE,
				UTF16_LITTLE_ENDIAN,
				(__u8 *)out->body.kvp_ip_val.gate_way,
				MAX_GATEWAY_SIZE);

		utf16s_to_utf8s((wchar_t *)in->kvp_ip_val.dns_addr,
				MAX_IP_ADDR_SIZE,
				UTF16_LITTLE_ENDIAN,
				(__u8 *)out->body.kvp_ip_val.dns_addr,
				MAX_IP_ADDR_SIZE);

		out->body.kvp_ip_val.dhcp_enabled = in->kvp_ip_val.dhcp_enabled;

	default:
		utf16s_to_utf8s((wchar_t *)in->kvp_ip_val.adapter_id,
				MAX_ADAPTER_ID_SIZE,
				UTF16_LITTLE_ENDIAN,
				(__u8 *)out->body.kvp_ip_val.adapter_id,
				MAX_ADAPTER_ID_SIZE);

		out->body.kvp_ip_val.addr_family = in->kvp_ip_val.addr_family;
	}
}


static void
kvp_send_key(struct work_struct *dummy)
{
	struct cn_msg *msg;
	struct hv_kvp_msg *message;
	struct hv_kvp_msg *in_msg;
	__u8 operation = kvp_transaction.kvp_msg->kvp_hdr.operation;
	__u8 pool = kvp_transaction.kvp_msg->kvp_hdr.pool;
	__u32 val32;
	__u64 val64;

	msg = kzalloc(sizeof(*msg) + sizeof(struct hv_kvp_msg) , GFP_ATOMIC);
	if (!msg)
		return;

	msg->id.idx =  CN_KVP_IDX;
	msg->id.val = CN_KVP_VAL;

	message = (struct hv_kvp_msg *)msg->data;
	message->kvp_hdr.operation = operation;
	message->kvp_hdr.pool = pool;
	in_msg = kvp_transaction.kvp_msg;

	/*
	 * The key/value strings sent from the host are encoded in
	 * in utf16; convert it to utf8 strings.
	 * The host assures us that the utf16 strings will not exceed
	 * the max lengths specified. We will however, reserve room
	 * for the string terminating character - in the utf16s_utf8s()
	 * function we limit the size of the buffer where the converted
	 * string is placed to HV_KVP_EXCHANGE_MAX_*_SIZE -1 to gaurantee
	 * that the strings can be properly terminated!
	 */

	switch (message->kvp_hdr.operation) {
	case KVP_OP_SET_IP_INFO:
		process_ib_ipinfo(in_msg, message, KVP_OP_SET_IP_INFO);
		break;
	case KVP_OP_GET_IP_INFO:
		process_ib_ipinfo(in_msg, message, KVP_OP_GET_IP_INFO);
		break;
	case KVP_OP_SET:
		switch (in_msg->body.kvp_set.data.value_type) {
		case REG_SZ:
			/*
			 * The value is a string - utf16 encoding.
			 */
			message->body.kvp_set.data.value_size =
				utf16s_to_utf8s(
				(wchar_t *)in_msg->body.kvp_set.data.value,
				in_msg->body.kvp_set.data.value_size,
				UTF16_LITTLE_ENDIAN,
				message->body.kvp_set.data.value,
				HV_KVP_EXCHANGE_MAX_VALUE_SIZE - 1) + 1;
				break;

		case REG_U32:
			/*
			 * The value is a 32 bit scalar.
			 * We save this as a utf8 string.
			 */
			val32 = in_msg->body.kvp_set.data.value_u32;
			message->body.kvp_set.data.value_size =
				sprintf(message->body.kvp_set.data.value,
					"%d", val32) + 1;
			break;

		case REG_U64:
			/*
			 * The value is a 64 bit scalar.
			 * We save this as a utf8 string.
			 */
			val64 = in_msg->body.kvp_set.data.value_u64;
			message->body.kvp_set.data.value_size =
				sprintf(message->body.kvp_set.data.value,
					"%llu", val64) + 1;
			break;

		}
	case KVP_OP_GET:
		message->body.kvp_set.data.key_size =
			utf16s_to_utf8s(
			(wchar_t *)in_msg->body.kvp_set.data.key,
			in_msg->body.kvp_set.data.key_size,
			UTF16_LITTLE_ENDIAN,
			message->body.kvp_set.data.key,
			HV_KVP_EXCHANGE_MAX_KEY_SIZE - 1) + 1;
			break;

	case KVP_OP_DELETE:
		message->body.kvp_delete.key_size =
			utf16s_to_utf8s(
			(wchar_t *)in_msg->body.kvp_delete.key,
			in_msg->body.kvp_delete.key_size,
			UTF16_LITTLE_ENDIAN,
			message->body.kvp_delete.key,
			HV_KVP_EXCHANGE_MAX_KEY_SIZE - 1) + 1;
			break;

	case KVP_OP_ENUMERATE:
		message->body.kvp_enum_data.index =
			in_msg->body.kvp_enum_data.index;
			break;
	}

	msg->len = sizeof(struct hv_kvp_msg);
	cn_netlink_send(msg, 0, GFP_ATOMIC);
	kfree(msg);

	return;
}

/*
 * Send a response back to the host.
 */

static void
kvp_respond_to_host(struct hv_kvp_msg *msg_to_host, int error)
{
	struct hv_kvp_msg  *kvp_msg;
	struct hv_kvp_exchg_msg_value  *kvp_data;
	char	*key_name;
	char	*value;
	struct icmsg_hdr *icmsghdrp;
	int	keylen = 0;
	int	valuelen = 0;
	u32	buf_len;
	struct vmbus_channel *channel;
	u64	req_id;
	int ret;

	/*
	 * If a transaction is not active; log and return.
	 */

	if (!kvp_transaction.active) {
		/*
		 * This is a spurious call!
		 */
		pr_warn("KVP: Transaction not active\n");
		return;
	}
	/*
	 * Copy the global state for completing the transaction. Note that
	 * only one transaction can be active at a time.
	 */

	buf_len = kvp_transaction.recv_len;
	channel = kvp_transaction.recv_channel;
	req_id = kvp_transaction.recv_req_id;

	kvp_transaction.active = false;

	icmsghdrp = (struct icmsg_hdr *)
			&recv_buffer[sizeof(struct vmbuspipe_hdr)];

	if (channel->onchannel_callback == NULL)
		/*
		 * We have raced with util driver being unloaded;
		 * silently return.
		 */
		return;

	icmsghdrp->status = error;

	/*
	 * If the error parameter is set, terminate the host's enumeration
	 * on this pool.
	 */
	if (error) {
		/*
		 * Something failed or we have timedout;
		 * terminate the current host-side iteration.
		 */
		goto response_done;
	}

	kvp_msg = (struct hv_kvp_msg *)
			&recv_buffer[sizeof(struct vmbuspipe_hdr) +
			sizeof(struct icmsg_hdr)];

	switch (kvp_transaction.kvp_msg->kvp_hdr.operation) {
	case KVP_OP_GET_IP_INFO:
		ret = process_ob_ipinfo(msg_to_host,
				 (struct hv_kvp_ip_msg *)kvp_msg,
				 KVP_OP_GET_IP_INFO);
		if (ret < 0)
			icmsghdrp->status = HV_E_FAIL;

		goto response_done;
	case KVP_OP_SET_IP_INFO:
		goto response_done;
	case KVP_OP_GET:
		kvp_data = &kvp_msg->body.kvp_get.data;
		goto copy_value;

	case KVP_OP_SET:
	case KVP_OP_DELETE:
		goto response_done;

	default:
		break;
	}

	kvp_data = &kvp_msg->body.kvp_enum_data.data;
	key_name = msg_to_host->body.kvp_enum_data.data.key;

	/*
	 * The windows host expects the key/value pair to be encoded
	 * in utf16. Ensure that the key/value size reported to the host
	 * will be less than or equal to the MAX size (including the
	 * terminating character).
	 */
	keylen = utf8s_to_utf16s(key_name, strlen(key_name), UTF16_HOST_ENDIAN,
				(wchar_t *) kvp_data->key,
				(HV_KVP_EXCHANGE_MAX_KEY_SIZE / 2) - 2);
	kvp_data->key_size = 2*(keylen + 1); /* utf16 encoding */

copy_value:
	value = msg_to_host->body.kvp_enum_data.data.value;
	valuelen = utf8s_to_utf16s(value, strlen(value), UTF16_HOST_ENDIAN,
				(wchar_t *) kvp_data->value,
				(HV_KVP_EXCHANGE_MAX_VALUE_SIZE / 2) - 2);
	kvp_data->value_size = 2*(valuelen + 1); /* utf16 encoding */

	/*
	 * If the utf8s to utf16s conversion failed; notify host
	 * of the error.
	 */
	if ((keylen < 0) || (valuelen < 0))
		icmsghdrp->status = HV_E_FAIL;

	kvp_data->value_type = REG_SZ; /* all our values are strings */

response_done:
	icmsghdrp->icflags = ICMSGHDRFLAG_TRANSACTION | ICMSGHDRFLAG_RESPONSE;

	vmbus_sendpacket(channel, recv_buffer, buf_len, req_id,
				VM_PKT_DATA_INBAND, 0);

}

/*
 * This callback is invoked when we get a KVP message from the host.
 * The host ensures that only one KVP transaction can be active at a time.
 * KVP implementation in Linux needs to forward the key to a user-mde
 * component to retrive the corresponding value. Consequently, we cannot
 * respond to the host in the conext of this callback. Since the host
 * guarantees that at most only one transaction can be active at a time,
 * we stash away the transaction state in a set of global variables.
 */

void hv_kvp_onchannelcallback(void *context)
{
	struct vmbus_channel *channel = context;
	u32 recvlen;
	u64 requestid;

	struct hv_kvp_msg *kvp_msg;

	struct icmsg_hdr *icmsghdrp;
	struct icmsg_negotiate *negop = NULL;

	if (kvp_transaction.active) {
		/*
		 * We will defer processing this callback once
		 * the current transaction is complete.
		 */
		kvp_transaction.kvp_context = context;
		return;
	}

	vmbus_recvpacket(channel, recv_buffer, PAGE_SIZE * 2, &recvlen,
			 &requestid);

	if (recvlen > 0) {
		icmsghdrp = (struct icmsg_hdr *)&recv_buffer[
			sizeof(struct vmbuspipe_hdr)];

		if (icmsghdrp->icmsgtype == ICMSGTYPE_NEGOTIATE) {
			/*
			 * We start with win8 version and if the host cannot
			 * support that we use the previous version.
			 */
			if (vmbus_prep_negotiate_resp(icmsghdrp, negop,
				 recv_buffer, UTIL_FW_MAJOR_MINOR,
				 WIN8_SRV_MAJOR_MINOR))
				goto done;

			vmbus_prep_negotiate_resp(icmsghdrp, negop,
				 recv_buffer, UTIL_FW_MAJOR_MINOR,
				 WIN7_SRV_MAJOR_MINOR);

		} else {
			kvp_msg = (struct hv_kvp_msg *)&recv_buffer[
				sizeof(struct vmbuspipe_hdr) +
				sizeof(struct icmsg_hdr)];

			/*
			 * Stash away this global state for completing the
			 * transaction; note transactions are serialized.
			 */

			kvp_transaction.recv_len = recvlen;
			kvp_transaction.recv_channel = channel;
			kvp_transaction.recv_req_id = requestid;
			kvp_transaction.active = true;
			kvp_transaction.kvp_msg = kvp_msg;

			/*
			 * Get the information from the
			 * user-mode component.
			 * component. This transaction will be
			 * completed when we get the value from
			 * the user-mode component.
			 * Set a timeout to deal with
			 * user-mode not responding.
			 */
			schedule_work(&kvp_sendkey_work);
			schedule_delayed_work(&kvp_work, 5*HZ);

			return;

		}
done:

		icmsghdrp->icflags = ICMSGHDRFLAG_TRANSACTION
			| ICMSGHDRFLAG_RESPONSE;

		vmbus_sendpacket(channel, recv_buffer,
				       recvlen, requestid,
				       VM_PKT_DATA_INBAND, 0);
	}

}

int
hv_kvp_init(struct hv_util_service *srv)
{
	int err;

	err = cn_add_callback(&kvp_id, kvp_name, kvp_cn_callback);
	if (err)
		return err;
	recv_buffer = srv->recv_buffer;

	/*
	 * When this driver loads, the user level daemon that
	 * processes the host requests may not yet be running.
	 * Defer processing channel callbacks until the daemon
	 * has registered.
	 */
	kvp_transaction.active = true;

	return 0;
}

void hv_kvp_deinit(void)
{
	cn_del_callback(&kvp_id);
	cancel_delayed_work_sync(&kvp_work);
	cancel_work_sync(&kvp_sendkey_work);
}
Commit	Line	Data
245ba56a KS	1	/*
	2	* An implementation of key value pair (KVP) functionality for Linux.
	3	*
	4	*
	5	* Copyright (C) 2010, Novell, Inc.
	6	* Author : K. Y. Srinivasan <[email protected]>
	7	*
	8	* This program is free software; you can redistribute it and/or modify it
	9	* under the terms of the GNU General Public License version 2 as published
	10	* by the Free Software Foundation.
	11	*
	12	* This program is distributed in the hope that it will be useful, but
	13	* WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
	15	* NON INFRINGEMENT. See the GNU General Public License for more
	16	* details.
	17	*
	18	* You should have received a copy of the GNU General Public License
	19	* along with this program; if not, write to the Free Software
	20	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	21	*
	22	*/
af7a5b6e	23	#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
245ba56a KS	24
	25	#include <linux/net.h>
	26	#include <linux/nls.h>
	27	#include <linux/connector.h>
	28	#include <linux/workqueue.h>
46a97191	29	#include <linux/hyperv.h>
245ba56a	30
245ba56a	31
6741335b S	32	/*
	33	* Pre win8 version numbers used in ws2008 and ws 2008 r2 (win7)
	34	*/
	35	#define WIN7_SRV_MAJOR 3
	36	#define WIN7_SRV_MINOR 0
	37	#define WIN7_SRV_MAJOR_MINOR (WIN7_SRV_MAJOR << 16 \| WIN7_SRV_MINOR)
	38
	39	#define WIN8_SRV_MAJOR 4
	40	#define WIN8_SRV_MINOR 0
	41	#define WIN8_SRV_MAJOR_MINOR (WIN8_SRV_MAJOR << 16 \| WIN8_SRV_MINOR)
245ba56a KS	42
	43	/*
	44	* Global state maintained for transaction that is being processed.
	45	* Note that only one transaction can be active at any point in time.
	46	*
	47	* This state is set when we receive a request from the host; we
	48	* cleanup this state when the transaction is completed - when we respond
	49	* to the host with the key value.
	50	*/
	51
	52	static struct {
	53	bool active; /* transaction status - active or not */
	54	int recv_len; /* number of bytes received. */
fa3d5b85	55	struct hv_kvp_msg kvp_msg; / current message */
245ba56a KS	56	struct vmbus_channel recv_channel; / chn we got the request */
245ba56a KS	57	u64 recv_req_id; /* request ID. */
fa3d5b85	58	void kvp_context; / for the channel callback */
245ba56a KS	59	} kvp_transaction;
245ba56a KS	60
b47a81dc S	61	/*
	62	* Before we can accept KVP messages from the host, we need
	63	* to handshake with the user level daemon. This state tracks
	64	* if we are in the handshake phase.
	65	*/
	66	static bool in_hand_shake = true;
	67
	68	/*
	69	* This state maintains the version number registered by the daemon.
	70	*/
	71	static int dm_reg_value;
	72
e2bb6537	73	static void kvp_send_key(struct work_struct *dummy);
245ba56a	74
76e5f813	75
03db7724	76	static void kvp_respond_to_host(struct hv_kvp_msg *msg, int error);
245ba56a	77	static void kvp_work_func(struct work_struct *dummy);
b47a81dc	78	static void kvp_register(int);
245ba56a KS	79
245ba56a KS	80	static DECLARE_DELAYED_WORK(kvp_work, kvp_work_func);
e2bb6537	81	static DECLARE_WORK(kvp_sendkey_work, kvp_send_key);
245ba56a KS	82
	83	static struct cb_id kvp_id = { CN_KVP_IDX, CN_KVP_VAL };
	84	static const char kvp_name[] = "kvp_kernel_module";
245ba56a KS	85	static u8 *recv_buffer;
	86	/*
	87	* Register the kernel component with the user-level daemon.
	88	* As part of this registration, pass the LIC version number.
cfc25993	89	* This number has no meaning, it satisfies the registration protocol.
245ba56a	90	*/
cfc25993	91	#define HV_DRV_VERSION "3.1"
245ba56a KS	92
245ba56a KS	93	static void
b47a81dc	94	kvp_register(int reg_value)
245ba56a KS	95	{
	96
	97	struct cn_msg *msg;
26403354 S	98	struct hv_kvp_msg *kvp_msg;
26403354 S	99	char *version;
245ba56a	100
26403354	101	msg = kzalloc(sizeof(*msg) + sizeof(struct hv_kvp_msg), GFP_ATOMIC);
245ba56a KS	102
245ba56a KS	103	if (msg) {
26403354	104	kvp_msg = (struct hv_kvp_msg *)msg->data;
e485ceac	105	version = kvp_msg->body.kvp_register.version;
245ba56a KS	106	msg->id.idx = CN_KVP_IDX;
245ba56a KS	107	msg->id.val = CN_KVP_VAL;
26403354	108
b47a81dc	109	kvp_msg->kvp_hdr.operation = reg_value;
26403354 S	110	strcpy(version, HV_DRV_VERSION);
26403354 S	111	msg->len = sizeof(struct hv_kvp_msg);
245ba56a KS	112	cn_netlink_send(msg, 0, GFP_ATOMIC);
	113	kfree(msg);
	114	}
	115	}
	116	static void
	117	kvp_work_func(struct work_struct *dummy)
	118	{
	119	/*
	120	* If the timer fires, the user-mode component has not responded;
	121	* process the pending transaction.
	122	*/
03db7724	123	kvp_respond_to_host(NULL, HV_E_FAIL);
b47a81dc S	124	}
	125
	126	static int kvp_handle_handshake(struct hv_kvp_msg *msg)
	127	{
	128	int ret = 1;
	129
	130	switch (msg->kvp_hdr.operation) {
	131	case KVP_OP_REGISTER:
	132	dm_reg_value = KVP_OP_REGISTER;
	133	pr_info("KVP: IP injection functionality not available\n");
	134	pr_info("KVP: Upgrade the KVP daemon\n");
	135	break;
	136	case KVP_OP_REGISTER1:
	137	dm_reg_value = KVP_OP_REGISTER1;
	138	break;
	139	default:
	140	pr_info("KVP: incompatible daemon\n");
	141	pr_info("KVP: KVP version: %d, Daemon version: %d\n",
	142	KVP_OP_REGISTER1, msg->kvp_hdr.operation);
	143	ret = 0;
	144	}
	145
	146	if (ret) {
	147	/*
	148	* We have a compatible daemon; complete the handshake.
	149	*/
	150	pr_info("KVP: user-mode registering done.\n");
	151	kvp_register(dm_reg_value);
	152	kvp_transaction.active = false;
	153	if (kvp_transaction.kvp_context)
	154	hv_kvp_onchannelcallback(kvp_transaction.kvp_context);
	155	}
	156	return ret;
245ba56a KS	157	}
245ba56a KS	158
b47a81dc	159
245ba56a KS	160	/*
	161	* Callback when data is received from user mode.
	162	*/
	163
	164	static void
	165	kvp_cn_callback(struct cn_msg msg, struct netlink_skb_parms nsp)
	166	{
26403354 S	167	struct hv_kvp_msg *message;
26403354 S	168	struct hv_kvp_msg_enumerate *data;
b47a81dc	169	int error = 0;
245ba56a	170
26403354	171	message = (struct hv_kvp_msg *)msg->data;
b47a81dc S	172
	173	/*
	174	* If we are negotiating the version information
	175	* with the daemon; handle that first.
	176	*/
	177
	178	if (in_hand_shake) {
	179	if (kvp_handle_handshake(message))
	180	in_hand_shake = false;
	181	return;
	182	}
	183
	184	/*
	185	* Based on the version of the daemon, we propagate errors from the
	186	* daemon differently.
	187	*/
	188
	189	data = &message->body.kvp_enum_data;
	190
	191	switch (dm_reg_value) {
fa3d5b85	192	case KVP_OP_REGISTER:
b47a81dc S	193	/*
	194	* Null string is used to pass back error condition.
	195	*/
	196	if (data->data.key[0] == 0)
	197	error = HV_S_CONT;
fa3d5b85	198	break;
245ba56a	199
b47a81dc	200	case KVP_OP_REGISTER1:
245ba56a	201	/*
b47a81dc S	202	* We use the message header information from
b47a81dc S	203	* the user level daemon to transmit errors.
245ba56a	204	*/
b47a81dc S	205	error = message->error;
b47a81dc S	206	break;
245ba56a	207	}
b47a81dc S	208
	209	/*
	210	* Complete the transaction by forwarding the key value
	211	* to the host. But first, cancel the timeout.
	212	*/
	213	if (cancel_delayed_work_sync(&kvp_work))
03db7724	214	kvp_respond_to_host(message, error);
245ba56a KS	215	}
245ba56a KS	216
03db7724 S	217
	218	static int process_ob_ipinfo(void in_msg, void out_msg, int op)
	219	{
	220	struct hv_kvp_msg *in = in_msg;
	221	struct hv_kvp_ip_msg *out = out_msg;
	222	int len;
	223
	224	switch (op) {
	225	case KVP_OP_GET_IP_INFO:
	226	/*
	227	* Transform all parameters into utf16 encoding.
	228	*/
	229	len = utf8s_to_utf16s((char *)in->body.kvp_ip_val.ip_addr,
	230	strlen((char *)in->body.kvp_ip_val.ip_addr),
	231	UTF16_HOST_ENDIAN,
	232	(wchar_t *)out->kvp_ip_val.ip_addr,
	233	MAX_IP_ADDR_SIZE);
	234	if (len < 0)
	235	return len;
	236
	237	len = utf8s_to_utf16s((char *)in->body.kvp_ip_val.sub_net,
	238	strlen((char *)in->body.kvp_ip_val.sub_net),
	239	UTF16_HOST_ENDIAN,
	240	(wchar_t *)out->kvp_ip_val.sub_net,
	241	MAX_IP_ADDR_SIZE);
	242	if (len < 0)
	243	return len;
	244
	245	len = utf8s_to_utf16s((char *)in->body.kvp_ip_val.gate_way,
	246	strlen((char *)in->body.kvp_ip_val.gate_way),
	247	UTF16_HOST_ENDIAN,
	248	(wchar_t *)out->kvp_ip_val.gate_way,
	249	MAX_GATEWAY_SIZE);
	250	if (len < 0)
	251	return len;
	252
	253	len = utf8s_to_utf16s((char *)in->body.kvp_ip_val.dns_addr,
	254	strlen((char *)in->body.kvp_ip_val.dns_addr),
	255	UTF16_HOST_ENDIAN,
	256	(wchar_t *)out->kvp_ip_val.dns_addr,
	257	MAX_IP_ADDR_SIZE);
	258	if (len < 0)
	259	return len;
	260
	261	len = utf8s_to_utf16s((char *)in->body.kvp_ip_val.adapter_id,
	262	strlen((char *)in->body.kvp_ip_val.adapter_id),
	263	UTF16_HOST_ENDIAN,
	264	(wchar_t *)out->kvp_ip_val.adapter_id,
	265	MAX_IP_ADDR_SIZE);
	266	if (len < 0)
	267	return len;
	268
	269	out->kvp_ip_val.dhcp_enabled =
	270	in->body.kvp_ip_val.dhcp_enabled;
a500e0e7 S	271	out->kvp_ip_val.addr_family =
a500e0e7 S	272	in->body.kvp_ip_val.addr_family;
03db7724 S	273	}
	274
	275	return 0;
	276	}
	277
	278	static void process_ib_ipinfo(void in_msg, void out_msg, int op)
	279	{
	280	struct hv_kvp_ip_msg *in = in_msg;
	281	struct hv_kvp_msg *out = out_msg;
	282
	283	switch (op) {
	284	case KVP_OP_SET_IP_INFO:
	285	/*
	286	* Transform all parameters into utf8 encoding.
	287	*/
	288	utf16s_to_utf8s((wchar_t *)in->kvp_ip_val.ip_addr,
	289	MAX_IP_ADDR_SIZE,
	290	UTF16_LITTLE_ENDIAN,
	291	(__u8 *)out->body.kvp_ip_val.ip_addr,
	292	MAX_IP_ADDR_SIZE);
	293
	294	utf16s_to_utf8s((wchar_t *)in->kvp_ip_val.sub_net,
	295	MAX_IP_ADDR_SIZE,
	296	UTF16_LITTLE_ENDIAN,
	297	(__u8 *)out->body.kvp_ip_val.sub_net,
	298	MAX_IP_ADDR_SIZE);
	299
	300	utf16s_to_utf8s((wchar_t *)in->kvp_ip_val.gate_way,
	301	MAX_GATEWAY_SIZE,
	302	UTF16_LITTLE_ENDIAN,
	303	(__u8 *)out->body.kvp_ip_val.gate_way,
	304	MAX_GATEWAY_SIZE);
	305
	306	utf16s_to_utf8s((wchar_t *)in->kvp_ip_val.dns_addr,
	307	MAX_IP_ADDR_SIZE,
	308	UTF16_LITTLE_ENDIAN,
	309	(__u8 *)out->body.kvp_ip_val.dns_addr,
	310	MAX_IP_ADDR_SIZE);
	311
	312	out->body.kvp_ip_val.dhcp_enabled = in->kvp_ip_val.dhcp_enabled;
	313
	314	default:
	315	utf16s_to_utf8s((wchar_t *)in->kvp_ip_val.adapter_id,
	316	MAX_ADAPTER_ID_SIZE,
	317	UTF16_LITTLE_ENDIAN,
	318	(__u8 *)out->body.kvp_ip_val.adapter_id,
	319	MAX_ADAPTER_ID_SIZE);
	320
	321	out->body.kvp_ip_val.addr_family = in->kvp_ip_val.addr_family;
	322	}
	323	}
	324
	325
	326
	327
e2bb6537 S	328	static void
e2bb6537 S	329	kvp_send_key(struct work_struct *dummy)
245ba56a KS	330	{
245ba56a KS	331	struct cn_msg *msg;
26403354	332	struct hv_kvp_msg *message;
fa3d5b85 S	333	struct hv_kvp_msg *in_msg;
	334	__u8 operation = kvp_transaction.kvp_msg->kvp_hdr.operation;
	335	__u8 pool = kvp_transaction.kvp_msg->kvp_hdr.pool;
	336	__u32 val32;
	337	__u64 val64;
245ba56a KS	338
245ba56a KS	339	msg = kzalloc(sizeof(*msg) + sizeof(struct hv_kvp_msg) , GFP_ATOMIC);
fa3d5b85 S	340	if (!msg)
fa3d5b85 S	341	return;
245ba56a	342
fa3d5b85 S	343	msg->id.idx = CN_KVP_IDX;
fa3d5b85 S	344	msg->id.val = CN_KVP_VAL;
26403354	345
fa3d5b85 S	346	message = (struct hv_kvp_msg *)msg->data;
	347	message->kvp_hdr.operation = operation;
	348	message->kvp_hdr.pool = pool;
	349	in_msg = kvp_transaction.kvp_msg;
	350
	351	/*
	352	* The key/value strings sent from the host are encoded in
	353	* in utf16; convert it to utf8 strings.
	354	* The host assures us that the utf16 strings will not exceed
	355	* the max lengths specified. We will however, reserve room
	356	* for the string terminating character - in the utf16s_utf8s()
	357	* function we limit the size of the buffer where the converted
	358	* string is placed to HV_KVP_EXCHANGE_MAX_*_SIZE -1 to gaurantee
	359	* that the strings can be properly terminated!
	360	*/
	361
	362	switch (message->kvp_hdr.operation) {
03db7724 S	363	case KVP_OP_SET_IP_INFO:
	364	process_ib_ipinfo(in_msg, message, KVP_OP_SET_IP_INFO);
	365	break;
	366	case KVP_OP_GET_IP_INFO:
	367	process_ib_ipinfo(in_msg, message, KVP_OP_GET_IP_INFO);
	368	break;
fa3d5b85 S	369	case KVP_OP_SET:
	370	switch (in_msg->body.kvp_set.data.value_type) {
	371	case REG_SZ:
	372	/*
	373	* The value is a string - utf16 encoding.
	374	*/
	375	message->body.kvp_set.data.value_size =
	376	utf16s_to_utf8s(
	377	(wchar_t *)in_msg->body.kvp_set.data.value,
	378	in_msg->body.kvp_set.data.value_size,
	379	UTF16_LITTLE_ENDIAN,
	380	message->body.kvp_set.data.value,
	381	HV_KVP_EXCHANGE_MAX_VALUE_SIZE - 1) + 1;
	382	break;
	383
	384	case REG_U32:
	385	/*
	386	* The value is a 32 bit scalar.
	387	* We save this as a utf8 string.
	388	*/
	389	val32 = in_msg->body.kvp_set.data.value_u32;
	390	message->body.kvp_set.data.value_size =
	391	sprintf(message->body.kvp_set.data.value,
	392	"%d", val32) + 1;
	393	break;
	394
	395	case REG_U64:
	396	/*
	397	* The value is a 64 bit scalar.
	398	* We save this as a utf8 string.
	399	*/
	400	val64 = in_msg->body.kvp_set.data.value_u64;
	401	message->body.kvp_set.data.value_size =
	402	sprintf(message->body.kvp_set.data.value,
	403	"%llu", val64) + 1;
	404	break;
	405
	406	}
	407	case KVP_OP_GET:
	408	message->body.kvp_set.data.key_size =
	409	utf16s_to_utf8s(
	410	(wchar_t *)in_msg->body.kvp_set.data.key,
	411	in_msg->body.kvp_set.data.key_size,
	412	UTF16_LITTLE_ENDIAN,
	413	message->body.kvp_set.data.key,
	414	HV_KVP_EXCHANGE_MAX_KEY_SIZE - 1) + 1;
	415	break;
	416
	417	case KVP_OP_DELETE:
	418	message->body.kvp_delete.key_size =
	419	utf16s_to_utf8s(
	420	(wchar_t *)in_msg->body.kvp_delete.key,
	421	in_msg->body.kvp_delete.key_size,
	422	UTF16_LITTLE_ENDIAN,
	423	message->body.kvp_delete.key,
	424	HV_KVP_EXCHANGE_MAX_KEY_SIZE - 1) + 1;
	425	break;
	426
	427	case KVP_OP_ENUMERATE:
	428	message->body.kvp_enum_data.index =
	429	in_msg->body.kvp_enum_data.index;
	430	break;
245ba56a	431	}
fa3d5b85 S	432
	433	msg->len = sizeof(struct hv_kvp_msg);
	434	cn_netlink_send(msg, 0, GFP_ATOMIC);
	435	kfree(msg);
	436
e2bb6537	437	return;
245ba56a KS	438	}
	439
	440	/*
	441	* Send a response back to the host.
	442	*/
	443
	444	static void
03db7724	445	kvp_respond_to_host(struct hv_kvp_msg *msg_to_host, int error)
245ba56a KS	446	{
245ba56a KS	447	struct hv_kvp_msg *kvp_msg;
fa3d5b85	448	struct hv_kvp_exchg_msg_value *kvp_data;
245ba56a	449	char *key_name;
03db7724	450	char *value;
245ba56a	451	struct icmsg_hdr *icmsghdrp;
fa3d5b85 S	452	int keylen = 0;
fa3d5b85 S	453	int valuelen = 0;
245ba56a KS	454	u32 buf_len;
	455	struct vmbus_channel *channel;
	456	u64 req_id;
03db7724	457	int ret;
245ba56a KS	458
	459	/*
	460	* If a transaction is not active; log and return.
	461	*/
	462
	463	if (!kvp_transaction.active) {
	464	/*
	465	* This is a spurious call!
	466	*/
af7a5b6e	467	pr_warn("KVP: Transaction not active\n");
245ba56a KS	468	return;
	469	}
	470	/*
	471	* Copy the global state for completing the transaction. Note that
	472	* only one transaction can be active at a time.
	473	*/
	474
	475	buf_len = kvp_transaction.recv_len;
	476	channel = kvp_transaction.recv_channel;
	477	req_id = kvp_transaction.recv_req_id;
	478
76e5f813 S	479	kvp_transaction.active = false;
76e5f813 S	480
fa3d5b85 S	481	icmsghdrp = (struct icmsg_hdr *)
	482	&recv_buffer[sizeof(struct vmbuspipe_hdr)];
	483
4e65f6e8 S	484	if (channel->onchannel_callback == NULL)
	485	/*
	486	* We have raced with util driver being unloaded;
	487	* silently return.
	488	*/
	489	return;
	490
b47a81dc	491	icmsghdrp->status = error;
245ba56a KS	492
245ba56a KS	493	/*
adc80ae6 S	494	* If the error parameter is set, terminate the host's enumeration
adc80ae6 S	495	* on this pool.
245ba56a KS	496	*/
	497	if (error) {
	498	/*
b47a81dc S	499	* Something failed or we have timedout;
b47a81dc S	500	* terminate the current host-side iteration.
245ba56a	501	*/
245ba56a KS	502	goto response_done;
	503	}
	504
fa3d5b85 S	505	kvp_msg = (struct hv_kvp_msg *)
	506	&recv_buffer[sizeof(struct vmbuspipe_hdr) +
	507	sizeof(struct icmsg_hdr)];
	508
	509	switch (kvp_transaction.kvp_msg->kvp_hdr.operation) {
03db7724 S	510	case KVP_OP_GET_IP_INFO:
	511	ret = process_ob_ipinfo(msg_to_host,
	512	(struct hv_kvp_ip_msg *)kvp_msg,
	513	KVP_OP_GET_IP_INFO);
	514	if (ret < 0)
	515	icmsghdrp->status = HV_E_FAIL;
	516
	517	goto response_done;
	518	case KVP_OP_SET_IP_INFO:
	519	goto response_done;
fa3d5b85 S	520	case KVP_OP_GET:
	521	kvp_data = &kvp_msg->body.kvp_get.data;
	522	goto copy_value;
	523
	524	case KVP_OP_SET:
	525	case KVP_OP_DELETE:
	526	goto response_done;
	527
	528	default:
	529	break;
	530	}
	531
	532	kvp_data = &kvp_msg->body.kvp_enum_data.data;
03db7724	533	key_name = msg_to_host->body.kvp_enum_data.data.key;
fa3d5b85	534
245ba56a KS	535	/*
245ba56a KS	536	* The windows host expects the key/value pair to be encoded
fa3d5b85 S	537	* in utf16. Ensure that the key/value size reported to the host
	538	* will be less than or equal to the MAX size (including the
	539	* terminating character).
245ba56a	540	*/
0720a06a	541	keylen = utf8s_to_utf16s(key_name, strlen(key_name), UTF16_HOST_ENDIAN,
fa3d5b85 S	542	(wchar_t *) kvp_data->key,
	543	(HV_KVP_EXCHANGE_MAX_KEY_SIZE / 2) - 2);
	544	kvp_data->key_size = 2(keylen + 1); / utf16 encoding */
	545
	546	copy_value:
03db7724	547	value = msg_to_host->body.kvp_enum_data.data.value;
0720a06a	548	valuelen = utf8s_to_utf16s(value, strlen(value), UTF16_HOST_ENDIAN,
fa3d5b85 S	549	(wchar_t *) kvp_data->value,
	550	(HV_KVP_EXCHANGE_MAX_VALUE_SIZE / 2) - 2);
	551	kvp_data->value_size = 2(valuelen + 1); / utf16 encoding */
245ba56a	552
fa3d5b85 S	553	/*
	554	* If the utf8s to utf16s conversion failed; notify host
	555	* of the error.
	556	*/
	557	if ((keylen < 0) \|\| (valuelen < 0))
	558	icmsghdrp->status = HV_E_FAIL;
	559
	560	kvp_data->value_type = REG_SZ; /* all our values are strings */
245ba56a KS	561
	562	response_done:
	563	icmsghdrp->icflags = ICMSGHDRFLAG_TRANSACTION \| ICMSGHDRFLAG_RESPONSE;
	564
	565	vmbus_sendpacket(channel, recv_buffer, buf_len, req_id,
415f2287	566	VM_PKT_DATA_INBAND, 0);
245ba56a	567
245ba56a KS	568	}
	569
	570	/*
	571	* This callback is invoked when we get a KVP message from the host.
	572	* The host ensures that only one KVP transaction can be active at a time.
	573	* KVP implementation in Linux needs to forward the key to a user-mde
	574	* component to retrive the corresponding value. Consequently, we cannot
	575	* respond to the host in the conext of this callback. Since the host
	576	* guarantees that at most only one transaction can be active at a time,
	577	* we stash away the transaction state in a set of global variables.
	578	*/
	579
	580	void hv_kvp_onchannelcallback(void *context)
	581	{
	582	struct vmbus_channel *channel = context;
	583	u32 recvlen;
	584	u64 requestid;
	585
	586	struct hv_kvp_msg *kvp_msg;
245ba56a KS	587
	588	struct icmsg_hdr *icmsghdrp;
	589	struct icmsg_negotiate *negop = NULL;
	590
fa3d5b85 S	591	if (kvp_transaction.active) {
	592	/*
	593	* We will defer processing this callback once
	594	* the current transaction is complete.
	595	*/
	596	kvp_transaction.kvp_context = context;
	597	return;
	598	}
245ba56a	599
03db7724 S	600	vmbus_recvpacket(channel, recv_buffer, PAGE_SIZE * 2, &recvlen,
03db7724 S	601	&requestid);
245ba56a KS	602
245ba56a KS	603	if (recvlen > 0) {
245ba56a KS	604	icmsghdrp = (struct icmsg_hdr *)&recv_buffer[
	605	sizeof(struct vmbuspipe_hdr)];
	606
	607	if (icmsghdrp->icmsgtype == ICMSGTYPE_NEGOTIATE) {
6741335b S	608	/*
	609	* We start with win8 version and if the host cannot
	610	* support that we use the previous version.
	611	*/
	612	if (vmbus_prep_negotiate_resp(icmsghdrp, negop,
	613	recv_buffer, UTIL_FW_MAJOR_MINOR,
	614	WIN8_SRV_MAJOR_MINOR))
	615	goto done;
	616
c836d0ab	617	vmbus_prep_negotiate_resp(icmsghdrp, negop,
6741335b S	618	recv_buffer, UTIL_FW_MAJOR_MINOR,
	619	WIN7_SRV_MAJOR_MINOR);
	620
245ba56a KS	621	} else {
	622	kvp_msg = (struct hv_kvp_msg *)&recv_buffer[
	623	sizeof(struct vmbuspipe_hdr) +
	624	sizeof(struct icmsg_hdr)];
	625
245ba56a KS	626	/*
	627	* Stash away this global state for completing the
	628	* transaction; note transactions are serialized.
	629	*/
fa3d5b85	630
245ba56a KS	631	kvp_transaction.recv_len = recvlen;
	632	kvp_transaction.recv_channel = channel;
	633	kvp_transaction.recv_req_id = requestid;
	634	kvp_transaction.active = true;
fa3d5b85	635	kvp_transaction.kvp_msg = kvp_msg;
245ba56a KS	636
	637	/*
	638	* Get the information from the
	639	* user-mode component.
	640	* component. This transaction will be
	641	* completed when we get the value from
	642	* the user-mode component.
	643	* Set a timeout to deal with
	644	* user-mode not responding.
	645	*/
e2bb6537 S	646	schedule_work(&kvp_sendkey_work);
e2bb6537 S	647	schedule_delayed_work(&kvp_work, 5*HZ);
245ba56a KS	648
	649	return;
	650
	651	}
6741335b	652	done:
245ba56a	653
245ba56a KS	654	icmsghdrp->icflags = ICMSGHDRFLAG_TRANSACTION
	655	\| ICMSGHDRFLAG_RESPONSE;
	656
	657	vmbus_sendpacket(channel, recv_buffer,
	658	recvlen, requestid,
415f2287	659	VM_PKT_DATA_INBAND, 0);
245ba56a KS	660	}
	661
	662	}
	663
	664	int
a29b643c	665	hv_kvp_init(struct hv_util_service *srv)
245ba56a KS	666	{
	667	int err;
	668
	669	err = cn_add_callback(&kvp_id, kvp_name, kvp_cn_callback);
	670	if (err)
	671	return err;
a29b643c	672	recv_buffer = srv->recv_buffer;
245ba56a	673
fa3d5b85 S	674	/*
	675	* When this driver loads, the user level daemon that
	676	* processes the host requests may not yet be running.
	677	* Defer processing channel callbacks until the daemon
	678	* has registered.
	679	*/
	680	kvp_transaction.active = true;
	681
245ba56a KS	682	return 0;
	683	}
	684
	685	void hv_kvp_deinit(void)
	686	{
	687	cn_del_callback(&kvp_id);
	688	cancel_delayed_work_sync(&kvp_work);
e2bb6537	689	cancel_work_sync(&kvp_sendkey_work);
245ba56a	690	}