hv_kvp.c revision 282212
1/*- 2 * Copyright (c) 2014 Microsoft Corp. 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice unmodified, this list of conditions, and the following 10 * disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 18 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 20 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 21 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 22 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 24 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 25 */ 26 27/* 28 * Author: Sainath Varanasi. 29 * Date: 4/2012 30 * Email: bsdic@microsoft.com 31 */ 32 33#include <sys/cdefs.h> 34__FBSDID("$FreeBSD: head/sys/dev/hyperv/utilities/hv_kvp.c 282212 2015-04-29 10:12:34Z whu $"); 35 36#include <sys/param.h> 37#include <sys/kernel.h> 38#include <sys/conf.h> 39#include <sys/uio.h> 40#include <sys/bus.h> 41#include <sys/malloc.h> 42#include <sys/mbuf.h> 43#include <sys/module.h> 44#include <sys/reboot.h> 45#include <sys/lock.h> 46#include <sys/taskqueue.h> 47#include <sys/sysctl.h> 48#include <sys/poll.h> 49#include <sys/proc.h> 50#include <sys/kthread.h> 51#include <sys/syscallsubr.h> 52#include <sys/sysproto.h> 53#include <sys/un.h> 54#include <sys/endian.h> 55#include <sys/_null.h> 56#include <sys/signal.h> 57#include <sys/syslog.h> 58#include <sys/systm.h> 59#include <sys/mutex.h> 60#include <net/if_arp.h> 61 62#include <dev/hyperv/include/hyperv.h> 63#include <dev/hyperv/netvsc/hv_net_vsc.h> 64 65#include "unicode.h" 66#include "hv_kvp.h" 67 68/* hv_kvp defines */ 69#define BUFFERSIZE sizeof(struct hv_kvp_msg) 70#define KVP_SUCCESS 0 71#define KVP_ERROR 1 72#define kvp_hdr hdr.kvp_hdr 73 74/* hv_kvp debug control */ 75static int hv_kvp_log = 0; 76SYSCTL_INT(_dev, OID_AUTO, hv_kvp_log, CTLFLAG_RW, &hv_kvp_log, 0, 77 "hv_kvp log"); 78 79#define hv_kvp_log_error(...) do { \ 80 if (hv_kvp_log > 0) \ 81 log(LOG_ERR, "hv_kvp: " __VA_ARGS__); \ 82} while (0) 83 84#define hv_kvp_log_info(...) do { \ 85 if (hv_kvp_log > 1) \ 86 log(LOG_INFO, "hv_kvp: " __VA_ARGS__); \ 87} while (0) 88 89/* character device prototypes */ 90static d_open_t hv_kvp_dev_open; 91static d_close_t hv_kvp_dev_close; 92static d_read_t hv_kvp_dev_daemon_read; 93static d_write_t hv_kvp_dev_daemon_write; 94static d_poll_t hv_kvp_dev_daemon_poll; 95 96/* hv_kvp prototypes */ 97static int hv_kvp_req_in_progress(void); 98static void hv_kvp_transaction_init(uint32_t, hv_vmbus_channel *, uint64_t, uint8_t *); 99static void hv_kvp_send_msg_to_daemon(void); 100static void hv_kvp_process_request(void *context); 101 102/* hv_kvp character device structure */ 103static struct cdevsw hv_kvp_cdevsw = 104{ 105 .d_version = D_VERSION, 106 .d_open = hv_kvp_dev_open, 107 .d_close = hv_kvp_dev_close, 108 .d_read = hv_kvp_dev_daemon_read, 109 .d_write = hv_kvp_dev_daemon_write, 110 .d_poll = hv_kvp_dev_daemon_poll, 111 .d_name = "hv_kvp_dev", 112}; 113static struct cdev *hv_kvp_dev; 114static struct hv_kvp_msg *hv_kvp_dev_buf; 115struct proc *daemon_task; 116 117/* 118 * Global state to track and synchronize multiple 119 * KVP transaction requests from the host. 120 */ 121static struct { 122 123 /* Pre-allocated work item for queue */ 124 hv_work_item work_item; 125 126 /* Unless specified the pending mutex should be 127 * used to alter the values of the following paramters: 128 * 1. req_in_progress 129 * 2. req_timed_out 130 * 3. pending_reqs. 131 */ 132 struct mtx pending_mutex; 133 134 /* To track if transaction is active or not */ 135 boolean_t req_in_progress; 136 /* Tracks if daemon did not reply back in time */ 137 boolean_t req_timed_out; 138 /* Tracks if daemon is serving a request currently */ 139 boolean_t daemon_busy; 140 /* Count of KVP requests from Hyper-V. */ 141 uint64_t pending_reqs; 142 143 144 /* Length of host message */ 145 uint32_t host_msg_len; 146 147 /* Pointer to channel */ 148 hv_vmbus_channel *channelp; 149 150 /* Host message id */ 151 uint64_t host_msg_id; 152 153 /* Current kvp message from the host */ 154 struct hv_kvp_msg *host_kvp_msg; 155 156 /* Current kvp message for daemon */ 157 struct hv_kvp_msg daemon_kvp_msg; 158 159 /* Rcv buffer for communicating with the host*/ 160 uint8_t *rcv_buf; 161 162 /* Device semaphore to control communication */ 163 struct sema dev_sema; 164 165 /* Indicates if daemon registered with driver */ 166 boolean_t register_done; 167 168 /* Character device status */ 169 boolean_t dev_accessed; 170} kvp_globals; 171 172/* global vars */ 173MALLOC_DECLARE(M_HV_KVP_DEV_BUF); 174MALLOC_DEFINE(M_HV_KVP_DEV_BUF, "hv_kvp_dev buffer", "buffer for hv_kvp_dev module"); 175 176/* 177 * hv_kvp low level functions 178 */ 179 180/* 181 * Check if kvp transaction is in progres 182 */ 183static int 184hv_kvp_req_in_progress(void) 185{ 186 187 return (kvp_globals.req_in_progress); 188} 189 190 191/* 192 * This routine is called whenever a message is received from the host 193 */ 194static void 195hv_kvp_transaction_init(uint32_t rcv_len, hv_vmbus_channel *rcv_channel, 196 uint64_t request_id, uint8_t *rcv_buf) 197{ 198 199 /* Store all the relevant message details in the global structure */ 200 /* Do not need to use mutex for req_in_progress here */ 201 kvp_globals.req_in_progress = true; 202 kvp_globals.host_msg_len = rcv_len; 203 kvp_globals.channelp = rcv_channel; 204 kvp_globals.host_msg_id = request_id; 205 kvp_globals.rcv_buf = rcv_buf; 206 kvp_globals.host_kvp_msg = (struct hv_kvp_msg *)&rcv_buf[ 207 sizeof(struct hv_vmbus_pipe_hdr) + 208 sizeof(struct hv_vmbus_icmsg_hdr)]; 209} 210 211 212/* 213 * hv_kvp - version neogtiation function 214 */ 215static void 216hv_kvp_negotiate_version(struct hv_vmbus_icmsg_hdr *icmsghdrp, 217 struct hv_vmbus_icmsg_negotiate *negop, 218 uint8_t *buf) 219{ 220 int icframe_vercnt; 221 int icmsg_vercnt; 222 223 icmsghdrp->icmsgsize = 0x10; 224 225 negop = (struct hv_vmbus_icmsg_negotiate *)&buf[ 226 sizeof(struct hv_vmbus_pipe_hdr) + 227 sizeof(struct hv_vmbus_icmsg_hdr)]; 228 icframe_vercnt = negop->icframe_vercnt; 229 icmsg_vercnt = negop->icmsg_vercnt; 230 231 /* 232 * Select the framework version number we will support 233 */ 234 if ((icframe_vercnt >= 2) && (negop->icversion_data[1].major == 3)) { 235 icframe_vercnt = 3; 236 if (icmsg_vercnt > 2) 237 icmsg_vercnt = 4; 238 else 239 icmsg_vercnt = 3; 240 } else { 241 icframe_vercnt = 1; 242 icmsg_vercnt = 1; 243 } 244 245 negop->icframe_vercnt = 1; 246 negop->icmsg_vercnt = 1; 247 negop->icversion_data[0].major = icframe_vercnt; 248 negop->icversion_data[0].minor = 0; 249 negop->icversion_data[1].major = icmsg_vercnt; 250 negop->icversion_data[1].minor = 0; 251} 252 253 254/* 255 * Convert ip related info in umsg from utf8 to utf16 and store in hmsg 256 */ 257static int 258hv_kvp_convert_utf8_ipinfo_to_utf16(struct hv_kvp_msg *umsg, 259 struct hv_kvp_ip_msg *host_ip_msg) 260{ 261 int err_ip, err_subnet, err_gway, err_dns, err_adap; 262 int UNUSED_FLAG = 1; 263 264 utf8_to_utf16((uint16_t *)host_ip_msg->kvp_ip_val.ip_addr, 265 MAX_IP_ADDR_SIZE, 266 (char *)umsg->body.kvp_ip_val.ip_addr, 267 strlen((char *)umsg->body.kvp_ip_val.ip_addr), 268 UNUSED_FLAG, 269 &err_ip); 270 utf8_to_utf16((uint16_t *)host_ip_msg->kvp_ip_val.sub_net, 271 MAX_IP_ADDR_SIZE, 272 (char *)umsg->body.kvp_ip_val.sub_net, 273 strlen((char *)umsg->body.kvp_ip_val.sub_net), 274 UNUSED_FLAG, 275 &err_subnet); 276 utf8_to_utf16((uint16_t *)host_ip_msg->kvp_ip_val.gate_way, 277 MAX_GATEWAY_SIZE, 278 (char *)umsg->body.kvp_ip_val.gate_way, 279 strlen((char *)umsg->body.kvp_ip_val.gate_way), 280 UNUSED_FLAG, 281 &err_gway); 282 utf8_to_utf16((uint16_t *)host_ip_msg->kvp_ip_val.dns_addr, 283 MAX_IP_ADDR_SIZE, 284 (char *)umsg->body.kvp_ip_val.dns_addr, 285 strlen((char *)umsg->body.kvp_ip_val.dns_addr), 286 UNUSED_FLAG, 287 &err_dns); 288 utf8_to_utf16((uint16_t *)host_ip_msg->kvp_ip_val.adapter_id, 289 MAX_IP_ADDR_SIZE, 290 (char *)umsg->body.kvp_ip_val.adapter_id, 291 strlen((char *)umsg->body.kvp_ip_val.adapter_id), 292 UNUSED_FLAG, 293 &err_adap); 294 295 host_ip_msg->kvp_ip_val.dhcp_enabled = umsg->body.kvp_ip_val.dhcp_enabled; 296 host_ip_msg->kvp_ip_val.addr_family = umsg->body.kvp_ip_val.addr_family; 297 298 return (err_ip | err_subnet | err_gway | err_dns | err_adap); 299} 300 301 302/* 303 * Convert ip related info in hmsg from utf16 to utf8 and store in umsg 304 */ 305static int 306hv_kvp_convert_utf16_ipinfo_to_utf8(struct hv_kvp_ip_msg *host_ip_msg, 307 struct hv_kvp_msg *umsg) 308{ 309 int err_ip, err_subnet, err_gway, err_dns, err_adap; 310 int UNUSED_FLAG = 1; 311 int guid_index; 312 struct hv_device *hv_dev; /* GUID Data Structure */ 313 hn_softc_t *sc; /* hn softc structure */ 314 char if_name[4]; 315 unsigned char guid_instance[40]; 316 char *guid_data = NULL; 317 char buf[39]; 318 319 struct guid_extract { 320 char a1[2]; 321 char a2[2]; 322 char a3[2]; 323 char a4[2]; 324 char b1[2]; 325 char b2[2]; 326 char c1[2]; 327 char c2[2]; 328 char d[4]; 329 char e[12]; 330 }; 331 332 struct guid_extract *id; 333 device_t *devs; 334 int devcnt; 335 336 /* IP Address */ 337 utf16_to_utf8((char *)umsg->body.kvp_ip_val.ip_addr, 338 MAX_IP_ADDR_SIZE, 339 (uint16_t *)host_ip_msg->kvp_ip_val.ip_addr, 340 MAX_IP_ADDR_SIZE, 341 UNUSED_FLAG, 342 &err_ip); 343 344 /* Adapter ID : GUID */ 345 utf16_to_utf8((char *)umsg->body.kvp_ip_val.adapter_id, 346 MAX_ADAPTER_ID_SIZE, 347 (uint16_t *)host_ip_msg->kvp_ip_val.adapter_id, 348 MAX_ADAPTER_ID_SIZE, 349 UNUSED_FLAG, 350 &err_adap); 351 352 if (devclass_get_devices(devclass_find("hn"), &devs, &devcnt) == 0) { 353 for (devcnt = devcnt - 1; devcnt >= 0; devcnt--) { 354 sc = device_get_softc(devs[devcnt]); 355 356 /* Trying to find GUID of Network Device */ 357 hv_dev = sc->hn_dev_obj; 358 359 for (guid_index = 0; guid_index < 16; guid_index++) { 360 sprintf(&guid_instance[guid_index * 2], "%02x", 361 hv_dev->device_id.data[guid_index]); 362 } 363 364 guid_data = (char *)guid_instance; 365 id = (struct guid_extract *)guid_data; 366 snprintf(buf, sizeof(buf), "{%.2s%.2s%.2s%.2s-%.2s%.2s-%.2s%.2s-%.4s-%s}", 367 id->a4, id->a3, id->a2, id->a1, 368 id->b2, id->b1, id->c2, id->c1, id->d, id->e); 369 guid_data = NULL; 370 sprintf(if_name, "%s%d", "hn", device_get_unit(devs[devcnt])); 371 372 if (strncmp(buf, (char *)umsg->body.kvp_ip_val.adapter_id, 39) == 0) { 373 strcpy((char *)umsg->body.kvp_ip_val.adapter_id, if_name); 374 break; 375 } 376 } 377 free(devs, M_TEMP); 378 } 379 380 /* Address Family , DHCP , SUBNET, Gateway, DNS */ 381 umsg->kvp_hdr.operation = host_ip_msg->operation; 382 umsg->body.kvp_ip_val.addr_family = host_ip_msg->kvp_ip_val.addr_family; 383 umsg->body.kvp_ip_val.dhcp_enabled = host_ip_msg->kvp_ip_val.dhcp_enabled; 384 utf16_to_utf8((char *)umsg->body.kvp_ip_val.sub_net, MAX_IP_ADDR_SIZE, 385 (uint16_t *)host_ip_msg->kvp_ip_val.sub_net, 386 MAX_IP_ADDR_SIZE, 387 UNUSED_FLAG, 388 &err_subnet); 389 390 utf16_to_utf8((char *)umsg->body.kvp_ip_val.gate_way, MAX_GATEWAY_SIZE, 391 (uint16_t *)host_ip_msg->kvp_ip_val.gate_way, 392 MAX_GATEWAY_SIZE, 393 UNUSED_FLAG, 394 &err_gway); 395 396 utf16_to_utf8((char *)umsg->body.kvp_ip_val.dns_addr, MAX_IP_ADDR_SIZE, 397 (uint16_t *)host_ip_msg->kvp_ip_val.dns_addr, 398 MAX_IP_ADDR_SIZE, 399 UNUSED_FLAG, 400 &err_dns); 401 402 return (err_ip | err_subnet | err_gway | err_dns | err_adap); 403} 404 405 406/* 407 * Prepare a user kvp msg based on host kvp msg (utf16 to utf8) 408 * Ensure utf16_utf8 takes care of the additional string terminating char!! 409 */ 410static void 411hv_kvp_convert_hostmsg_to_usermsg(void) 412{ 413 int utf_err = 0; 414 uint32_t value_type; 415 struct hv_kvp_ip_msg *host_ip_msg = (struct hv_kvp_ip_msg *) 416 kvp_globals.host_kvp_msg; 417 418 struct hv_kvp_msg *hmsg = kvp_globals.host_kvp_msg; 419 struct hv_kvp_msg *umsg = &kvp_globals.daemon_kvp_msg; 420 421 memset(umsg, 0, sizeof(struct hv_kvp_msg)); 422 423 umsg->kvp_hdr.operation = hmsg->kvp_hdr.operation; 424 umsg->kvp_hdr.pool = hmsg->kvp_hdr.pool; 425 426 switch (umsg->kvp_hdr.operation) { 427 case HV_KVP_OP_SET_IP_INFO: 428 hv_kvp_convert_utf16_ipinfo_to_utf8(host_ip_msg, umsg); 429 break; 430 431 case HV_KVP_OP_GET_IP_INFO: 432 utf16_to_utf8((char *)umsg->body.kvp_ip_val.adapter_id, 433 MAX_ADAPTER_ID_SIZE, 434 (uint16_t *)host_ip_msg->kvp_ip_val.adapter_id, 435 MAX_ADAPTER_ID_SIZE, 1, &utf_err); 436 437 umsg->body.kvp_ip_val.addr_family = 438 host_ip_msg->kvp_ip_val.addr_family; 439 break; 440 441 case HV_KVP_OP_SET: 442 value_type = hmsg->body.kvp_set.data.value_type; 443 444 switch (value_type) { 445 case HV_REG_SZ: 446 umsg->body.kvp_set.data.value_size = 447 utf16_to_utf8( 448 (char *)umsg->body.kvp_set.data.msg_value.value, 449 HV_KVP_EXCHANGE_MAX_VALUE_SIZE - 1, 450 (uint16_t *)hmsg->body.kvp_set.data.msg_value.value, 451 hmsg->body.kvp_set.data.value_size, 452 1, &utf_err); 453 /* utf8 encoding */ 454 umsg->body.kvp_set.data.value_size = 455 umsg->body.kvp_set.data.value_size / 2; 456 break; 457 458 case HV_REG_U32: 459 umsg->body.kvp_set.data.value_size = 460 sprintf(umsg->body.kvp_set.data.msg_value.value, "%d", 461 hmsg->body.kvp_set.data.msg_value.value_u32) + 1; 462 break; 463 464 case HV_REG_U64: 465 umsg->body.kvp_set.data.value_size = 466 sprintf(umsg->body.kvp_set.data.msg_value.value, "%llu", 467 (unsigned long long) 468 hmsg->body.kvp_set.data.msg_value.value_u64) + 1; 469 break; 470 } 471 472 umsg->body.kvp_set.data.key_size = 473 utf16_to_utf8( 474 umsg->body.kvp_set.data.key, 475 HV_KVP_EXCHANGE_MAX_KEY_SIZE - 1, 476 (uint16_t *)hmsg->body.kvp_set.data.key, 477 hmsg->body.kvp_set.data.key_size, 478 1, &utf_err); 479 480 /* utf8 encoding */ 481 umsg->body.kvp_set.data.key_size = 482 umsg->body.kvp_set.data.key_size / 2; 483 break; 484 485 case HV_KVP_OP_GET: 486 umsg->body.kvp_get.data.key_size = 487 utf16_to_utf8(umsg->body.kvp_get.data.key, 488 HV_KVP_EXCHANGE_MAX_KEY_SIZE - 1, 489 (uint16_t *)hmsg->body.kvp_get.data.key, 490 hmsg->body.kvp_get.data.key_size, 491 1, &utf_err); 492 /* utf8 encoding */ 493 umsg->body.kvp_get.data.key_size = 494 umsg->body.kvp_get.data.key_size / 2; 495 break; 496 497 case HV_KVP_OP_DELETE: 498 umsg->body.kvp_delete.key_size = 499 utf16_to_utf8(umsg->body.kvp_delete.key, 500 HV_KVP_EXCHANGE_MAX_KEY_SIZE - 1, 501 (uint16_t *)hmsg->body.kvp_delete.key, 502 hmsg->body.kvp_delete.key_size, 503 1, &utf_err); 504 /* utf8 encoding */ 505 umsg->body.kvp_delete.key_size = 506 umsg->body.kvp_delete.key_size / 2; 507 break; 508 509 case HV_KVP_OP_ENUMERATE: 510 umsg->body.kvp_enum_data.index = 511 hmsg->body.kvp_enum_data.index; 512 break; 513 514 default: 515 hv_kvp_log_info("%s: daemon_kvp_msg: Invalid operation : %d\n", 516 __func__, umsg->kvp_hdr.operation); 517 } 518} 519 520 521/* 522 * Prepare a host kvp msg based on user kvp msg (utf8 to utf16) 523 */ 524static int 525hv_kvp_convert_usermsg_to_hostmsg(void) 526{ 527 int hkey_len = 0, hvalue_len = 0, utf_err = 0; 528 struct hv_kvp_exchg_msg_value *host_exchg_data; 529 char *key_name, *value; 530 531 struct hv_kvp_msg *umsg = &kvp_globals.daemon_kvp_msg; 532 struct hv_kvp_msg *hmsg = kvp_globals.host_kvp_msg; 533 struct hv_kvp_ip_msg *host_ip_msg = (struct hv_kvp_ip_msg *)hmsg; 534 535 switch (hmsg->kvp_hdr.operation) { 536 case HV_KVP_OP_GET_IP_INFO: 537 return (hv_kvp_convert_utf8_ipinfo_to_utf16(umsg, host_ip_msg)); 538 539 case HV_KVP_OP_SET_IP_INFO: 540 case HV_KVP_OP_SET: 541 case HV_KVP_OP_DELETE: 542 return (KVP_SUCCESS); 543 544 case HV_KVP_OP_ENUMERATE: 545 host_exchg_data = &hmsg->body.kvp_enum_data.data; 546 key_name = umsg->body.kvp_enum_data.data.key; 547 hkey_len = utf8_to_utf16((uint16_t *)host_exchg_data->key, 548 ((HV_KVP_EXCHANGE_MAX_KEY_SIZE / 2) - 2), 549 key_name, strlen(key_name), 550 1, &utf_err); 551 /* utf16 encoding */ 552 host_exchg_data->key_size = 2 * (hkey_len + 1); 553 value = umsg->body.kvp_enum_data.data.msg_value.value; 554 hvalue_len = utf8_to_utf16( 555 (uint16_t *)host_exchg_data->msg_value.value, 556 ((HV_KVP_EXCHANGE_MAX_VALUE_SIZE / 2) - 2), 557 value, strlen(value), 558 1, &utf_err); 559 host_exchg_data->value_size = 2 * (hvalue_len + 1); 560 host_exchg_data->value_type = HV_REG_SZ; 561 562 if ((hkey_len < 0) || (hvalue_len < 0)) 563 return (HV_KVP_E_FAIL); 564 565 return (KVP_SUCCESS); 566 567 case HV_KVP_OP_GET: 568 host_exchg_data = &hmsg->body.kvp_get.data; 569 value = umsg->body.kvp_get.data.msg_value.value; 570 hvalue_len = utf8_to_utf16( 571 (uint16_t *)host_exchg_data->msg_value.value, 572 ((HV_KVP_EXCHANGE_MAX_VALUE_SIZE / 2) - 2), 573 value, strlen(value), 574 1, &utf_err); 575 /* Convert value size to uft16 */ 576 host_exchg_data->value_size = 2 * (hvalue_len + 1); 577 /* Use values by string */ 578 host_exchg_data->value_type = HV_REG_SZ; 579 580 if ((hkey_len < 0) || (hvalue_len < 0)) 581 return (HV_KVP_E_FAIL); 582 583 return (KVP_SUCCESS); 584 585 default: 586 return (HV_KVP_E_FAIL); 587 } 588} 589 590 591/* 592 * Send the response back to the host. 593 */ 594static void 595hv_kvp_respond_host(int error) 596{ 597 struct hv_vmbus_icmsg_hdr *hv_icmsg_hdrp; 598 599 hv_icmsg_hdrp = (struct hv_vmbus_icmsg_hdr *) 600 &kvp_globals.rcv_buf[sizeof(struct hv_vmbus_pipe_hdr)]; 601 602 if (error) 603 error = HV_KVP_E_FAIL; 604 605 hv_icmsg_hdrp->status = error; 606 hv_icmsg_hdrp->icflags = HV_ICMSGHDRFLAG_TRANSACTION | HV_ICMSGHDRFLAG_RESPONSE; 607 608 error = hv_vmbus_channel_send_packet(kvp_globals.channelp, 609 kvp_globals.rcv_buf, 610 kvp_globals.host_msg_len, kvp_globals.host_msg_id, 611 HV_VMBUS_PACKET_TYPE_DATA_IN_BAND, 0); 612 613 if (error) 614 hv_kvp_log_info("%s: hv_kvp_respond_host: sendpacket error:%d\n", 615 __func__, error); 616} 617 618 619/* 620 * This is the main kvp kernel process that interacts with both user daemon 621 * and the host 622 */ 623static void 624hv_kvp_send_msg_to_daemon(void) 625{ 626 /* Prepare kvp_msg to be sent to user */ 627 hv_kvp_convert_hostmsg_to_usermsg(); 628 629 /* Send the msg to user via function deamon_read - setting sema */ 630 sema_post(&kvp_globals.dev_sema); 631} 632 633 634/* 635 * Function to read the kvp request buffer from host 636 * and interact with daemon 637 */ 638static void 639hv_kvp_process_request(void *context) 640{ 641 uint8_t *kvp_buf; 642 hv_vmbus_channel *channel = context; 643 uint32_t recvlen = 0; 644 uint64_t requestid; 645 struct hv_vmbus_icmsg_hdr *icmsghdrp; 646 int ret = 0; 647 uint64_t pending_cnt = 1; 648 649 hv_kvp_log_info("%s: entering hv_kvp_process_request\n", __func__); 650 kvp_buf = receive_buffer[HV_KVP]; 651 ret = hv_vmbus_channel_recv_packet(channel, kvp_buf, 2 * PAGE_SIZE, 652 &recvlen, &requestid); 653 654 /* 655 * We start counting only after the daemon registers 656 * and therefore there could be requests pending in 657 * the VMBus that are not reflected in pending_cnt. 658 * Therefore we continue reading as long as either of 659 * the below conditions is true. 660 */ 661 662 while ((pending_cnt>0) || ((ret == 0) && (recvlen > 0))) { 663 664 if ((ret == 0) && (recvlen>0)) { 665 666 icmsghdrp = (struct hv_vmbus_icmsg_hdr *) 667 &kvp_buf[sizeof(struct hv_vmbus_pipe_hdr)]; 668 669 hv_kvp_transaction_init(recvlen, channel, requestid, kvp_buf); 670 if (icmsghdrp->icmsgtype == HV_ICMSGTYPE_NEGOTIATE) { 671 hv_kvp_negotiate_version(icmsghdrp, NULL, kvp_buf); 672 hv_kvp_respond_host(ret); 673 674 /* 675 * It is ok to not acquire the mutex before setting 676 * req_in_progress here because negotiation is the 677 * first thing that happens and hence there is no 678 * chance of a race condition. 679 */ 680 681 kvp_globals.req_in_progress = false; 682 hv_kvp_log_info("%s :version negotiated\n", __func__); 683 684 } else { 685 if (!kvp_globals.daemon_busy) { 686 687 hv_kvp_log_info("%s: issuing qury to daemon\n", __func__); 688 mtx_lock(&kvp_globals.pending_mutex); 689 kvp_globals.req_timed_out = false; 690 kvp_globals.daemon_busy = true; 691 mtx_unlock(&kvp_globals.pending_mutex); 692 693 hv_kvp_send_msg_to_daemon(); 694 hv_kvp_log_info("%s: waiting for daemon\n", __func__); 695 } 696 697 /* Wait 5 seconds for daemon to respond back */ 698 tsleep(&kvp_globals, 0, "kvpworkitem", 5 * hz); 699 hv_kvp_log_info("%s: came out of wait\n", __func__); 700 } 701 } 702 703 mtx_lock(&kvp_globals.pending_mutex); 704 705 /* Notice that once req_timed_out is set to true 706 * it will remain true until the next request is 707 * sent to the daemon. The response from daemon 708 * is forwarded to host only when this flag is 709 * false. 710 */ 711 kvp_globals.req_timed_out = true; 712 713 /* 714 * Cancel request if so need be. 715 */ 716 if (hv_kvp_req_in_progress()) { 717 hv_kvp_log_info("%s: request was still active after wait so failing\n", __func__); 718 hv_kvp_respond_host(HV_KVP_E_FAIL); 719 kvp_globals.req_in_progress = false; 720 } 721 722 /* 723 * Decrement pending request count and 724 */ 725 if (kvp_globals.pending_reqs>0) { 726 kvp_globals.pending_reqs = kvp_globals.pending_reqs - 1; 727 } 728 pending_cnt = kvp_globals.pending_reqs; 729 730 mtx_unlock(&kvp_globals.pending_mutex); 731 732 /* 733 * Try reading next buffer 734 */ 735 recvlen = 0; 736 ret = hv_vmbus_channel_recv_packet(channel, kvp_buf, 2 * PAGE_SIZE, 737 &recvlen, &requestid); 738 hv_kvp_log_info("%s: read: context %p, pending_cnt %llu ret =%d, recvlen=%d\n", 739 __func__, context, (unsigned long long)pending_cnt, ret, recvlen); 740 } 741} 742 743 744/* 745 * Callback routine that gets called whenever there is a message from host 746 */ 747void 748hv_kvp_callback(void *context) 749{ 750 uint64_t pending_cnt = 0; 751 752 if (kvp_globals.register_done == false) { 753 754 kvp_globals.channelp = context; 755 } else { 756 757 mtx_lock(&kvp_globals.pending_mutex); 758 kvp_globals.pending_reqs = kvp_globals.pending_reqs + 1; 759 pending_cnt = kvp_globals.pending_reqs; 760 mtx_unlock(&kvp_globals.pending_mutex); 761 if (pending_cnt == 1) { 762 hv_kvp_log_info("%s: Queuing work item\n", __func__); 763 hv_queue_work_item( 764 service_table[HV_KVP].work_queue, 765 hv_kvp_process_request, 766 context 767 ); 768 } 769 } 770} 771 772 773/* 774 * This function is called by the hv_kvp_init - 775 * creates character device hv_kvp_dev 776 * allocates memory to hv_kvp_dev_buf 777 * 778 */ 779static int 780hv_kvp_dev_init(void) 781{ 782 int error = 0; 783 784 /* initialize semaphore */ 785 sema_init(&kvp_globals.dev_sema, 0, "hv_kvp device semaphore"); 786 /* create character device */ 787 error = make_dev_p(MAKEDEV_CHECKNAME | MAKEDEV_WAITOK, 788 &hv_kvp_dev, 789 &hv_kvp_cdevsw, 790 0, 791 UID_ROOT, 792 GID_WHEEL, 793 0640, 794 "hv_kvp_dev"); 795 796 if (error != 0) 797 return (error); 798 799 /* 800 * Malloc with M_WAITOK flag will never fail. 801 */ 802 hv_kvp_dev_buf = malloc(sizeof(*hv_kvp_dev_buf), M_HV_KVP_DEV_BUF, M_WAITOK | 803 M_ZERO); 804 805 return (0); 806} 807 808 809/* 810 * This function is called by the hv_kvp_deinit - 811 * destroy character device 812 */ 813static void 814hv_kvp_dev_destroy(void) 815{ 816 817 if (daemon_task != NULL) { 818 PROC_LOCK(daemon_task); 819 kern_psignal(daemon_task, SIGKILL); 820 PROC_UNLOCK(daemon_task); 821 } 822 823 destroy_dev(hv_kvp_dev); 824 free(hv_kvp_dev_buf, M_HV_KVP_DEV_BUF); 825 return; 826} 827 828 829static int 830hv_kvp_dev_open(struct cdev *dev, int oflags, int devtype, 831 struct thread *td) 832{ 833 834 hv_kvp_log_info("%s: Opened device \"hv_kvp_device\" successfully.\n", __func__); 835 if (kvp_globals.dev_accessed) 836 return (-EBUSY); 837 838 daemon_task = curproc; 839 kvp_globals.dev_accessed = true; 840 kvp_globals.daemon_busy = false; 841 return (0); 842} 843 844 845static int 846hv_kvp_dev_close(struct cdev *dev __unused, int fflag __unused, int devtype __unused, 847 struct thread *td __unused) 848{ 849 850 hv_kvp_log_info("%s: Closing device \"hv_kvp_device\".\n", __func__); 851 kvp_globals.dev_accessed = false; 852 kvp_globals.register_done = false; 853 return (0); 854} 855 856 857/* 858 * hv_kvp_daemon read invokes this function 859 * acts as a send to daemon 860 */ 861static int 862hv_kvp_dev_daemon_read(struct cdev *dev __unused, struct uio *uio, int ioflag __unused) 863{ 864 size_t amt; 865 int error = 0; 866 867 /* Check hv_kvp daemon registration status*/ 868 if (!kvp_globals.register_done) 869 return (KVP_ERROR); 870 871 sema_wait(&kvp_globals.dev_sema); 872 873 memcpy(hv_kvp_dev_buf, &kvp_globals.daemon_kvp_msg, sizeof(struct hv_kvp_msg)); 874 875 amt = MIN(uio->uio_resid, uio->uio_offset >= BUFFERSIZE + 1 ? 0 : 876 BUFFERSIZE + 1 - uio->uio_offset); 877 878 if ((error = uiomove(hv_kvp_dev_buf, amt, uio)) != 0) 879 hv_kvp_log_info("%s: hv_kvp uiomove read failed!\n", __func__); 880 881 return (error); 882} 883 884 885/* 886 * hv_kvp_daemon write invokes this function 887 * acts as a recieve from daemon 888 */ 889static int 890hv_kvp_dev_daemon_write(struct cdev *dev __unused, struct uio *uio, int ioflag __unused) 891{ 892 size_t amt; 893 int error = 0; 894 895 uio->uio_offset = 0; 896 897 amt = MIN(uio->uio_resid, BUFFERSIZE); 898 error = uiomove(hv_kvp_dev_buf, amt, uio); 899 900 if (error != 0) 901 return (error); 902 903 memcpy(&kvp_globals.daemon_kvp_msg, hv_kvp_dev_buf, sizeof(struct hv_kvp_msg)); 904 905 if (kvp_globals.register_done == false) { 906 if (kvp_globals.daemon_kvp_msg.kvp_hdr.operation == HV_KVP_OP_REGISTER) { 907 908 kvp_globals.register_done = true; 909 if (kvp_globals.channelp) { 910 911 hv_kvp_callback(kvp_globals.channelp); 912 } 913 } 914 else { 915 hv_kvp_log_info("%s, KVP Registration Failed\n", __func__); 916 return (KVP_ERROR); 917 } 918 } else { 919 920 mtx_lock(&kvp_globals.pending_mutex); 921 922 if(!kvp_globals.req_timed_out) { 923 924 hv_kvp_convert_usermsg_to_hostmsg(); 925 hv_kvp_respond_host(KVP_SUCCESS); 926 wakeup(&kvp_globals); 927 kvp_globals.req_in_progress = false; 928 } 929 930 kvp_globals.daemon_busy = false; 931 mtx_unlock(&kvp_globals.pending_mutex); 932 } 933 934 return (error); 935} 936 937 938/* 939 * hv_kvp_daemon poll invokes this function to check if data is available 940 * for daemon to read. 941 */ 942static int 943hv_kvp_dev_daemon_poll(struct cdev *dev __unused, int events, struct thread *td __unused) 944{ 945 int revents = 0; 946 947 mtx_lock(&kvp_globals.pending_mutex); 948 /* 949 * We check global flag daemon_busy for the data availiability for 950 * userland to read. Deamon_busy is set to true before driver has data 951 * for daemon to read. It is set to false after daemon sends 952 * then response back to driver. 953 */ 954 if (kvp_globals.daemon_busy == true) 955 revents = POLLIN; 956 mtx_unlock(&kvp_globals.pending_mutex); 957 958 return (revents); 959} 960 961 962/* 963 * hv_kvp initialization function 964 * called from hv_util service. 965 * 966 */ 967int 968hv_kvp_init(hv_vmbus_service *srv) 969{ 970 int error = 0; 971 hv_work_queue *work_queue = NULL; 972 973 memset(&kvp_globals, 0, sizeof(kvp_globals)); 974 975 work_queue = hv_work_queue_create("KVP Service"); 976 if (work_queue == NULL) { 977 hv_kvp_log_info("%s: Work queue alloc failed\n", __func__); 978 error = ENOMEM; 979 hv_kvp_log_error("%s: ENOMEM\n", __func__); 980 goto Finish; 981 } 982 srv->work_queue = work_queue; 983 984 error = hv_kvp_dev_init(); 985 mtx_init(&kvp_globals.pending_mutex, "hv-kvp pending mutex", 986 NULL, MTX_DEF); 987 kvp_globals.pending_reqs = 0; 988 989 990Finish: 991 return (error); 992} 993 994 995void 996hv_kvp_deinit(void) 997{ 998 hv_kvp_dev_destroy(); 999 mtx_destroy(&kvp_globals.pending_mutex); 1000 1001 return; 1002} 1003