drivers/hv/hv_kvp.c

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