5 files changed, 283 insertions, 97 deletions

diff --git a/drivers/hv/hv.c b/drivers/hv/hv.c
index 86f8885aeb45..3648f8f0f368 100644
--- a/drivers/hv/hv.c
+++ b/drivers/hv/hv.c
@@ -26,6 +26,7 @@
 #include <linux/slab.h>
 #include <linux/vmalloc.h>
 #include <linux/hyperv.h>
+#include <linux/version.h>
 #include <asm/hyperv.h>
 #include "hyperv_vmbus.h"
 
@@ -38,28 +39,6 @@ struct hv_context hv_context = {
 };
 
 /*
- * query_hypervisor_presence
- * - Query the cpuid for presence of windows hypervisor
- */
-static int query_hypervisor_presence(void)
-{
-        unsigned int eax;
-        unsigned int ebx;
-        unsigned int ecx;
-        unsigned int edx;
-        unsigned int op;
-
-        eax = 0;
-        ebx = 0;
-        ecx = 0;
-        edx = 0;
-        op = HVCPUID_VERSION_FEATURES;
-        cpuid(op, &eax, &ebx, &ecx, &edx);
-
-        return ecx & HV_PRESENT_BIT;
-}
-
-/*
  * query_hypervisor_info - Get version info of the windows hypervisor
  */
 static int query_hypervisor_info(void)
@@ -159,14 +138,13 @@ int hv_init(void)
         memset(hv_context.synic_message_page, 0,
                sizeof(void *) * NR_CPUS);
 
-        if (!query_hypervisor_presence())
-                goto cleanup;
-
         max_leaf = query_hypervisor_info();
 
-        /* Write our OS info */
-        wrmsrl(HV_X64_MSR_GUEST_OS_ID, HV_LINUX_GUEST_ID);
-        hv_context.guestid = HV_LINUX_GUEST_ID;
+        /*
+         * Write our OS ID.
+         */
+        hv_context.guestid = generate_guest_id(0, LINUX_VERSION_CODE, 0);
+        wrmsrl(HV_X64_MSR_GUEST_OS_ID, hv_context.guestid);
 
         /* See if the hypercall page is already set */
         rdmsrl(HV_X64_MSR_HYPERCALL, hypercall_msr.as_uint64);
diff --git a/drivers/hv/hv_kvp.c b/drivers/hv/hv_kvp.c
index 0012eed6d872..ed50e9e83c61 100644
--- a/drivers/hv/hv_kvp.c
+++ b/drivers/hv/hv_kvp.c
@@ -48,13 +48,24 @@ static struct {
         void *kvp_context; /* for the channel callback */
 } kvp_transaction;
 
+/*
+ * Before we can accept KVP messages from the host, we need
+ * to handshake with the user level daemon. This state tracks
+ * if we are in the handshake phase.
+ */
+static bool in_hand_shake = true;
+
+/*
+ * This state maintains the version number registered by the daemon.
+ */
+static int dm_reg_value;
+
 static void kvp_send_key(struct work_struct *dummy);
 
-#define TIMEOUT_FIRED 1
 
-static void kvp_respond_to_host(char *key, char *value, int error);
+static void kvp_respond_to_host(struct hv_kvp_msg *msg, int error);
 static void kvp_work_func(struct work_struct *dummy);
-static void kvp_register(void);
+static void kvp_register(int);
 
 static DECLARE_DELAYED_WORK(kvp_work, kvp_work_func);
 static DECLARE_WORK(kvp_sendkey_work, kvp_send_key);
@@ -68,7 +79,7 @@ static u8 *recv_buffer;
  */
 
 static void
