drivers/hv/hv_util.c

   1 /*
   2  * Copyright (c) 2010, Microsoft Corporation.
   3  *
   4  * This program is free software; you can redistribute it and/or modify it
   5  * under the terms and conditions of the GNU General Public License,
   6  * version 2, as published by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope it will be useful, but WITHOUT
   9  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  10  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  11  * more details.
  12  *
  13  * You should have received a copy of the GNU General Public License along with
  14  * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
  15  * Place - Suite 330, Boston, MA 02111-1307 USA.
  16  *
  17  * Authors:
  18  *   Haiyang Zhang <haiyangz@microsoft.com>
  19  *   Hank Janssen  <hjanssen@microsoft.com>
  20  */
  21 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  22
  23 #include <linux/kernel.h>
  24 #include <linux/init.h>
  25 #include <linux/module.h>
  26 #include <linux/slab.h>
  27 #include <linux/sysctl.h>
  28 #include <linux/reboot.h>
  29 #include <linux/hyperv.h>
  30
  31 #include "hyperv_vmbus.h"
  32
  33 #define SD_MAJOR        3
  34 #define SD_MINOR        0
  35 #define SD_VERSION      (SD_MAJOR << 16 | SD_MINOR)
  36
  37 #define SD_MAJOR_1      1
  38 #define SD_VERSION_1    (SD_MAJOR_1 << 16 | SD_MINOR)
  39
  40 #define TS_MAJOR        4
  41 #define TS_MINOR        0
  42 #define TS_VERSION      (TS_MAJOR << 16 | TS_MINOR)
  43
  44 #define TS_MAJOR_1      1
  45 #define TS_VERSION_1    (TS_MAJOR_1 << 16 | TS_MINOR)
  46
  47 #define TS_MAJOR_3      3
  48 #define TS_VERSION_3    (TS_MAJOR_3 << 16 | TS_MINOR)
  49
  50 #define HB_MAJOR        3
  51 #define HB_MINOR        0
  52 #define HB_VERSION      (HB_MAJOR << 16 | HB_MINOR)
  53
  54 #define HB_MAJOR_1      1
  55 #define HB_VERSION_1    (HB_MAJOR_1 << 16 | HB_MINOR)
  56
  57 static int sd_srv_version;
  58 static int ts_srv_version;
  59 static int hb_srv_version;
  60 static int util_fw_version;
  61
  62 static void shutdown_onchannelcallback(void *context);
  63 static struct hv_util_service util_shutdown = {
  64         .util_cb = shutdown_onchannelcallback,
  65 };
  66
  67 static int hv_timesync_init(struct hv_util_service *srv);
  68 static void hv_timesync_deinit(void);
  69
  70 static void timesync_onchannelcallback(void *context);
  71 static struct hv_util_service util_timesynch = {
  72         .util_cb = timesync_onchannelcallback,
  73         .util_init = hv_timesync_init,
  74         .util_deinit = hv_timesync_deinit,
  75 };
  76
  77 static void heartbeat_onchannelcallback(void *context);
  78 static struct hv_util_service util_heartbeat = {
  79         .util_cb = heartbeat_onchannelcallback,
  80 };
  81
  82 static struct hv_util_service util_kvp = {
  83         .util_cb = hv_kvp_onchannelcallback,
  84         .util_init = hv_kvp_init,
  85         .util_deinit = hv_kvp_deinit,
  86 };
  87
  88 static struct hv_util_service util_vss = {
  89         .util_cb = hv_vss_onchannelcallback,
  90         .util_init = hv_vss_init,
  91         .util_deinit = hv_vss_deinit,
  92 };
  93
  94 static struct hv_util_service util_fcopy = {
  95         .util_cb = hv_fcopy_onchannelcallback,
  96         .util_init = hv_fcopy_init,
  97         .util_deinit = hv_fcopy_deinit,
  98 };
  99
 100 static void perform_shutdown(struct work_struct *dummy)
 101 {
 102         orderly_poweroff(true);
 103 }
 104
 105 /*
 106  * Perform the shutdown operation in a thread context.
 107  */
 108 static DECLARE_WORK(shutdown_work, perform_shutdown);
 109
 110 static void shutdown_onchannelcallback(void *context)
 111 {
 112         struct vmbus_channel *channel = context;
 113         u32 recvlen;
 114         u64 requestid;
 115         bool execute_shutdown = false;
 116         u8  *shut_txf_buf = util_shutdown.recv_buffer;
 117
 118         struct shutdown_msg_data *shutdown_msg;
 119
 120         struct icmsg_hdr *icmsghdrp;
 121         struct icmsg_negotiate *negop = NULL;
 122
 123         vmbus_recvpacket(channel, shut_txf_buf,
 124                          PAGE_SIZE, &recvlen, &requestid);
 125
 126         if (recvlen > 0) {
 127                 icmsghdrp = (struct icmsg_hdr *)&shut_txf_buf[
 128                         sizeof(struct vmbuspipe_hdr)];
 129
 130                 if (icmsghdrp->icmsgtype == ICMSGTYPE_NEGOTIATE) {
 131                         vmbus_prep_negotiate_resp(icmsghdrp, negop,
 132                                         shut_txf_buf, util_fw_version,
 133                                         sd_srv_version);
 134                 } else {
 135                         shutdown_msg =
 136                                 (struct shutdown_msg_data *)&shut_txf_buf[
 137                                         sizeof(struct vmbuspipe_hdr) +
 138                                         sizeof(struct icmsg_hdr)];
 139
 140                         switch (shutdown_msg->flags) {
 141                         case 0:
 142                         case 1:
 143                                 icmsghdrp->status = HV_S_OK;
 144                                 execute_shutdown = true;
 145
 146                                 pr_info("Shutdown request received -"
 147                                             " graceful shutdown initiated\n");
 148                                 break;
 149                         default:
 150                                 icmsghdrp->status = HV_E_FAIL;
 151                                 execute_shutdown = false;
 152
 153                                 pr_info("Shutdown request received -"
 154                                             " Invalid request\n");
 155                                 break;
 156                         }
 157                 }
 158
 159                 icmsghdrp->icflags = ICMSGHDRFLAG_TRANSACTION
 160                         | ICMSGHDRFLAG_RESPONSE;
 161
 162                 vmbus_sendpacket(channel, shut_txf_buf,
 163                                        recvlen, requestid,
 164                                        VM_PKT_DATA_INBAND, 0);
 165         }
 166
 167         if (execute_shutdown == true)
 168                 schedule_work(&shutdown_work);
 169 }
 170
 171 /*
 172  * Set the host time in a process context.
 173  */
 174
 175 struct adj_time_work {
 176         struct work_struct work;
 177         u64     host_time;
 178         u64     ref_time;
 179         u8      flags;
 180 };
 181
 182 static void hv_set_host_time(struct work_struct *work)
 183 {
 184         struct adj_time_work    *wrk;
 185         s64 host_tns;
 186         u64 newtime;
 187         struct timespec host_ts;
 188
 189         wrk = container_of(work, struct adj_time_work, work);
 190
 191         newtime = wrk->host_time;
 192         if (ts_srv_version > TS_VERSION_3) {
 193                 /*
 194                  * Some latency has been introduced since Hyper-V generated
 195                  * its time sample. Take that latency into account before
 196                  * using TSC reference time sample from Hyper-V.
 197                  *
 198                  * This sample is given by TimeSync v4 and above hosts.
 199                  */
 200                 u64 current_tick;
 201
 202                 rdmsrl(HV_X64_MSR_TIME_REF_COUNT, current_tick);
 203                 newtime += (current_tick - wrk->ref_time);
 204         }
 205         host_tns = (newtime - WLTIMEDELTA) * 100;
 206         host_ts = ns_to_timespec(host_tns);
 207
 208         do_settimeofday(&host_ts);
 209 }
 210
 211 /*
 212  * Synchronize time with host after reboot, restore, etc.
 213  *
 214  * ICTIMESYNCFLAG_SYNC flag bit indicates reboot, restore events of the VM.
 215  * After reboot the flag ICTIMESYNCFLAG_SYNC is included in the first time
 216  * message after the timesync channel is opened. Since the hv_utils module is
 217  * loaded after hv_vmbus, the first message is usually missed. This bit is
 218  * considered a hard request to discipline the clock.
 219  *
 220  * ICTIMESYNCFLAG_SAMPLE bit indicates a time sample from host. This is
 221  * typically used as a hint to the guest. The guest is under no obligation
 222  * to discipline the clock.
 223  */
 224 static struct adj_time_work  wrk;
 225 static inline void adj_guesttime(u64 hosttime, u64 reftime, u8 flags)
 226 {
 227
 228         /*
 229          * This check is safe since we are executing in the
 230          * interrupt context and time synch messages arre always
 231          * delivered on the same CPU.
 232          */
 233         if (work_pending(&wrk.work))
 234                 return;
 235
 236         wrk.host_time = hosttime;
 237         wrk.ref_time = reftime;
 238         wrk.flags = flags;
 239         if ((flags & (ICTIMESYNCFLAG_SYNC | ICTIMESYNCFLAG_SAMPLE)) != 0) {
 240                 schedule_work(&wrk.work);
 241         }
 242 }
 243
 244 /*
 245  * Time Sync Channel message handler.
 246  */
 247 static void timesync_onchannelcallback(void *context)
 248 {
 249         struct vmbus_channel *channel = context;
 250         u32 recvlen;
 251         u64 requestid;
 252         struct icmsg_hdr *icmsghdrp;
 253         struct ictimesync_data *timedatap;
 254         struct ictimesync_ref_data *refdata;
 255         u8 *time_txf_buf = util_timesynch.recv_buffer;
 256         struct icmsg_negotiate *negop = NULL;
 257
 258         vmbus_recvpacket(channel, time_txf_buf,
 259                          PAGE_SIZE, &recvlen, &requestid);
 260
 261         if (recvlen > 0) {
 262                 icmsghdrp = (struct icmsg_hdr *)&time_txf_buf[
 263                                 sizeof(struct vmbuspipe_hdr)];
 264
 265                 if (icmsghdrp->icmsgtype == ICMSGTYPE_NEGOTIATE) {
 266                         vmbus_prep_negotiate_resp(icmsghdrp, negop,
 267                                                 time_txf_buf,
 268                                                 util_fw_version,
 269                                                 ts_srv_version);
 270                         pr_info("Using TimeSync version %d.%d\n",
 271                                 ts_srv_version >> 16, ts_srv_version & 0xFFFF);
 272                 } else {
 273                         if (ts_srv_version > TS_VERSION_3) {
 274                                 refdata = (struct ictimesync_ref_data *)
 275                                         &time_txf_buf[
 276                                         sizeof(struct vmbuspipe_hdr) +
 277                                         sizeof(struct icmsg_hdr)];
 278
 279                                 adj_guesttime(refdata->parenttime,
 280                                                 refdata->vmreferencetime,
 281                                                 refdata->flags);
 282                         } else {
 283                                 timedatap = (struct ictimesync_data *)
 284                                         &time_txf_buf[
 285                                         sizeof(struct vmbuspipe_hdr) +
 286                                         sizeof(struct icmsg_hdr)];
 287                                 adj_guesttime(timedatap->parenttime,
 288                                                 0,
 289                                                 timedatap->flags);
 290                         }
 291                 }
 292
 293                 icmsghdrp->icflags = ICMSGHDRFLAG_TRANSACTION
 294                         | ICMSGHDRFLAG_RESPONSE;
 295
 296                 vmbus_sendpacket(channel, time_txf_buf,
 297                                 recvlen, requestid,
 298                                 VM_PKT_DATA_INBAND, 0);
 299         }
 300 }
 301
 302 /*
 303  * Heartbeat functionality.
 304  * Every two seconds, Hyper-V send us a heartbeat request message.
 305  * we respond to this message, and Hyper-V knows we are alive.
 306  */
 307 static void heartbeat_onchannelcallback(void *context)
 308 {
 309         struct vmbus_channel *channel = context;
 310         u32 recvlen;
 311         u64 requestid;
 312         struct icmsg_hdr *icmsghdrp;
 313         struct heartbeat_msg_data *heartbeat_msg;
 314         u8 *hbeat_txf_buf = util_heartbeat.recv_buffer;
 315         struct icmsg_negotiate *negop = NULL;
 316
 317         while (1) {
 318
 319                 vmbus_recvpacket(channel, hbeat_txf_buf,
 320                                  PAGE_SIZE, &recvlen, &requestid);
 321
 322                 if (!recvlen)
 323                         break;
 324
 325                 icmsghdrp = (struct icmsg_hdr *)&hbeat_txf_buf[
 326                                 sizeof(struct vmbuspipe_hdr)];
 327
 328                 if (icmsghdrp->icmsgtype == ICMSGTYPE_NEGOTIATE) {
 329                         vmbus_prep_negotiate_resp(icmsghdrp, negop,
 330                                 hbeat_txf_buf, util_fw_version,
 331                                 hb_srv_version);
 332                 } else {
 333                         heartbeat_msg =
 334                                 (struct heartbeat_msg_data *)&hbeat_txf_buf[
 335                                         sizeof(struct vmbuspipe_hdr) +
 336                                         sizeof(struct icmsg_hdr)];
 337
 338                         heartbeat_msg->seq_num += 1;
 339                 }
 340
 341                 icmsghdrp->icflags = ICMSGHDRFLAG_TRANSACTION
 342                         | ICMSGHDRFLAG_RESPONSE;
 343
 344                 vmbus_sendpacket(channel, hbeat_txf_buf,
 345                                        recvlen, requestid,
 346                                        VM_PKT_DATA_INBAND, 0);
 347         }
 348 }
 349
 350 static int util_probe(struct hv_device *dev,
 351                         const struct hv_vmbus_device_id *dev_id)
 352 {
 353         struct hv_util_service *srv =
 354                 (struct hv_util_service *)dev_id->driver_data;
 355         int ret;
 356
 357         srv->recv_buffer = kmalloc(PAGE_SIZE * 4, GFP_KERNEL);
 358         if (!srv->recv_buffer)
 359                 return -ENOMEM;
 360         srv->channel = dev->channel;
 361         if (srv->util_init) {
 362                 ret = srv->util_init(srv);
 363                 if (ret) {
 364                         ret = -ENODEV;
 365                         goto error1;
 366                 }
 367         }
 368
 369         /*
 370          * The set of services managed by the util driver are not performance
 371          * critical and do not need batched reading. Furthermore, some services
 372          * such as KVP can only handle one message from the host at a time.
 373          * Turn off batched reading for all util drivers before we open the
 374          * channel.
 375          */
 376
 377         set_channel_read_state(dev->channel, false);
 378
 379         hv_set_drvdata(dev, srv);
 380
 381         /*
 382          * Based on the host; initialize the framework and
 383          * service version numbers we will negotiate.
 384          */
 385         switch (vmbus_proto_version) {
 386         case (VERSION_WS2008):
 387                 util_fw_version = UTIL_WS2K8_FW_VERSION;
 388                 sd_srv_version = SD_VERSION_1;
 389                 ts_srv_version = TS_VERSION_1;
 390                 hb_srv_version = HB_VERSION_1;
 391                 break;
 392         case(VERSION_WIN10):
 393                 util_fw_version = UTIL_FW_VERSION;
 394                 sd_srv_version = SD_VERSION;
 395                 ts_srv_version = TS_VERSION;
 396                 hb_srv_version = HB_VERSION;
 397                 break;
 398         default:
 399                 util_fw_version = UTIL_FW_VERSION;
 400                 sd_srv_version = SD_VERSION;
 401                 ts_srv_version = TS_VERSION_3;
 402                 hb_srv_version = HB_VERSION;
 403         }
 404
 405         ret = vmbus_open(dev->channel, 4 * PAGE_SIZE, 4 * PAGE_SIZE, NULL, 0,
 406                         srv->util_cb, dev->channel);
 407         if (ret)
 408                 goto error;
 409
 410         return 0;
 411
 412 error:
 413         if (srv->util_deinit)
 414                 srv->util_deinit();
 415 error1:
 416         kfree(srv->recv_buffer);
 417         return ret;
 418 }
 419
 420 static int util_remove(struct hv_device *dev)
 421 {
 422         struct hv_util_service *srv = hv_get_drvdata(dev);
 423
 424         if (srv->util_deinit)
 425                 srv->util_deinit();
 426         vmbus_close(dev->channel);
 427         kfree(srv->recv_buffer);
 428
 429         return 0;
 430 }
 431
 432 static const struct hv_vmbus_device_id id_table[] = {
 433         /* Shutdown guid */
 434         { HV_SHUTDOWN_GUID,
 435           .driver_data = (unsigned long)&util_shutdown
 436         },
 437         /* Time synch guid */
 438         { HV_TS_GUID,
 439           .driver_data = (unsigned long)&util_timesynch
 440         },
 441         /* Heartbeat guid */
 442         { HV_HEART_BEAT_GUID,
 443           .driver_data = (unsigned long)&util_heartbeat
 444         },
 445         /* KVP guid */
 446         { HV_KVP_GUID,
 447           .driver_data = (unsigned long)&util_kvp
 448         },
 449         /* VSS GUID */
 450         { HV_VSS_GUID,
 451           .driver_data = (unsigned long)&util_vss
 452         },
 453         /* File copy GUID */
 454         { HV_FCOPY_GUID,
 455           .driver_data = (unsigned long)&util_fcopy
 456         },
 457         { },
 458 };
 459
 460 MODULE_DEVICE_TABLE(vmbus, id_table);
 461
 462 /* The one and only one */
 463 static  struct hv_driver util_drv = {
 464         .name = "hv_util",
 465         .id_table = id_table,
 466         .probe =  util_probe,
 467         .remove =  util_remove,
 468 };
 469
 470 static int hv_timesync_init(struct hv_util_service *srv)
 471 {
 472         INIT_WORK(&wrk.work, hv_set_host_time);
 473         return 0;
 474 }
 475
 476 static void hv_timesync_deinit(void)
 477 {
 478         cancel_work_sync(&wrk.work);
 479 }
 480
 481 static int __init init_hyperv_utils(void)
 482 {
 483         pr_info("Registering HyperV Utility Driver\n");
 484
 485         return vmbus_driver_register(&util_drv);
 486 }
 487
 488 static void exit_hyperv_utils(void)
 489 {
 490         pr_info("De-Registered HyperV Utility Driver\n");
 491
 492         vmbus_driver_unregister(&util_drv);
 493 }
 494
 495 module_init(init_hyperv_utils);
 496 module_exit(exit_hyperv_utils);
 497
 498 MODULE_DESCRIPTION("Hyper-V Utilities");
 499 MODULE_LICENSE("GPL");