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 perform_shutdown(struct work_struct
*dummy
)
54 orderly_poweroff(true);
58 * Perform the shutdown operation in a thread context.
60 static DECLARE_WORK(shutdown_work
, perform_shutdown
);
62 static void shutdown_onchannelcallback(void *context
)
64 struct vmbus_channel
*channel
= context
;
67 u8 execute_shutdown
= false;
68 u8
*shut_txf_buf
= util_shutdown
.recv_buffer
;
70 struct shutdown_msg_data
*shutdown_msg
;
72 struct icmsg_hdr
*icmsghdrp
;
73 struct icmsg_negotiate
*negop
= NULL
;
75 vmbus_recvpacket(channel
, shut_txf_buf
,
76 PAGE_SIZE
, &recvlen
, &requestid
);
79 icmsghdrp
= (struct icmsg_hdr
*)&shut_txf_buf
[
80 sizeof(struct vmbuspipe_hdr
)];
82 if (icmsghdrp
->icmsgtype
== ICMSGTYPE_NEGOTIATE
) {
83 vmbus_prep_negotiate_resp(icmsghdrp
, negop
,
84 shut_txf_buf
, MAX_SRV_VER
, MAX_SRV_VER
);
87 (struct shutdown_msg_data
*)&shut_txf_buf
[
88 sizeof(struct vmbuspipe_hdr
) +
89 sizeof(struct icmsg_hdr
)];
91 switch (shutdown_msg
->flags
) {
94 icmsghdrp
->status
= HV_S_OK
;
95 execute_shutdown
= true;
97 pr_info("Shutdown request received -"
98 " graceful shutdown initiated\n");
101 icmsghdrp
->status
= HV_E_FAIL
;
102 execute_shutdown
= false;
104 pr_info("Shutdown request received -"
105 " Invalid request\n");
110 icmsghdrp
->icflags
= ICMSGHDRFLAG_TRANSACTION
111 | ICMSGHDRFLAG_RESPONSE
;
113 vmbus_sendpacket(channel
, shut_txf_buf
,
115 VM_PKT_DATA_INBAND
, 0);
118 if (execute_shutdown
== true)
119 schedule_work(&shutdown_work
);
123 * Set guest time to host UTC time.
125 static inline void do_adj_guesttime(u64 hosttime
)
128 struct timespec host_ts
;
130 host_tns
= (hosttime
- WLTIMEDELTA
) * 100;
131 host_ts
= ns_to_timespec(host_tns
);
133 do_settimeofday(&host_ts
);
137 * Set the host time in a process context.
140 struct adj_time_work
{
141 struct work_struct work
;
145 static void hv_set_host_time(struct work_struct
*work
)
147 struct adj_time_work
*wrk
;
149 wrk
= container_of(work
, struct adj_time_work
, work
);
150 do_adj_guesttime(wrk
->host_time
);
155 * Synchronize time with host after reboot, restore, etc.
157 * ICTIMESYNCFLAG_SYNC flag bit indicates reboot, restore events of the VM.
158 * After reboot the flag ICTIMESYNCFLAG_SYNC is included in the first time
159 * message after the timesync channel is opened. Since the hv_utils module is
160 * loaded after hv_vmbus, the first message is usually missed. The other
161 * thing is, systime is automatically set to emulated hardware clock which may
162 * not be UTC time or in the same time zone. So, to override these effects, we
163 * use the first 50 time samples for initial system time setting.
165 static inline void adj_guesttime(u64 hosttime
, u8 flags
)
167 struct adj_time_work
*wrk
;
168 static s32 scnt
= 50;
170 wrk
= kmalloc(sizeof(struct adj_time_work
), GFP_ATOMIC
);
174 wrk
->host_time
= hosttime
;
175 if ((flags
& ICTIMESYNCFLAG_SYNC
) != 0) {
176 INIT_WORK(&wrk
->work
, hv_set_host_time
);
177 schedule_work(&wrk
->work
);
181 if ((flags
& ICTIMESYNCFLAG_SAMPLE
) != 0 && scnt
> 0) {
183 INIT_WORK(&wrk
->work
, hv_set_host_time
);
184 schedule_work(&wrk
->work
);
190 * Time Sync Channel message handler.
192 static void timesync_onchannelcallback(void *context
)
194 struct vmbus_channel
*channel
= context
;
197 struct icmsg_hdr
*icmsghdrp
;
198 struct ictimesync_data
*timedatap
;
199 u8
*time_txf_buf
= util_timesynch
.recv_buffer
;
201 vmbus_recvpacket(channel
, time_txf_buf
,
202 PAGE_SIZE
, &recvlen
, &requestid
);
205 icmsghdrp
= (struct icmsg_hdr
*)&time_txf_buf
[
206 sizeof(struct vmbuspipe_hdr
)];
208 if (icmsghdrp
->icmsgtype
== ICMSGTYPE_NEGOTIATE
) {
209 vmbus_prep_negotiate_resp(icmsghdrp
, NULL
, time_txf_buf
,
210 MAX_SRV_VER
, MAX_SRV_VER
);
212 timedatap
= (struct ictimesync_data
*)&time_txf_buf
[
213 sizeof(struct vmbuspipe_hdr
) +
214 sizeof(struct icmsg_hdr
)];
215 adj_guesttime(timedatap
->parenttime
, timedatap
->flags
);
218 icmsghdrp
->icflags
= ICMSGHDRFLAG_TRANSACTION
219 | ICMSGHDRFLAG_RESPONSE
;
221 vmbus_sendpacket(channel
, time_txf_buf
,
223 VM_PKT_DATA_INBAND
, 0);
228 * Heartbeat functionality.
229 * Every two seconds, Hyper-V send us a heartbeat request message.
230 * we respond to this message, and Hyper-V knows we are alive.
232 static void heartbeat_onchannelcallback(void *context
)
234 struct vmbus_channel
*channel
= context
;
237 struct icmsg_hdr
*icmsghdrp
;
238 struct heartbeat_msg_data
*heartbeat_msg
;
239 u8
*hbeat_txf_buf
= util_heartbeat
.recv_buffer
;
241 vmbus_recvpacket(channel
, hbeat_txf_buf
,
242 PAGE_SIZE
, &recvlen
, &requestid
);
245 icmsghdrp
= (struct icmsg_hdr
*)&hbeat_txf_buf
[
246 sizeof(struct vmbuspipe_hdr
)];
248 if (icmsghdrp
->icmsgtype
== ICMSGTYPE_NEGOTIATE
) {
249 vmbus_prep_negotiate_resp(icmsghdrp
, NULL
,
250 hbeat_txf_buf
, MAX_SRV_VER
, MAX_SRV_VER
);
253 (struct heartbeat_msg_data
*)&hbeat_txf_buf
[
254 sizeof(struct vmbuspipe_hdr
) +
255 sizeof(struct icmsg_hdr
)];
257 heartbeat_msg
->seq_num
+= 1;
260 icmsghdrp
->icflags
= ICMSGHDRFLAG_TRANSACTION
261 | ICMSGHDRFLAG_RESPONSE
;
263 vmbus_sendpacket(channel
, hbeat_txf_buf
,
265 VM_PKT_DATA_INBAND
, 0);
269 static int util_probe(struct hv_device
*dev
,
270 const struct hv_vmbus_device_id
*dev_id
)
272 struct hv_util_service
*srv
=
273 (struct hv_util_service
*)dev_id
->driver_data
;
276 srv
->recv_buffer
= kmalloc(PAGE_SIZE
* 2, GFP_KERNEL
);
277 if (!srv
->recv_buffer
)
279 if (srv
->util_init
) {
280 ret
= srv
->util_init(srv
);
288 * The set of services managed by the util driver are not performance
289 * critical and do not need batched reading. Furthermore, some services
290 * such as KVP can only handle one message from the host at a time.
291 * Turn off batched reading for all util drivers before we open the
295 set_channel_read_state(dev
->channel
, false);
297 ret
= vmbus_open(dev
->channel
, 4 * PAGE_SIZE
, 4 * PAGE_SIZE
, NULL
, 0,
298 srv
->util_cb
, dev
->channel
);
302 hv_set_drvdata(dev
, srv
);
306 if (srv
->util_deinit
)
309 kfree(srv
->recv_buffer
);
313 static int util_remove(struct hv_device
*dev
)
315 struct hv_util_service
*srv
= hv_get_drvdata(dev
);
317 vmbus_close(dev
->channel
);
318 if (srv
->util_deinit
)
320 kfree(srv
->recv_buffer
);
325 static const struct hv_vmbus_device_id id_table
[] = {
328 .driver_data
= (unsigned long)&util_shutdown
330 /* Time synch guid */
332 .driver_data
= (unsigned long)&util_timesynch
335 { HV_HEART_BEAT_GUID
,
336 .driver_data
= (unsigned long)&util_heartbeat
340 .driver_data
= (unsigned long)&util_kvp
345 MODULE_DEVICE_TABLE(vmbus
, id_table
);
347 /* The one and only one */
348 static struct hv_driver util_drv
= {
350 .id_table
= id_table
,
352 .remove
= util_remove
,
355 static int __init
init_hyperv_utils(void)
357 pr_info("Registering HyperV Utility Driver\n");
359 return vmbus_driver_register(&util_drv
);
362 static void exit_hyperv_utils(void)
364 pr_info("De-Registered HyperV Utility Driver\n");
366 vmbus_driver_unregister(&util_drv
);
369 module_init(init_hyperv_utils
);
370 module_exit(exit_hyperv_utils
);
372 MODULE_DESCRIPTION("Hyper-V Utilities");
373 MODULE_VERSION(HV_DRV_VERSION
);
374 MODULE_LICENSE("GPL");