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>
29 #include <linux/hyperv.h>
31 static void shutdown_onchannelcallback(void *context
);
32 static struct hv_util_service util_shutdown
= {
33 .util_cb
= shutdown_onchannelcallback
,
36 static void timesync_onchannelcallback(void *context
);
37 static struct hv_util_service util_timesynch
= {
38 .util_cb
= timesync_onchannelcallback
,
41 static void heartbeat_onchannelcallback(void *context
);
42 static struct hv_util_service util_heartbeat
= {
43 .util_cb
= heartbeat_onchannelcallback
,
46 static struct hv_util_service util_kvp
= {
47 .util_cb
= hv_kvp_onchannelcallback
,
48 .util_init
= hv_kvp_init
,
49 .util_deinit
= hv_kvp_deinit
,
52 static void shutdown_onchannelcallback(void *context
)
54 struct vmbus_channel
*channel
= context
;
57 u8 execute_shutdown
= false;
58 u8
*shut_txf_buf
= util_shutdown
.recv_buffer
;
60 struct shutdown_msg_data
*shutdown_msg
;
62 struct icmsg_hdr
*icmsghdrp
;
63 struct icmsg_negotiate
*negop
= NULL
;
65 vmbus_recvpacket(channel
, shut_txf_buf
,
66 PAGE_SIZE
, &recvlen
, &requestid
);
69 icmsghdrp
= (struct icmsg_hdr
*)&shut_txf_buf
[
70 sizeof(struct vmbuspipe_hdr
)];
72 if (icmsghdrp
->icmsgtype
== ICMSGTYPE_NEGOTIATE
) {
73 vmbus_prep_negotiate_resp(icmsghdrp
, negop
, shut_txf_buf
);
76 (struct shutdown_msg_data
*)&shut_txf_buf
[
77 sizeof(struct vmbuspipe_hdr
) +
78 sizeof(struct icmsg_hdr
)];
80 switch (shutdown_msg
->flags
) {
83 icmsghdrp
->status
= HV_S_OK
;
84 execute_shutdown
= true;
86 pr_info("Shutdown request received -"
87 " graceful shutdown initiated\n");
90 icmsghdrp
->status
= HV_E_FAIL
;
91 execute_shutdown
= false;
93 pr_info("Shutdown request received -"
94 " Invalid request\n");
99 icmsghdrp
->icflags
= ICMSGHDRFLAG_TRANSACTION
100 | ICMSGHDRFLAG_RESPONSE
;
102 vmbus_sendpacket(channel
, shut_txf_buf
,
104 VM_PKT_DATA_INBAND
, 0);
107 if (execute_shutdown
== true)
108 orderly_poweroff(true);
112 * Set guest time to host UTC time.
114 static inline void do_adj_guesttime(u64 hosttime
)
117 struct timespec host_ts
;
119 host_tns
= (hosttime
- WLTIMEDELTA
) * 100;
120 host_ts
= ns_to_timespec(host_tns
);
122 do_settimeofday(&host_ts
);
126 * Set the host time in a process context.
129 struct adj_time_work
{
130 struct work_struct work
;
134 static void hv_set_host_time(struct work_struct
*work
)
136 struct adj_time_work
*wrk
;
138 wrk
= container_of(work
, struct adj_time_work
, work
);
139 do_adj_guesttime(wrk
->host_time
);
144 * Synchronize time with host after reboot, restore, etc.
146 * ICTIMESYNCFLAG_SYNC flag bit indicates reboot, restore events of the VM.
147 * After reboot the flag ICTIMESYNCFLAG_SYNC is included in the first time
148 * message after the timesync channel is opened. Since the hv_utils module is
149 * loaded after hv_vmbus, the first message is usually missed. The other
150 * thing is, systime is automatically set to emulated hardware clock which may
151 * not be UTC time or in the same time zone. So, to override these effects, we
152 * use the first 50 time samples for initial system time setting.
154 static inline void adj_guesttime(u64 hosttime
, u8 flags
)
156 struct adj_time_work
*wrk
;
157 static s32 scnt
= 50;
159 wrk
= kmalloc(sizeof(struct adj_time_work
), GFP_ATOMIC
);
163 wrk
->host_time
= hosttime
;
164 if ((flags
& ICTIMESYNCFLAG_SYNC
) != 0) {
165 INIT_WORK(&wrk
->work
, hv_set_host_time
);
166 schedule_work(&wrk
->work
);
170 if ((flags
& ICTIMESYNCFLAG_SAMPLE
) != 0 && scnt
> 0) {
172 INIT_WORK(&wrk
->work
, hv_set_host_time
);
173 schedule_work(&wrk
->work
);
179 * Time Sync Channel message handler.
181 static void timesync_onchannelcallback(void *context
)
183 struct vmbus_channel
*channel
= context
;
186 struct icmsg_hdr
*icmsghdrp
;
187 struct ictimesync_data
*timedatap
;
188 u8
*time_txf_buf
= util_timesynch
.recv_buffer
;
190 vmbus_recvpacket(channel
, time_txf_buf
,
191 PAGE_SIZE
, &recvlen
, &requestid
);
194 icmsghdrp
= (struct icmsg_hdr
*)&time_txf_buf
[
195 sizeof(struct vmbuspipe_hdr
)];
197 if (icmsghdrp
->icmsgtype
== ICMSGTYPE_NEGOTIATE
) {
198 vmbus_prep_negotiate_resp(icmsghdrp
, NULL
, time_txf_buf
);
200 timedatap
= (struct ictimesync_data
*)&time_txf_buf
[
201 sizeof(struct vmbuspipe_hdr
) +
202 sizeof(struct icmsg_hdr
)];
203 adj_guesttime(timedatap
->parenttime
, timedatap
->flags
);
206 icmsghdrp
->icflags
= ICMSGHDRFLAG_TRANSACTION
207 | ICMSGHDRFLAG_RESPONSE
;
209 vmbus_sendpacket(channel
, time_txf_buf
,
211 VM_PKT_DATA_INBAND
, 0);
216 * Heartbeat functionality.
217 * Every two seconds, Hyper-V send us a heartbeat request message.
218 * we respond to this message, and Hyper-V knows we are alive.
220 static void heartbeat_onchannelcallback(void *context
)
222 struct vmbus_channel
*channel
= context
;
225 struct icmsg_hdr
*icmsghdrp
;
226 struct heartbeat_msg_data
*heartbeat_msg
;
227 u8
*hbeat_txf_buf
= util_heartbeat
.recv_buffer
;
229 vmbus_recvpacket(channel
, hbeat_txf_buf
,
230 PAGE_SIZE
, &recvlen
, &requestid
);
233 icmsghdrp
= (struct icmsg_hdr
*)&hbeat_txf_buf
[
234 sizeof(struct vmbuspipe_hdr
)];
236 if (icmsghdrp
->icmsgtype
== ICMSGTYPE_NEGOTIATE
) {
237 vmbus_prep_negotiate_resp(icmsghdrp
, NULL
, hbeat_txf_buf
);
240 (struct heartbeat_msg_data
*)&hbeat_txf_buf
[
241 sizeof(struct vmbuspipe_hdr
) +
242 sizeof(struct icmsg_hdr
)];
244 heartbeat_msg
->seq_num
+= 1;
247 icmsghdrp
->icflags
= ICMSGHDRFLAG_TRANSACTION
248 | ICMSGHDRFLAG_RESPONSE
;
250 vmbus_sendpacket(channel
, hbeat_txf_buf
,
252 VM_PKT_DATA_INBAND
, 0);
256 static int util_probe(struct hv_device
*dev
,
257 const struct hv_vmbus_device_id
*dev_id
)
259 struct hv_util_service
*srv
=
260 (struct hv_util_service
*)dev_id
->driver_data
;
263 srv
->recv_buffer
= kmalloc(PAGE_SIZE
, GFP_KERNEL
);
264 if (!srv
->recv_buffer
)
266 if (srv
->util_init
) {
267 ret
= srv
->util_init(srv
);
274 ret
= vmbus_open(dev
->channel
, 2 * PAGE_SIZE
, 2 * PAGE_SIZE
, NULL
, 0,
275 srv
->util_cb
, dev
->channel
);
279 hv_set_drvdata(dev
, srv
);
283 if (srv
->util_deinit
)
286 kfree(srv
->recv_buffer
);
290 static int util_remove(struct hv_device
*dev
)
292 struct hv_util_service
*srv
= hv_get_drvdata(dev
);
294 vmbus_close(dev
->channel
);
295 if (srv
->util_deinit
)
297 kfree(srv
->recv_buffer
);
302 static const struct hv_vmbus_device_id id_table
[] = {
304 { VMBUS_DEVICE(0x31, 0x60, 0x0B, 0X0E, 0x13, 0x52, 0x34, 0x49,
305 0x81, 0x8B, 0x38, 0XD9, 0x0C, 0xED, 0x39, 0xDB)
306 .driver_data
= (unsigned long)&util_shutdown
},
307 /* Time synch guid */
308 { VMBUS_DEVICE(0x30, 0xe6, 0x27, 0x95, 0xae, 0xd0, 0x7b, 0x49,
309 0xad, 0xce, 0xe8, 0x0a, 0xb0, 0x17, 0x5c, 0xaf)
310 .driver_data
= (unsigned long)&util_timesynch
},
312 { VMBUS_DEVICE(0x39, 0x4f, 0x16, 0x57, 0x15, 0x91, 0x78, 0x4e,
313 0xab, 0x55, 0x38, 0x2f, 0x3b, 0xd5, 0x42, 0x2d)
314 .driver_data
= (unsigned long)&util_heartbeat
},
316 { VMBUS_DEVICE(0xe7, 0xf4, 0xa0, 0xa9, 0x45, 0x5a, 0x96, 0x4d,
317 0xb8, 0x27, 0x8a, 0x84, 0x1e, 0x8c, 0x3, 0xe6)
318 .driver_data
= (unsigned long)&util_kvp
},
322 MODULE_DEVICE_TABLE(vmbus
, id_table
);
324 /* The one and only one */
325 static struct hv_driver util_drv
= {
327 .id_table
= id_table
,
329 .remove
= util_remove
,
332 static int __init
init_hyperv_utils(void)
334 pr_info("Registering HyperV Utility Driver\n");
336 return vmbus_driver_register(&util_drv
);
339 static void exit_hyperv_utils(void)
341 pr_info("De-Registered HyperV Utility Driver\n");
343 vmbus_driver_unregister(&util_drv
);
346 module_init(init_hyperv_utils
);
347 module_exit(exit_hyperv_utils
);
349 MODULE_DESCRIPTION("Hyper-V Utilities");
350 MODULE_VERSION(HV_DRV_VERSION
);
351 MODULE_LICENSE("GPL");