2 * Copyright (c) 2014,2016 Microsoft Corp.
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice unmodified, this list of conditions, and the following
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.
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.
28 * Author: Sainath Varanasi.
30 * Email: bsdic@microsoft.com
33 #include <sys/cdefs.h>
34 __FBSDID("$FreeBSD$");
36 #include <sys/param.h>
37 #include <sys/kernel.h>
41 #include <sys/malloc.h>
43 #include <sys/module.h>
44 #include <sys/reboot.h>
46 #include <sys/taskqueue.h>
47 #include <sys/selinfo.h>
48 #include <sys/sysctl.h>
51 #include <sys/kthread.h>
52 #include <sys/syscallsubr.h>
53 #include <sys/sysproto.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>
63 #include <net/if_arp.h>
64 #include <net/if_var.h>
66 #include <dev/hyperv/include/hyperv.h>
67 #include <dev/hyperv/netvsc/hv_net_vsc.h>
75 #define BUFFERSIZE sizeof(struct hv_kvp_msg)
78 #define kvp_hdr hdr.kvp_hdr
80 /* hv_kvp debug control */
81 static int hv_kvp_log = 0;
83 #define hv_kvp_log_error(...) do { \
85 log(LOG_ERR, "hv_kvp: " __VA_ARGS__); \
88 #define hv_kvp_log_info(...) do { \
90 log(LOG_INFO, "hv_kvp: " __VA_ARGS__); \
93 static const struct hyperv_guid service_guid = { .hv_guid =
94 {0xe7, 0xf4, 0xa0, 0xa9, 0x45, 0x5a, 0x96, 0x4d,
95 0xb8, 0x27, 0x8a, 0x84, 0x1e, 0x8c, 0x3, 0xe6} };
97 /* character device prototypes */
98 static d_open_t hv_kvp_dev_open;
99 static d_close_t hv_kvp_dev_close;
100 static d_read_t hv_kvp_dev_daemon_read;
101 static d_write_t hv_kvp_dev_daemon_write;
102 static d_poll_t hv_kvp_dev_daemon_poll;
104 /* hv_kvp character device structure */
105 static struct cdevsw hv_kvp_cdevsw =
107 .d_version = D_VERSION,
108 .d_open = hv_kvp_dev_open,
109 .d_close = hv_kvp_dev_close,
110 .d_read = hv_kvp_dev_daemon_read,
111 .d_write = hv_kvp_dev_daemon_write,
112 .d_poll = hv_kvp_dev_daemon_poll,
113 .d_name = "hv_kvp_dev",
118 * Global state to track and synchronize multiple
119 * KVP transaction requests from the host.
121 typedef struct hv_kvp_sc {
122 struct hv_util_sc util_sc;
124 /* Unless specified the pending mutex should be
125 * used to alter the values of the following paramters:
129 struct mtx pending_mutex;
133 /* To track if transaction is active or not */
134 boolean_t req_in_progress;
135 /* Tracks if daemon did not reply back in time */
136 boolean_t req_timed_out;
137 /* Tracks if daemon is serving a request currently */
138 boolean_t daemon_busy;
140 /* Length of host message */
141 uint32_t host_msg_len;
143 /* Host message id */
144 uint64_t host_msg_id;
146 /* Current kvp message from the host */
147 struct hv_kvp_msg *host_kvp_msg;
149 /* Current kvp message for daemon */
150 struct hv_kvp_msg daemon_kvp_msg;
152 /* Rcv buffer for communicating with the host*/
155 /* Device semaphore to control communication */
156 struct sema dev_sema;
158 /* Indicates if daemon registered with driver */
159 boolean_t register_done;
161 /* Character device status */
162 boolean_t dev_accessed;
164 struct cdev *hv_kvp_dev;
166 struct proc *daemon_task;
168 struct selinfo hv_kvp_selinfo;
171 /* hv_kvp prototypes */
172 static int hv_kvp_req_in_progress(hv_kvp_sc *sc);
173 static void hv_kvp_transaction_init(hv_kvp_sc *sc, uint32_t, uint64_t, uint8_t *);
174 static void hv_kvp_send_msg_to_daemon(hv_kvp_sc *sc);
175 static void hv_kvp_process_request(void *context, int pending);
178 * hv_kvp low level functions
182 * Check if kvp transaction is in progres
185 hv_kvp_req_in_progress(hv_kvp_sc *sc)
188 return (sc->req_in_progress);
193 * This routine is called whenever a message is received from the host
196 hv_kvp_transaction_init(hv_kvp_sc *sc, uint32_t rcv_len,
197 uint64_t request_id, uint8_t *rcv_buf)
200 /* Store all the relevant message details in the global structure */
201 /* Do not need to use mutex for req_in_progress here */
202 sc->req_in_progress = true;
203 sc->host_msg_len = rcv_len;
204 sc->host_msg_id = request_id;
205 sc->rcv_buf = rcv_buf;
206 sc->host_kvp_msg = (struct hv_kvp_msg *)&rcv_buf[
207 sizeof(struct hv_vmbus_pipe_hdr) +
208 sizeof(struct hv_vmbus_icmsg_hdr)];
213 * hv_kvp - version neogtiation function
216 hv_kvp_negotiate_version(struct hv_vmbus_icmsg_hdr *icmsghdrp,
217 struct hv_vmbus_icmsg_negotiate *negop,
223 icmsghdrp->icmsgsize = 0x10;
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;
232 * Select the framework version number we will support
234 if ((icframe_vercnt >= 2) && (negop->icversion_data[1].major == 3)) {
236 if (icmsg_vercnt > 2)
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;
255 * Convert ip related info in umsg from utf8 to utf16 and store in hmsg
258 hv_kvp_convert_utf8_ipinfo_to_utf16(struct hv_kvp_msg *umsg,
259 struct hv_kvp_ip_msg *host_ip_msg)
261 int err_ip, err_subnet, err_gway, err_dns, err_adap;
264 utf8_to_utf16((uint16_t *)host_ip_msg->kvp_ip_val.ip_addr,
266 (char *)umsg->body.kvp_ip_val.ip_addr,
267 strlen((char *)umsg->body.kvp_ip_val.ip_addr),
270 utf8_to_utf16((uint16_t *)host_ip_msg->kvp_ip_val.sub_net,
272 (char *)umsg->body.kvp_ip_val.sub_net,
273 strlen((char *)umsg->body.kvp_ip_val.sub_net),
276 utf8_to_utf16((uint16_t *)host_ip_msg->kvp_ip_val.gate_way,
278 (char *)umsg->body.kvp_ip_val.gate_way,
279 strlen((char *)umsg->body.kvp_ip_val.gate_way),
282 utf8_to_utf16((uint16_t *)host_ip_msg->kvp_ip_val.dns_addr,
284 (char *)umsg->body.kvp_ip_val.dns_addr,
285 strlen((char *)umsg->body.kvp_ip_val.dns_addr),
288 utf8_to_utf16((uint16_t *)host_ip_msg->kvp_ip_val.adapter_id,
290 (char *)umsg->body.kvp_ip_val.adapter_id,
291 strlen((char *)umsg->body.kvp_ip_val.adapter_id),
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;
298 return (err_ip | err_subnet | err_gway | err_dns | err_adap);
303 * Convert ip related info in hmsg from utf16 to utf8 and store in umsg
306 hv_kvp_convert_utf16_ipinfo_to_utf8(struct hv_kvp_ip_msg *host_ip_msg,
307 struct hv_kvp_msg *umsg)
309 int err_ip, err_subnet, err_gway, err_dns, err_adap;
315 utf16_to_utf8((char *)umsg->body.kvp_ip_val.ip_addr,
317 (uint16_t *)host_ip_msg->kvp_ip_val.ip_addr,
322 /* Adapter ID : GUID */
323 utf16_to_utf8((char *)umsg->body.kvp_ip_val.adapter_id,
325 (uint16_t *)host_ip_msg->kvp_ip_val.adapter_id,
330 if (devclass_get_devices(devclass_find("hn"), &devs, &devcnt) == 0) {
331 for (devcnt = devcnt - 1; devcnt >= 0; devcnt--) {
332 /* XXX access other driver's softc? are you kidding? */
333 device_t dev = devs[devcnt];
334 struct hn_softc *sc = device_get_softc(dev);
335 struct hv_vmbus_channel *chan;
336 char buf[HYPERV_GUID_STRLEN];
339 * Trying to find GUID of Network Device
340 * TODO: need vmbus interface.
342 chan = vmbus_get_channel(dev);
343 hyperv_guid2str(&chan->ch_guid_inst, buf, sizeof(buf));
345 if (strncmp(buf, (char *)umsg->body.kvp_ip_val.adapter_id,
346 HYPERV_GUID_STRLEN - 1) == 0) {
347 strlcpy((char *)umsg->body.kvp_ip_val.adapter_id,
348 sc->hn_ifp->if_xname, MAX_ADAPTER_ID_SIZE);
355 /* Address Family , DHCP , SUBNET, Gateway, DNS */
356 umsg->kvp_hdr.operation = host_ip_msg->operation;
357 umsg->body.kvp_ip_val.addr_family = host_ip_msg->kvp_ip_val.addr_family;
358 umsg->body.kvp_ip_val.dhcp_enabled = host_ip_msg->kvp_ip_val.dhcp_enabled;
359 utf16_to_utf8((char *)umsg->body.kvp_ip_val.sub_net, MAX_IP_ADDR_SIZE,
360 (uint16_t *)host_ip_msg->kvp_ip_val.sub_net,
365 utf16_to_utf8((char *)umsg->body.kvp_ip_val.gate_way, MAX_GATEWAY_SIZE,
366 (uint16_t *)host_ip_msg->kvp_ip_val.gate_way,
371 utf16_to_utf8((char *)umsg->body.kvp_ip_val.dns_addr, MAX_IP_ADDR_SIZE,
372 (uint16_t *)host_ip_msg->kvp_ip_val.dns_addr,
377 return (err_ip | err_subnet | err_gway | err_dns | err_adap);
382 * Prepare a user kvp msg based on host kvp msg (utf16 to utf8)
383 * Ensure utf16_utf8 takes care of the additional string terminating char!!
386 hv_kvp_convert_hostmsg_to_usermsg(struct hv_kvp_msg *hmsg, struct hv_kvp_msg *umsg)
390 struct hv_kvp_ip_msg *host_ip_msg;
392 host_ip_msg = (struct hv_kvp_ip_msg*)hmsg;
393 memset(umsg, 0, sizeof(struct hv_kvp_msg));
395 umsg->kvp_hdr.operation = hmsg->kvp_hdr.operation;
396 umsg->kvp_hdr.pool = hmsg->kvp_hdr.pool;
398 switch (umsg->kvp_hdr.operation) {
399 case HV_KVP_OP_SET_IP_INFO:
400 hv_kvp_convert_utf16_ipinfo_to_utf8(host_ip_msg, umsg);
403 case HV_KVP_OP_GET_IP_INFO:
404 utf16_to_utf8((char *)umsg->body.kvp_ip_val.adapter_id,
406 (uint16_t *)host_ip_msg->kvp_ip_val.adapter_id,
407 MAX_ADAPTER_ID_SIZE, 1, &utf_err);
409 umsg->body.kvp_ip_val.addr_family =
410 host_ip_msg->kvp_ip_val.addr_family;
414 value_type = hmsg->body.kvp_set.data.value_type;
416 switch (value_type) {
418 umsg->body.kvp_set.data.value_size =
420 (char *)umsg->body.kvp_set.data.msg_value.value,
421 HV_KVP_EXCHANGE_MAX_VALUE_SIZE - 1,
422 (uint16_t *)hmsg->body.kvp_set.data.msg_value.value,
423 hmsg->body.kvp_set.data.value_size,
426 umsg->body.kvp_set.data.value_size =
427 umsg->body.kvp_set.data.value_size / 2;
431 umsg->body.kvp_set.data.value_size =
432 sprintf(umsg->body.kvp_set.data.msg_value.value, "%d",
433 hmsg->body.kvp_set.data.msg_value.value_u32) + 1;
437 umsg->body.kvp_set.data.value_size =
438 sprintf(umsg->body.kvp_set.data.msg_value.value, "%llu",
440 hmsg->body.kvp_set.data.msg_value.value_u64) + 1;
444 umsg->body.kvp_set.data.key_size =
446 umsg->body.kvp_set.data.key,
447 HV_KVP_EXCHANGE_MAX_KEY_SIZE - 1,
448 (uint16_t *)hmsg->body.kvp_set.data.key,
449 hmsg->body.kvp_set.data.key_size,
453 umsg->body.kvp_set.data.key_size =
454 umsg->body.kvp_set.data.key_size / 2;
458 umsg->body.kvp_get.data.key_size =
459 utf16_to_utf8(umsg->body.kvp_get.data.key,
460 HV_KVP_EXCHANGE_MAX_KEY_SIZE - 1,
461 (uint16_t *)hmsg->body.kvp_get.data.key,
462 hmsg->body.kvp_get.data.key_size,
465 umsg->body.kvp_get.data.key_size =
466 umsg->body.kvp_get.data.key_size / 2;
469 case HV_KVP_OP_DELETE:
470 umsg->body.kvp_delete.key_size =
471 utf16_to_utf8(umsg->body.kvp_delete.key,
472 HV_KVP_EXCHANGE_MAX_KEY_SIZE - 1,
473 (uint16_t *)hmsg->body.kvp_delete.key,
474 hmsg->body.kvp_delete.key_size,
477 umsg->body.kvp_delete.key_size =
478 umsg->body.kvp_delete.key_size / 2;
481 case HV_KVP_OP_ENUMERATE:
482 umsg->body.kvp_enum_data.index =
483 hmsg->body.kvp_enum_data.index;
487 hv_kvp_log_info("%s: daemon_kvp_msg: Invalid operation : %d\n",
488 __func__, umsg->kvp_hdr.operation);
494 * Prepare a host kvp msg based on user kvp msg (utf8 to utf16)
497 hv_kvp_convert_usermsg_to_hostmsg(struct hv_kvp_msg *umsg, struct hv_kvp_msg *hmsg)
499 int hkey_len = 0, hvalue_len = 0, utf_err = 0;
500 struct hv_kvp_exchg_msg_value *host_exchg_data;
501 char *key_name, *value;
503 struct hv_kvp_ip_msg *host_ip_msg = (struct hv_kvp_ip_msg *)hmsg;
505 switch (hmsg->kvp_hdr.operation) {
506 case HV_KVP_OP_GET_IP_INFO:
507 return (hv_kvp_convert_utf8_ipinfo_to_utf16(umsg, host_ip_msg));
509 case HV_KVP_OP_SET_IP_INFO:
511 case HV_KVP_OP_DELETE:
512 return (KVP_SUCCESS);
514 case HV_KVP_OP_ENUMERATE:
515 host_exchg_data = &hmsg->body.kvp_enum_data.data;
516 key_name = umsg->body.kvp_enum_data.data.key;
517 hkey_len = utf8_to_utf16((uint16_t *)host_exchg_data->key,
518 ((HV_KVP_EXCHANGE_MAX_KEY_SIZE / 2) - 2),
519 key_name, strlen(key_name),
522 host_exchg_data->key_size = 2 * (hkey_len + 1);
523 value = umsg->body.kvp_enum_data.data.msg_value.value;
524 hvalue_len = utf8_to_utf16(
525 (uint16_t *)host_exchg_data->msg_value.value,
526 ((HV_KVP_EXCHANGE_MAX_VALUE_SIZE / 2) - 2),
527 value, strlen(value),
529 host_exchg_data->value_size = 2 * (hvalue_len + 1);
530 host_exchg_data->value_type = HV_REG_SZ;
532 if ((hkey_len < 0) || (hvalue_len < 0))
533 return (HV_KVP_E_FAIL);
535 return (KVP_SUCCESS);
538 host_exchg_data = &hmsg->body.kvp_get.data;
539 value = umsg->body.kvp_get.data.msg_value.value;
540 hvalue_len = utf8_to_utf16(
541 (uint16_t *)host_exchg_data->msg_value.value,
542 ((HV_KVP_EXCHANGE_MAX_VALUE_SIZE / 2) - 2),
543 value, strlen(value),
545 /* Convert value size to uft16 */
546 host_exchg_data->value_size = 2 * (hvalue_len + 1);
547 /* Use values by string */
548 host_exchg_data->value_type = HV_REG_SZ;
550 if ((hkey_len < 0) || (hvalue_len < 0))
551 return (HV_KVP_E_FAIL);
553 return (KVP_SUCCESS);
556 return (HV_KVP_E_FAIL);
562 * Send the response back to the host.
565 hv_kvp_respond_host(hv_kvp_sc *sc, int error)
567 struct hv_vmbus_icmsg_hdr *hv_icmsg_hdrp;
569 hv_icmsg_hdrp = (struct hv_vmbus_icmsg_hdr *)
570 &sc->rcv_buf[sizeof(struct hv_vmbus_pipe_hdr)];
573 error = HV_KVP_E_FAIL;
575 hv_icmsg_hdrp->status = error;
576 hv_icmsg_hdrp->icflags = HV_ICMSGHDRFLAG_TRANSACTION | HV_ICMSGHDRFLAG_RESPONSE;
578 error = hv_vmbus_channel_send_packet(sc->util_sc.channel,
580 sc->host_msg_len, sc->host_msg_id,
581 VMBUS_CHANPKT_TYPE_INBAND, 0);
584 hv_kvp_log_info("%s: hv_kvp_respond_host: sendpacket error:%d\n",
590 * This is the main kvp kernel process that interacts with both user daemon
594 hv_kvp_send_msg_to_daemon(hv_kvp_sc *sc)
596 struct hv_kvp_msg *hmsg = sc->host_kvp_msg;
597 struct hv_kvp_msg *umsg = &sc->daemon_kvp_msg;
599 /* Prepare kvp_msg to be sent to user */
600 hv_kvp_convert_hostmsg_to_usermsg(hmsg, umsg);
602 /* Send the msg to user via function deamon_read - setting sema */
603 sema_post(&sc->dev_sema);
605 /* We should wake up the daemon, in case it's doing poll() */
606 selwakeup(&sc->hv_kvp_selinfo);
611 * Function to read the kvp request buffer from host
612 * and interact with daemon
615 hv_kvp_process_request(void *context, int pending)
618 hv_vmbus_channel *channel;
619 uint32_t recvlen = 0;
621 struct hv_vmbus_icmsg_hdr *icmsghdrp;
625 hv_kvp_log_info("%s: entering hv_kvp_process_request\n", __func__);
627 sc = (hv_kvp_sc*)context;
628 kvp_buf = sc->util_sc.receive_buffer;;
629 channel = sc->util_sc.channel;
631 ret = hv_vmbus_channel_recv_packet(channel, kvp_buf, 2 * PAGE_SIZE,
632 &recvlen, &requestid);
634 while ((ret == 0) && (recvlen > 0)) {
636 icmsghdrp = (struct hv_vmbus_icmsg_hdr *)
637 &kvp_buf[sizeof(struct hv_vmbus_pipe_hdr)];
639 hv_kvp_transaction_init(sc, recvlen, requestid, kvp_buf);
640 if (icmsghdrp->icmsgtype == HV_ICMSGTYPE_NEGOTIATE) {
641 hv_kvp_negotiate_version(icmsghdrp, NULL, kvp_buf);
642 hv_kvp_respond_host(sc, ret);
645 * It is ok to not acquire the mutex before setting
646 * req_in_progress here because negotiation is the
647 * first thing that happens and hence there is no
648 * chance of a race condition.
651 sc->req_in_progress = false;
652 hv_kvp_log_info("%s :version negotiated\n", __func__);
655 if (!sc->daemon_busy) {
657 hv_kvp_log_info("%s: issuing qury to daemon\n", __func__);
658 mtx_lock(&sc->pending_mutex);
659 sc->req_timed_out = false;
660 sc->daemon_busy = true;
661 mtx_unlock(&sc->pending_mutex);
663 hv_kvp_send_msg_to_daemon(sc);
664 hv_kvp_log_info("%s: waiting for daemon\n", __func__);
667 /* Wait 5 seconds for daemon to respond back */
668 tsleep(sc, 0, "kvpworkitem", 5 * hz);
669 hv_kvp_log_info("%s: came out of wait\n", __func__);
672 mtx_lock(&sc->pending_mutex);
674 /* Notice that once req_timed_out is set to true
675 * it will remain true until the next request is
676 * sent to the daemon. The response from daemon
677 * is forwarded to host only when this flag is
680 sc->req_timed_out = true;
683 * Cancel request if so need be.
685 if (hv_kvp_req_in_progress(sc)) {
686 hv_kvp_log_info("%s: request was still active after wait so failing\n", __func__);
687 hv_kvp_respond_host(sc, HV_KVP_E_FAIL);
688 sc->req_in_progress = false;
691 mtx_unlock(&sc->pending_mutex);
694 * Try reading next buffer
697 ret = hv_vmbus_channel_recv_packet(channel, kvp_buf, 2 * PAGE_SIZE,
698 &recvlen, &requestid);
699 hv_kvp_log_info("%s: read: context %p, ret =%d, recvlen=%d\n",
700 __func__, context, ret, recvlen);
706 * Callback routine that gets called whenever there is a message from host
709 hv_kvp_callback(void *context)
711 hv_kvp_sc *sc = (hv_kvp_sc*)context;
713 The first request from host will not be handled until daemon is registered.
714 when callback is triggered without a registered daemon, callback just return.
715 When a new daemon gets regsitered, this callbcak is trigged from _write op.
717 if (sc->register_done) {
718 hv_kvp_log_info("%s: Queuing work item\n", __func__);
719 taskqueue_enqueue(taskqueue_thread, &sc->task);
724 hv_kvp_dev_open(struct cdev *dev, int oflags, int devtype,
727 hv_kvp_sc *sc = (hv_kvp_sc*)dev->si_drv1;
729 hv_kvp_log_info("%s: Opened device \"hv_kvp_device\" successfully.\n", __func__);
730 if (sc->dev_accessed)
733 sc->daemon_task = curproc;
734 sc->dev_accessed = true;
735 sc->daemon_busy = false;
741 hv_kvp_dev_close(struct cdev *dev __unused, int fflag __unused, int devtype __unused,
742 struct thread *td __unused)
744 hv_kvp_sc *sc = (hv_kvp_sc*)dev->si_drv1;
746 hv_kvp_log_info("%s: Closing device \"hv_kvp_device\".\n", __func__);
747 sc->dev_accessed = false;
748 sc->register_done = false;
754 * hv_kvp_daemon read invokes this function
755 * acts as a send to daemon
758 hv_kvp_dev_daemon_read(struct cdev *dev, struct uio *uio, int ioflag __unused)
762 struct hv_kvp_msg *hv_kvp_dev_buf;
763 hv_kvp_sc *sc = (hv_kvp_sc*)dev->si_drv1;
765 /* Check hv_kvp daemon registration status*/
766 if (!sc->register_done)
769 sema_wait(&sc->dev_sema);
771 hv_kvp_dev_buf = malloc(sizeof(*hv_kvp_dev_buf), M_TEMP, M_WAITOK);
772 memcpy(hv_kvp_dev_buf, &sc->daemon_kvp_msg, sizeof(struct hv_kvp_msg));
774 amt = MIN(uio->uio_resid, uio->uio_offset >= BUFFERSIZE + 1 ? 0 :
775 BUFFERSIZE + 1 - uio->uio_offset);
777 if ((error = uiomove(hv_kvp_dev_buf, amt, uio)) != 0)
778 hv_kvp_log_info("%s: hv_kvp uiomove read failed!\n", __func__);
780 free(hv_kvp_dev_buf, M_TEMP);
786 * hv_kvp_daemon write invokes this function
787 * acts as a recieve from daemon
790 hv_kvp_dev_daemon_write(struct cdev *dev, struct uio *uio, int ioflag __unused)
794 struct hv_kvp_msg *hv_kvp_dev_buf;
795 hv_kvp_sc *sc = (hv_kvp_sc*)dev->si_drv1;
798 hv_kvp_dev_buf = malloc(sizeof(*hv_kvp_dev_buf), M_TEMP, M_WAITOK);
800 amt = MIN(uio->uio_resid, BUFFERSIZE);
801 error = uiomove(hv_kvp_dev_buf, amt, uio);
804 free(hv_kvp_dev_buf, M_TEMP);
807 memcpy(&sc->daemon_kvp_msg, hv_kvp_dev_buf, sizeof(struct hv_kvp_msg));
809 free(hv_kvp_dev_buf, M_TEMP);
810 if (sc->register_done == false) {
811 if (sc->daemon_kvp_msg.kvp_hdr.operation == HV_KVP_OP_REGISTER) {
812 sc->register_done = true;
813 hv_kvp_callback(dev->si_drv1);
816 hv_kvp_log_info("%s, KVP Registration Failed\n", __func__);
821 mtx_lock(&sc->pending_mutex);
823 if(!sc->req_timed_out) {
824 struct hv_kvp_msg *hmsg = sc->host_kvp_msg;
825 struct hv_kvp_msg *umsg = &sc->daemon_kvp_msg;
827 hv_kvp_convert_usermsg_to_hostmsg(umsg, hmsg);
828 hv_kvp_respond_host(sc, KVP_SUCCESS);
830 sc->req_in_progress = false;
833 sc->daemon_busy = false;
834 mtx_unlock(&sc->pending_mutex);
842 * hv_kvp_daemon poll invokes this function to check if data is available
843 * for daemon to read.
846 hv_kvp_dev_daemon_poll(struct cdev *dev, int events, struct thread *td)
849 hv_kvp_sc *sc = (hv_kvp_sc*)dev->si_drv1;
851 mtx_lock(&sc->pending_mutex);
853 * We check global flag daemon_busy for the data availiability for
854 * userland to read. Deamon_busy is set to true before driver has data
855 * for daemon to read. It is set to false after daemon sends
856 * then response back to driver.
858 if (sc->daemon_busy == true)
861 selrecord(td, &sc->hv_kvp_selinfo);
863 mtx_unlock(&sc->pending_mutex);
869 hv_kvp_probe(device_t dev)
871 if (resource_disabled("hvkvp", 0))
874 if (VMBUS_PROBE_GUID(device_get_parent(dev), dev, &service_guid) == 0) {
875 device_set_desc(dev, "Hyper-V KVP Service");
876 return BUS_PROBE_DEFAULT;
882 hv_kvp_attach(device_t dev)
885 struct sysctl_oid_list *child;
886 struct sysctl_ctx_list *ctx;
888 hv_kvp_sc *sc = (hv_kvp_sc*)device_get_softc(dev);
890 sc->util_sc.callback = hv_kvp_callback;
891 sema_init(&sc->dev_sema, 0, "hv_kvp device semaphore");
892 mtx_init(&sc->pending_mutex, "hv-kvp pending mutex",
895 ctx = device_get_sysctl_ctx(dev);
896 child = SYSCTL_CHILDREN(device_get_sysctl_tree(dev));
898 SYSCTL_ADD_INT(ctx, child, OID_AUTO, "hv_kvp_log",
899 CTLFLAG_RW, &hv_kvp_log, 0, "Hyperv KVP service log level");
901 TASK_INIT(&sc->task, 0, hv_kvp_process_request, sc);
903 /* create character device */
904 error = make_dev_p(MAKEDEV_CHECKNAME | MAKEDEV_WAITOK,
915 sc->hv_kvp_dev->si_drv1 = sc;
917 return hv_util_attach(dev);
921 hv_kvp_detach(device_t dev)
923 hv_kvp_sc *sc = (hv_kvp_sc*)device_get_softc(dev);
925 if (sc->daemon_task != NULL) {
926 PROC_LOCK(sc->daemon_task);
927 kern_psignal(sc->daemon_task, SIGKILL);
928 PROC_UNLOCK(sc->daemon_task);
931 destroy_dev(sc->hv_kvp_dev);
932 return hv_util_detach(dev);
935 static device_method_t kvp_methods[] = {
936 /* Device interface */
937 DEVMETHOD(device_probe, hv_kvp_probe),
938 DEVMETHOD(device_attach, hv_kvp_attach),
939 DEVMETHOD(device_detach, hv_kvp_detach),
943 static driver_t kvp_driver = { "hvkvp", kvp_methods, sizeof(hv_kvp_sc)};
945 static devclass_t kvp_devclass;
947 DRIVER_MODULE(hv_kvp, vmbus, kvp_driver, kvp_devclass, NULL, NULL);
948 MODULE_VERSION(hv_kvp, 1);
949 MODULE_DEPEND(hv_kvp, vmbus, 1, 1, 1);