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 53static int sd_srv_version; 54static int ts_srv_version; 55static int hb_srv_version; 56 57#define SD_VER_COUNT 4 58static 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 66static const int ts_versions[] = { 67 TS_VERSION, 68 TS_VERSION_3, 69 TS_VERSION_1 70}; 71 72#define HB_VER_COUNT 2 73static const int hb_versions[] = { 74 HB_VERSION, 75 HB_VERSION_1 76}; 77 78#define FW_VER_COUNT 2 79static 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 */ 87struct hibernate_work_context { 88 struct work_struct work; 89 struct hv_device *dev; 90}; 91 92static struct hibernate_work_context hibernate_context; 93static bool hibernation_supported; 94 95static 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 107static 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 119static void shutdown_onchannelcallback(void *context); 120static struct hv_util_service util_shutdown = { 121 .util_cb = shutdown_onchannelcallback, 122 .util_init = hv_shutdown_init, 123}; 124 125static int hv_timesync_init(struct hv_util_service *srv); 126static int hv_timesync_pre_suspend(void); 127static void hv_timesync_deinit(void); 128 129static void timesync_onchannelcallback(void *context); 130static 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 137static void heartbeat_onchannelcallback(void *context); 138static struct hv_util_service util_heartbeat = { 139 .util_cb = heartbeat_onchannelcallback, 140}; 141 142static 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 150static 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 158static 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 166static void perform_shutdown(struct work_struct *dummy) 167{ 168 orderly_poweroff(true); 169} 170 171static void perform_restart(struct work_struct *dummy) 172{ 173 orderly_reboot(); 174} 175 176/* 177 * Perform the shutdown operation in a thread context. 178 */ 179static DECLARE_WORK(shutdown_work, perform_shutdown); 180 181/* 182 * Perform the restart operation in a thread context. 183 */ 184static DECLARE_WORK(restart_work, perform_restart); 185 186static 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 */ 272static 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 */ 279static struct { 280 u64 host_time; 281 u64 ref_time; 282 spinlock_t lock; 283} host_ts; 284 285static 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 */ 293static const u64 HOST_TIMESYNC_DELAY_THRESH = 600 * (u64)NSEC_PER_SEC; 294 295static 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 324static 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 */ 346static 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 */ 380static 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 */ 454static 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#define HV_UTIL_RING_SEND_SIZE VMBUS_RING_SIZE(3 * HV_HYP_PAGE_SIZE) 504#define HV_UTIL_RING_RECV_SIZE VMBUS_RING_SIZE(3 * HV_HYP_PAGE_SIZE) 505 506static int util_probe(struct hv_device *dev, 507 const struct hv_vmbus_device_id *dev_id) 508{ 509 struct hv_util_service *srv = 510 (struct hv_util_service *)dev_id->driver_data; 511 int ret; 512 513 srv->recv_buffer = kmalloc(HV_HYP_PAGE_SIZE * 4, GFP_KERNEL); 514 if (!srv->recv_buffer) 515 return -ENOMEM; 516 srv->channel = dev->channel; 517 if (srv->util_init) { 518 ret = srv->util_init(srv); 519 if (ret) { 520 ret = -ENODEV; 521 goto error1; 522 } 523 } 524 525 /* 526 * The set of services managed by the util driver are not performance 527 * critical and do not need batched reading. Furthermore, some services 528 * such as KVP can only handle one message from the host at a time. 529 * Turn off batched reading for all util drivers before we open the 530 * channel. 531 */ 532 set_channel_read_mode(dev->channel, HV_CALL_DIRECT); 533 534 hv_set_drvdata(dev, srv); 535 536 ret = vmbus_open(dev->channel, HV_UTIL_RING_SEND_SIZE, 537 HV_UTIL_RING_RECV_SIZE, NULL, 0, srv->util_cb, 538 dev->channel); 539 if (ret) 540 goto error; 541 542 return 0; 543 544error: 545 if (srv->util_deinit) 546 srv->util_deinit(); 547error1: 548 kfree(srv->recv_buffer); 549 return ret; 550} 551 552static int util_remove(struct hv_device *dev) 553{ 554 struct hv_util_service *srv = hv_get_drvdata(dev); 555 556 if (srv->util_deinit) 557 srv->util_deinit(); 558 vmbus_close(dev->channel); 559 kfree(srv->recv_buffer); 560 561 return 0; 562} 563 564/* 565 * When we're in util_suspend(), all the userspace processes have been frozen 566 * (refer to hibernate() -> freeze_processes()). The userspace is thawed only 567 * after the whole resume procedure, including util_resume(), finishes. 568 */ 569static int util_suspend(struct hv_device *dev) 570{ 571 struct hv_util_service *srv = hv_get_drvdata(dev); 572 int ret = 0; 573 574 if (srv->util_pre_suspend) { 575 ret = srv->util_pre_suspend(); 576 if (ret) 577 return ret; 578 } 579 580 vmbus_close(dev->channel); 581 582 return 0; 583} 584 585static int util_resume(struct hv_device *dev) 586{ 587 struct hv_util_service *srv = hv_get_drvdata(dev); 588 int ret = 0; 589 590 if (srv->util_pre_resume) { 591 ret = srv->util_pre_resume(); 592 if (ret) 593 return ret; 594 } 595 596 ret = vmbus_open(dev->channel, HV_UTIL_RING_SEND_SIZE, 597 HV_UTIL_RING_RECV_SIZE, NULL, 0, srv->util_cb, 598 dev->channel); 599 return ret; 600} 601 602static const struct hv_vmbus_device_id id_table[] = { 603 /* Shutdown guid */ 604 { HV_SHUTDOWN_GUID, 605 .driver_data = (unsigned long)&util_shutdown 606 }, 607 /* Time synch guid */ 608 { HV_TS_GUID, 609 .driver_data = (unsigned long)&util_timesynch 610 }, 611 /* Heartbeat guid */ 612 { HV_HEART_BEAT_GUID, 613 .driver_data = (unsigned long)&util_heartbeat 614 }, 615 /* KVP guid */ 616 { HV_KVP_GUID, 617 .driver_data = (unsigned long)&util_kvp 618 }, 619 /* VSS GUID */ 620 { HV_VSS_GUID, 621 .driver_data = (unsigned long)&util_vss 622 }, 623 /* File copy GUID */ 624 { HV_FCOPY_GUID, 625 .driver_data = (unsigned long)&util_fcopy 626 }, 627 { }, 628}; 629 630MODULE_DEVICE_TABLE(vmbus, id_table); 631 632/* The one and only one */ 633static struct hv_driver util_drv = { 634 .name = "hv_utils", 635 .id_table = id_table, 636 .probe = util_probe, 637 .remove = util_remove, 638 .suspend = util_suspend, 639 .resume = util_resume, 640 .driver = { 641 .probe_type = PROBE_PREFER_ASYNCHRONOUS, 642 }, 643}; 644 645static int hv_ptp_enable(struct ptp_clock_info *info, 646 struct ptp_clock_request *request, int on) 647{ 648 return -EOPNOTSUPP; 649} 650 651static int hv_ptp_settime(struct ptp_clock_info *p, const struct timespec64 *ts) 652{ 653 return -EOPNOTSUPP; 654} 655 656static int hv_ptp_adjfreq(struct ptp_clock_info *ptp, s32 delta) 657{ 658 return -EOPNOTSUPP; 659} 660static int hv_ptp_adjtime(struct ptp_clock_info *ptp, s64 delta) 661{ 662 return -EOPNOTSUPP; 663} 664 665static int hv_ptp_gettime(struct ptp_clock_info *info, struct timespec64 *ts) 666{ 667 return hv_get_adj_host_time(ts); 668} 669 670static struct ptp_clock_info ptp_hyperv_info = { 671 .name = "hyperv", 672 .enable = hv_ptp_enable, 673 .adjtime = hv_ptp_adjtime, 674 .adjfreq = hv_ptp_adjfreq, 675 .gettime64 = hv_ptp_gettime, 676 .settime64 = hv_ptp_settime, 677 .owner = THIS_MODULE, 678}; 679 680static struct ptp_clock *hv_ptp_clock; 681 682static int hv_timesync_init(struct hv_util_service *srv) 683{ 684 /* TimeSync requires Hyper-V clocksource. */ 685 if (!hv_read_reference_counter) 686 return -ENODEV; 687 688 spin_lock_init(&host_ts.lock); 689 690 INIT_WORK(&adj_time_work, hv_set_host_time); 691 692 /* 693 * ptp_clock_register() returns NULL when CONFIG_PTP_1588_CLOCK is 694 * disabled but the driver is still useful without the PTP device 695 * as it still handles the ICTIMESYNCFLAG_SYNC case. 696 */ 697 hv_ptp_clock = ptp_clock_register(&ptp_hyperv_info, NULL); 698 if (IS_ERR_OR_NULL(hv_ptp_clock)) { 699 pr_err("cannot register PTP clock: %d\n", 700 PTR_ERR_OR_ZERO(hv_ptp_clock)); 701 hv_ptp_clock = NULL; 702 } 703 704 return 0; 705} 706 707static void hv_timesync_cancel_work(void) 708{ 709 cancel_work_sync(&adj_time_work); 710} 711 712static int hv_timesync_pre_suspend(void) 713{ 714 hv_timesync_cancel_work(); 715 return 0; 716} 717 718static void hv_timesync_deinit(void) 719{ 720 if (hv_ptp_clock) 721 ptp_clock_unregister(hv_ptp_clock); 722 723 hv_timesync_cancel_work(); 724} 725 726static int __init init_hyperv_utils(void) 727{ 728 pr_info("Registering HyperV Utility Driver\n"); 729 730 return vmbus_driver_register(&util_drv); 731} 732 733static void exit_hyperv_utils(void) 734{ 735 pr_info("De-Registered HyperV Utility Driver\n"); 736 737 vmbus_driver_unregister(&util_drv); 738} 739 740module_init(init_hyperv_utils); 741module_exit(exit_hyperv_utils); 742 743MODULE_DESCRIPTION("Hyper-V Utilities"); 744MODULE_LICENSE("GPL"); 745