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 #include <linux/clockchips.h> 31 #include <linux/ptp_clock_kernel.h> 32 #include <asm/mshyperv.h> 33 34 #include "hyperv_vmbus.h" 35 36 #define SD_MAJOR 3 37 #define SD_MINOR 0 38 #define SD_VERSION (SD_MAJOR << 16 | SD_MINOR) 39 40 #define SD_MAJOR_1 1 41 #define SD_VERSION_1 (SD_MAJOR_1 << 16 | SD_MINOR) 42 43 #define TS_MAJOR 4 44 #define TS_MINOR 0 45 #define TS_VERSION (TS_MAJOR << 16 | TS_MINOR) 46 47 #define TS_MAJOR_1 1 48 #define TS_VERSION_1 (TS_MAJOR_1 << 16 | TS_MINOR) 49 50 #define TS_MAJOR_3 3 51 #define TS_VERSION_3 (TS_MAJOR_3 << 16 | TS_MINOR) 52 53 #define HB_MAJOR 3 54 #define HB_MINOR 0 55 #define HB_VERSION (HB_MAJOR << 16 | HB_MINOR) 56 57 #define HB_MAJOR_1 1 58 #define HB_VERSION_1 (HB_MAJOR_1 << 16 | HB_MINOR) 59 60 static int sd_srv_version; 61 static int ts_srv_version; 62 static int hb_srv_version; 63 64 #define SD_VER_COUNT 2 65 static const int sd_versions[] = { 66 SD_VERSION, 67 SD_VERSION_1 68 }; 69 70 #define TS_VER_COUNT 3 71 static const int ts_versions[] = { 72 TS_VERSION, 73 TS_VERSION_3, 74 TS_VERSION_1 75 }; 76 77 #define HB_VER_COUNT 2 78 static const int hb_versions[] = { 79 HB_VERSION, 80 HB_VERSION_1 81 }; 82 83 #define FW_VER_COUNT 2 84 static const int fw_versions[] = { 85 UTIL_FW_VERSION, 86 UTIL_WS2K8_FW_VERSION 87 }; 88 89 static void shutdown_onchannelcallback(void *context); 90 static struct hv_util_service util_shutdown = { 91 .util_cb = shutdown_onchannelcallback, 92 }; 93 94 static int hv_timesync_init(struct hv_util_service *srv); 95 static void hv_timesync_deinit(void); 96 97 static void timesync_onchannelcallback(void *context); 98 static struct hv_util_service util_timesynch = { 99 .util_cb = timesync_onchannelcallback, 100 .util_init = hv_timesync_init, 101 .util_deinit = hv_timesync_deinit, 102 }; 103 104 static void heartbeat_onchannelcallback(void *context); 105 static struct hv_util_service util_heartbeat = { 106 .util_cb = heartbeat_onchannelcallback, 107 }; 108 109 static struct hv_util_service util_kvp = { 110 .util_cb = hv_kvp_onchannelcallback, 111 .util_init = hv_kvp_init, 112 .util_deinit = hv_kvp_deinit, 113 }; 114 115 static struct hv_util_service util_vss = { 116 .util_cb = hv_vss_onchannelcallback, 117 .util_init = hv_vss_init, 118 .util_deinit = hv_vss_deinit, 119 }; 120 121 static struct hv_util_service util_fcopy = { 122 .util_cb = hv_fcopy_onchannelcallback, 123 .util_init = hv_fcopy_init, 124 .util_deinit = hv_fcopy_deinit, 125 }; 126 127 static void perform_shutdown(struct work_struct *dummy) 128 { 129 orderly_poweroff(true); 130 } 131 132 /* 133 * Perform the shutdown operation in a thread context. 134 */ 135 static DECLARE_WORK(shutdown_work, perform_shutdown); 136 137 static void shutdown_onchannelcallback(void *context) 138 { 139 struct vmbus_channel *channel = context; 140 u32 recvlen; 141 u64 requestid; 142 bool execute_shutdown = false; 143 u8 *shut_txf_buf = util_shutdown.recv_buffer; 144 145 struct shutdown_msg_data *shutdown_msg; 146 147 struct icmsg_hdr *icmsghdrp; 148 149 vmbus_recvpacket(channel, shut_txf_buf, 150 PAGE_SIZE, &recvlen, &requestid); 151 152 if (recvlen > 0) { 153 icmsghdrp = (struct icmsg_hdr *)&shut_txf_buf[ 154 sizeof(struct vmbuspipe_hdr)]; 155 156 if (icmsghdrp->icmsgtype == ICMSGTYPE_NEGOTIATE) { 157 if (vmbus_prep_negotiate_resp(icmsghdrp, shut_txf_buf, 158 fw_versions, FW_VER_COUNT, 159 sd_versions, SD_VER_COUNT, 160 NULL, &sd_srv_version)) { 161 pr_info("Shutdown IC version %d.%d\n", 162 sd_srv_version >> 16, 163 sd_srv_version & 0xFFFF); 164 } 165 } else { 166 shutdown_msg = 167 (struct shutdown_msg_data *)&shut_txf_buf[ 168 sizeof(struct vmbuspipe_hdr) + 169 sizeof(struct icmsg_hdr)]; 170 171 switch (shutdown_msg->flags) { 172 case 0: 173 case 1: 174 icmsghdrp->status = HV_S_OK; 175 execute_shutdown = true; 176 177 pr_info("Shutdown request received -" 178 " graceful shutdown initiated\n"); 179 break; 180 default: 181 icmsghdrp->status = HV_E_FAIL; 182 execute_shutdown = false; 183 184 pr_info("Shutdown request received -" 185 " Invalid request\n"); 186 break; 187 } 188 } 189 190 icmsghdrp->icflags = ICMSGHDRFLAG_TRANSACTION 191 | ICMSGHDRFLAG_RESPONSE; 192 193 vmbus_sendpacket(channel, shut_txf_buf, 194 recvlen, requestid, 195 VM_PKT_DATA_INBAND, 0); 196 } 197 198 if (execute_shutdown == true) 199 schedule_work(&shutdown_work); 200 } 201 202 /* 203 * Set the host time in a process context. 204 */ 205 static struct work_struct adj_time_work; 206 207 /* 208 * The last time sample, received from the host. PTP device responds to 209 * requests by using this data and the current partition-wide time reference 210 * count. 211 */ 212 static struct { 213 u64 host_time; 214 u64 ref_time; 215 spinlock_t lock; 216 } host_ts; 217 218 static struct timespec64 hv_get_adj_host_time(void) 219 { 220 struct timespec64 ts; 221 u64 newtime, reftime; 222 unsigned long flags; 223 224 spin_lock_irqsave(&host_ts.lock, flags); 225 reftime = hyperv_cs->read(hyperv_cs); 226 newtime = host_ts.host_time + (reftime - host_ts.ref_time); 227 ts = ns_to_timespec64((newtime - WLTIMEDELTA) * 100); 228 spin_unlock_irqrestore(&host_ts.lock, flags); 229 230 return ts; 231 } 232 233 static void hv_set_host_time(struct work_struct *work) 234 { 235 struct timespec64 ts = hv_get_adj_host_time(); 236 237 do_settimeofday64(&ts); 238 } 239 240 /* 241 * Synchronize time with host after reboot, restore, etc. 242 * 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. 248 * 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. 252 */ 253 static inline void adj_guesttime(u64 hosttime, u64 reftime, u8 adj_flags) 254 { 255 unsigned long flags; 256 u64 cur_reftime; 257 258 /* 259 * Save the adjusted time sample from the host and the snapshot 260 * of the current system time. 261 */ 262 spin_lock_irqsave(&host_ts.lock, flags); 263 264 cur_reftime = hyperv_cs->read(hyperv_cs); 265 host_ts.host_time = hosttime; 266 host_ts.ref_time = cur_reftime; 267 268 /* 269 * TimeSync v4 messages contain reference time (guest's Hyper-V 270 * clocksource read when the time sample was generated), we can 271 * improve the precision by adding the delta between now and the 272 * time of generation. For older protocols we set 273 * reftime == cur_reftime on call. 274 */ 275 host_ts.host_time += (cur_reftime - reftime); 276 277 spin_unlock_irqrestore(&host_ts.lock, flags); 278 279 /* Schedule work to do do_settimeofday64() */ 280 if (adj_flags & ICTIMESYNCFLAG_SYNC) 281 schedule_work(&adj_time_work); 282 } 283 284 /* 285 * Time Sync Channel message handler. 286 */ 287 static void timesync_onchannelcallback(void *context) 288 { 289 struct vmbus_channel *channel = context; 290 u32 recvlen; 291 u64 requestid; 292 struct icmsg_hdr *icmsghdrp; 293 struct ictimesync_data *timedatap; 294 struct ictimesync_ref_data *refdata; 295 u8 *time_txf_buf = util_timesynch.recv_buffer; 296 297 vmbus_recvpacket(channel, time_txf_buf, 298 PAGE_SIZE, &recvlen, &requestid); 299 300 if (recvlen > 0) { 301 icmsghdrp = (struct icmsg_hdr *)&time_txf_buf[ 302 sizeof(struct vmbuspipe_hdr)]; 303 304 if (icmsghdrp->icmsgtype == ICMSGTYPE_NEGOTIATE) { 305 if (vmbus_prep_negotiate_resp(icmsghdrp, time_txf_buf, 306 fw_versions, FW_VER_COUNT, 307 ts_versions, TS_VER_COUNT, 308 NULL, &ts_srv_version)) { 309 pr_info("TimeSync IC version %d.%d\n", 310 ts_srv_version >> 16, 311 ts_srv_version & 0xFFFF); 312 } 313 } else { 314 if (ts_srv_version > TS_VERSION_3) { 315 refdata = (struct ictimesync_ref_data *) 316 &time_txf_buf[ 317 sizeof(struct vmbuspipe_hdr) + 318 sizeof(struct icmsg_hdr)]; 319 320 adj_guesttime(refdata->parenttime, 321 refdata->vmreferencetime, 322 refdata->flags); 323 } else { 324 timedatap = (struct ictimesync_data *) 325 &time_txf_buf[ 326 sizeof(struct vmbuspipe_hdr) + 327 sizeof(struct icmsg_hdr)]; 328 adj_guesttime(timedatap->parenttime, 329 hyperv_cs->read(hyperv_cs), 330 timedatap->flags); 331 } 332 } 333 334 icmsghdrp->icflags = ICMSGHDRFLAG_TRANSACTION 335 | ICMSGHDRFLAG_RESPONSE; 336 337 vmbus_sendpacket(channel, time_txf_buf, 338 recvlen, requestid, 339 VM_PKT_DATA_INBAND, 0); 340 } 341 } 342 343 /* 344 * Heartbeat functionality. 345 * Every two seconds, Hyper-V send us a heartbeat request message. 346 * we respond to this message, and Hyper-V knows we are alive. 347 */ 348 static void heartbeat_onchannelcallback(void *context) 349 { 350 struct vmbus_channel *channel = context; 351 u32 recvlen; 352 u64 requestid; 353 struct icmsg_hdr *icmsghdrp; 354 struct heartbeat_msg_data *heartbeat_msg; 355 u8 *hbeat_txf_buf = util_heartbeat.recv_buffer; 356 357 while (1) { 358 359 vmbus_recvpacket(channel, hbeat_txf_buf, 360 PAGE_SIZE, &recvlen, &requestid); 361 362 if (!recvlen) 363 break; 364 365 icmsghdrp = (struct icmsg_hdr *)&hbeat_txf_buf[ 366 sizeof(struct vmbuspipe_hdr)]; 367 368 if (icmsghdrp->icmsgtype == ICMSGTYPE_NEGOTIATE) { 369 if (vmbus_prep_negotiate_resp(icmsghdrp, 370 hbeat_txf_buf, 371 fw_versions, FW_VER_COUNT, 372 hb_versions, HB_VER_COUNT, 373 NULL, &hb_srv_version)) { 374 375 pr_info("Heartbeat IC version %d.%d\n", 376 hb_srv_version >> 16, 377 hb_srv_version & 0xFFFF); 378 } 379 } else { 380 heartbeat_msg = 381 (struct heartbeat_msg_data *)&hbeat_txf_buf[ 382 sizeof(struct vmbuspipe_hdr) + 383 sizeof(struct icmsg_hdr)]; 384 385 heartbeat_msg->seq_num += 1; 386 } 387 388 icmsghdrp->icflags = ICMSGHDRFLAG_TRANSACTION 389 | ICMSGHDRFLAG_RESPONSE; 390 391 vmbus_sendpacket(channel, hbeat_txf_buf, 392 recvlen, requestid, 393 VM_PKT_DATA_INBAND, 0); 394 } 395 } 396 397 static int util_probe(struct hv_device *dev, 398 const struct hv_vmbus_device_id *dev_id) 399 { 400 struct hv_util_service *srv = 401 (struct hv_util_service *)dev_id->driver_data; 402 int ret; 403 404 srv->recv_buffer = kmalloc(PAGE_SIZE * 4, GFP_KERNEL); 405 if (!srv->recv_buffer) 406 return -ENOMEM; 407 srv->channel = dev->channel; 408 if (srv->util_init) { 409 ret = srv->util_init(srv); 410 if (ret) { 411 ret = -ENODEV; 412 goto error1; 413 } 414 } 415 416 /* 417 * The set of services managed by the util driver are not performance 418 * critical and do not need batched reading. Furthermore, some services 419 * such as KVP can only handle one message from the host at a time. 420 * Turn off batched reading for all util drivers before we open the 421 * channel. 422 */ 423 set_channel_read_mode(dev->channel, HV_CALL_DIRECT); 424 425 hv_set_drvdata(dev, srv); 426 427 ret = vmbus_open(dev->channel, 4 * PAGE_SIZE, 4 * PAGE_SIZE, NULL, 0, 428 srv->util_cb, dev->channel); 429 if (ret) 430 goto error; 431 432 return 0; 433 434 error: 435 if (srv->util_deinit) 436 srv->util_deinit(); 437 error1: 438 kfree(srv->recv_buffer); 439 return ret; 440 } 441 442 static int util_remove(struct hv_device *dev) 443 { 444 struct hv_util_service *srv = hv_get_drvdata(dev); 445 446 if (srv->util_deinit) 447 srv->util_deinit(); 448 vmbus_close(dev->channel); 449 kfree(srv->recv_buffer); 450 451 return 0; 452 } 453 454 static const struct hv_vmbus_device_id id_table[] = { 455 /* Shutdown guid */ 456 { HV_SHUTDOWN_GUID, 457 .driver_data = (unsigned long)&util_shutdown 458 }, 459 /* Time synch guid */ 460 { HV_TS_GUID, 461 .driver_data = (unsigned long)&util_timesynch 462 }, 463 /* Heartbeat guid */ 464 { HV_HEART_BEAT_GUID, 465 .driver_data = (unsigned long)&util_heartbeat 466 }, 467 /* KVP guid */ 468 { HV_KVP_GUID, 469 .driver_data = (unsigned long)&util_kvp 470 }, 471 /* VSS GUID */ 472 { HV_VSS_GUID, 473 .driver_data = (unsigned long)&util_vss 474 }, 475 /* File copy GUID */ 476 { HV_FCOPY_GUID, 477 .driver_data = (unsigned long)&util_fcopy 478 }, 479 { }, 480 }; 481 482 MODULE_DEVICE_TABLE(vmbus, id_table); 483 484 /* The one and only one */ 485 static struct hv_driver util_drv = { 486 .name = "hv_util", 487 .id_table = id_table, 488 .probe = util_probe, 489 .remove = util_remove, 490 .driver = { 491 .probe_type = PROBE_PREFER_ASYNCHRONOUS, 492 }, 493 }; 494 495 static int hv_ptp_enable(struct ptp_clock_info *info, 496 struct ptp_clock_request *request, int on) 497 { 498 return -EOPNOTSUPP; 499 } 500 501 static int hv_ptp_settime(struct ptp_clock_info *p, const struct timespec64 *ts) 502 { 503 return -EOPNOTSUPP; 504 } 505 506 static int hv_ptp_adjfreq(struct ptp_clock_info *ptp, s32 delta) 507 { 508 return -EOPNOTSUPP; 509 } 510 static int hv_ptp_adjtime(struct ptp_clock_info *ptp, s64 delta) 511 { 512 return -EOPNOTSUPP; 513 } 514 515 static int hv_ptp_gettime(struct ptp_clock_info *info, struct timespec64 *ts) 516 { 517 *ts = hv_get_adj_host_time(); 518 519 return 0; 520 } 521 522 static struct ptp_clock_info ptp_hyperv_info = { 523 .name = "hyperv", 524 .enable = hv_ptp_enable, 525 .adjtime = hv_ptp_adjtime, 526 .adjfreq = hv_ptp_adjfreq, 527 .gettime64 = hv_ptp_gettime, 528 .settime64 = hv_ptp_settime, 529 .owner = THIS_MODULE, 530 }; 531 532 static struct ptp_clock *hv_ptp_clock; 533 534 static int hv_timesync_init(struct hv_util_service *srv) 535 { 536 /* TimeSync requires Hyper-V clocksource. */ 537 if (!hyperv_cs) 538 return -ENODEV; 539 540 spin_lock_init(&host_ts.lock); 541 542 INIT_WORK(&adj_time_work, hv_set_host_time); 543 544 /* 545 * ptp_clock_register() returns NULL when CONFIG_PTP_1588_CLOCK is 546 * disabled but the driver is still useful without the PTP device 547 * as it still handles the ICTIMESYNCFLAG_SYNC case. 548 */ 549 hv_ptp_clock = ptp_clock_register(&ptp_hyperv_info, NULL); 550 if (IS_ERR_OR_NULL(hv_ptp_clock)) { 551 pr_err("cannot register PTP clock: %ld\n", 552 PTR_ERR(hv_ptp_clock)); 553 hv_ptp_clock = NULL; 554 } 555 556 return 0; 557 } 558 559 static void hv_timesync_deinit(void) 560 { 561 if (hv_ptp_clock) 562 ptp_clock_unregister(hv_ptp_clock); 563 cancel_work_sync(&adj_time_work); 564 } 565 566 static int __init init_hyperv_utils(void) 567 { 568 pr_info("Registering HyperV Utility Driver\n"); 569 570 return vmbus_driver_register(&util_drv); 571 } 572 573 static void exit_hyperv_utils(void) 574 { 575 pr_info("De-Registered HyperV Utility Driver\n"); 576 577 vmbus_driver_unregister(&util_drv); 578 } 579 580 module_init(init_hyperv_utils); 581 module_exit(exit_hyperv_utils); 582 583 MODULE_DESCRIPTION("Hyper-V Utilities"); 584 MODULE_LICENSE("GPL"); 585