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