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