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>
33 * Pre win8 version numbers used in ws2008 and ws 2008 r2 (win7)
35 #define WIN7_SRV_MAJOR 3
36 #define WIN7_SRV_MINOR 0
37 #define WIN7_SRV_MAJOR_MINOR (WIN7_SRV_MAJOR << 16 | WIN7_SRV_MINOR)
39 #define WIN8_SRV_MAJOR 4
40 #define WIN8_SRV_MINOR 0
41 #define WIN8_SRV_MAJOR_MINOR (WIN8_SRV_MAJOR << 16 | WIN8_SRV_MINOR)
44 * Global state maintained for transaction that is being processed.
45 * Note that only one transaction can be active at any point in time.
47 * This state is set when we receive a request from the host; we
48 * cleanup this state when the transaction is completed - when we respond
49 * to the host with the key value.
53 bool active
; /* transaction status - active or not */
54 int recv_len
; /* number of bytes received. */
55 struct hv_kvp_msg
*kvp_msg
; /* current message */
56 struct vmbus_channel
*recv_channel
; /* chn we got the request */
57 u64 recv_req_id
; /* request ID. */
58 void *kvp_context
; /* for the channel callback */
62 * Before we can accept KVP messages from the host, we need
63 * to handshake with the user level daemon. This state tracks
64 * if we are in the handshake phase.
66 static bool in_hand_shake
= true;
69 * This state maintains the version number registered by the daemon.
71 static int dm_reg_value
;
73 static void kvp_send_key(struct work_struct
*dummy
);
76 static void kvp_respond_to_host(struct hv_kvp_msg
*msg
, int error
);
77 static void kvp_work_func(struct work_struct
*dummy
);
78 static void kvp_register(int);
80 static DECLARE_DELAYED_WORK(kvp_work
, kvp_work_func
);
81 static DECLARE_WORK(kvp_sendkey_work
, kvp_send_key
);
83 static struct cb_id kvp_id
= { CN_KVP_IDX
, CN_KVP_VAL
};
84 static const char kvp_name
[] = "kvp_kernel_module";
85 static u8
*recv_buffer
;
87 * Register the kernel component with the user-level daemon.
88 * As part of this registration, pass the LIC version number.
89 * This number has no meaning, it satisfies the registration protocol.
91 #define HV_DRV_VERSION "3.1"
94 kvp_register(int reg_value
)
98 struct hv_kvp_msg
*kvp_msg
;
101 msg
= kzalloc(sizeof(*msg
) + sizeof(struct hv_kvp_msg
), GFP_ATOMIC
);
104 kvp_msg
= (struct hv_kvp_msg
*)msg
->data
;
105 version
= kvp_msg
->body
.kvp_register
.version
;
106 msg
->id
.idx
= CN_KVP_IDX
;
107 msg
->id
.val
= CN_KVP_VAL
;
109 kvp_msg
->kvp_hdr
.operation
= reg_value
;
110 strcpy(version
, HV_DRV_VERSION
);
111 msg
->len
= sizeof(struct hv_kvp_msg
);
112 cn_netlink_send(msg
, 0, GFP_ATOMIC
);
117 kvp_work_func(struct work_struct
*dummy
)
120 * If the timer fires, the user-mode component has not responded;
121 * process the pending transaction.
123 kvp_respond_to_host(NULL
, HV_E_FAIL
);
126 static int kvp_handle_handshake(struct hv_kvp_msg
*msg
)
130 switch (msg
->kvp_hdr
.operation
) {
131 case KVP_OP_REGISTER
:
132 dm_reg_value
= KVP_OP_REGISTER
;
133 pr_info("KVP: IP injection functionality not available\n");
134 pr_info("KVP: Upgrade the KVP daemon\n");
136 case KVP_OP_REGISTER1
:
137 dm_reg_value
= KVP_OP_REGISTER1
;
140 pr_info("KVP: incompatible daemon\n");
141 pr_info("KVP: KVP version: %d, Daemon version: %d\n",
142 KVP_OP_REGISTER1
, msg
->kvp_hdr
.operation
);
148 * We have a compatible daemon; complete the handshake.
150 pr_info("KVP: user-mode registering done.\n");
151 kvp_register(dm_reg_value
);
152 kvp_transaction
.active
= false;
153 if (kvp_transaction
.kvp_context
)
154 hv_kvp_onchannelcallback(kvp_transaction
.kvp_context
);
161 * Callback when data is received from user mode.
165 kvp_cn_callback(struct cn_msg
*msg
, struct netlink_skb_parms
*nsp
)
167 struct hv_kvp_msg
*message
;
168 struct hv_kvp_msg_enumerate
*data
;
171 message
= (struct hv_kvp_msg
*)msg
->data
;
174 * If we are negotiating the version information
175 * with the daemon; handle that first.
179 if (kvp_handle_handshake(message
))
180 in_hand_shake
= false;
185 * Based on the version of the daemon, we propagate errors from the
186 * daemon differently.
189 data
= &message
->body
.kvp_enum_data
;
191 switch (dm_reg_value
) {
192 case KVP_OP_REGISTER
:
194 * Null string is used to pass back error condition.
196 if (data
->data
.key
[0] == 0)
200 case KVP_OP_REGISTER1
:
202 * We use the message header information from
203 * the user level daemon to transmit errors.
205 error
= message
->error
;
210 * Complete the transaction by forwarding the key value
211 * to the host. But first, cancel the timeout.
213 if (cancel_delayed_work_sync(&kvp_work
))
214 kvp_respond_to_host(message
, error
);
218 static int process_ob_ipinfo(void *in_msg
, void *out_msg
, int op
)
220 struct hv_kvp_msg
*in
= in_msg
;
221 struct hv_kvp_ip_msg
*out
= out_msg
;
225 case KVP_OP_GET_IP_INFO
:
227 * Transform all parameters into utf16 encoding.
229 len
= utf8s_to_utf16s((char *)in
->body
.kvp_ip_val
.ip_addr
,
230 strlen((char *)in
->body
.kvp_ip_val
.ip_addr
),
232 (wchar_t *)out
->kvp_ip_val
.ip_addr
,
237 len
= utf8s_to_utf16s((char *)in
->body
.kvp_ip_val
.sub_net
,
238 strlen((char *)in
->body
.kvp_ip_val
.sub_net
),
240 (wchar_t *)out
->kvp_ip_val
.sub_net
,
245 len
= utf8s_to_utf16s((char *)in
->body
.kvp_ip_val
.gate_way
,
246 strlen((char *)in
->body
.kvp_ip_val
.gate_way
),
248 (wchar_t *)out
->kvp_ip_val
.gate_way
,
253 len
= utf8s_to_utf16s((char *)in
->body
.kvp_ip_val
.dns_addr
,
254 strlen((char *)in
->body
.kvp_ip_val
.dns_addr
),
256 (wchar_t *)out
->kvp_ip_val
.dns_addr
,
261 len
= utf8s_to_utf16s((char *)in
->body
.kvp_ip_val
.adapter_id
,
262 strlen((char *)in
->body
.kvp_ip_val
.adapter_id
),
264 (wchar_t *)out
->kvp_ip_val
.adapter_id
,
269 out
->kvp_ip_val
.dhcp_enabled
=
270 in
->body
.kvp_ip_val
.dhcp_enabled
;
271 out
->kvp_ip_val
.addr_family
=
272 in
->body
.kvp_ip_val
.addr_family
;
278 static void process_ib_ipinfo(void *in_msg
, void *out_msg
, int op
)
280 struct hv_kvp_ip_msg
*in
= in_msg
;
281 struct hv_kvp_msg
*out
= out_msg
;
284 case KVP_OP_SET_IP_INFO
:
286 * Transform all parameters into utf8 encoding.
288 utf16s_to_utf8s((wchar_t *)in
->kvp_ip_val
.ip_addr
,
291 (__u8
*)out
->body
.kvp_ip_val
.ip_addr
,
294 utf16s_to_utf8s((wchar_t *)in
->kvp_ip_val
.sub_net
,
297 (__u8
*)out
->body
.kvp_ip_val
.sub_net
,
300 utf16s_to_utf8s((wchar_t *)in
->kvp_ip_val
.gate_way
,
303 (__u8
*)out
->body
.kvp_ip_val
.gate_way
,
306 utf16s_to_utf8s((wchar_t *)in
->kvp_ip_val
.dns_addr
,
309 (__u8
*)out
->body
.kvp_ip_val
.dns_addr
,
312 out
->body
.kvp_ip_val
.dhcp_enabled
= in
->kvp_ip_val
.dhcp_enabled
;
315 utf16s_to_utf8s((wchar_t *)in
->kvp_ip_val
.adapter_id
,
318 (__u8
*)out
->body
.kvp_ip_val
.adapter_id
,
319 MAX_ADAPTER_ID_SIZE
);
321 out
->body
.kvp_ip_val
.addr_family
= in
->kvp_ip_val
.addr_family
;
329 kvp_send_key(struct work_struct
*dummy
)
332 struct hv_kvp_msg
*message
;
333 struct hv_kvp_msg
*in_msg
;
334 __u8 operation
= kvp_transaction
.kvp_msg
->kvp_hdr
.operation
;
335 __u8 pool
= kvp_transaction
.kvp_msg
->kvp_hdr
.pool
;
339 msg
= kzalloc(sizeof(*msg
) + sizeof(struct hv_kvp_msg
) , GFP_ATOMIC
);
343 msg
->id
.idx
= CN_KVP_IDX
;
344 msg
->id
.val
= CN_KVP_VAL
;
346 message
= (struct hv_kvp_msg
*)msg
->data
;
347 message
->kvp_hdr
.operation
= operation
;
348 message
->kvp_hdr
.pool
= pool
;
349 in_msg
= kvp_transaction
.kvp_msg
;
352 * The key/value strings sent from the host are encoded in
353 * in utf16; convert it to utf8 strings.
354 * The host assures us that the utf16 strings will not exceed
355 * the max lengths specified. We will however, reserve room
356 * for the string terminating character - in the utf16s_utf8s()
357 * function we limit the size of the buffer where the converted
358 * string is placed to HV_KVP_EXCHANGE_MAX_*_SIZE -1 to gaurantee
359 * that the strings can be properly terminated!
362 switch (message
->kvp_hdr
.operation
) {
363 case KVP_OP_SET_IP_INFO
:
364 process_ib_ipinfo(in_msg
, message
, KVP_OP_SET_IP_INFO
);
366 case KVP_OP_GET_IP_INFO
:
367 process_ib_ipinfo(in_msg
, message
, KVP_OP_GET_IP_INFO
);
370 switch (in_msg
->body
.kvp_set
.data
.value_type
) {
373 * The value is a string - utf16 encoding.
375 message
->body
.kvp_set
.data
.value_size
=
377 (wchar_t *)in_msg
->body
.kvp_set
.data
.value
,
378 in_msg
->body
.kvp_set
.data
.value_size
,
380 message
->body
.kvp_set
.data
.value
,
381 HV_KVP_EXCHANGE_MAX_VALUE_SIZE
- 1) + 1;
386 * The value is a 32 bit scalar.
387 * We save this as a utf8 string.
389 val32
= in_msg
->body
.kvp_set
.data
.value_u32
;
390 message
->body
.kvp_set
.data
.value_size
=
391 sprintf(message
->body
.kvp_set
.data
.value
,
397 * The value is a 64 bit scalar.
398 * We save this as a utf8 string.
400 val64
= in_msg
->body
.kvp_set
.data
.value_u64
;
401 message
->body
.kvp_set
.data
.value_size
=
402 sprintf(message
->body
.kvp_set
.data
.value
,
408 message
->body
.kvp_set
.data
.key_size
=
410 (wchar_t *)in_msg
->body
.kvp_set
.data
.key
,
411 in_msg
->body
.kvp_set
.data
.key_size
,
413 message
->body
.kvp_set
.data
.key
,
414 HV_KVP_EXCHANGE_MAX_KEY_SIZE
- 1) + 1;
418 message
->body
.kvp_delete
.key_size
=
420 (wchar_t *)in_msg
->body
.kvp_delete
.key
,
421 in_msg
->body
.kvp_delete
.key_size
,
423 message
->body
.kvp_delete
.key
,
424 HV_KVP_EXCHANGE_MAX_KEY_SIZE
- 1) + 1;
427 case KVP_OP_ENUMERATE
:
428 message
->body
.kvp_enum_data
.index
=
429 in_msg
->body
.kvp_enum_data
.index
;
433 msg
->len
= sizeof(struct hv_kvp_msg
);
434 cn_netlink_send(msg
, 0, GFP_ATOMIC
);
441 * Send a response back to the host.
445 kvp_respond_to_host(struct hv_kvp_msg
*msg_to_host
, int error
)
447 struct hv_kvp_msg
*kvp_msg
;
448 struct hv_kvp_exchg_msg_value
*kvp_data
;
451 struct icmsg_hdr
*icmsghdrp
;
455 struct vmbus_channel
*channel
;
460 * If a transaction is not active; log and return.
463 if (!kvp_transaction
.active
) {
465 * This is a spurious call!
467 pr_warn("KVP: Transaction not active\n");
471 * Copy the global state for completing the transaction. Note that
472 * only one transaction can be active at a time.
475 buf_len
= kvp_transaction
.recv_len
;
476 channel
= kvp_transaction
.recv_channel
;
477 req_id
= kvp_transaction
.recv_req_id
;
479 kvp_transaction
.active
= false;
481 icmsghdrp
= (struct icmsg_hdr
*)
482 &recv_buffer
[sizeof(struct vmbuspipe_hdr
)];
484 if (channel
->onchannel_callback
== NULL
)
486 * We have raced with util driver being unloaded;
491 icmsghdrp
->status
= error
;
494 * If the error parameter is set, terminate the host's enumeration
499 * Something failed or we have timedout;
500 * terminate the current host-side iteration.
505 kvp_msg
= (struct hv_kvp_msg
*)
506 &recv_buffer
[sizeof(struct vmbuspipe_hdr
) +
507 sizeof(struct icmsg_hdr
)];
509 switch (kvp_transaction
.kvp_msg
->kvp_hdr
.operation
) {
510 case KVP_OP_GET_IP_INFO
:
511 ret
= process_ob_ipinfo(msg_to_host
,
512 (struct hv_kvp_ip_msg
*)kvp_msg
,
515 icmsghdrp
->status
= HV_E_FAIL
;
518 case KVP_OP_SET_IP_INFO
:
521 kvp_data
= &kvp_msg
->body
.kvp_get
.data
;
532 kvp_data
= &kvp_msg
->body
.kvp_enum_data
.data
;
533 key_name
= msg_to_host
->body
.kvp_enum_data
.data
.key
;
536 * The windows host expects the key/value pair to be encoded
537 * in utf16. Ensure that the key/value size reported to the host
538 * will be less than or equal to the MAX size (including the
539 * terminating character).
541 keylen
= utf8s_to_utf16s(key_name
, strlen(key_name
), UTF16_HOST_ENDIAN
,
542 (wchar_t *) kvp_data
->key
,
543 (HV_KVP_EXCHANGE_MAX_KEY_SIZE
/ 2) - 2);
544 kvp_data
->key_size
= 2*(keylen
+ 1); /* utf16 encoding */
547 value
= msg_to_host
->body
.kvp_enum_data
.data
.value
;
548 valuelen
= utf8s_to_utf16s(value
, strlen(value
), UTF16_HOST_ENDIAN
,
549 (wchar_t *) kvp_data
->value
,
550 (HV_KVP_EXCHANGE_MAX_VALUE_SIZE
/ 2) - 2);
551 kvp_data
->value_size
= 2*(valuelen
+ 1); /* utf16 encoding */
554 * If the utf8s to utf16s conversion failed; notify host
557 if ((keylen
< 0) || (valuelen
< 0))
558 icmsghdrp
->status
= HV_E_FAIL
;
560 kvp_data
->value_type
= REG_SZ
; /* all our values are strings */
563 icmsghdrp
->icflags
= ICMSGHDRFLAG_TRANSACTION
| ICMSGHDRFLAG_RESPONSE
;
565 vmbus_sendpacket(channel
, recv_buffer
, buf_len
, req_id
,
566 VM_PKT_DATA_INBAND
, 0);
571 * This callback is invoked when we get a KVP message from the host.
572 * The host ensures that only one KVP transaction can be active at a time.
573 * KVP implementation in Linux needs to forward the key to a user-mde
574 * component to retrive the corresponding value. Consequently, we cannot
575 * respond to the host in the conext of this callback. Since the host
576 * guarantees that at most only one transaction can be active at a time,
577 * we stash away the transaction state in a set of global variables.
580 void hv_kvp_onchannelcallback(void *context
)
582 struct vmbus_channel
*channel
= context
;
586 struct hv_kvp_msg
*kvp_msg
;
588 struct icmsg_hdr
*icmsghdrp
;
589 struct icmsg_negotiate
*negop
= NULL
;
591 if (kvp_transaction
.active
) {
593 * We will defer processing this callback once
594 * the current transaction is complete.
596 kvp_transaction
.kvp_context
= context
;
600 vmbus_recvpacket(channel
, recv_buffer
, PAGE_SIZE
* 2, &recvlen
,
604 icmsghdrp
= (struct icmsg_hdr
*)&recv_buffer
[
605 sizeof(struct vmbuspipe_hdr
)];
607 if (icmsghdrp
->icmsgtype
== ICMSGTYPE_NEGOTIATE
) {
609 * We start with win8 version and if the host cannot
610 * support that we use the previous version.
612 if (vmbus_prep_negotiate_resp(icmsghdrp
, negop
,
613 recv_buffer
, UTIL_FW_MAJOR_MINOR
,
614 WIN8_SRV_MAJOR_MINOR
))
617 vmbus_prep_negotiate_resp(icmsghdrp
, negop
,
618 recv_buffer
, UTIL_FW_MAJOR_MINOR
,
619 WIN7_SRV_MAJOR_MINOR
);
622 kvp_msg
= (struct hv_kvp_msg
*)&recv_buffer
[
623 sizeof(struct vmbuspipe_hdr
) +
624 sizeof(struct icmsg_hdr
)];
627 * Stash away this global state for completing the
628 * transaction; note transactions are serialized.
631 kvp_transaction
.recv_len
= recvlen
;
632 kvp_transaction
.recv_channel
= channel
;
633 kvp_transaction
.recv_req_id
= requestid
;
634 kvp_transaction
.active
= true;
635 kvp_transaction
.kvp_msg
= kvp_msg
;
638 * Get the information from the
639 * user-mode component.
640 * component. This transaction will be
641 * completed when we get the value from
642 * the user-mode component.
643 * Set a timeout to deal with
644 * user-mode not responding.
646 schedule_work(&kvp_sendkey_work
);
647 schedule_delayed_work(&kvp_work
, 5*HZ
);
654 icmsghdrp
->icflags
= ICMSGHDRFLAG_TRANSACTION
655 | ICMSGHDRFLAG_RESPONSE
;
657 vmbus_sendpacket(channel
, recv_buffer
,
659 VM_PKT_DATA_INBAND
, 0);
665 hv_kvp_init(struct hv_util_service
*srv
)
669 err
= cn_add_callback(&kvp_id
, kvp_name
, kvp_cn_callback
);
672 recv_buffer
= srv
->recv_buffer
;
675 * When this driver loads, the user level daemon that
676 * processes the host requests may not yet be running.
677 * Defer processing channel callbacks until the daemon
680 kvp_transaction
.active
= true;
685 void hv_kvp_deinit(void)
687 cn_del_callback(&kvp_id
);
688 cancel_delayed_work_sync(&kvp_work
);
689 cancel_work_sync(&kvp_sendkey_work
);