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 inline u64 reftime_to_ns(u64 reftime) 286 { 287 return (reftime - WLTIMEDELTA) * 100; 288 } 289 290 /* 291 * Hard coded threshold for host timesync delay: 600 seconds 292 */ 293 static const u64 HOST_TIMESYNC_DELAY_THRESH = 600 * (u64)NSEC_PER_SEC; 294 295 static int hv_get_adj_host_time(struct timespec64 *ts) 296 { 297 u64 newtime, reftime, timediff_adj; 298 unsigned long flags; 299 int ret = 0; 300 301 spin_lock_irqsave(&host_ts.lock, flags); 302 reftime = hv_read_reference_counter(); 303 304 /* 305 * We need to let the caller know that last update from host 306 * is older than the max allowable threshold. clock_gettime() 307 * and PTP ioctl do not have a documented error that we could 308 * return for this specific case. Use ESTALE to report this. 309 */ 310 timediff_adj = reftime - host_ts.ref_time; 311 if (timediff_adj * 100 > HOST_TIMESYNC_DELAY_THRESH) { 312 pr_warn_once("TIMESYNC IC: Stale time stamp, %llu nsecs old\n", 313 (timediff_adj * 100)); 314 ret = -ESTALE; 315 } 316 317 newtime = host_ts.host_time + timediff_adj; 318 *ts = ns_to_timespec64(reftime_to_ns(newtime)); 319 spin_unlock_irqrestore(&host_ts.lock, flags); 320 321 return ret; 322 } 323 324 static void hv_set_host_time(struct work_struct *work) 325 { 326 327 struct timespec64 ts; 328 329 if (!hv_get_adj_host_time(&ts)) 330 do_settimeofday64(&ts); 331 } 332 333 /* 334 * Synchronize time with host after reboot, restore, etc. 335 * 336 * ICTIMESYNCFLAG_SYNC flag bit indicates reboot, restore events of the VM. 337 * After reboot the flag ICTIMESYNCFLAG_SYNC is included in the first time 338 * message after the timesync channel is opened. Since the hv_utils module is 339 * loaded after hv_vmbus, the first message is usually missed. This bit is 340 * considered a hard request to discipline the clock. 341 * 342 * ICTIMESYNCFLAG_SAMPLE bit indicates a time sample from host. This is 343 * typically used as a hint to the guest. The guest is under no obligation 344 * to discipline the clock. 345 */ 346 static inline void adj_guesttime(u64 hosttime, u64 reftime, u8 adj_flags) 347 { 348 unsigned long flags; 349 u64 cur_reftime; 350 351 /* 352 * Save the adjusted time sample from the host and the snapshot 353 * of the current system time. 354 */ 355 spin_lock_irqsave(&host_ts.lock, flags); 356 357 cur_reftime = hv_read_reference_counter(); 358 host_ts.host_time = hosttime; 359 host_ts.ref_time = cur_reftime; 360 361 /* 362 * TimeSync v4 messages contain reference time (guest's Hyper-V 363 * clocksource read when the time sample was generated), we can 364 * improve the precision by adding the delta between now and the 365 * time of generation. For older protocols we set 366 * reftime == cur_reftime on call. 367 */ 368 host_ts.host_time += (cur_reftime - reftime); 369 370 spin_unlock_irqrestore(&host_ts.lock, flags); 371 372 /* Schedule work to do do_settimeofday64() */ 373 if (adj_flags & ICTIMESYNCFLAG_SYNC) 374 schedule_work(&adj_time_work); 375 } 376 377 /* 378 * Time Sync Channel message handler. 379 */ 380 static void timesync_onchannelcallback(void *context) 381 { 382 struct vmbus_channel *channel = context; 383 u32 recvlen; 384 u64 requestid; 385 struct icmsg_hdr *icmsghdrp; 386 struct ictimesync_data *timedatap; 387 struct ictimesync_ref_data *refdata; 388 u8 *time_txf_buf = util_timesynch.recv_buffer; 389 390 /* 391 * Drain the ring buffer and use the last packet to update 392 * host_ts 393 */ 394 while (1) { 395 int ret = vmbus_recvpacket(channel, time_txf_buf, 396 HV_HYP_PAGE_SIZE, &recvlen, 397 &requestid); 398 if (ret) { 399 pr_warn_once("TimeSync IC pkt recv failed (Err: %d)\n", 400 ret); 401 break; 402 } 403 404 if (!recvlen) 405 break; 406 407 icmsghdrp = (struct icmsg_hdr *)&time_txf_buf[ 408 sizeof(struct vmbuspipe_hdr)]; 409 410 if (icmsghdrp->icmsgtype == ICMSGTYPE_NEGOTIATE) { 411 if (vmbus_prep_negotiate_resp(icmsghdrp, time_txf_buf, 412 fw_versions, FW_VER_COUNT, 413 ts_versions, TS_VER_COUNT, 414 NULL, &ts_srv_version)) { 415 pr_info("TimeSync IC version %d.%d\n", 416 ts_srv_version >> 16, 417 ts_srv_version & 0xFFFF); 418 } 419 } else { 420 if (ts_srv_version > TS_VERSION_3) { 421 refdata = (struct ictimesync_ref_data *) 422 &time_txf_buf[ 423 sizeof(struct vmbuspipe_hdr) + 424 sizeof(struct icmsg_hdr)]; 425 426 adj_guesttime(refdata->parenttime, 427 refdata->vmreferencetime, 428 refdata->flags); 429 } else { 430 timedatap = (struct ictimesync_data *) 431 &time_txf_buf[ 432 sizeof(struct vmbuspipe_hdr) + 433 sizeof(struct icmsg_hdr)]; 434 adj_guesttime(timedatap->parenttime, 435 hv_read_reference_counter(), 436 timedatap->flags); 437 } 438 } 439 440 icmsghdrp->icflags = ICMSGHDRFLAG_TRANSACTION 441 | ICMSGHDRFLAG_RESPONSE; 442 443 vmbus_sendpacket(channel, time_txf_buf, 444 recvlen, requestid, 445 VM_PKT_DATA_INBAND, 0); 446 } 447 } 448 449 /* 450 * Heartbeat functionality. 451 * Every two seconds, Hyper-V send us a heartbeat request message. 452 * we respond to this message, and Hyper-V knows we are alive. 453 */ 454 static void heartbeat_onchannelcallback(void *context) 455 { 456 struct vmbus_channel *channel = context; 457 u32 recvlen; 458 u64 requestid; 459 struct icmsg_hdr *icmsghdrp; 460 struct heartbeat_msg_data *heartbeat_msg; 461 u8 *hbeat_txf_buf = util_heartbeat.recv_buffer; 462 463 while (1) { 464 465 vmbus_recvpacket(channel, hbeat_txf_buf, 466 HV_HYP_PAGE_SIZE, &recvlen, &requestid); 467 468 if (!recvlen) 469 break; 470 471 icmsghdrp = (struct icmsg_hdr *)&hbeat_txf_buf[ 472 sizeof(struct vmbuspipe_hdr)]; 473 474 if (icmsghdrp->icmsgtype == ICMSGTYPE_NEGOTIATE) { 475 if (vmbus_prep_negotiate_resp(icmsghdrp, 476 hbeat_txf_buf, 477 fw_versions, FW_VER_COUNT, 478 hb_versions, HB_VER_COUNT, 479 NULL, &hb_srv_version)) { 480 481 pr_info("Heartbeat IC version %d.%d\n", 482 hb_srv_version >> 16, 483 hb_srv_version & 0xFFFF); 484 } 485 } else { 486 heartbeat_msg = 487 (struct heartbeat_msg_data *)&hbeat_txf_buf[ 488 sizeof(struct vmbuspipe_hdr) + 489 sizeof(struct icmsg_hdr)]; 490 491 heartbeat_msg->seq_num += 1; 492 } 493 494 icmsghdrp->icflags = ICMSGHDRFLAG_TRANSACTION 495 | ICMSGHDRFLAG_RESPONSE; 496 497 vmbus_sendpacket(channel, hbeat_txf_buf, 498 recvlen, requestid, 499 VM_PKT_DATA_INBAND, 0); 500 } 501 } 502 503 static int util_probe(struct hv_device *dev, 504 const struct hv_vmbus_device_id *dev_id) 505 { 506 struct hv_util_service *srv = 507 (struct hv_util_service *)dev_id->driver_data; 508 int ret; 509 510 srv->recv_buffer = kmalloc(HV_HYP_PAGE_SIZE * 4, GFP_KERNEL); 511 if (!srv->recv_buffer) 512 return -ENOMEM; 513 srv->channel = dev->channel; 514 if (srv->util_init) { 515 ret = srv->util_init(srv); 516 if (ret) { 517 ret = -ENODEV; 518 goto error1; 519 } 520 } 521 522 /* 523 * The set of services managed by the util driver are not performance 524 * critical and do not need batched reading. Furthermore, some services 525 * such as KVP can only handle one message from the host at a time. 526 * Turn off batched reading for all util drivers before we open the 527 * channel. 528 */ 529 set_channel_read_mode(dev->channel, HV_CALL_DIRECT); 530 531 hv_set_drvdata(dev, srv); 532 533 ret = vmbus_open(dev->channel, 4 * HV_HYP_PAGE_SIZE, 534 4 * HV_HYP_PAGE_SIZE, NULL, 0, srv->util_cb, 535 dev->channel); 536 if (ret) 537 goto error; 538 539 return 0; 540 541 error: 542 if (srv->util_deinit) 543 srv->util_deinit(); 544 error1: 545 kfree(srv->recv_buffer); 546 return ret; 547 } 548 549 static int util_remove(struct hv_device *dev) 550 { 551 struct hv_util_service *srv = hv_get_drvdata(dev); 552 553 if (srv->util_deinit) 554 srv->util_deinit(); 555 vmbus_close(dev->channel); 556 kfree(srv->recv_buffer); 557 558 return 0; 559 } 560 561 /* 562 * When we're in util_suspend(), all the userspace processes have been frozen 563 * (refer to hibernate() -> freeze_processes()). The userspace is thawed only 564 * after the whole resume procedure, including util_resume(), finishes. 565 */ 566 static int util_suspend(struct hv_device *dev) 567 { 568 struct hv_util_service *srv = hv_get_drvdata(dev); 569 int ret = 0; 570 571 if (srv->util_pre_suspend) { 572 ret = srv->util_pre_suspend(); 573 if (ret) 574 return ret; 575 } 576 577 vmbus_close(dev->channel); 578 579 return 0; 580 } 581 582 static int util_resume(struct hv_device *dev) 583 { 584 struct hv_util_service *srv = hv_get_drvdata(dev); 585 int ret = 0; 586 587 if (srv->util_pre_resume) { 588 ret = srv->util_pre_resume(); 589 if (ret) 590 return ret; 591 } 592 593 ret = vmbus_open(dev->channel, 4 * HV_HYP_PAGE_SIZE, 594 4 * HV_HYP_PAGE_SIZE, NULL, 0, srv->util_cb, 595 dev->channel); 596 return ret; 597 } 598 599 static const struct hv_vmbus_device_id id_table[] = { 600 /* Shutdown guid */ 601 { HV_SHUTDOWN_GUID, 602 .driver_data = (unsigned long)&util_shutdown 603 }, 604 /* Time synch guid */ 605 { HV_TS_GUID, 606 .driver_data = (unsigned long)&util_timesynch 607 }, 608 /* Heartbeat guid */ 609 { HV_HEART_BEAT_GUID, 610 .driver_data = (unsigned long)&util_heartbeat 611 }, 612 /* KVP guid */ 613 { HV_KVP_GUID, 614 .driver_data = (unsigned long)&util_kvp 615 }, 616 /* VSS GUID */ 617 { HV_VSS_GUID, 618 .driver_data = (unsigned long)&util_vss 619 }, 620 /* File copy GUID */ 621 { HV_FCOPY_GUID, 622 .driver_data = (unsigned long)&util_fcopy 623 }, 624 { }, 625 }; 626 627 MODULE_DEVICE_TABLE(vmbus, id_table); 628 629 /* The one and only one */ 630 static struct hv_driver util_drv = { 631 .name = "hv_utils", 632 .id_table = id_table, 633 .probe = util_probe, 634 .remove = util_remove, 635 .suspend = util_suspend, 636 .resume = util_resume, 637 .driver = { 638 .probe_type = PROBE_PREFER_ASYNCHRONOUS, 639 }, 640 }; 641 642 static int hv_ptp_enable(struct ptp_clock_info *info, 643 struct ptp_clock_request *request, int on) 644 { 645 return -EOPNOTSUPP; 646 } 647 648 static int hv_ptp_settime(struct ptp_clock_info *p, const struct timespec64 *ts) 649 { 650 return -EOPNOTSUPP; 651 } 652 653 static int hv_ptp_adjfreq(struct ptp_clock_info *ptp, s32 delta) 654 { 655 return -EOPNOTSUPP; 656 } 657 static int hv_ptp_adjtime(struct ptp_clock_info *ptp, s64 delta) 658 { 659 return -EOPNOTSUPP; 660 } 661 662 static int hv_ptp_gettime(struct ptp_clock_info *info, struct timespec64 *ts) 663 { 664 return hv_get_adj_host_time(ts); 665 } 666 667 static struct ptp_clock_info ptp_hyperv_info = { 668 .name = "hyperv", 669 .enable = hv_ptp_enable, 670 .adjtime = hv_ptp_adjtime, 671 .adjfreq = hv_ptp_adjfreq, 672 .gettime64 = hv_ptp_gettime, 673 .settime64 = hv_ptp_settime, 674 .owner = THIS_MODULE, 675 }; 676 677 static struct ptp_clock *hv_ptp_clock; 678 679 static int hv_timesync_init(struct hv_util_service *srv) 680 { 681 /* TimeSync requires Hyper-V clocksource. */ 682 if (!hv_read_reference_counter) 683 return -ENODEV; 684 685 spin_lock_init(&host_ts.lock); 686 687 INIT_WORK(&adj_time_work, hv_set_host_time); 688 689 /* 690 * ptp_clock_register() returns NULL when CONFIG_PTP_1588_CLOCK is 691 * disabled but the driver is still useful without the PTP device 692 * as it still handles the ICTIMESYNCFLAG_SYNC case. 693 */ 694 hv_ptp_clock = ptp_clock_register(&ptp_hyperv_info, NULL); 695 if (IS_ERR_OR_NULL(hv_ptp_clock)) { 696 pr_err("cannot register PTP clock: %ld\n", 697 PTR_ERR(hv_ptp_clock)); 698 hv_ptp_clock = NULL; 699 } 700 701 return 0; 702 } 703 704 static void hv_timesync_cancel_work(void) 705 { 706 cancel_work_sync(&adj_time_work); 707 } 708 709 static int hv_timesync_pre_suspend(void) 710 { 711 hv_timesync_cancel_work(); 712 return 0; 713 } 714 715 static void hv_timesync_deinit(void) 716 { 717 if (hv_ptp_clock) 718 ptp_clock_unregister(hv_ptp_clock); 719 720 hv_timesync_cancel_work(); 721 } 722 723 static int __init init_hyperv_utils(void) 724 { 725 pr_info("Registering HyperV Utility Driver\n"); 726 727 return vmbus_driver_register(&util_drv); 728 } 729 730 static void exit_hyperv_utils(void) 731 { 732 pr_info("De-Registered HyperV Utility Driver\n"); 733 734 vmbus_driver_unregister(&util_drv); 735 } 736 737 module_init(init_hyperv_utils); 738 module_exit(exit_hyperv_utils); 739 740 MODULE_DESCRIPTION("Hyper-V Utilities"); 741 MODULE_LICENSE("GPL"); 742