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