Merge branch 'upstream-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jgarzi...

[net-next-2.6.git] / drivers / staging / hv / hv_utils.c

diff --git a/drivers/staging/hv/hv_utils.c b/drivers/staging/hv/hv_utils.c
index 6ccaea27d75a72dd86295875ac83320682860922..2adc9b48ca9cf5aea96de4cc672f62327945af83 100644 (file)
--- a/drivers/staging/hv/hv_utils.c
+++ b/drivers/staging/hv/hv_utils.c
@@ -24,16 +24,18 @@
 #include <linux/slab.h>
 #include <linux/sysctl.h>
 #include <linux/reboot.h>
+#include <linux/dmi.h>
+#include <linux/pci.h>
 
 #include "logging.h"
 #include "osd.h"
 #include "vmbus.h"
-#include "VmbusPacketFormat.h"
-#include "VmbusChannelInterface.h"
-#include "VersionInfo.h"
+#include "vmbus_packet_format.h"
+#include "vmbus_channel_interface.h"
+#include "version_info.h"
 #include "channel.h"
-#include "VmbusPrivate.h"
-#include "VmbusApi.h"
+#include "vmbus_private.h"
+#include "vmbus_api.h"
 #include "utils.h"
 
 
@@ -106,31 +108,44 @@ static void shutdown_onchannelcallback(void *context)
                orderly_poweroff(false);
 }
 
-
 /*
- * Synchronize time with host after reboot, restore, etc.
+ * Set guest time to host UTC time.
  */
