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