-kvp_register(void)
+kvp_register(int reg_value)
 {
 
         struct cn_msg *msg;
@@ -83,7 +94,7 @@ kvp_register(void)
                 msg->id.idx =  CN_KVP_IDX;
                 msg->id.val = CN_KVP_VAL;
 
-                kvp_msg->kvp_hdr.operation = KVP_OP_REGISTER;
+                kvp_msg->kvp_hdr.operation = reg_value;
                 strcpy(version, HV_DRV_VERSION);
                 msg->len = sizeof(struct hv_kvp_msg);
                 cn_netlink_send(msg, 0, GFP_ATOMIC);
@@ -97,9 +108,43 @@ kvp_work_func(struct work_struct *dummy)
          * If the timer fires, the user-mode component has not responded;
          * process the pending transaction.
          */
-        kvp_respond_to_host("Unknown key", "Guest timed out", TIMEOUT_FIRED);
+        kvp_respond_to_host(NULL, HV_E_FAIL);
+}
+
+static int kvp_handle_handshake(struct hv_kvp_msg *msg)
+{
+        int ret = 1;
+
+        switch (msg->kvp_hdr.operation) {
+        case KVP_OP_REGISTER:
+                dm_reg_value = KVP_OP_REGISTER;
+                pr_info("KVP: IP injection functionality not available\n");
+                pr_info("KVP: Upgrade the KVP daemon\n");
+                break;
+        case KVP_OP_REGISTER1:
+                dm_reg_value = KVP_OP_REGISTER1;
+                break;
+        default:
+                pr_info("KVP: incompatible daemon\n");
+                pr_info("KVP: KVP version: %d, Daemon version: %d\n",
+                        KVP_OP_REGISTER1, msg->kvp_hdr.operation);
+                ret = 0;
+        }
+
+        if (ret) {
+                /*
+                 * We have a compatible daemon; complete the handshake.
+                 */
+                pr_info("KVP: user-mode registering done.\n");
+                kvp_register(dm_reg_value);
+                kvp_transaction.active = false;
+                if (kvp_transaction.kvp_context)
+                        hv_kvp_onchannelcallback(kvp_transaction.kvp_context);
+        }
+        return ret;
 }
 
+
 /*
  * Callback when data is received from user mode.
  */
