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