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 #include <asm/mshyperv.h>
  31
  32 #include "hyperv_vmbus.h"
  33
  34 #define SD_MAJOR        3
  35 #define SD_MINOR        0
  36 #define SD_VERSION      (SD_MAJOR << 16 | SD_MINOR)
  37
  38 #define SD_MAJOR_1      1
  39 #define SD_VERSION_1    (SD_MAJOR_1 << 16 | SD_MINOR)
  40
  41 #define TS_MAJOR        4
  42 #define TS_MINOR        0
  43 #define TS_VERSION      (TS_MAJOR << 16 | TS_MINOR)
  44
  45 #define TS_MAJOR_1      1
  46 #define TS_VERSION_1    (TS_MAJOR_1 << 16 | TS_MINOR)
  47
  48 #define TS_MAJOR_3      3
  49 #define TS_VERSION_3    (TS_MAJOR_3 << 16 | TS_MINOR)
  50
  51 #define HB_MAJOR        3
  52 #define HB_MINOR        0
  53 #define HB_VERSION      (HB_MAJOR << 16 | HB_MINOR)
  54
  55 #define HB_MAJOR_1      1
  56 #define HB_VERSION_1    (HB_MAJOR_1 << 16 | HB_MINOR)
  57
  58 static int sd_srv_version;
  59 static int ts_srv_version;
  60 static int hb_srv_version;
  61
  62 #define SD_VER_COUNT 2
  63 static const int sd_versions[] = {
  64         SD_VERSION,
  65         SD_VERSION_1
  66 };
  67
  68 #define TS_VER_COUNT 3
  69 static const int ts_versions[] = {
  70         TS_VERSION,
  71         TS_VERSION_3,
  72         TS_VERSION_1
  73 };
  74
  75 #define HB_VER_COUNT 2
  76 static const int hb_versions[] = {
  77         HB_VERSION,
  78         HB_VERSION_1
  79 };
  80
  81 #define FW_VER_COUNT 2
  82 static const int fw_versions[] = {
  83         UTIL_FW_VERSION,
  84         UTIL_WS2K8_FW_VERSION
  85 };
  86
  87 static void shutdown_onchannelcallback(void *context);
  88 static struct hv_util_service util_shutdown = {
  89         .util_cb = shutdown_onchannelcallback,
  90 };
  91
  92 static int hv_timesync_init(struct hv_util_service *srv);
  93 static void hv_timesync_deinit(void);
  94
  95 static void timesync_onchannelcallback(void *context);
  96 static struct hv_util_service util_timesynch = {
  97         .util_cb = timesync_onchannelcallback,
  98         .util_init = hv_timesync_init,
  99         .util_deinit = hv_timesync_deinit,
 100 };
 101
 102 static void heartbeat_onchannelcallback(void *context);
 103 static struct hv_util_service util_heartbeat = {
 104         .util_cb = heartbeat_onchannelcallback,
 105 };
 106
 107 static struct hv_util_service util_kvp = {
 108         .util_cb = hv_kvp_onchannelcallback,
 109         .util_init = hv_kvp_init,
 110         .util_deinit = hv_kvp_deinit,
 111 };
 112
 113 static struct hv_util_service util_vss = {
 114         .util_cb = hv_vss_onchannelcallback,
 115         .util_init = hv_vss_init,
 116         .util_deinit = hv_vss_deinit,
 117 };
 118
 119 static struct hv_util_service util_fcopy = {
 120         .util_cb = hv_fcopy_onchannelcallback,
 121         .util_init = hv_fcopy_init,
 122         .util_deinit = hv_fcopy_deinit,
 123 };
 124
 125 static void perform_shutdown(struct work_struct *dummy)
 126 {
 127         orderly_poweroff(true);
 128 }
 129
 130 /*
 131  * Perform the shutdown operation in a thread context.
 132  */
 133 static DECLARE_WORK(shutdown_work, perform_shutdown);
 134
 135 static void shutdown_onchannelcallback(void *context)
 136 {
 137         struct vmbus_channel *channel = context;
 138         u32 recvlen;
 139         u64 requestid;
 140         bool execute_shutdown = false;
 141         u8  *shut_txf_buf = util_shutdown.recv_buffer;
 142
 143         struct shutdown_msg_data *shutdown_msg;
 144
 145         struct icmsg_hdr *icmsghdrp;
 146
 147         vmbus_recvpacket(channel, shut_txf_buf,
 148                          PAGE_SIZE, &recvlen, &requestid);
 149
 150         if (recvlen > 0) {
 151                 icmsghdrp = (struct icmsg_hdr *)&shut_txf_buf[
 152                         sizeof(struct vmbuspipe_hdr)];
 153
 154                 if (icmsghdrp->icmsgtype == ICMSGTYPE_NEGOTIATE) {
 155                         if (vmbus_prep_negotiate_resp(icmsghdrp, shut_txf_buf,
 156                                         fw_versions, FW_VER_COUNT,
 157                                         sd_versions, SD_VER_COUNT,
 158                                         NULL, &sd_srv_version)) {
 159                                 pr_info("Shutdown IC version %d.%d\n",
 160                                         sd_srv_version >> 16,
 161                                         sd_srv_version & 0xFFFF);
 162                         }
 163                 } else {
 164                         shutdown_msg =
 165                                 (struct shutdown_msg_data *)&shut_txf_buf[
 166                                         sizeof(struct vmbuspipe_hdr) +
 167                                         sizeof(struct icmsg_hdr)];
 168
 169                         switch (shutdown_msg->flags) {
 170                         case 0:
 171                         case 1:
 172                                 icmsghdrp->status = HV_S_OK;
 173                                 execute_shutdown = true;
 174
 175                                 pr_info("Shutdown request received -"
 176                                             " graceful shutdown initiated\n");
 177                                 break;
 178                         default:
 179                                 icmsghdrp->status = HV_E_FAIL;
 180                                 execute_shutdown = false;
 181
 182                                 pr_info("Shutdown request received -"
 183                                             " Invalid request\n");
 184                                 break;
 185                         }
 186                 }
 187
 188                 icmsghdrp->icflags = ICMSGHDRFLAG_TRANSACTION
 189                         | ICMSGHDRFLAG_RESPONSE;
 190
 191                 vmbus_sendpacket(channel, shut_txf_buf,
 192                                        recvlen, requestid,
 193                                        VM_PKT_DATA_INBAND, 0);
 194         }
 195
 196         if (execute_shutdown == true)
 197                 schedule_work(&shutdown_work);
 198 }
 199
 200 /*
 201  * Set the host time in a process context.
 202  */
 203
 204 struct adj_time_work {
 205         struct work_struct work;
 206         u64     host_time;
 207         u64     ref_time;
 208         u8      flags;
 209 };
 210
 211 static void hv_set_host_time(struct work_struct *work)
 212 {
 213         struct adj_time_work    *wrk;
 214         s64 host_tns;
 215         u64 newtime;
 216         struct timespec64 host_ts;
 217
 218         wrk = container_of(work, struct adj_time_work, work);
 219
 220         newtime = wrk->host_time;
 221         if (ts_srv_version > TS_VERSION_3) {
 222                 /*
 223                  * Some latency has been introduced since Hyper-V generated
 224                  * its time sample. Take that latency into account before
 225                  * using TSC reference time sample from Hyper-V.
 226                  *
 227                  * This sample is given by TimeSync v4 and above hosts.
 228                  */
 229                 u64 current_tick;
 230
 231                 hv_get_current_tick(current_tick);
 232                 newtime += (current_tick - wrk->ref_time);
 233         }
 234         host_tns = (newtime - WLTIMEDELTA) * 100;
 235         host_ts = ns_to_timespec64(host_tns);
 236
 237         do_settimeofday64(&host_ts);
 238 }
 239
 240 /*
 241  * Synchronize time with host after reboot, restore, etc.
 242  *
 243  * ICTIMESYNCFLAG_SYNC flag bit indicates reboot, restore events of the VM.
 244  * After reboot the flag ICTIMESYNCFLAG_SYNC is included in the first time
 245  * message after the timesync channel is opened. Since the hv_utils module is
 246  * loaded after hv_vmbus, the first message is usually missed. This bit is
 247  * considered a hard request to discipline the clock.
 248  *
 249  * ICTIMESYNCFLAG_SAMPLE bit indicates a time sample from host. This is
 250  * typically used as a hint to the guest. The guest is under no obligation
 251  * to discipline the clock.
 252  */
 253 static struct adj_time_work  wrk;
 254 static inline void adj_guesttime(u64 hosttime, u64 reftime, u8 flags)
 255 {
 256
 257         /*
 258          * This check is safe since we are executing in the
 259          * interrupt context and time synch messages arre always
 260          * delivered on the same CPU.
 261          */
 262         if (work_pending(&wrk.work))
 263                 return;
 264
 265         wrk.host_time = hosttime;
 266         wrk.ref_time = reftime;
 267         wrk.flags = flags;
 268         if ((flags & (ICTIMESYNCFLAG_SYNC | ICTIMESYNCFLAG_SAMPLE)) != 0) {
 269                 schedule_work(&wrk.work);
 270         }
 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                          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 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                                                 0,
 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                                  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 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(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
 413         set_channel_read_state(dev->channel, false);
 414
 415         hv_set_drvdata(dev, srv);
 416
 417         ret = vmbus_open(dev->channel, 4 * PAGE_SIZE, 4 * PAGE_SIZE, NULL, 0,
 418                         srv->util_cb, 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_util",
 477         .id_table = id_table,
 478         .probe =  util_probe,
 479         .remove =  util_remove,
 480 };
 481
 482 static int hv_timesync_init(struct hv_util_service *srv)
 483 {
 484         INIT_WORK(&wrk.work, hv_set_host_time);
 485         return 0;
 486 }
 487
 488 static void hv_timesync_deinit(void)
 489 {
 490         cancel_work_sync(&wrk.work);
 491 }
 492
 493 static int __init init_hyperv_utils(void)
 494 {
 495         pr_info("Registering HyperV Utility Driver\n");
 496
 497         return vmbus_driver_register(&util_drv);
 498 }
 499
 500 static void exit_hyperv_utils(void)
 501 {
 502         pr_info("De-Registered HyperV Utility Driver\n");
 503
 504         vmbus_driver_unregister(&util_drv);
 505 }
 506
 507 module_init(init_hyperv_utils);
 508 module_exit(exit_hyperv_utils);
 509
 510 MODULE_DESCRIPTION("Hyper-V Utilities");
 511 MODULE_LICENSE("GPL");