-static void adj_guesttime(u64 hosttime, u8 flags)
+static inline void do_adj_guesttime(u64 hosttime)
 {
        s64 host_tns;
        struct timespec host_ts;
-       static s32 scnt = 50;
 
        host_tns = (hosttime - WLTIMEDELTA) * 100;
        host_ts = ns_to_timespec(host_tns);
 
+       do_settimeofday(&host_ts);
+}
+
+/*
+ * Synchronize time with host after reboot, restore, etc.
+ *
+ * ICTIMESYNCFLAG_SYNC flag bit indicates reboot, restore events of the VM.
+ * After reboot the flag ICTIMESYNCFLAG_SYNC is included in the first time
+ * message after the timesync channel is opened. Since the hv_utils module is
+ * loaded after hv_vmbus, the first message is usually missed. The other
+ * thing is, systime is automatically set to emulated hardware clock which may
+ * not be UTC time or in the same time zone. So, to override these effects, we
+ * use the first 50 time samples for initial system time setting.
+ */
+static inline void adj_guesttime(u64 hosttime, u8 flags)
+{
+       static s32 scnt = 50;
+
        if ((flags & ICTIMESYNCFLAG_SYNC) != 0) {
-               do_settimeofday(&host_ts);
+               do_adj_guesttime(hosttime);
                return;
        }
 
-       if ((flags & ICTIMESYNCFLAG_SAMPLE) != 0 &&
-           scnt > 0) {
+       if ((flags & ICTIMESYNCFLAG_SAMPLE) != 0 && scnt > 0) {
                scnt--;
-               do_settimeofday(&host_ts);
+               do_adj_guesttime(hosttime);
        }
-
-       return;
 }
 
 /*
@@ -181,11 +196,93 @@ static void timesync_onchannelcallback(void *context)
        DPRINT_EXIT(VMBUS);
 }
 
+/*
+ * Heartbeat functionality.
+ * Every two seconds, Hyper-V send us a heartbeat request message.
+ * we respond to this message, and Hyper-V knows we are alive.
+ */
+static void heartbeat_onchannelcallback(void *context)
+{
+       struct vmbus_channel *channel = context;
+       u8 *buf;
+       u32 buflen, recvlen;
+       u64 requestid;
+       struct icmsg_hdr *icmsghdrp;
+       struct heartbeat_msg_data *heartbeat_msg;
+
+       DPRINT_ENTER(VMBUS);
+
+       buflen = PAGE_SIZE;
+       buf = kmalloc(buflen, GFP_ATOMIC);
+
+       VmbusChannelRecvPacket(channel, buf, buflen, &recvlen, &requestid);
+
+       if (recvlen > 0) {
+               DPRINT_DBG(VMBUS, "heartbeat packet: len=%d, requestid=%lld",
+                          recvlen, requestid);
+
+               icmsghdrp = (struct icmsg_hdr *)&buf[
+                       sizeof(struct vmbuspipe_hdr)];
+
+               icmsghdrp = (struct icmsg_hdr *)&buf[
+                               sizeof(struct vmbuspipe_hdr)];
+
+               if (icmsghdrp->icmsgtype == ICMSGTYPE_NEGOTIATE) {
+                       prep_negotiate_resp(icmsghdrp, NULL, buf);
+               } else {
+                       heartbeat_msg = (struct heartbeat_msg_data *)&buf[
+                               sizeof(struct vmbuspipe_hdr) +
+                               sizeof(struct icmsg_hdr)];
+
+                       DPRINT_DBG(VMBUS, "heartbeat seq = %lld",
+                                  heartbeat_msg->seq_num);
+
+                       heartbeat_msg->seq_num += 1;
+               }
+
+               icmsghdrp->icflags = ICMSGHDRFLAG_TRANSACTION
+                       | ICMSGHDRFLAG_RESPONSE;
+
+               VmbusChannelSendPacket(channel, buf,
+                                      recvlen, requestid,
+                                      VmbusPacketTypeDataInBand, 0);
+       }
+
+       kfree(buf);
+
+       DPRINT_EXIT(VMBUS);
+}
+
+static const struct pci_device_id __initconst
+hv_utils_pci_table[] __maybe_unused = {
+       { PCI_DEVICE(0x1414, 0x5353) }, /* Hyper-V emulated VGA controller */
+       { 0 }
+};
+MODULE_DEVICE_TABLE(pci, hv_utils_pci_table);
+
+
+static const struct dmi_system_id __initconst
+hv_utils_dmi_table[] __maybe_unused  = {
+       {
+               .ident = "Hyper-V",
+               .matches = {
+                       DMI_MATCH(DMI_SYS_VENDOR, "Microsoft Corporation"),
+                       DMI_MATCH(DMI_PRODUCT_NAME, "Virtual Machine"),
+                       DMI_MATCH(DMI_BOARD_NAME, "Virtual Machine"),
+               },
+       },
+       { },
+};
+MODULE_DEVICE_TABLE(dmi, hv_utils_dmi_table);
+
 
 static int __init init_hyperv_utils(void)
 {
        printk(KERN_INFO "Registering HyperV Utility Driver\n");
 
+       if (!dmi_check_system(hv_utils_dmi_table))
+               return -ENODEV;
+
        hv_cb_utils[HV_SHUTDOWN_MSG].channel->OnChannelCallback =
                &shutdown_onchannelcallback;
        hv_cb_utils[HV_SHUTDOWN_MSG].callback = &shutdown_onchannelcallback;
@@ -194,6 +291,10 @@ static int __init init_hyperv_utils(void)
                &timesync_onchannelcallback;
        hv_cb_utils[HV_TIMESYNC_MSG].callback = &timesync_onchannelcallback;
 
+       hv_cb_utils[HV_HEARTBEAT_MSG].channel->OnChannelCallback =
+               &heartbeat_onchannelcallback;
+       hv_cb_utils[HV_HEARTBEAT_MSG].callback = &heartbeat_onchannelcallback;
+
        return 0;
 }
 
@@ -208,6 +309,10 @@ static void exit_hyperv_utils(void)
        hv_cb_utils[HV_TIMESYNC_MSG].channel->OnChannelCallback =
                &chn_cb_negotiate;
        hv_cb_utils[HV_TIMESYNC_MSG].callback = &chn_cb_negotiate;
+
+       hv_cb_utils[HV_HEARTBEAT_MSG].channel->OnChannelCallback =
+               &chn_cb_negotiate;
+       hv_cb_utils[HV_HEARTBEAT_MSG].callback = &chn_cb_negotiate;
 }
 
 module_init(init_hyperv_utils);