@@ -109,29 +154,165 @@ kvp_cn_callback(struct cn_msg *msg, struct netlink_skb_parms *nsp)
 {
         struct hv_kvp_msg *message;
         struct hv_kvp_msg_enumerate *data;
+        int     error = 0;
 
         message = (struct hv_kvp_msg *)msg->data;
-        switch (message->kvp_hdr.operation) {
+
+        /*
+         * If we are negotiating the version information
+         * with the daemon; handle that first.
+         */
+
+        if (in_hand_shake) {
+                if (kvp_handle_handshake(message))
+                        in_hand_shake = false;
+                return;
+        }
+
+        /*
+         * Based on the version of the daemon, we propagate errors from the
+         * daemon differently.
+         */
+
+        data = &message->body.kvp_enum_data;
+
+        switch (dm_reg_value) {
         case KVP_OP_REGISTER:
-                pr_info("KVP: user-mode registering done.\n");
-                kvp_register();
-                kvp_transaction.active = false;
-                hv_kvp_onchannelcallback(kvp_transaction.kvp_context);
+                /*
+                 * Null string is used to pass back error condition.
+                 */
+                if (data->data.key[0] == 0)
+                        error = HV_S_CONT;
                 break;
 
-        default:
-                data = &message->body.kvp_enum_data;
+        case KVP_OP_REGISTER1:
                 /*
-                 * Complete the transaction by forwarding the key value
-                 * to the host. But first, cancel the timeout.
+                 * We use the message header information from
+                 * the user level daemon to transmit errors.
                  */
-                if (cancel_delayed_work_sync(&kvp_work))
-                        kvp_respond_to_host(data->data.key,
-                                         data->data.value,
-                                        !strlen(data->data.key));
+                error = message->error;
+                break;
+        }
+
+        /*
+         * Complete the transaction by forwarding the key value
+         * to the host. But first, cancel the timeout.
+         */
+        if (cancel_delayed_work_sync(&kvp_work))
+                kvp_respond_to_host(message, error);
+}
+
+
+static int process_ob_ipinfo(void *in_msg, void *out_msg, int op)
+{
+        struct hv_kvp_msg *in = in_msg;
+        struct hv_kvp_ip_msg *out = out_msg;
+        int len;
+
+        switch (op) {
+        case KVP_OP_GET_IP_INFO:
+                /*
+                 * Transform all parameters into utf16 encoding.
+                 */
+                len = utf8s_to_utf16s((char *)in->body.kvp_ip_val.ip_addr,
+                                strlen((char *)in->body.kvp_ip_val.ip_addr),
+                                UTF16_HOST_ENDIAN,
+                                (wchar_t *)out->kvp_ip_val.ip_addr,
+                                MAX_IP_ADDR_SIZE);
+                if (len < 0)
+                        return len;
+
+                len = utf8s_to_utf16s((char *)in->body.kvp_ip_val.sub_net,
+                                strlen((char *)in->body.kvp_ip_val.sub_net),
+                                UTF16_HOST_ENDIAN,
+                                (wchar_t *)out->kvp_ip_val.sub_net,
+                                MAX_IP_ADDR_SIZE);
+                if (len < 0)
+                        return len;
+
+                len = utf8s_to_utf16s((char *)in->body.kvp_ip_val.gate_way,
+                                strlen((char *)in->body.kvp_ip_val.gate_way),
+                                UTF16_HOST_ENDIAN,
+                                (wchar_t *)out->kvp_ip_val.gate_way,
+                                MAX_GATEWAY_SIZE);
+                if (len < 0)
+                        return len;
+
+                len = utf8s_to_utf16s((char *)in->body.kvp_ip_val.dns_addr,
+                                strlen((char *)in->body.kvp_ip_val.dns_addr),
+                                UTF16_HOST_ENDIAN,
+                                (wchar_t *)out->kvp_ip_val.dns_addr,
+                                MAX_IP_ADDR_SIZE);
+                if (len < 0)
+                        return len;
+
+                len = utf8s_to_utf16s((char *)in->body.kvp_ip_val.adapter_id,
+                                strlen((char *)in->body.kvp_ip_val.adapter_id),
+                                UTF16_HOST_ENDIAN,
+                                (wchar_t *)out->kvp_ip_val.adapter_id,
+                                MAX_IP_ADDR_SIZE);
+                if (len < 0)
+                        return len;
+
+                out->kvp_ip_val.dhcp_enabled =
+                        in->body.kvp_ip_val.dhcp_enabled;
+                out->kvp_ip_val.addr_family =
+                        in->body.kvp_ip_val.addr_family;
+        }
+
+        return 0;
+}
+
+static void process_ib_ipinfo(void *in_msg, void *out_msg, int op)
+{
+        struct hv_kvp_ip_msg *in = in_msg;
+        struct hv_kvp_msg *out = out_msg;
+
+        switch (op) {
+        case KVP_OP_SET_IP_INFO:
+                /*
+                 * Transform all parameters into utf8 encoding.
+                 */
+                utf16s_to_utf8s((wchar_t *)in->kvp_ip_val.ip_addr,
+                                MAX_IP_ADDR_SIZE,
+                                UTF16_LITTLE_ENDIAN,
+                                (__u8 *)out->body.kvp_ip_val.ip_addr,
+                                MAX_IP_ADDR_SIZE);
+
+                utf16s_to_utf8s((wchar_t *)in->kvp_ip_val.sub_net,
+                                MAX_IP_ADDR_SIZE,
+                                UTF16_LITTLE_ENDIAN,
+                                (__u8 *)out->body.kvp_ip_val.sub_net,
+                                MAX_IP_ADDR_SIZE);
+
+                utf16s_to_utf8s((wchar_t *)in->kvp_ip_val.gate_way,
+                                MAX_GATEWAY_SIZE,
+                                UTF16_LITTLE_ENDIAN,
+                                (__u8 *)out->body.kvp_ip_val.gate_way,
+                                MAX_GATEWAY_SIZE);
+
+                utf16s_to_utf8s((wchar_t *)in->kvp_ip_val.dns_addr,
+                                MAX_IP_ADDR_SIZE,
+                                UTF16_LITTLE_ENDIAN,
+                                (__u8 *)out->body.kvp_ip_val.dns_addr,
+                                MAX_IP_ADDR_SIZE);
+
+                out->body.kvp_ip_val.dhcp_enabled = in->kvp_ip_val.dhcp_enabled;
+
+        default:
+                utf16s_to_utf8s((wchar_t *)in->kvp_ip_val.adapter_id,
+                                MAX_ADAPTER_ID_SIZE,
+                                UTF16_LITTLE_ENDIAN,
+                                (__u8 *)out->body.kvp_ip_val.adapter_id,
+                                MAX_ADAPTER_ID_SIZE);
+
+                out->body.kvp_ip_val.addr_family = in->kvp_ip_val.addr_family;
         }
 }
 
+
+
+
 static void
 kvp_send_key(struct work_struct *dummy)
 {
@@ -167,6 +348,12 @@ kvp_send_key(struct work_struct *dummy)
          */
 
         switch (message->kvp_hdr.operation) {
+        case KVP_OP_SET_IP_INFO:
+                process_ib_ipinfo(in_msg, message, KVP_OP_SET_IP_INFO);
+                break;
+        case KVP_OP_GET_IP_INFO:
+                process_ib_ipinfo(in_msg, message, KVP_OP_GET_IP_INFO);
+                break;
         case KVP_OP_SET:
                 switch (in_msg->body.kvp_set.data.value_type) {
                 case REG_SZ:
@@ -243,17 +430,19 @@ kvp_send_key(struct work_struct *dummy)
  */
 
 static void
-kvp_respond_to_host(char *key, char *value, int error)
+kvp_respond_to_host(struct hv_kvp_msg *msg_to_host, int error)
 {
         struct hv_kvp_msg  *kvp_msg;
         struct hv_kvp_exchg_msg_value  *kvp_data;
         char    *key_name;
+        char    *value;
         struct icmsg_hdr *icmsghdrp;
         int     keylen = 0;
         int     valuelen = 0;
         u32     buf_len;
         struct vmbus_channel *channel;
         u64     req_id;
+        int ret;
 
         /*
          * If a transaction is not active; log and return.
@@ -287,6 +476,7 @@ kvp_respond_to_host(char *key, char *value, int error)
                  */
                 return;
 
+        icmsghdrp->status = error;
 
         /*
          * If the error parameter is set, terminate the host's enumeration
@@ -294,20 +484,27 @@ kvp_respond_to_host(char *key, char *value, int error)
          */
         if (error) {
                 /*
-                 * Something failed or the we have timedout;
-                 * terminate the current  host-side iteration.
+                 * Something failed or we have timedout;
+                 * terminate the current host-side iteration.
                  */
-                icmsghdrp->status = HV_S_CONT;
                 goto response_done;
         }
 
-        icmsghdrp->status = HV_S_OK;
-
         kvp_msg = (struct hv_kvp_msg *)
                         &recv_buffer[sizeof(struct vmbuspipe_hdr) +
                         sizeof(struct icmsg_hdr)];
 
         switch (kvp_transaction.kvp_msg->kvp_hdr.operation) {
+        case KVP_OP_GET_IP_INFO:
+                ret = process_ob_ipinfo(msg_to_host,
+                                 (struct hv_kvp_ip_msg *)kvp_msg,
+                                 KVP_OP_GET_IP_INFO);
+                if (ret < 0)
+                        icmsghdrp->status = HV_E_FAIL;
+
+                goto response_done;
+        case KVP_OP_SET_IP_INFO:
+                goto response_done;
         case KVP_OP_GET:
                 kvp_data = &kvp_msg->body.kvp_get.data;
                 goto copy_value;
@@ -321,7 +518,7 @@ kvp_respond_to_host(char *key, char *value, int error)
         }
 
         kvp_data = &kvp_msg->body.kvp_enum_data.data;
-        key_name = key;
+        key_name = msg_to_host->body.kvp_enum_data.data.key;
 
         /*
          * The windows host expects the key/value pair to be encoded
@@ -335,6 +532,7 @@ kvp_respond_to_host(char *key, char *value, int error)
         kvp_data->key_size = 2*(keylen + 1); /* utf16 encoding */
 
 copy_value:
+        value = msg_to_host->body.kvp_enum_data.data.value;
         valuelen = utf8s_to_utf16s(value, strlen(value), UTF16_HOST_ENDIAN,
                                 (wchar_t *) kvp_data->value,
                                 (HV_KVP_EXCHANGE_MAX_VALUE_SIZE / 2) - 2);
@@ -387,7 +585,8 @@ void hv_kvp_onchannelcallback(void *context)
                 return;
         }
 
-        vmbus_recvpacket(channel, recv_buffer, PAGE_SIZE, &recvlen, &requestid);
+        vmbus_recvpacket(channel, recv_buffer, PAGE_SIZE * 2, &recvlen,
+                         &requestid);
 
         if (recvlen > 0) {
                 icmsghdrp = (struct icmsg_hdr *)&recv_buffer[
diff --git a/drivers/hv/hv_util.c b/drivers/hv/hv_util.c
index d3ac6a40118b..a0667de7a04c 100644
--- a/drivers/hv/hv_util.c
+++ b/drivers/hv/hv_util.c
@@ -263,7 +263,7 @@ static int util_probe(struct hv_device *dev,
                 (struct hv_util_service *)dev_id->driver_data;
         int ret;
 
-        srv->recv_buffer = kmalloc(PAGE_SIZE, GFP_KERNEL);
+        srv->recv_buffer = kmalloc(PAGE_SIZE * 2, GFP_KERNEL);
         if (!srv->recv_buffer)
                 return -ENOMEM;
         if (srv->util_init) {
@@ -274,7 +274,7 @@ static int util_probe(struct hv_device *dev,
                 }
         }
 
-        ret = vmbus_open(dev->channel, 2 * PAGE_SIZE, 2 * PAGE_SIZE, NULL, 0,
+        ret = vmbus_open(dev->channel, 4 * PAGE_SIZE, 4 * PAGE_SIZE, NULL, 0,
                         srv->util_cb, dev->channel);
         if (ret)
                 goto error;
diff --git a/drivers/hv/hyperv_vmbus.h b/drivers/hv/hyperv_vmbus.h
index 0614ff3a7d7e..d8d1fadb398a 100644
--- a/drivers/hv/hyperv_vmbus.h
+++ b/drivers/hv/hyperv_vmbus.h
@@ -410,10 +410,49 @@ enum {
 
 #define HV_PRESENT_BIT                  0x80000000
 
-#define HV_LINUX_GUEST_ID_LO            0x00000000
-#define HV_LINUX_GUEST_ID_HI            2976579765
-#define HV_LINUX_GUEST_ID               (((u64)HV_LINUX_GUEST_ID_HI << 32) | \
-                                           HV_LINUX_GUEST_ID_LO)
+/*
+ * The guest OS needs to register the guest ID with the hypervisor.
+ * The guest ID is a 64 bit entity and the structure of this ID is
+ * specified in the Hyper-V specification:
+ *
+ * http://msdn.microsoft.com/en-us/library/windows/hardware/ff542653%28v=vs.85%29.aspx
+ *
+ * While the current guideline does not specify how Linux guest ID(s)
+ * need to be generated, our plan is to publish the guidelines for
+ * Linux and other guest operating systems that currently are hosted
+ * on Hyper-V. The implementation here conforms to this yet
+ * unpublished guidelines.
+ *
+ *
+ * Bit(s)
+ * 63 - Indicates if the OS is Open Source or not; 1 is Open Source
+ * 62:56 - Os Type; Linux is 0x100
+ * 55:48 - Distro specific identification
+ * 47:16 - Linux kernel version number
+ * 15:0  - Distro specific identification
+ *
+ *
+ */
+
+#define HV_LINUX_VENDOR_ID              0x8100
+
+/*
+ * Generate the guest ID based on the guideline described above.
+ */
+
+static inline  __u64 generate_guest_id(__u8 d_info1, __u32 kernel_version,
+                                        __u16 d_info2)
+{
+        __u64 guest_id = 0;
+
+        guest_id = (((__u64)HV_LINUX_VENDOR_ID) << 48);
+        guest_id |= (((__u64)(d_info1)) << 48);
+        guest_id |= (((__u64)(kernel_version)) << 16);
+        guest_id |= ((__u64)(d_info2));
+
+        return guest_id;
+}
+
 
 #define HV_CPU_POWER_MANAGEMENT         (1 << 0)
 #define HV_RECOMMENDATIONS_MAX          4
diff --git a/drivers/hv/vmbus_drv.c b/drivers/hv/vmbus_drv.c
index 4748086eaaf2..8e1a9ec53003 100644
--- a/drivers/hv/vmbus_drv.c
+++ b/drivers/hv/vmbus_drv.c
@@ -34,6 +34,7 @@
 #include <linux/completion.h>
 #include <linux/hyperv.h>
 #include <asm/hyperv.h>
+#include <asm/hypervisor.h>
 #include "hyperv_vmbus.h"
 
 
@@ -146,43 +147,9 @@ static ssize_t vmbus_show_device_attr(struct device *dev,
         get_channel_info(hv_dev, device_info);
 
         if (!strcmp(dev_attr->attr.name, "class_id")) {
-                ret = sprintf(buf, "{%02x%02x%02x%02x-%02x%02x-%02x%02x-"
-                               "%02x%02x%02x%02x%02x%02x%02x%02x}\n",
-                               device_info->chn_type.b[3],
-                               device_info->chn_type.b[2],
-                               device_info->chn_type.b[1],
-                               device_info->chn_type.b[0],
-                               device_info->chn_type.b[5],
-                               device_info->chn_type.b[4],
-                               device_info->chn_type.b[7],
-                               device_info->chn_type.b[6],
-                               device_info->chn_type.b[8],
-                               device_info->chn_type.b[9],
-                               device_info->chn_type.b[10],
-                               device_info->chn_type.b[11],
-                               device_info->chn_type.b[12],
-                               device_info->chn_type.b[13],
-                               device_info->chn_type.b[14],
-                               device_info->chn_type.b[15]);
+                ret = sprintf(buf, "{%pUl}\n", device_info->chn_type.b);
         } else if (!strcmp(dev_attr->attr.name, "device_id")) {
-                ret = sprintf(buf, "{%02x%02x%02x%02x-%02x%02x-%02x%02x-"
-                               "%02x%02x%02x%02x%02x%02x%02x%02x}\n",
-                               device_info->chn_instance.b[3],
-                               device_info->chn_instance.b[2],
-                               device_info->chn_instance.b[1],
-                               device_info->chn_instance.b[0],
-                               device_info->chn_instance.b[5],
-                               device_info->chn_instance.b[4],
-                               device_info->chn_instance.b[7],
-                               device_info->chn_instance.b[6],
-                               device_info->chn_instance.b[8],
-                               device_info->chn_instance.b[9],
-                               device_info->chn_instance.b[10],
-                               device_info->chn_instance.b[11],
-                               device_info->chn_instance.b[12],
-                               device_info->chn_instance.b[13],
-                               device_info->chn_instance.b[14],
-                               device_info->chn_instance.b[15]);
+                ret = sprintf(buf, "{%pUl}\n", device_info->chn_instance.b);
         } else if (!strcmp(dev_attr->attr.name, "modalias")) {
                 print_alias_name(hv_dev, alias_name);
                 ret = sprintf(buf, "vmbus:%s\n", alias_name);
@@ -757,6 +724,9 @@ static int __init hv_acpi_init(void)
 {
         int ret, t;
 
+        if (x86_hyper != &x86_hyper_ms_hyperv)
+                return -ENODEV;
+
         init_completion(&probe_event);
 
         /*