2 * An implementation of key value pair (KVP) functionality for Linux.
5 * Copyright (C) 2010, Novell, Inc.
6 * Author : K. Y. Srinivasan <ksrinivasan@novell.com>
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License version 2 as published
10 * by the Free Software Foundation.
12 * This program is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
15 * NON INFRINGEMENT. See the GNU General Public License for more
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
23 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
25 #include <linux/net.h>
26 #include <linux/nls.h>
27 #include <linux/connector.h>
28 #include <linux/workqueue.h>
29 #include <linux/hyperv.h>
31 #include "hyperv_vmbus.h"
32 #include "hv_utils_transport.h"
35 * Pre win8 version numbers used in ws2008 and ws 2008 r2 (win7)
37 #define WS2008_SRV_MAJOR 1
38 #define WS2008_SRV_MINOR 0
39 #define WS2008_SRV_VERSION (WS2008_SRV_MAJOR << 16 | WS2008_SRV_MINOR)
41 #define WIN7_SRV_MAJOR 3
42 #define WIN7_SRV_MINOR 0
43 #define WIN7_SRV_VERSION (WIN7_SRV_MAJOR << 16 | WIN7_SRV_MINOR)
45 #define WIN8_SRV_MAJOR 4
46 #define WIN8_SRV_MINOR 0
47 #define WIN8_SRV_VERSION (WIN8_SRV_MAJOR << 16 | WIN8_SRV_MINOR)
50 * Global state maintained for transaction that is being processed. For a class
51 * of integration services, including the "KVP service", the specified protocol
52 * is a "request/response" protocol which means that there can only be single
53 * outstanding transaction from the host at any given point in time. We use
54 * this to simplify memory management in this driver - we cache and process
55 * only one message at a time.
57 * While the request/response protocol is guaranteed by the host, we further
58 * ensure this by serializing packet processing in this driver - we do not
59 * read additional packets from the VMBUs until the current packet is fully
64 int state
; /* hvutil_device_state */
65 int recv_len
; /* number of bytes received. */
66 struct hv_kvp_msg
*kvp_msg
; /* current message */
67 struct vmbus_channel
*recv_channel
; /* chn we got the request */
68 u64 recv_req_id
; /* request ID. */
69 void *kvp_context
; /* for the channel callback */
73 * This state maintains the version number registered by the daemon.
75 static int dm_reg_value
;
77 static void kvp_send_key(struct work_struct
*dummy
);
80 static void kvp_respond_to_host(struct hv_kvp_msg
*msg
, int error
);
81 static void kvp_timeout_func(struct work_struct
*dummy
);
82 static void kvp_register(int);
84 static DECLARE_DELAYED_WORK(kvp_timeout_work
, kvp_timeout_func
);
85 static DECLARE_WORK(kvp_sendkey_work
, kvp_send_key
);
87 static const char kvp_devname
[] = "vmbus/hv_kvp";
88 static u8
*recv_buffer
;
89 static struct hvutil_transport
*hvt
;
91 * Register the kernel component with the user-level daemon.
92 * As part of this registration, pass the LIC version number.
93 * This number has no meaning, it satisfies the registration protocol.
95 #define HV_DRV_VERSION "3.1"
98 kvp_register(int reg_value
)
101 struct hv_kvp_msg
*kvp_msg
;
104 kvp_msg
= kzalloc(sizeof(*kvp_msg
), GFP_KERNEL
);
107 version
= kvp_msg
->body
.kvp_register
.version
;
108 kvp_msg
->kvp_hdr
.operation
= reg_value
;
109 strcpy(version
, HV_DRV_VERSION
);
111 hvutil_transport_send(hvt
, kvp_msg
, sizeof(*kvp_msg
));
116 static void kvp_timeout_func(struct work_struct
*dummy
)
119 * If the timer fires, the user-mode component has not responded;
120 * process the pending transaction.
122 kvp_respond_to_host(NULL
, HV_E_FAIL
);
124 /* Transaction is finished, reset the state. */
125 if (kvp_transaction
.state
> HVUTIL_READY
)
126 kvp_transaction
.state
= HVUTIL_READY
;
128 hv_poll_channel(kvp_transaction
.kvp_context
,
129 hv_kvp_onchannelcallback
);
132 static int kvp_handle_handshake(struct hv_kvp_msg
*msg
)
134 switch (msg
->kvp_hdr
.operation
) {
135 case KVP_OP_REGISTER
:
136 dm_reg_value
= KVP_OP_REGISTER
;
137 pr_info("KVP: IP injection functionality not available\n");
138 pr_info("KVP: Upgrade the KVP daemon\n");
140 case KVP_OP_REGISTER1
:
141 dm_reg_value
= KVP_OP_REGISTER1
;
144 pr_info("KVP: incompatible daemon\n");
145 pr_info("KVP: KVP version: %d, Daemon version: %d\n",
146 KVP_OP_REGISTER1
, msg
->kvp_hdr
.operation
);
151 * We have a compatible daemon; complete the handshake.
153 pr_debug("KVP: userspace daemon ver. %d registered\n",
155 kvp_register(dm_reg_value
);
156 kvp_transaction
.state
= HVUTIL_READY
;
163 * Callback when data is received from user mode.
166 static int kvp_on_msg(void *msg
, int len
)
168 struct hv_kvp_msg
*message
= (struct hv_kvp_msg
*)msg
;
169 struct hv_kvp_msg_enumerate
*data
;
172 if (len
< sizeof(*message
))
176 * If we are negotiating the version information
177 * with the daemon; handle that first.
180 if (kvp_transaction
.state
< HVUTIL_READY
) {
181 return kvp_handle_handshake(message
);
184 /* We didn't send anything to userspace so the reply is spurious */
185 if (kvp_transaction
.state
< HVUTIL_USERSPACE_REQ
)
188 kvp_transaction
.state
= HVUTIL_USERSPACE_RECV
;
191 * Based on the version of the daemon, we propagate errors from the
192 * daemon differently.
195 data
= &message
->body
.kvp_enum_data
;
197 switch (dm_reg_value
) {
198 case KVP_OP_REGISTER
:
200 * Null string is used to pass back error condition.
202 if (data
->data
.key
[0] == 0)
206 case KVP_OP_REGISTER1
:
208 * We use the message header information from
209 * the user level daemon to transmit errors.
211 error
= message
->error
;
216 * Complete the transaction by forwarding the key value
217 * to the host. But first, cancel the timeout.
219 if (cancel_delayed_work_sync(&kvp_timeout_work
)) {
220 kvp_respond_to_host(message
, error
);
221 kvp_transaction
.state
= HVUTIL_READY
;
222 hv_poll_channel(kvp_transaction
.kvp_context
,
223 hv_kvp_onchannelcallback
);
230 static int process_ob_ipinfo(void *in_msg
, void *out_msg
, int op
)
232 struct hv_kvp_msg
*in
= in_msg
;
233 struct hv_kvp_ip_msg
*out
= out_msg
;
237 case KVP_OP_GET_IP_INFO
:
239 * Transform all parameters into utf16 encoding.
241 len
= utf8s_to_utf16s((char *)in
->body
.kvp_ip_val
.ip_addr
,
242 strlen((char *)in
->body
.kvp_ip_val
.ip_addr
),
244 (wchar_t *)out
->kvp_ip_val
.ip_addr
,
249 len
= utf8s_to_utf16s((char *)in
->body
.kvp_ip_val
.sub_net
,
250 strlen((char *)in
->body
.kvp_ip_val
.sub_net
),
252 (wchar_t *)out
->kvp_ip_val
.sub_net
,
257 len
= utf8s_to_utf16s((char *)in
->body
.kvp_ip_val
.gate_way
,
258 strlen((char *)in
->body
.kvp_ip_val
.gate_way
),
260 (wchar_t *)out
->kvp_ip_val
.gate_way
,
265 len
= utf8s_to_utf16s((char *)in
->body
.kvp_ip_val
.dns_addr
,
266 strlen((char *)in
->body
.kvp_ip_val
.dns_addr
),
268 (wchar_t *)out
->kvp_ip_val
.dns_addr
,
273 len
= utf8s_to_utf16s((char *)in
->body
.kvp_ip_val
.adapter_id
,
274 strlen((char *)in
->body
.kvp_ip_val
.adapter_id
),
276 (wchar_t *)out
->kvp_ip_val
.adapter_id
,
281 out
->kvp_ip_val
.dhcp_enabled
=
282 in
->body
.kvp_ip_val
.dhcp_enabled
;
283 out
->kvp_ip_val
.addr_family
=
284 in
->body
.kvp_ip_val
.addr_family
;
290 static void process_ib_ipinfo(void *in_msg
, void *out_msg
, int op
)
292 struct hv_kvp_ip_msg
*in
= in_msg
;
293 struct hv_kvp_msg
*out
= out_msg
;
296 case KVP_OP_SET_IP_INFO
:
298 * Transform all parameters into utf8 encoding.
300 utf16s_to_utf8s((wchar_t *)in
->kvp_ip_val
.ip_addr
,
303 (__u8
*)out
->body
.kvp_ip_val
.ip_addr
,
306 utf16s_to_utf8s((wchar_t *)in
->kvp_ip_val
.sub_net
,
309 (__u8
*)out
->body
.kvp_ip_val
.sub_net
,
312 utf16s_to_utf8s((wchar_t *)in
->kvp_ip_val
.gate_way
,
315 (__u8
*)out
->body
.kvp_ip_val
.gate_way
,
318 utf16s_to_utf8s((wchar_t *)in
->kvp_ip_val
.dns_addr
,
321 (__u8
*)out
->body
.kvp_ip_val
.dns_addr
,
324 out
->body
.kvp_ip_val
.dhcp_enabled
= in
->kvp_ip_val
.dhcp_enabled
;
327 utf16s_to_utf8s((wchar_t *)in
->kvp_ip_val
.adapter_id
,
330 (__u8
*)out
->body
.kvp_ip_val
.adapter_id
,
331 MAX_ADAPTER_ID_SIZE
);
333 out
->body
.kvp_ip_val
.addr_family
= in
->kvp_ip_val
.addr_family
;
341 kvp_send_key(struct work_struct
*dummy
)
343 struct hv_kvp_msg
*message
;
344 struct hv_kvp_msg
*in_msg
;
345 __u8 operation
= kvp_transaction
.kvp_msg
->kvp_hdr
.operation
;
346 __u8 pool
= kvp_transaction
.kvp_msg
->kvp_hdr
.pool
;
351 /* The transaction state is wrong. */
352 if (kvp_transaction
.state
!= HVUTIL_HOSTMSG_RECEIVED
)
355 message
= kzalloc(sizeof(*message
), GFP_KERNEL
);
356 message
->kvp_hdr
.operation
= operation
;
357 message
->kvp_hdr
.pool
= pool
;
358 in_msg
= kvp_transaction
.kvp_msg
;
361 * The key/value strings sent from the host are encoded in
362 * in utf16; convert it to utf8 strings.
363 * The host assures us that the utf16 strings will not exceed
364 * the max lengths specified. We will however, reserve room
365 * for the string terminating character - in the utf16s_utf8s()
366 * function we limit the size of the buffer where the converted
367 * string is placed to HV_KVP_EXCHANGE_MAX_*_SIZE -1 to gaurantee
368 * that the strings can be properly terminated!
371 switch (message
->kvp_hdr
.operation
) {
372 case KVP_OP_SET_IP_INFO
:
373 process_ib_ipinfo(in_msg
, message
, KVP_OP_SET_IP_INFO
);
375 case KVP_OP_GET_IP_INFO
:
376 process_ib_ipinfo(in_msg
, message
, KVP_OP_GET_IP_INFO
);
379 switch (in_msg
->body
.kvp_set
.data
.value_type
) {
382 * The value is a string - utf16 encoding.
384 message
->body
.kvp_set
.data
.value_size
=
386 (wchar_t *)in_msg
->body
.kvp_set
.data
.value
,
387 in_msg
->body
.kvp_set
.data
.value_size
,
389 message
->body
.kvp_set
.data
.value
,
390 HV_KVP_EXCHANGE_MAX_VALUE_SIZE
- 1) + 1;
395 * The value is a 32 bit scalar.
396 * We save this as a utf8 string.
398 val32
= in_msg
->body
.kvp_set
.data
.value_u32
;
399 message
->body
.kvp_set
.data
.value_size
=
400 sprintf(message
->body
.kvp_set
.data
.value
,
406 * The value is a 64 bit scalar.
407 * We save this as a utf8 string.
409 val64
= in_msg
->body
.kvp_set
.data
.value_u64
;
410 message
->body
.kvp_set
.data
.value_size
=
411 sprintf(message
->body
.kvp_set
.data
.value
,
417 message
->body
.kvp_set
.data
.key_size
=
419 (wchar_t *)in_msg
->body
.kvp_set
.data
.key
,
420 in_msg
->body
.kvp_set
.data
.key_size
,
422 message
->body
.kvp_set
.data
.key
,
423 HV_KVP_EXCHANGE_MAX_KEY_SIZE
- 1) + 1;
427 message
->body
.kvp_delete
.key_size
=
429 (wchar_t *)in_msg
->body
.kvp_delete
.key
,
430 in_msg
->body
.kvp_delete
.key_size
,
432 message
->body
.kvp_delete
.key
,
433 HV_KVP_EXCHANGE_MAX_KEY_SIZE
- 1) + 1;
436 case KVP_OP_ENUMERATE
:
437 message
->body
.kvp_enum_data
.index
=
438 in_msg
->body
.kvp_enum_data
.index
;
442 kvp_transaction
.state
= HVUTIL_USERSPACE_REQ
;
443 rc
= hvutil_transport_send(hvt
, message
, sizeof(*message
));
445 pr_debug("KVP: failed to communicate to the daemon: %d\n", rc
);
446 if (cancel_delayed_work_sync(&kvp_timeout_work
)) {
447 kvp_respond_to_host(message
, HV_E_FAIL
);
448 kvp_transaction
.state
= HVUTIL_READY
;
458 * Send a response back to the host.
462 kvp_respond_to_host(struct hv_kvp_msg
*msg_to_host
, int error
)
464 struct hv_kvp_msg
*kvp_msg
;
465 struct hv_kvp_exchg_msg_value
*kvp_data
;
468 struct icmsg_hdr
*icmsghdrp
;
472 struct vmbus_channel
*channel
;
477 * Copy the global state for completing the transaction. Note that
478 * only one transaction can be active at a time.
481 buf_len
= kvp_transaction
.recv_len
;
482 channel
= kvp_transaction
.recv_channel
;
483 req_id
= kvp_transaction
.recv_req_id
;
485 icmsghdrp
= (struct icmsg_hdr
*)
486 &recv_buffer
[sizeof(struct vmbuspipe_hdr
)];
488 if (channel
->onchannel_callback
== NULL
)
490 * We have raced with util driver being unloaded;
495 icmsghdrp
->status
= error
;
498 * If the error parameter is set, terminate the host's enumeration
503 * Something failed or we have timedout;
504 * terminate the current host-side iteration.
509 kvp_msg
= (struct hv_kvp_msg
*)
510 &recv_buffer
[sizeof(struct vmbuspipe_hdr
) +
511 sizeof(struct icmsg_hdr
)];
513 switch (kvp_transaction
.kvp_msg
->kvp_hdr
.operation
) {
514 case KVP_OP_GET_IP_INFO
:
515 ret
= process_ob_ipinfo(msg_to_host
,
516 (struct hv_kvp_ip_msg
*)kvp_msg
,
519 icmsghdrp
->status
= HV_E_FAIL
;
522 case KVP_OP_SET_IP_INFO
:
525 kvp_data
= &kvp_msg
->body
.kvp_get
.data
;
536 kvp_data
= &kvp_msg
->body
.kvp_enum_data
.data
;
537 key_name
= msg_to_host
->body
.kvp_enum_data
.data
.key
;
540 * The windows host expects the key/value pair to be encoded
541 * in utf16. Ensure that the key/value size reported to the host
542 * will be less than or equal to the MAX size (including the
543 * terminating character).
545 keylen
= utf8s_to_utf16s(key_name
, strlen(key_name
), UTF16_HOST_ENDIAN
,
546 (wchar_t *) kvp_data
->key
,
547 (HV_KVP_EXCHANGE_MAX_KEY_SIZE
/ 2) - 2);
548 kvp_data
->key_size
= 2*(keylen
+ 1); /* utf16 encoding */
551 value
= msg_to_host
->body
.kvp_enum_data
.data
.value
;
552 valuelen
= utf8s_to_utf16s(value
, strlen(value
), UTF16_HOST_ENDIAN
,
553 (wchar_t *) kvp_data
->value
,
554 (HV_KVP_EXCHANGE_MAX_VALUE_SIZE
/ 2) - 2);
555 kvp_data
->value_size
= 2*(valuelen
+ 1); /* utf16 encoding */
558 * If the utf8s to utf16s conversion failed; notify host
561 if ((keylen
< 0) || (valuelen
< 0))
562 icmsghdrp
->status
= HV_E_FAIL
;
564 kvp_data
->value_type
= REG_SZ
; /* all our values are strings */
567 icmsghdrp
->icflags
= ICMSGHDRFLAG_TRANSACTION
| ICMSGHDRFLAG_RESPONSE
;
569 vmbus_sendpacket(channel
, recv_buffer
, buf_len
, req_id
,
570 VM_PKT_DATA_INBAND
, 0);
574 * This callback is invoked when we get a KVP message from the host.
575 * The host ensures that only one KVP transaction can be active at a time.
576 * KVP implementation in Linux needs to forward the key to a user-mde
577 * component to retrive the corresponding value. Consequently, we cannot
578 * respond to the host in the conext of this callback. Since the host
579 * guarantees that at most only one transaction can be active at a time,
580 * we stash away the transaction state in a set of global variables.
583 void hv_kvp_onchannelcallback(void *context
)
585 struct vmbus_channel
*channel
= context
;
589 struct hv_kvp_msg
*kvp_msg
;
591 struct icmsg_hdr
*icmsghdrp
;
592 struct icmsg_negotiate
*negop
= NULL
;
596 if (kvp_transaction
.state
> HVUTIL_READY
) {
598 * We will defer processing this callback once
599 * the current transaction is complete.
601 kvp_transaction
.kvp_context
= context
;
604 kvp_transaction
.kvp_context
= NULL
;
606 vmbus_recvpacket(channel
, recv_buffer
, PAGE_SIZE
* 4, &recvlen
,
610 icmsghdrp
= (struct icmsg_hdr
*)&recv_buffer
[
611 sizeof(struct vmbuspipe_hdr
)];
613 if (icmsghdrp
->icmsgtype
== ICMSGTYPE_NEGOTIATE
) {
615 * Based on the host, select appropriate
616 * framework and service versions we will
619 switch (vmbus_proto_version
) {
620 case (VERSION_WS2008
):
621 util_fw_version
= UTIL_WS2K8_FW_VERSION
;
622 kvp_srv_version
= WS2008_SRV_VERSION
;
625 util_fw_version
= UTIL_FW_VERSION
;
626 kvp_srv_version
= WIN7_SRV_VERSION
;
629 util_fw_version
= UTIL_FW_VERSION
;
630 kvp_srv_version
= WIN8_SRV_VERSION
;
632 vmbus_prep_negotiate_resp(icmsghdrp
, negop
,
633 recv_buffer
, util_fw_version
,
637 kvp_msg
= (struct hv_kvp_msg
*)&recv_buffer
[
638 sizeof(struct vmbuspipe_hdr
) +
639 sizeof(struct icmsg_hdr
)];
642 * Stash away this global state for completing the
643 * transaction; note transactions are serialized.
646 kvp_transaction
.recv_len
= recvlen
;
647 kvp_transaction
.recv_channel
= channel
;
648 kvp_transaction
.recv_req_id
= requestid
;
649 kvp_transaction
.kvp_msg
= kvp_msg
;
651 if (kvp_transaction
.state
< HVUTIL_READY
) {
652 /* Userspace is not registered yet */
653 kvp_respond_to_host(NULL
, HV_E_FAIL
);
656 kvp_transaction
.state
= HVUTIL_HOSTMSG_RECEIVED
;
659 * Get the information from the
660 * user-mode component.
661 * component. This transaction will be
662 * completed when we get the value from
663 * the user-mode component.
664 * Set a timeout to deal with
665 * user-mode not responding.
667 schedule_work(&kvp_sendkey_work
);
668 schedule_delayed_work(&kvp_timeout_work
, 5*HZ
);
674 icmsghdrp
->icflags
= ICMSGHDRFLAG_TRANSACTION
675 | ICMSGHDRFLAG_RESPONSE
;
677 vmbus_sendpacket(channel
, recv_buffer
,
679 VM_PKT_DATA_INBAND
, 0);
684 static void kvp_on_reset(void)
686 if (cancel_delayed_work_sync(&kvp_timeout_work
))
687 kvp_respond_to_host(NULL
, HV_E_FAIL
);
688 kvp_transaction
.state
= HVUTIL_DEVICE_INIT
;
692 hv_kvp_init(struct hv_util_service
*srv
)
694 recv_buffer
= srv
->recv_buffer
;
697 * When this driver loads, the user level daemon that
698 * processes the host requests may not yet be running.
699 * Defer processing channel callbacks until the daemon
702 kvp_transaction
.state
= HVUTIL_DEVICE_INIT
;
704 hvt
= hvutil_transport_init(kvp_devname
, CN_KVP_IDX
, CN_KVP_VAL
,
705 kvp_on_msg
, kvp_on_reset
);
712 void hv_kvp_deinit(void)
714 kvp_transaction
.state
= HVUTIL_DEVICE_DYING
;
715 cancel_delayed_work_sync(&kvp_timeout_work
);
716 cancel_work_sync(&kvp_sendkey_work
);
717 hvutil_transport_destroy(hvt
);