1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (c) 2010, Microsoft Corporation. 4 * 5 * Authors: 6 * Haiyang Zhang <haiyangz@microsoft.com> 7 * Hank Janssen <hjanssen@microsoft.com> 8 */ 9 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 10 11 #include <linux/kernel.h> 12 #include <linux/init.h> 13 #include <linux/module.h> 14 #include <linux/slab.h> 15 #include <linux/sysctl.h> 16 #include <linux/reboot.h> 17 #include <linux/hyperv.h> 18 #include <linux/clockchips.h> 19 #include <linux/ptp_clock_kernel.h> 20 #include <clocksource/hyperv_timer.h> 21 #include <asm/mshyperv.h> 22 23 #include "hyperv_vmbus.h" 24 25 #define SD_MAJOR 3 26 #define SD_MINOR 0 27 #define SD_MINOR_1 1 28 #define SD_MINOR_2 2 29 #define SD_VERSION_3_1 (SD_MAJOR << 16 | SD_MINOR_1) 30 #define SD_VERSION_3_2 (SD_MAJOR << 16 | SD_MINOR_2) 31 #define SD_VERSION (SD_MAJOR << 16 | SD_MINOR) 32 33 #define SD_MAJOR_1 1 34 #define SD_VERSION_1 (SD_MAJOR_1 << 16 | SD_MINOR) 35 36 #define TS_MAJOR 4 37 #define TS_MINOR 0 38 #define TS_VERSION (TS_MAJOR << 16 | TS_MINOR) 39 40 #define TS_MAJOR_1 1 41 #define TS_VERSION_1 (TS_MAJOR_1 << 16 | TS_MINOR) 42 43 #define TS_MAJOR_3 3 44 #define TS_VERSION_3 (TS_MAJOR_3 << 16 | TS_MINOR) 45 46 #define HB_MAJOR 3 47 #define HB_MINOR 0 48 #define HB_VERSION (HB_MAJOR << 16 | HB_MINOR) 49 50 #define HB_MAJOR_1 1 51 #define HB_VERSION_1 (HB_MAJOR_1 << 16 | HB_MINOR) 52 53 static int sd_srv_version; 54 static int ts_srv_version; 55 static int hb_srv_version; 56 57 #define SD_VER_COUNT 4 58 static const int sd_versions[] = { 59 SD_VERSION_3_2, 60 SD_VERSION_3_1, 61 SD_VERSION, 62 SD_VERSION_1 63 }; 64 65 #define TS_VER_COUNT 3 66 static const int ts_versions[] = { 67 TS_VERSION, 68 TS_VERSION_3, 69 TS_VERSION_1 70 }; 71 72 #define HB_VER_COUNT 2 73 static const int hb_versions[] = { 74 HB_VERSION, 75 HB_VERSION_1 76 }; 77 78 #define FW_VER_COUNT 2 79 static const int fw_versions[] = { 80 UTIL_FW_VERSION, 81 UTIL_WS2K8_FW_VERSION 82 }; 83 84 /* 85 * Send the "hibernate" udev event in a thread context. 86 */ 87 struct hibernate_work_context { 88 struct work_struct work; 89 struct hv_device *dev; 90 }; 91 92 static struct hibernate_work_context hibernate_context; 93 static bool hibernation_supported; 94 95 static void send_hibernate_uevent(struct work_struct *work) 96 { 97 char *uevent_env[2] = { "EVENT=hibernate", NULL }; 98 struct hibernate_work_context *ctx; 99 100 ctx = container_of(work, struct hibernate_work_context, work); 101 102 kobject_uevent_env(&ctx->dev->device.kobj, KOBJ_CHANGE, uevent_env); 103 104 pr_info("Sent hibernation uevent\n"); 105 } 106 107 static int hv_shutdown_init(struct hv_util_service *srv) 108 { 109 struct vmbus_channel *channel = srv->channel; 110 111 INIT_WORK(&hibernate_context.work, send_hibernate_uevent); 112 hibernate_context.dev = channel->device_obj; 113 114 hibernation_supported = hv_is_hibernation_supported(); 115 116 return 0; 117 } 118 119 static void shutdown_onchannelcallback(void *context); 120 static struct hv_util_service util_shutdown = { 121 .util_cb = shutdown_onchannelcallback, 122 .util_init = hv_shutdown_init, 123 }; 124 125 static int hv_timesync_init(struct hv_util_service *srv); 126 static int hv_timesync_pre_suspend(void); 127 static void hv_timesync_deinit(void); 128 129 static void timesync_onchannelcallback(void *context); 130 static struct hv_util_service util_timesynch = { 131 .util_cb = timesync_onchannelcallback, 132 .util_init = hv_timesync_init, 133 .util_pre_suspend = hv_timesync_pre_suspend, 134 .util_deinit = hv_timesync_deinit, 135 }; 136 137 static void heartbeat_onchannelcallback(void *context); 138 static struct hv_util_service util_heartbeat = { 139 .util_cb = heartbeat_onchannelcallback, 140 }; 141 142 static struct hv_util_service util_kvp = { 143 .util_cb = hv_kvp_onchannelcallback, 144 .util_init = hv_kvp_init, 145 .util_pre_suspend = hv_kvp_pre_suspend, 146 .util_pre_resume = hv_kvp_pre_resume, 147 .util_deinit = hv_kvp_deinit, 148 }; 149 150 static struct hv_util_service util_vss = { 151 .util_cb = hv_vss_onchannelcallback, 152 .util_init = hv_vss_init, 153 .util_pre_suspend = hv_vss_pre_suspend, 154 .util_pre_resume = hv_vss_pre_resume, 155 .util_deinit = hv_vss_deinit, 156 }; 157 158 static struct hv_util_service util_fcopy = { 159 .util_cb = hv_fcopy_onchannelcallback, 160 .util_init = hv_fcopy_init, 161 .util_pre_suspend = hv_fcopy_pre_suspend, 162 .util_pre_resume = hv_fcopy_pre_resume, 163 .util_deinit = hv_fcopy_deinit, 164 }; 165 166 static void perform_shutdown(struct work_struct *dummy) 167 { 168 orderly_poweroff(true); 169 } 170 171 static void perform_restart(struct work_struct *dummy) 172 { 173 orderly_reboot(); 174 } 175 176 /* 177 * Perform the shutdown operation in a thread context. 178 */ 179 static DECLARE_WORK(shutdown_work, perform_shutdown); 180 181 /* 182 * Perform the restart operation in a thread context. 183 */ 184 static DECLARE_WORK(restart_work, perform_restart); 185 186 static void shutdown_onchannelcallback(void *context) 187 { 188 struct vmbus_channel *channel = context; 189 struct work_struct *work = NULL; 190 u32 recvlen; 191 u64 requestid; 192 u8 *shut_txf_buf = util_shutdown.recv_buffer; 193 194 struct shutdown_msg_data *shutdown_msg; 195 196 struct icmsg_hdr *icmsghdrp; 197 198 vmbus_recvpacket(channel, shut_txf_buf, 199 HV_HYP_PAGE_SIZE, &recvlen, &requestid); 200 201 if (recvlen > 0) { 202 icmsghdrp = (struct icmsg_hdr *)&shut_txf_buf[ 203 sizeof(struct vmbuspipe_hdr)]; 204 205 if (icmsghdrp->icmsgtype == ICMSGTYPE_NEGOTIATE) { 206 if (vmbus_prep_negotiate_resp(icmsghdrp, shut_txf_buf, 207 fw_versions, FW_VER_COUNT, 208 sd_versions, SD_VER_COUNT, 209 NULL, &sd_srv_version)) { 210 pr_info("Shutdown IC version %d.%d\n", 211 sd_srv_version >> 16, 212 sd_srv_version & 0xFFFF); 213 } 214 } else { 215 shutdown_msg = 216 (struct shutdown_msg_data *)&shut_txf_buf[ 217 sizeof(struct vmbuspipe_hdr) + 218 sizeof(struct icmsg_hdr)]; 219 220 /* 221 * shutdown_msg->flags can be 0(shut down), 2(reboot), 222 * or 4(hibernate). It may bitwise-OR 1, which means 223 * performing the request by force. Linux always tries 224 * to perform the request by force. 225 */ 226 switch (shutdown_msg->flags) { 227 case 0: 228 case 1: 229 icmsghdrp->status = HV_S_OK; 230 work = &shutdown_work; 231 pr_info("Shutdown request received -" 232 " graceful shutdown initiated\n"); 233 break; 234 case 2: 235 case 3: 236 icmsghdrp->status = HV_S_OK; 237 work = &restart_work; 238 pr_info("Restart request received -" 239 " graceful restart initiated\n"); 240 break; 241 case 4: 242 case 5: 243 pr_info("Hibernation request received\n"); 244 icmsghdrp->status = hibernation_supported ? 245 HV_S_OK : HV_E_FAIL; 246 if (hibernation_supported) 247 work = &hibernate_context.work; 248 break; 249 default: 250 icmsghdrp->status = HV_E_FAIL; 251 pr_info("Shutdown request received -" 252 " Invalid request\n"); 253 break; 254 } 255 } 256 257 icmsghdrp->icflags = ICMSGHDRFLAG_TRANSACTION 258 | ICMSGHDRFLAG_RESPONSE; 259 260 vmbus_sendpacket(channel, shut_txf_buf, 261 recvlen, requestid, 262 VM_PKT_DATA_INBAND, 0); 263 } 264 265 if (work) 266 schedule_work(work); 267 } 268 269 /* 270 * Set the host time in a process context. 271 */ 272 static struct work_struct adj_time_work; 273 274 /* 275 * The last time sample, received from the host. PTP device responds to 276 * requests by using this data and the current partition-wide time reference 277 * count. 278 */ 279 static struct { 280 u64 host_time; 281 u64 ref_time; 282 spinlock_t lock; 283 } host_ts; 284 285 static struct timespec64 hv_get_adj_host_time(void) 286 { 287 struct timespec64 ts; 288 u64 newtime, reftime; 289 unsigned long flags; 290 291 spin_lock_irqsave(&host_ts.lock, flags); 292 reftime = hv_read_reference_counter(); 293 newtime = host_ts.host_time + (reftime - host_ts.ref_time); 294 ts = ns_to_timespec64((newtime - WLTIMEDELTA) * 100); 295 spin_unlock_irqrestore(&host_ts.lock, flags); 296 297 return ts; 298 } 299 300 static void hv_set_host_time(struct work_struct *work) 301 { 302 struct timespec64 ts = hv_get_adj_host_time(); 303 304 do_settimeofday64(&ts); 305 } 306 307 /* 308 * Synchronize time with host after reboot, restore, etc. 309 * 310 * ICTIMESYNCFLAG_SYNC flag bit indicates reboot, restore events of the VM. 311 * After reboot the flag ICTIMESYNCFLAG_SYNC is included in the first time 312 * message after the timesync channel is opened. Since the hv_utils module is 313 * loaded after hv_vmbus, the first message is usually missed. This bit is 314 * considered a hard request to discipline the clock. 315 * 316 * ICTIMESYNCFLAG_SAMPLE bit indicates a time sample from host. This is 317 * typically used as a hint to the guest. The guest is under no obligation 318 * to discipline the clock. 319 */ 320 static inline void adj_guesttime(u64 hosttime, u64 reftime, u8 adj_flags) 321 { 322 unsigned long flags; 323 u64 cur_reftime; 324 325 /* 326 * Save the adjusted time sample from the host and the snapshot 327 * of the current system time. 328 */ 329 spin_lock_irqsave(&host_ts.lock, flags); 330 331 cur_reftime = hv_read_reference_counter(); 332 host_ts.host_time = hosttime; 333 host_ts.ref_time = cur_reftime; 334 335 /* 336 * TimeSync v4 messages contain reference time (guest's Hyper-V 337 * clocksource read when the time sample was generated), we can 338 * improve the precision by adding the delta between now and the 339 * time of generation. For older protocols we set 340 * reftime == cur_reftime on call. 341 */ 342 host_ts.host_time += (cur_reftime - reftime); 343 344 spin_unlock_irqrestore(&host_ts.lock, flags); 345 346 /* Schedule work to do do_settimeofday64() */ 347 if (adj_flags & ICTIMESYNCFLAG_SYNC) 348 schedule_work(&adj_time_work); 349 } 350 351 /* 352 * Time Sync Channel message handler. 353 */ 354 static void timesync_onchannelcallback(void *context) 355 { 356 struct vmbus_channel *channel = context; 357 u32 recvlen; 358 u64 requestid; 359 struct icmsg_hdr *icmsghdrp; 360 struct ictimesync_data *timedatap; 361 struct ictimesync_ref_data *refdata; 362 u8 *time_txf_buf = util_timesynch.recv_buffer; 363 364 vmbus_recvpacket(channel, time_txf_buf, 365 HV_HYP_PAGE_SIZE, &recvlen, &requestid); 366 367 if (recvlen > 0) { 368 icmsghdrp = (struct icmsg_hdr *)&time_txf_buf[ 369 sizeof(struct vmbuspipe_hdr)]; 370 371 if (icmsghdrp->icmsgtype == ICMSGTYPE_NEGOTIATE) { 372 if (vmbus_prep_negotiate_resp(icmsghdrp, time_txf_buf, 373 fw_versions, FW_VER_COUNT, 374 ts_versions, TS_VER_COUNT, 375 NULL, &ts_srv_version)) { 376 pr_info("TimeSync IC version %d.%d\n", 377 ts_srv_version >> 16, 378 ts_srv_version & 0xFFFF); 379 } 380 } else { 381 if (ts_srv_version > TS_VERSION_3) { 382 refdata = (struct ictimesync_ref_data *) 383 &time_txf_buf[ 384 sizeof(struct vmbuspipe_hdr) + 385 sizeof(struct icmsg_hdr)]; 386 387 adj_guesttime(refdata->parenttime, 388 refdata->vmreferencetime, 389 refdata->flags); 390 } else { 391 timedatap = (struct ictimesync_data *) 392 &time_txf_buf[ 393 sizeof(struct vmbuspipe_hdr) + 394 sizeof(struct icmsg_hdr)]; 395 adj_guesttime(timedatap->parenttime, 396 hv_read_reference_counter(), 397 timedatap->flags); 398 } 399 } 400 401 icmsghdrp->icflags = ICMSGHDRFLAG_TRANSACTION 402 | ICMSGHDRFLAG_RESPONSE; 403 404 vmbus_sendpacket(channel, time_txf_buf, 405 recvlen, requestid, 406 VM_PKT_DATA_INBAND, 0); 407 } 408 } 409 410 /* 411 * Heartbeat functionality. 412 * Every two seconds, Hyper-V send us a heartbeat request message. 413 * we respond to this message, and Hyper-V knows we are alive. 414 */ 415 static void heartbeat_onchannelcallback(void *context) 416 { 417 struct vmbus_channel *channel = context; 418 u32 recvlen; 419 u64 requestid; 420 struct icmsg_hdr *icmsghdrp; 421 struct heartbeat_msg_data *heartbeat_msg; 422 u8 *hbeat_txf_buf = util_heartbeat.recv_buffer; 423 424 while (1) { 425 426 vmbus_recvpacket(channel, hbeat_txf_buf, 427 HV_HYP_PAGE_SIZE, &recvlen, &requestid); 428 429 if (!recvlen) 430 break; 431 432 icmsghdrp = (struct icmsg_hdr *)&hbeat_txf_buf[ 433 sizeof(struct vmbuspipe_hdr)]; 434 435 if (icmsghdrp->icmsgtype == ICMSGTYPE_NEGOTIATE) { 436 if (vmbus_prep_negotiate_resp(icmsghdrp, 437 hbeat_txf_buf, 438 fw_versions, FW_VER_COUNT, 439 hb_versions, HB_VER_COUNT, 440 NULL, &hb_srv_version)) { 441 442 pr_info("Heartbeat IC version %d.%d\n", 443 hb_srv_version >> 16, 444 hb_srv_version & 0xFFFF); 445 } 446 } else { 447 heartbeat_msg = 448 (struct heartbeat_msg_data *)&hbeat_txf_buf[ 449 sizeof(struct vmbuspipe_hdr) + 450 sizeof(struct icmsg_hdr)]; 451 452 heartbeat_msg->seq_num += 1; 453 } 454 455 icmsghdrp->icflags = ICMSGHDRFLAG_TRANSACTION 456 | ICMSGHDRFLAG_RESPONSE; 457 458 vmbus_sendpacket(channel, hbeat_txf_buf, 459 recvlen, requestid, 460 VM_PKT_DATA_INBAND, 0); 461 } 462 } 463 464 static int util_probe(struct hv_device *dev, 465 const struct hv_vmbus_device_id *dev_id) 466 { 467 struct hv_util_service *srv = 468 (struct hv_util_service *)dev_id->driver_data; 469 int ret; 470 471 srv->recv_buffer = kmalloc(HV_HYP_PAGE_SIZE * 4, GFP_KERNEL); 472 if (!srv->recv_buffer) 473 return -ENOMEM; 474 srv->channel = dev->channel; 475 if (srv->util_init) { 476 ret = srv->util_init(srv); 477 if (ret) { 478 ret = -ENODEV; 479 goto error1; 480 } 481 } 482 483 /* 484 * The set of services managed by the util driver are not performance 485 * critical and do not need batched reading. Furthermore, some services 486 * such as KVP can only handle one message from the host at a time. 487 * Turn off batched reading for all util drivers before we open the 488 * channel. 489 */ 490 set_channel_read_mode(dev->channel, HV_CALL_DIRECT); 491 492 hv_set_drvdata(dev, srv); 493 494 ret = vmbus_open(dev->channel, 4 * HV_HYP_PAGE_SIZE, 495 4 * HV_HYP_PAGE_SIZE, NULL, 0, srv->util_cb, 496 dev->channel); 497 if (ret) 498 goto error; 499 500 return 0; 501 502 error: 503 if (srv->util_deinit) 504 srv->util_deinit(); 505 error1: 506 kfree(srv->recv_buffer); 507 return ret; 508 } 509 510 static int util_remove(struct hv_device *dev) 511 { 512 struct hv_util_service *srv = hv_get_drvdata(dev); 513 514 if (srv->util_deinit) 515 srv->util_deinit(); 516 vmbus_close(dev->channel); 517 kfree(srv->recv_buffer); 518 519 return 0; 520 } 521 522 /* 523 * When we're in util_suspend(), all the userspace processes have been frozen 524 * (refer to hibernate() -> freeze_processes()). The userspace is thawed only 525 * after the whole resume procedure, including util_resume(), finishes. 526 */ 527 static int util_suspend(struct hv_device *dev) 528 { 529 struct hv_util_service *srv = hv_get_drvdata(dev); 530 int ret = 0; 531 532 if (srv->util_pre_suspend) { 533 ret = srv->util_pre_suspend(); 534 if (ret) 535 return ret; 536 } 537 538 vmbus_close(dev->channel); 539 540 return 0; 541 } 542 543 static int util_resume(struct hv_device *dev) 544 { 545 struct hv_util_service *srv = hv_get_drvdata(dev); 546 int ret = 0; 547 548 if (srv->util_pre_resume) { 549 ret = srv->util_pre_resume(); 550 if (ret) 551 return ret; 552 } 553 554 ret = vmbus_open(dev->channel, 4 * HV_HYP_PAGE_SIZE, 555 4 * HV_HYP_PAGE_SIZE, NULL, 0, srv->util_cb, 556 dev->channel); 557 return ret; 558 } 559 560 static const struct hv_vmbus_device_id id_table[] = { 561 /* Shutdown guid */ 562 { HV_SHUTDOWN_GUID, 563 .driver_data = (unsigned long)&util_shutdown 564 }, 565 /* Time synch guid */ 566 { HV_TS_GUID, 567 .driver_data = (unsigned long)&util_timesynch 568 }, 569 /* Heartbeat guid */ 570 { HV_HEART_BEAT_GUID, 571 .driver_data = (unsigned long)&util_heartbeat 572 }, 573 /* KVP guid */ 574 { HV_KVP_GUID, 575 .driver_data = (unsigned long)&util_kvp 576 }, 577 /* VSS GUID */ 578 { HV_VSS_GUID, 579 .driver_data = (unsigned long)&util_vss 580 }, 581 /* File copy GUID */ 582 { HV_FCOPY_GUID, 583 .driver_data = (unsigned long)&util_fcopy 584 }, 585 { }, 586 }; 587 588 MODULE_DEVICE_TABLE(vmbus, id_table); 589 590 /* The one and only one */ 591 static struct hv_driver util_drv = { 592 .name = "hv_utils", 593 .id_table = id_table, 594 .probe = util_probe, 595 .remove = util_remove, 596 .suspend = util_suspend, 597 .resume = util_resume, 598 .driver = { 599 .probe_type = PROBE_PREFER_ASYNCHRONOUS, 600 }, 601 }; 602 603 static int hv_ptp_enable(struct ptp_clock_info *info, 604 struct ptp_clock_request *request, int on) 605 { 606 return -EOPNOTSUPP; 607 } 608 609 static int hv_ptp_settime(struct ptp_clock_info *p, const struct timespec64 *ts) 610 { 611 return -EOPNOTSUPP; 612 } 613 614 static int hv_ptp_adjfreq(struct ptp_clock_info *ptp, s32 delta) 615 { 616 return -EOPNOTSUPP; 617 } 618 static int hv_ptp_adjtime(struct ptp_clock_info *ptp, s64 delta) 619 { 620 return -EOPNOTSUPP; 621 } 622 623 static int hv_ptp_gettime(struct ptp_clock_info *info, struct timespec64 *ts) 624 { 625 *ts = hv_get_adj_host_time(); 626 627 return 0; 628 } 629 630 static struct ptp_clock_info ptp_hyperv_info = { 631 .name = "hyperv", 632 .enable = hv_ptp_enable, 633 .adjtime = hv_ptp_adjtime, 634 .adjfreq = hv_ptp_adjfreq, 635 .gettime64 = hv_ptp_gettime, 636 .settime64 = hv_ptp_settime, 637 .owner = THIS_MODULE, 638 }; 639 640 static struct ptp_clock *hv_ptp_clock; 641 642 static int hv_timesync_init(struct hv_util_service *srv) 643 { 644 /* TimeSync requires Hyper-V clocksource. */ 645 if (!hv_read_reference_counter) 646 return -ENODEV; 647 648 spin_lock_init(&host_ts.lock); 649 650 INIT_WORK(&adj_time_work, hv_set_host_time); 651 652 /* 653 * ptp_clock_register() returns NULL when CONFIG_PTP_1588_CLOCK is 654 * disabled but the driver is still useful without the PTP device 655 * as it still handles the ICTIMESYNCFLAG_SYNC case. 656 */ 657 hv_ptp_clock = ptp_clock_register(&ptp_hyperv_info, NULL); 658 if (IS_ERR_OR_NULL(hv_ptp_clock)) { 659 pr_err("cannot register PTP clock: %ld\n", 660 PTR_ERR(hv_ptp_clock)); 661 hv_ptp_clock = NULL; 662 } 663 664 return 0; 665 } 666 667 static void hv_timesync_cancel_work(void) 668 { 669 cancel_work_sync(&adj_time_work); 670 } 671 672 static int hv_timesync_pre_suspend(void) 673 { 674 hv_timesync_cancel_work(); 675 return 0; 676 } 677 678 static void hv_timesync_deinit(void) 679 { 680 if (hv_ptp_clock) 681 ptp_clock_unregister(hv_ptp_clock); 682 683 hv_timesync_cancel_work(); 684 } 685 686 static int __init init_hyperv_utils(void) 687 { 688 pr_info("Registering HyperV Utility Driver\n"); 689 690 return vmbus_driver_register(&util_drv); 691 } 692 693 static void exit_hyperv_utils(void) 694 { 695 pr_info("De-Registered HyperV Utility Driver\n"); 696 697 vmbus_driver_unregister(&util_drv); 698 } 699 700 module_init(init_hyperv_utils); 701 module_exit(exit_hyperv_utils); 702 703 MODULE_DESCRIPTION("Hyper-V Utilities"); 704 MODULE_LICENSE("GPL"); 705