2 * Copyright (c) 2010, Microsoft Corporation.
4 * This program is free software; you can redistribute it and/or modify it
5 * under the terms and conditions of the GNU General Public License,
6 * version 2, as published by the Free Software Foundation.
8 * This program is distributed in the hope it will be useful, but WITHOUT
9 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
13 * You should have received a copy of the GNU General Public License along with
14 * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
15 * Place - Suite 330, Boston, MA 02111-1307 USA.
18 * Haiyang Zhang <haiyangz@microsoft.com>
19 * Hank Janssen <hjanssen@microsoft.com>
21 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
23 #include <linux/kernel.h>
24 #include <linux/init.h>
25 #include <linux/module.h>
26 #include <linux/slab.h>
27 #include <linux/sysctl.h>
28 #include <linux/reboot.h>
33 static u8 *shut_txf_buf;
34 static u8 *time_txf_buf;
35 static u8 *hbeat_txf_buf;
37 static void shutdown_onchannelcallback(void *context)
39 struct vmbus_channel *channel = context;
42 u8 execute_shutdown = false;
44 struct shutdown_msg_data *shutdown_msg;
46 struct icmsg_hdr *icmsghdrp;
47 struct icmsg_negotiate *negop = NULL;
49 vmbus_recvpacket(channel, shut_txf_buf,
50 PAGE_SIZE, &recvlen, &requestid);
53 icmsghdrp = (struct icmsg_hdr *)&shut_txf_buf[
54 sizeof(struct vmbuspipe_hdr)];
56 if (icmsghdrp->icmsgtype == ICMSGTYPE_NEGOTIATE) {
57 prep_negotiate_resp(icmsghdrp, negop, shut_txf_buf);
60 (struct shutdown_msg_data *)&shut_txf_buf[
61 sizeof(struct vmbuspipe_hdr) +
62 sizeof(struct icmsg_hdr)];
64 switch (shutdown_msg->flags) {
67 icmsghdrp->status = HV_S_OK;
68 execute_shutdown = true;
70 pr_info("Shutdown request received -"
71 " graceful shutdown initiated\n");
74 icmsghdrp->status = HV_E_FAIL;
75 execute_shutdown = false;
77 pr_info("Shutdown request received -"
78 " Invalid request\n");
83 icmsghdrp->icflags = ICMSGHDRFLAG_TRANSACTION
84 | ICMSGHDRFLAG_RESPONSE;
86 vmbus_sendpacket(channel, shut_txf_buf,
88 VM_PKT_DATA_INBAND, 0);
91 if (execute_shutdown == true)
92 orderly_poweroff(true);
96 * Set guest time to host UTC time.
98 static inline void do_adj_guesttime(u64 hosttime)
101 struct timespec host_ts;
103 host_tns = (hosttime - WLTIMEDELTA) * 100;
104 host_ts = ns_to_timespec(host_tns);
106 do_settimeofday(&host_ts);
110 * Set the host time in a process context.
113 struct adj_time_work {
114 struct work_struct work;
118 static void hv_set_host_time(struct work_struct *work)
120 struct adj_time_work *wrk;
122 wrk = container_of(work, struct adj_time_work, work);
123 do_adj_guesttime(wrk->host_time);
128 * Synchronize time with host after reboot, restore, etc.
130 * ICTIMESYNCFLAG_SYNC flag bit indicates reboot, restore events of the VM.
131 * After reboot the flag ICTIMESYNCFLAG_SYNC is included in the first time
132 * message after the timesync channel is opened. Since the hv_utils module is
133 * loaded after hv_vmbus, the first message is usually missed. The other
134 * thing is, systime is automatically set to emulated hardware clock which may
135 * not be UTC time or in the same time zone. So, to override these effects, we
136 * use the first 50 time samples for initial system time setting.
138 static inline void adj_guesttime(u64 hosttime, u8 flags)
140 struct adj_time_work *wrk;
141 static s32 scnt = 50;
143 wrk = kmalloc(sizeof(struct adj_time_work), GFP_ATOMIC);
147 wrk->host_time = hosttime;
148 if ((flags & ICTIMESYNCFLAG_SYNC) != 0) {
149 INIT_WORK(&wrk->work, hv_set_host_time);
150 schedule_work(&wrk->work);
154 if ((flags & ICTIMESYNCFLAG_SAMPLE) != 0 && scnt > 0) {
156 INIT_WORK(&wrk->work, hv_set_host_time);
157 schedule_work(&wrk->work);
163 * Time Sync Channel message handler.
165 static void timesync_onchannelcallback(void *context)
167 struct vmbus_channel *channel = context;
170 struct icmsg_hdr *icmsghdrp;
171 struct ictimesync_data *timedatap;
173 vmbus_recvpacket(channel, time_txf_buf,
174 PAGE_SIZE, &recvlen, &requestid);
177 icmsghdrp = (struct icmsg_hdr *)&time_txf_buf[
178 sizeof(struct vmbuspipe_hdr)];
180 if (icmsghdrp->icmsgtype == ICMSGTYPE_NEGOTIATE) {
181 prep_negotiate_resp(icmsghdrp, NULL, time_txf_buf);
183 timedatap = (struct ictimesync_data *)&time_txf_buf[
184 sizeof(struct vmbuspipe_hdr) +
185 sizeof(struct icmsg_hdr)];
186 adj_guesttime(timedatap->parenttime, timedatap->flags);
189 icmsghdrp->icflags = ICMSGHDRFLAG_TRANSACTION
190 | ICMSGHDRFLAG_RESPONSE;
192 vmbus_sendpacket(channel, time_txf_buf,
194 VM_PKT_DATA_INBAND, 0);
199 * Heartbeat functionality.
200 * Every two seconds, Hyper-V send us a heartbeat request message.
201 * we respond to this message, and Hyper-V knows we are alive.
203 static void heartbeat_onchannelcallback(void *context)
205 struct vmbus_channel *channel = context;
208 struct icmsg_hdr *icmsghdrp;
209 struct heartbeat_msg_data *heartbeat_msg;
211 vmbus_recvpacket(channel, hbeat_txf_buf,
212 PAGE_SIZE, &recvlen, &requestid);
215 icmsghdrp = (struct icmsg_hdr *)&hbeat_txf_buf[
216 sizeof(struct vmbuspipe_hdr)];
218 if (icmsghdrp->icmsgtype == ICMSGTYPE_NEGOTIATE) {
219 prep_negotiate_resp(icmsghdrp, NULL, hbeat_txf_buf);
222 (struct heartbeat_msg_data *)&hbeat_txf_buf[
223 sizeof(struct vmbuspipe_hdr) +
224 sizeof(struct icmsg_hdr)];
226 heartbeat_msg->seq_num += 1;
229 icmsghdrp->icflags = ICMSGHDRFLAG_TRANSACTION
230 | ICMSGHDRFLAG_RESPONSE;
232 vmbus_sendpacket(channel, hbeat_txf_buf,
234 VM_PKT_DATA_INBAND, 0);
239 * The devices managed by the util driver don't need any additional
242 static int util_probe(struct hv_device *dev)
247 static int util_remove(struct hv_device *dev)
252 static const struct hv_vmbus_device_id id_table[] = {
254 { VMBUS_DEVICE(0x31, 0x60, 0x0B, 0X0E, 0x13, 0x52, 0x34, 0x49,
255 0x81, 0x8B, 0x38, 0XD9, 0x0C, 0xED, 0x39, 0xDB) },
256 /* Time synch guid */
257 { VMBUS_DEVICE(0x30, 0xe6, 0x27, 0x95, 0xae, 0xd0, 0x7b, 0x49,
258 0xad, 0xce, 0xe8, 0x0a, 0xb0, 0x17, 0x5c, 0xaf) },
260 { VMBUS_DEVICE(0x39, 0x4f, 0x16, 0x57, 0x15, 0x91, 0x78, 0x4e,
261 0xab, 0x55, 0x38, 0x2f, 0x3b, 0xd5, 0x42, 0x2d) },
263 { VMBUS_DEVICE(0xe7, 0xf4, 0xa0, 0xa9, 0x45, 0x5a, 0x96, 0x4d,
264 0xb8, 0x27, 0x8a, 0x84, 0x1e, 0x8c, 0x3, 0xe6) },
268 MODULE_DEVICE_TABLE(vmbus, id_table);
270 /* The one and only one */
271 static struct hv_driver util_drv = {
273 .id_table = id_table,
275 .remove = util_remove,
278 static int __init init_hyperv_utils(void)
280 pr_info("Registering HyperV Utility Driver\n");
286 shut_txf_buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
287 time_txf_buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
288 hbeat_txf_buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
290 if (!shut_txf_buf || !time_txf_buf || !hbeat_txf_buf) {
291 pr_info("Unable to allocate memory for receive buffer\n");
294 kfree(hbeat_txf_buf);
298 hv_cb_utils[HV_SHUTDOWN_MSG].callback = &shutdown_onchannelcallback;
300 hv_cb_utils[HV_TIMESYNC_MSG].callback = ×ync_onchannelcallback;
302 hv_cb_utils[HV_HEARTBEAT_MSG].callback = &heartbeat_onchannelcallback;
304 hv_cb_utils[HV_KVP_MSG].callback = &hv_kvp_onchannelcallback;
306 return vmbus_driver_register(&util_drv);
309 static void exit_hyperv_utils(void)
311 pr_info("De-Registered HyperV Utility Driver\n");
313 if (hv_cb_utils[HV_SHUTDOWN_MSG].channel != NULL)
314 hv_cb_utils[HV_SHUTDOWN_MSG].channel->onchannel_callback =
316 hv_cb_utils[HV_SHUTDOWN_MSG].callback = NULL;
318 if (hv_cb_utils[HV_TIMESYNC_MSG].channel != NULL)
319 hv_cb_utils[HV_TIMESYNC_MSG].channel->onchannel_callback =
321 hv_cb_utils[HV_TIMESYNC_MSG].callback = NULL;
323 if (hv_cb_utils[HV_HEARTBEAT_MSG].channel != NULL)
324 hv_cb_utils[HV_HEARTBEAT_MSG].channel->onchannel_callback =
326 hv_cb_utils[HV_HEARTBEAT_MSG].callback = NULL;
328 if (hv_cb_utils[HV_KVP_MSG].channel != NULL)
329 hv_cb_utils[HV_KVP_MSG].channel->onchannel_callback =
331 hv_cb_utils[HV_KVP_MSG].callback = NULL;
337 kfree(hbeat_txf_buf);
338 vmbus_driver_unregister(&util_drv);
341 module_init(init_hyperv_utils);
342 module_exit(exit_hyperv_utils);
344 MODULE_DESCRIPTION("Hyper-V Utilities");
345 MODULE_VERSION(HV_DRV_VERSION);
346 MODULE_LICENSE("GPL");