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