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>
30 #include <asm/mshyperv.h>
32 #include "hyperv_vmbus.h"
36 #define SD_VERSION (SD_MAJOR << 16 | SD_MINOR)
39 #define SD_VERSION_1 (SD_MAJOR_1 << 16 | SD_MINOR)
43 #define TS_VERSION (TS_MAJOR << 16 | TS_MINOR)
46 #define TS_VERSION_1 (TS_MAJOR_1 << 16 | TS_MINOR)
49 #define TS_VERSION_3 (TS_MAJOR_3 << 16 | TS_MINOR)
53 #define HB_VERSION (HB_MAJOR << 16 | HB_MINOR)
56 #define HB_VERSION_1 (HB_MAJOR_1 << 16 | HB_MINOR)
58 static int sd_srv_version;
59 static int ts_srv_version;
60 static int hb_srv_version;
62 #define SD_VER_COUNT 2
63 static const int sd_versions[] = {
68 #define TS_VER_COUNT 3
69 static const int ts_versions[] = {
75 #define HB_VER_COUNT 2
76 static const int hb_versions[] = {
81 #define FW_VER_COUNT 2
82 static const int fw_versions[] = {
87 static void shutdown_onchannelcallback(void *context);
88 static struct hv_util_service util_shutdown = {
89 .util_cb = shutdown_onchannelcallback,
92 static int hv_timesync_init(struct hv_util_service *srv);
93 static void hv_timesync_deinit(void);
95 static void timesync_onchannelcallback(void *context);
96 static struct hv_util_service util_timesynch = {
97 .util_cb = timesync_onchannelcallback,
98 .util_init = hv_timesync_init,
99 .util_deinit = hv_timesync_deinit,
102 static void heartbeat_onchannelcallback(void *context);
103 static struct hv_util_service util_heartbeat = {
104 .util_cb = heartbeat_onchannelcallback,
107 static struct hv_util_service util_kvp = {
108 .util_cb = hv_kvp_onchannelcallback,
109 .util_init = hv_kvp_init,
110 .util_deinit = hv_kvp_deinit,
113 static struct hv_util_service util_vss = {
114 .util_cb = hv_vss_onchannelcallback,
115 .util_init = hv_vss_init,
116 .util_deinit = hv_vss_deinit,
119 static struct hv_util_service util_fcopy = {
120 .util_cb = hv_fcopy_onchannelcallback,
121 .util_init = hv_fcopy_init,
122 .util_deinit = hv_fcopy_deinit,
125 static void perform_shutdown(struct work_struct *dummy)
127 orderly_poweroff(true);
131 * Perform the shutdown operation in a thread context.
133 static DECLARE_WORK(shutdown_work, perform_shutdown);
135 static void shutdown_onchannelcallback(void *context)
137 struct vmbus_channel *channel = context;
140 bool execute_shutdown = false;
141 u8 *shut_txf_buf = util_shutdown.recv_buffer;
143 struct shutdown_msg_data *shutdown_msg;
145 struct icmsg_hdr *icmsghdrp;
147 vmbus_recvpacket(channel, shut_txf_buf,
148 PAGE_SIZE, &recvlen, &requestid);
151 icmsghdrp = (struct icmsg_hdr *)&shut_txf_buf[
152 sizeof(struct vmbuspipe_hdr)];
154 if (icmsghdrp->icmsgtype == ICMSGTYPE_NEGOTIATE) {
155 if (vmbus_prep_negotiate_resp(icmsghdrp, shut_txf_buf,
156 fw_versions, FW_VER_COUNT,
157 sd_versions, SD_VER_COUNT,
158 NULL, &sd_srv_version)) {
159 pr_info("Shutdown IC version %d.%d\n",
160 sd_srv_version >> 16,
161 sd_srv_version & 0xFFFF);
165 (struct shutdown_msg_data *)&shut_txf_buf[
166 sizeof(struct vmbuspipe_hdr) +
167 sizeof(struct icmsg_hdr)];
169 switch (shutdown_msg->flags) {
172 icmsghdrp->status = HV_S_OK;
173 execute_shutdown = true;
175 pr_info("Shutdown request received -"
176 " graceful shutdown initiated\n");
179 icmsghdrp->status = HV_E_FAIL;
180 execute_shutdown = false;
182 pr_info("Shutdown request received -"
183 " Invalid request\n");
188 icmsghdrp->icflags = ICMSGHDRFLAG_TRANSACTION
189 | ICMSGHDRFLAG_RESPONSE;
191 vmbus_sendpacket(channel, shut_txf_buf,
193 VM_PKT_DATA_INBAND, 0);
196 if (execute_shutdown == true)
197 schedule_work(&shutdown_work);
201 * Set the host time in a process context.
204 struct adj_time_work {
205 struct work_struct work;
211 static void hv_set_host_time(struct work_struct *work)
213 struct adj_time_work *wrk;
216 struct timespec64 host_ts;
218 wrk = container_of(work, struct adj_time_work, work);
220 newtime = wrk->host_time;
221 if (ts_srv_version > TS_VERSION_3) {
223 * Some latency has been introduced since Hyper-V generated
224 * its time sample. Take that latency into account before
225 * using TSC reference time sample from Hyper-V.
227 * This sample is given by TimeSync v4 and above hosts.
231 hv_get_current_tick(current_tick);
232 newtime += (current_tick - wrk->ref_time);
234 host_tns = (newtime - WLTIMEDELTA) * 100;
235 host_ts = ns_to_timespec64(host_tns);
237 do_settimeofday64(&host_ts);
241 * Synchronize time with host after reboot, restore, etc.
243 * ICTIMESYNCFLAG_SYNC flag bit indicates reboot, restore events of the VM.
244 * After reboot the flag ICTIMESYNCFLAG_SYNC is included in the first time
245 * message after the timesync channel is opened. Since the hv_utils module is
246 * loaded after hv_vmbus, the first message is usually missed. This bit is
247 * considered a hard request to discipline the clock.
249 * ICTIMESYNCFLAG_SAMPLE bit indicates a time sample from host. This is
250 * typically used as a hint to the guest. The guest is under no obligation
251 * to discipline the clock.
253 static struct adj_time_work wrk;
254 static inline void adj_guesttime(u64 hosttime, u64 reftime, u8 flags)
258 * This check is safe since we are executing in the
259 * interrupt context and time synch messages arre always
260 * delivered on the same CPU.
262 if (work_pending(&wrk.work))
265 wrk.host_time = hosttime;
266 wrk.ref_time = reftime;
268 if ((flags & (ICTIMESYNCFLAG_SYNC | ICTIMESYNCFLAG_SAMPLE)) != 0) {
269 schedule_work(&wrk.work);
274 * Time Sync Channel message handler.
276 static void timesync_onchannelcallback(void *context)
278 struct vmbus_channel *channel = context;
281 struct icmsg_hdr *icmsghdrp;
282 struct ictimesync_data *timedatap;
283 struct ictimesync_ref_data *refdata;
284 u8 *time_txf_buf = util_timesynch.recv_buffer;
286 vmbus_recvpacket(channel, time_txf_buf,
287 PAGE_SIZE, &recvlen, &requestid);
290 icmsghdrp = (struct icmsg_hdr *)&time_txf_buf[
291 sizeof(struct vmbuspipe_hdr)];
293 if (icmsghdrp->icmsgtype == ICMSGTYPE_NEGOTIATE) {
294 if (vmbus_prep_negotiate_resp(icmsghdrp, time_txf_buf,
295 fw_versions, FW_VER_COUNT,
296 ts_versions, TS_VER_COUNT,
297 NULL, &ts_srv_version)) {
298 pr_info("TimeSync IC version %d.%d\n",
299 ts_srv_version >> 16,
300 ts_srv_version & 0xFFFF);
303 if (ts_srv_version > TS_VERSION_3) {
304 refdata = (struct ictimesync_ref_data *)
306 sizeof(struct vmbuspipe_hdr) +
307 sizeof(struct icmsg_hdr)];
309 adj_guesttime(refdata->parenttime,
310 refdata->vmreferencetime,
313 timedatap = (struct ictimesync_data *)
315 sizeof(struct vmbuspipe_hdr) +
316 sizeof(struct icmsg_hdr)];
317 adj_guesttime(timedatap->parenttime,
323 icmsghdrp->icflags = ICMSGHDRFLAG_TRANSACTION
324 | ICMSGHDRFLAG_RESPONSE;
326 vmbus_sendpacket(channel, time_txf_buf,
328 VM_PKT_DATA_INBAND, 0);
333 * Heartbeat functionality.
334 * Every two seconds, Hyper-V send us a heartbeat request message.
335 * we respond to this message, and Hyper-V knows we are alive.
337 static void heartbeat_onchannelcallback(void *context)
339 struct vmbus_channel *channel = context;
342 struct icmsg_hdr *icmsghdrp;
343 struct heartbeat_msg_data *heartbeat_msg;
344 u8 *hbeat_txf_buf = util_heartbeat.recv_buffer;
348 vmbus_recvpacket(channel, hbeat_txf_buf,
349 PAGE_SIZE, &recvlen, &requestid);
354 icmsghdrp = (struct icmsg_hdr *)&hbeat_txf_buf[
355 sizeof(struct vmbuspipe_hdr)];
357 if (icmsghdrp->icmsgtype == ICMSGTYPE_NEGOTIATE) {
358 if (vmbus_prep_negotiate_resp(icmsghdrp,
360 fw_versions, FW_VER_COUNT,
361 hb_versions, HB_VER_COUNT,
362 NULL, &hb_srv_version)) {
364 pr_info("Heartbeat IC version %d.%d\n",
365 hb_srv_version >> 16,
366 hb_srv_version & 0xFFFF);
370 (struct heartbeat_msg_data *)&hbeat_txf_buf[
371 sizeof(struct vmbuspipe_hdr) +
372 sizeof(struct icmsg_hdr)];
374 heartbeat_msg->seq_num += 1;
377 icmsghdrp->icflags = ICMSGHDRFLAG_TRANSACTION
378 | ICMSGHDRFLAG_RESPONSE;
380 vmbus_sendpacket(channel, hbeat_txf_buf,
382 VM_PKT_DATA_INBAND, 0);
386 static int util_probe(struct hv_device *dev,
387 const struct hv_vmbus_device_id *dev_id)
389 struct hv_util_service *srv =
390 (struct hv_util_service *)dev_id->driver_data;
393 srv->recv_buffer = kmalloc(PAGE_SIZE * 4, GFP_KERNEL);
394 if (!srv->recv_buffer)
396 srv->channel = dev->channel;
397 if (srv->util_init) {
398 ret = srv->util_init(srv);
406 * The set of services managed by the util driver are not performance
407 * critical and do not need batched reading. Furthermore, some services
408 * such as KVP can only handle one message from the host at a time.
409 * Turn off batched reading for all util drivers before we open the
413 set_channel_read_state(dev->channel, false);
415 hv_set_drvdata(dev, srv);
417 ret = vmbus_open(dev->channel, 4 * PAGE_SIZE, 4 * PAGE_SIZE, NULL, 0,
418 srv->util_cb, dev->channel);
425 if (srv->util_deinit)
428 kfree(srv->recv_buffer);
432 static int util_remove(struct hv_device *dev)
434 struct hv_util_service *srv = hv_get_drvdata(dev);
436 if (srv->util_deinit)
438 vmbus_close(dev->channel);
439 kfree(srv->recv_buffer);
444 static const struct hv_vmbus_device_id id_table[] = {
447 .driver_data = (unsigned long)&util_shutdown
449 /* Time synch guid */
451 .driver_data = (unsigned long)&util_timesynch
454 { HV_HEART_BEAT_GUID,
455 .driver_data = (unsigned long)&util_heartbeat
459 .driver_data = (unsigned long)&util_kvp
463 .driver_data = (unsigned long)&util_vss
467 .driver_data = (unsigned long)&util_fcopy
472 MODULE_DEVICE_TABLE(vmbus, id_table);
474 /* The one and only one */
475 static struct hv_driver util_drv = {
477 .id_table = id_table,
479 .remove = util_remove,
482 static int hv_timesync_init(struct hv_util_service *srv)
484 INIT_WORK(&wrk.work, hv_set_host_time);
488 static void hv_timesync_deinit(void)
490 cancel_work_sync(&wrk.work);
493 static int __init init_hyperv_utils(void)
495 pr_info("Registering HyperV Utility Driver\n");
497 return vmbus_driver_register(&util_drv);
500 static void exit_hyperv_utils(void)
502 pr_info("De-Registered HyperV Utility Driver\n");
504 vmbus_driver_unregister(&util_drv);
507 module_init(init_hyperv_utils);
508 module_exit(exit_hyperv_utils);
510 MODULE_DESCRIPTION("Hyper-V Utilities");
511 MODULE_LICENSE("GPL");