drivers/hv/hv_util.c

   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");