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