1 /* 2 * Copyright (c) 2010, Microsoft Corporation. 3 * 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. 7 * 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 11 * more details. 12 * 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. 16 * 17 * Authors: 18 * Haiyang Zhang <haiyangz@microsoft.com> 19 * Hank Janssen <hjanssen@microsoft.com> 20 */ 21 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 22 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 31 static void shutdown_onchannelcallback(void *context); 32 static struct hv_util_service util_shutdown = { 33 .util_cb = shutdown_onchannelcallback, 34 }; 35 36 static void timesync_onchannelcallback(void *context); 37 static struct hv_util_service util_timesynch = { 38 .util_cb = timesync_onchannelcallback, 39 }; 40 41 static void heartbeat_onchannelcallback(void *context); 42 static struct hv_util_service util_heartbeat = { 43 .util_cb = heartbeat_onchannelcallback, 44 }; 45 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, 50 }; 51 52 static void shutdown_onchannelcallback(void *context) 53 { 54 struct vmbus_channel *channel = context; 55 u32 recvlen; 56 u64 requestid; 57 u8 execute_shutdown = false; 58 u8 *shut_txf_buf = util_shutdown.recv_buffer; 59 60 struct shutdown_msg_data *shutdown_msg; 61 62 struct icmsg_hdr *icmsghdrp; 63 struct icmsg_negotiate *negop = NULL; 64 65 vmbus_recvpacket(channel, shut_txf_buf, 66 PAGE_SIZE, &recvlen, &requestid); 67 68 if (recvlen > 0) { 69 icmsghdrp = (struct icmsg_hdr *)&shut_txf_buf[ 70 sizeof(struct vmbuspipe_hdr)]; 71 72 if (icmsghdrp->icmsgtype == ICMSGTYPE_NEGOTIATE) { 73 vmbus_prep_negotiate_resp(icmsghdrp, negop, shut_txf_buf); 74 } else { 75 shutdown_msg = 76 (struct shutdown_msg_data *)&shut_txf_buf[ 77 sizeof(struct vmbuspipe_hdr) + 78 sizeof(struct icmsg_hdr)]; 79 80 switch (shutdown_msg->flags) { 81 case 0: 82 case 1: 83 icmsghdrp->status = HV_S_OK; 84 execute_shutdown = true; 85 86 pr_info("Shutdown request received -" 87 " graceful shutdown initiated\n"); 88 break; 89 default: 90 icmsghdrp->status = HV_E_FAIL; 91 execute_shutdown = false; 92 93 pr_info("Shutdown request received -" 94 " Invalid request\n"); 95 break; 96 } 97 } 98 99 icmsghdrp->icflags = ICMSGHDRFLAG_TRANSACTION 100 | ICMSGHDRFLAG_RESPONSE; 101 102 vmbus_sendpacket(channel, shut_txf_buf, 103 recvlen, requestid, 104 VM_PKT_DATA_INBAND, 0); 105 } 106 107 if (execute_shutdown == true) 108 orderly_poweroff(true); 109 } 110 111 /* 112 * Set guest time to host UTC time. 113 */ 114 static inline void do_adj_guesttime(u64 hosttime) 115 { 116 s64 host_tns; 117 struct timespec host_ts; 118 119 host_tns = (hosttime - WLTIMEDELTA) * 100; 120 host_ts = ns_to_timespec(host_tns); 121 122 do_settimeofday(&host_ts); 123 } 124 125 /* 126 * Set the host time in a process context. 127 */ 128 129 struct adj_time_work { 130 struct work_struct work; 131 u64 host_time; 132 }; 133 134 static void hv_set_host_time(struct work_struct *work) 135 { 136 struct adj_time_work *wrk; 137 138 wrk = container_of(work, struct adj_time_work, work); 139 do_adj_guesttime(wrk->host_time); 140 kfree(wrk); 141 } 142 143 /* 144 * Synchronize time with host after reboot, restore, etc. 145 * 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. 153 */ 154 static inline void adj_guesttime(u64 hosttime, u8 flags) 155 { 156 struct adj_time_work *wrk; 157 static s32 scnt = 50; 158 159 wrk = kmalloc(sizeof(struct adj_time_work), GFP_ATOMIC); 160 if (wrk == NULL) 161 return; 162 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); 167 return; 168 } 169 170 if ((flags & ICTIMESYNCFLAG_SAMPLE) != 0 && scnt > 0) { 171 scnt--; 172 INIT_WORK(&wrk->work, hv_set_host_time); 173 schedule_work(&wrk->work); 174 } else 175 kfree(wrk); 176 } 177 178 /* 179 * Time Sync Channel message handler. 180 */ 181 static void timesync_onchannelcallback(void *context) 182 { 183 struct vmbus_channel *channel = context; 184 u32 recvlen; 185 u64 requestid; 186 struct icmsg_hdr *icmsghdrp; 187 struct ictimesync_data *timedatap; 188 u8 *time_txf_buf = util_timesynch.recv_buffer; 189 190 vmbus_recvpacket(channel, time_txf_buf, 191 PAGE_SIZE, &recvlen, &requestid); 192 193 if (recvlen > 0) { 194 icmsghdrp = (struct icmsg_hdr *)&time_txf_buf[ 195 sizeof(struct vmbuspipe_hdr)]; 196 197 if (icmsghdrp->icmsgtype == ICMSGTYPE_NEGOTIATE) { 198 vmbus_prep_negotiate_resp(icmsghdrp, NULL, time_txf_buf); 199 } else { 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); 204 } 205 206 icmsghdrp->icflags = ICMSGHDRFLAG_TRANSACTION 207 | ICMSGHDRFLAG_RESPONSE; 208 209 vmbus_sendpacket(channel, time_txf_buf, 210 recvlen, requestid, 211 VM_PKT_DATA_INBAND, 0); 212 } 213 } 214 215 /* 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. 219 */ 220 static void heartbeat_onchannelcallback(void *context) 221 { 222 struct vmbus_channel *channel = context; 223 u32 recvlen; 224 u64 requestid; 225 struct icmsg_hdr *icmsghdrp; 226 struct heartbeat_msg_data *heartbeat_msg; 227 u8 *hbeat_txf_buf = util_heartbeat.recv_buffer; 228 229 vmbus_recvpacket(channel, hbeat_txf_buf, 230 PAGE_SIZE, &recvlen, &requestid); 231 232 if (recvlen > 0) { 233 icmsghdrp = (struct icmsg_hdr *)&hbeat_txf_buf[ 234 sizeof(struct vmbuspipe_hdr)]; 235 236 if (icmsghdrp->icmsgtype == ICMSGTYPE_NEGOTIATE) { 237 vmbus_prep_negotiate_resp(icmsghdrp, NULL, hbeat_txf_buf); 238 } else { 239 heartbeat_msg = 240 (struct heartbeat_msg_data *)&hbeat_txf_buf[ 241 sizeof(struct vmbuspipe_hdr) + 242 sizeof(struct icmsg_hdr)]; 243 244 heartbeat_msg->seq_num += 1; 245 } 246 247 icmsghdrp->icflags = ICMSGHDRFLAG_TRANSACTION 248 | ICMSGHDRFLAG_RESPONSE; 249 250 vmbus_sendpacket(channel, hbeat_txf_buf, 251 recvlen, requestid, 252 VM_PKT_DATA_INBAND, 0); 253 } 254 } 255 256 static int util_probe(struct hv_device *dev, 257 const struct hv_vmbus_device_id *dev_id) 258 { 259 struct hv_util_service *srv = 260 (struct hv_util_service *)dev_id->driver_data; 261 int ret; 262 263 srv->recv_buffer = kmalloc(PAGE_SIZE, GFP_KERNEL); 264 if (!srv->recv_buffer) 265 return -ENOMEM; 266 if (srv->util_init) { 267 ret = srv->util_init(srv); 268 if (ret) { 269 ret = -ENODEV; 270 goto error1; 271 } 272 } 273 274 ret = vmbus_open(dev->channel, 2 * PAGE_SIZE, 2 * PAGE_SIZE, NULL, 0, 275 srv->util_cb, dev->channel); 276 if (ret) 277 goto error; 278 279 hv_set_drvdata(dev, srv); 280 return 0; 281 282 error: 283 if (srv->util_deinit) 284 srv->util_deinit(); 285 error1: 286 kfree(srv->recv_buffer); 287 return ret; 288 } 289 290 static int util_remove(struct hv_device *dev) 291 { 292 struct hv_util_service *srv = hv_get_drvdata(dev); 293 294 vmbus_close(dev->channel); 295 if (srv->util_deinit) 296 srv->util_deinit(); 297 kfree(srv->recv_buffer); 298 299 return 0; 300 } 301 302 static const struct hv_vmbus_device_id id_table[] = { 303 /* Shutdown guid */ 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 }, 311 /* Heartbeat guid */ 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 }, 315 /* KVP guid */ 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 }, 319 { }, 320 }; 321 322 MODULE_DEVICE_TABLE(vmbus, id_table); 323 324 /* The one and only one */ 325 static struct hv_driver util_drv = { 326 .name = "hv_util", 327 .id_table = id_table, 328 .probe = util_probe, 329 .remove = util_remove, 330 }; 331 332 static int __init init_hyperv_utils(void) 333 { 334 pr_info("Registering HyperV Utility Driver\n"); 335 336 return vmbus_driver_register(&util_drv); 337 } 338 339 static void exit_hyperv_utils(void) 340 { 341 pr_info("De-Registered HyperV Utility Driver\n"); 342 343 vmbus_driver_unregister(&util_drv); 344 } 345 346 module_init(init_hyperv_utils); 347 module_exit(exit_hyperv_utils); 348 349 MODULE_DESCRIPTION("Hyper-V Utilities"); 350 MODULE_VERSION(HV_DRV_VERSION); 351 MODULE_LICENSE("GPL"); 352