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