Hank Janssen | c88c4e4 | 2010-05-04 15:55:05 -0700 | [diff] [blame] | 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 | */ |
Hank Janssen | af7a5b6 | 2011-03-29 13:58:49 -0700 | [diff] [blame] | 21 | #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt |
| 22 | |
Hank Janssen | c88c4e4 | 2010-05-04 15:55:05 -0700 | [diff] [blame] | 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> |
Greg Kroah-Hartman | 9e62907 | 2010-05-04 08:26:23 -0700 | [diff] [blame] | 28 | #include <linux/reboot.h> |
Greg Kroah-Hartman | 46a9719 | 2011-10-04 12:29:52 -0700 | [diff] [blame] | 29 | #include <linux/hyperv.h> |
Hank Janssen | c88c4e4 | 2010-05-04 15:55:05 -0700 | [diff] [blame] | 30 | |
K. Y. Srinivasan | 01325476 | 2014-02-16 11:34:30 -0800 | [diff] [blame] | 31 | #include "hyperv_vmbus.h" |
K. Y. Srinivasan | 6741335 | 2013-07-02 10:31:30 -0700 | [diff] [blame] | 32 | |
K. Y. Srinivasan | 3a49160 | 2013-09-06 11:49:56 -0700 | [diff] [blame] | 33 | #define SD_MAJOR 3 |
| 34 | #define SD_MINOR 0 |
| 35 | #define SD_VERSION (SD_MAJOR << 16 | SD_MINOR) |
K. Y. Srinivasan | 6741335 | 2013-07-02 10:31:30 -0700 | [diff] [blame] | 36 | |
Alex Ng | abeda47 | 2016-09-08 05:24:12 -0700 | [diff] [blame] | 37 | #define SD_MAJOR_1 1 |
| 38 | #define SD_VERSION_1 (SD_MAJOR_1 << 16 | SD_MINOR) |
K. Y. Srinivasan | 3a49160 | 2013-09-06 11:49:56 -0700 | [diff] [blame] | 39 | |
Alex Ng | 8e1d260 | 2016-09-08 05:24:14 -0700 | [diff] [blame] | 40 | #define TS_MAJOR 4 |
K. Y. Srinivasan | 3a49160 | 2013-09-06 11:49:56 -0700 | [diff] [blame] | 41 | #define TS_MINOR 0 |
| 42 | #define TS_VERSION (TS_MAJOR << 16 | TS_MINOR) |
| 43 | |
Alex Ng | abeda47 | 2016-09-08 05:24:12 -0700 | [diff] [blame] | 44 | #define TS_MAJOR_1 1 |
| 45 | #define TS_VERSION_1 (TS_MAJOR_1 << 16 | TS_MINOR) |
K. Y. Srinivasan | 3a49160 | 2013-09-06 11:49:56 -0700 | [diff] [blame] | 46 | |
Alex Ng | 8e1d260 | 2016-09-08 05:24:14 -0700 | [diff] [blame] | 47 | #define TS_MAJOR_3 3 |
| 48 | #define TS_VERSION_3 (TS_MAJOR_3 << 16 | TS_MINOR) |
| 49 | |
K. Y. Srinivasan | 3a49160 | 2013-09-06 11:49:56 -0700 | [diff] [blame] | 50 | #define HB_MAJOR 3 |
Alex Ng | abeda47 | 2016-09-08 05:24:12 -0700 | [diff] [blame] | 51 | #define HB_MINOR 0 |
K. Y. Srinivasan | 3a49160 | 2013-09-06 11:49:56 -0700 | [diff] [blame] | 52 | #define HB_VERSION (HB_MAJOR << 16 | HB_MINOR) |
| 53 | |
Alex Ng | abeda47 | 2016-09-08 05:24:12 -0700 | [diff] [blame] | 54 | #define HB_MAJOR_1 1 |
| 55 | #define HB_VERSION_1 (HB_MAJOR_1 << 16 | HB_MINOR) |
K. Y. Srinivasan | 3a49160 | 2013-09-06 11:49:56 -0700 | [diff] [blame] | 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; |
K. Y. Srinivasan | 6741335 | 2013-07-02 10:31:30 -0700 | [diff] [blame] | 61 | |
K. Y. Srinivasan | a29b643 | 2011-09-18 10:31:33 -0700 | [diff] [blame] | 62 | static void shutdown_onchannelcallback(void *context); |
| 63 | static struct hv_util_service util_shutdown = { |
| 64 | .util_cb = shutdown_onchannelcallback, |
| 65 | }; |
| 66 | |
Vivek yadav | 3ba1eb1 | 2016-09-09 00:42:30 -0700 | [diff] [blame] | 67 | static int hv_timesync_init(struct hv_util_service *srv); |
| 68 | static void hv_timesync_deinit(void); |
| 69 | |
K. Y. Srinivasan | a29b643 | 2011-09-18 10:31:33 -0700 | [diff] [blame] | 70 | static void timesync_onchannelcallback(void *context); |
| 71 | static struct hv_util_service util_timesynch = { |
| 72 | .util_cb = timesync_onchannelcallback, |
Vivek yadav | 3ba1eb1 | 2016-09-09 00:42:30 -0700 | [diff] [blame] | 73 | .util_init = hv_timesync_init, |
| 74 | .util_deinit = hv_timesync_deinit, |
K. Y. Srinivasan | a29b643 | 2011-09-18 10:31:33 -0700 | [diff] [blame] | 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 | }; |
Hank Janssen | c88c4e4 | 2010-05-04 15:55:05 -0700 | [diff] [blame] | 87 | |
K. Y. Srinivasan | 96dd86f | 2013-03-15 12:30:06 -0700 | [diff] [blame] | 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 | |
K. Y. Srinivasan | 01325476 | 2014-02-16 11:34:30 -0800 | [diff] [blame] | 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 | |
K. Y. Srinivasan | 3dd6cb4 | 2013-01-23 17:42:45 -0800 | [diff] [blame] | 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 | |
Greg Kroah-Hartman | 6610944 | 2010-05-04 14:31:18 -0700 | [diff] [blame] | 110 | static void shutdown_onchannelcallback(void *context) |
Hank Janssen | c88c4e4 | 2010-05-04 15:55:05 -0700 | [diff] [blame] | 111 | { |
| 112 | struct vmbus_channel *channel = context; |
Hank Janssen | 45241e5 | 2010-12-13 16:23:36 -0800 | [diff] [blame] | 113 | u32 recvlen; |
Hank Janssen | c88c4e4 | 2010-05-04 15:55:05 -0700 | [diff] [blame] | 114 | u64 requestid; |
Peter Senna Tschudin | 3173463 | 2013-09-22 00:27:34 +0200 | [diff] [blame] | 115 | bool execute_shutdown = false; |
K. Y. Srinivasan | a29b643 | 2011-09-18 10:31:33 -0700 | [diff] [blame] | 116 | u8 *shut_txf_buf = util_shutdown.recv_buffer; |
Hank Janssen | c88c4e4 | 2010-05-04 15:55:05 -0700 | [diff] [blame] | 117 | |
| 118 | struct shutdown_msg_data *shutdown_msg; |
| 119 | |
| 120 | struct icmsg_hdr *icmsghdrp; |
| 121 | struct icmsg_negotiate *negop = NULL; |
| 122 | |
Hank Janssen | 45241e5 | 2010-12-13 16:23:36 -0800 | [diff] [blame] | 123 | vmbus_recvpacket(channel, shut_txf_buf, |
| 124 | PAGE_SIZE, &recvlen, &requestid); |
Hank Janssen | c88c4e4 | 2010-05-04 15:55:05 -0700 | [diff] [blame] | 125 | |
| 126 | if (recvlen > 0) { |
Hank Janssen | 45241e5 | 2010-12-13 16:23:36 -0800 | [diff] [blame] | 127 | icmsghdrp = (struct icmsg_hdr *)&shut_txf_buf[ |
Hank Janssen | c88c4e4 | 2010-05-04 15:55:05 -0700 | [diff] [blame] | 128 | sizeof(struct vmbuspipe_hdr)]; |
| 129 | |
| 130 | if (icmsghdrp->icmsgtype == ICMSGTYPE_NEGOTIATE) { |
K. Y. Srinivasan | c836d0a | 2012-05-12 13:44:58 -0700 | [diff] [blame] | 131 | vmbus_prep_negotiate_resp(icmsghdrp, negop, |
K. Y. Srinivasan | 3a49160 | 2013-09-06 11:49:56 -0700 | [diff] [blame] | 132 | shut_txf_buf, util_fw_version, |
| 133 | sd_srv_version); |
Hank Janssen | c88c4e4 | 2010-05-04 15:55:05 -0700 | [diff] [blame] | 134 | } else { |
Hank Janssen | 45241e5 | 2010-12-13 16:23:36 -0800 | [diff] [blame] | 135 | shutdown_msg = |
| 136 | (struct shutdown_msg_data *)&shut_txf_buf[ |
| 137 | sizeof(struct vmbuspipe_hdr) + |
| 138 | sizeof(struct icmsg_hdr)]; |
Hank Janssen | c88c4e4 | 2010-05-04 15:55:05 -0700 | [diff] [blame] | 139 | |
| 140 | switch (shutdown_msg->flags) { |
| 141 | case 0: |
| 142 | case 1: |
| 143 | icmsghdrp->status = HV_S_OK; |
| 144 | execute_shutdown = true; |
| 145 | |
Hank Janssen | af7a5b6 | 2011-03-29 13:58:49 -0700 | [diff] [blame] | 146 | pr_info("Shutdown request received -" |
Greg Kroah-Hartman | 32235b0 | 2011-04-13 12:14:05 -0700 | [diff] [blame] | 147 | " graceful shutdown initiated\n"); |
Hank Janssen | c88c4e4 | 2010-05-04 15:55:05 -0700 | [diff] [blame] | 148 | break; |
| 149 | default: |
| 150 | icmsghdrp->status = HV_E_FAIL; |
| 151 | execute_shutdown = false; |
| 152 | |
Hank Janssen | af7a5b6 | 2011-03-29 13:58:49 -0700 | [diff] [blame] | 153 | pr_info("Shutdown request received -" |
| 154 | " Invalid request\n"); |
Hank Janssen | c88c4e4 | 2010-05-04 15:55:05 -0700 | [diff] [blame] | 155 | break; |
Joe Perches | 95cd17c | 2011-04-10 14:31:35 -0700 | [diff] [blame] | 156 | } |
Hank Janssen | c88c4e4 | 2010-05-04 15:55:05 -0700 | [diff] [blame] | 157 | } |
| 158 | |
| 159 | icmsghdrp->icflags = ICMSGHDRFLAG_TRANSACTION |
| 160 | | ICMSGHDRFLAG_RESPONSE; |
| 161 | |
Hank Janssen | 45241e5 | 2010-12-13 16:23:36 -0800 | [diff] [blame] | 162 | vmbus_sendpacket(channel, shut_txf_buf, |
Hank Janssen | c88c4e4 | 2010-05-04 15:55:05 -0700 | [diff] [blame] | 163 | recvlen, requestid, |
Haiyang Zhang | 415f228 | 2011-01-26 12:12:13 -0800 | [diff] [blame] | 164 | VM_PKT_DATA_INBAND, 0); |
Hank Janssen | c88c4e4 | 2010-05-04 15:55:05 -0700 | [diff] [blame] | 165 | } |
| 166 | |
Hank Janssen | c88c4e4 | 2010-05-04 15:55:05 -0700 | [diff] [blame] | 167 | if (execute_shutdown == true) |
K. Y. Srinivasan | 3dd6cb4 | 2013-01-23 17:42:45 -0800 | [diff] [blame] | 168 | schedule_work(&shutdown_work); |
Hank Janssen | c88c4e4 | 2010-05-04 15:55:05 -0700 | [diff] [blame] | 169 | } |
| 170 | |
Haiyang Zhang | 39c4e9c | 2010-05-05 19:23:46 +0000 | [diff] [blame] | 171 | /* |
K. Y. Srinivasan | 95ff7cd | 2011-08-27 11:31:31 -0700 | [diff] [blame] | 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; |
Alex Ng | 8e1d260 | 2016-09-08 05:24:14 -0700 | [diff] [blame] | 178 | u64 ref_time; |
| 179 | u8 flags; |
K. Y. Srinivasan | 95ff7cd | 2011-08-27 11:31:31 -0700 | [diff] [blame] | 180 | }; |
| 181 | |
| 182 | static void hv_set_host_time(struct work_struct *work) |
| 183 | { |
| 184 | struct adj_time_work *wrk; |
Alex Ng | 8e1d260 | 2016-09-08 05:24:14 -0700 | [diff] [blame] | 185 | s64 host_tns; |
| 186 | u64 newtime; |
| 187 | struct timespec host_ts; |
K. Y. Srinivasan | 95ff7cd | 2011-08-27 11:31:31 -0700 | [diff] [blame] | 188 | |
| 189 | wrk = container_of(work, struct adj_time_work, work); |
Alex Ng | 8e1d260 | 2016-09-08 05:24:14 -0700 | [diff] [blame] | 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); |
K. Y. Srinivasan | 95ff7cd | 2011-08-27 11:31:31 -0700 | [diff] [blame] | 209 | } |
| 210 | |
| 211 | /* |
Haiyang Zhang | e9ec360 | 2010-05-11 15:11:24 +0000 | [diff] [blame] | 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 |
Alex Ng | 2e338f7 | 2016-09-08 05:24:13 -0700 | [diff] [blame] | 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. |
Haiyang Zhang | e9ec360 | 2010-05-11 15:11:24 +0000 | [diff] [blame] | 223 | */ |
Vivek yadav | 3ba1eb1 | 2016-09-09 00:42:30 -0700 | [diff] [blame] | 224 | static struct adj_time_work wrk; |
Alex Ng | 8e1d260 | 2016-09-08 05:24:14 -0700 | [diff] [blame] | 225 | static inline void adj_guesttime(u64 hosttime, u64 reftime, u8 flags) |
Haiyang Zhang | e9ec360 | 2010-05-11 15:11:24 +0000 | [diff] [blame] | 226 | { |
Haiyang Zhang | e9ec360 | 2010-05-11 15:11:24 +0000 | [diff] [blame] | 227 | |
Vivek yadav | 3ba1eb1 | 2016-09-09 00:42:30 -0700 | [diff] [blame] | 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)) |
K. Y. Srinivasan | 95ff7cd | 2011-08-27 11:31:31 -0700 | [diff] [blame] | 234 | return; |
| 235 | |
Vivek yadav | 3ba1eb1 | 2016-09-09 00:42:30 -0700 | [diff] [blame] | 236 | wrk.host_time = hosttime; |
| 237 | wrk.ref_time = reftime; |
| 238 | wrk.flags = flags; |
Alex Ng | 2e338f7 | 2016-09-08 05:24:13 -0700 | [diff] [blame] | 239 | if ((flags & (ICTIMESYNCFLAG_SYNC | ICTIMESYNCFLAG_SAMPLE)) != 0) { |
Vivek yadav | 3ba1eb1 | 2016-09-09 00:42:30 -0700 | [diff] [blame] | 240 | schedule_work(&wrk.work); |
| 241 | } |
Haiyang Zhang | 39c4e9c | 2010-05-05 19:23:46 +0000 | [diff] [blame] | 242 | } |
| 243 | |
| 244 | /* |
| 245 | * Time Sync Channel message handler. |
| 246 | */ |
| 247 | static void timesync_onchannelcallback(void *context) |
| 248 | { |
| 249 | struct vmbus_channel *channel = context; |
Hank Janssen | 45241e5 | 2010-12-13 16:23:36 -0800 | [diff] [blame] | 250 | u32 recvlen; |
Haiyang Zhang | 39c4e9c | 2010-05-05 19:23:46 +0000 | [diff] [blame] | 251 | u64 requestid; |
| 252 | struct icmsg_hdr *icmsghdrp; |
| 253 | struct ictimesync_data *timedatap; |
Alex Ng | 8e1d260 | 2016-09-08 05:24:14 -0700 | [diff] [blame] | 254 | struct ictimesync_ref_data *refdata; |
K. Y. Srinivasan | a29b643 | 2011-09-18 10:31:33 -0700 | [diff] [blame] | 255 | u8 *time_txf_buf = util_timesynch.recv_buffer; |
K. Y. Srinivasan | 3a49160 | 2013-09-06 11:49:56 -0700 | [diff] [blame] | 256 | struct icmsg_negotiate *negop = NULL; |
Haiyang Zhang | 39c4e9c | 2010-05-05 19:23:46 +0000 | [diff] [blame] | 257 | |
Hank Janssen | 45241e5 | 2010-12-13 16:23:36 -0800 | [diff] [blame] | 258 | vmbus_recvpacket(channel, time_txf_buf, |
| 259 | PAGE_SIZE, &recvlen, &requestid); |
Haiyang Zhang | 39c4e9c | 2010-05-05 19:23:46 +0000 | [diff] [blame] | 260 | |
| 261 | if (recvlen > 0) { |
Hank Janssen | 45241e5 | 2010-12-13 16:23:36 -0800 | [diff] [blame] | 262 | icmsghdrp = (struct icmsg_hdr *)&time_txf_buf[ |
Haiyang Zhang | 39c4e9c | 2010-05-05 19:23:46 +0000 | [diff] [blame] | 263 | sizeof(struct vmbuspipe_hdr)]; |
| 264 | |
| 265 | if (icmsghdrp->icmsgtype == ICMSGTYPE_NEGOTIATE) { |
K. Y. Srinivasan | 3a49160 | 2013-09-06 11:49:56 -0700 | [diff] [blame] | 266 | vmbus_prep_negotiate_resp(icmsghdrp, negop, |
| 267 | time_txf_buf, |
| 268 | util_fw_version, |
| 269 | ts_srv_version); |
Alex Ng | 8e1d260 | 2016-09-08 05:24:14 -0700 | [diff] [blame] | 270 | pr_info("Using TimeSync version %d.%d\n", |
| 271 | ts_srv_version >> 16, ts_srv_version & 0xFFFF); |
Haiyang Zhang | 39c4e9c | 2010-05-05 19:23:46 +0000 | [diff] [blame] | 272 | } else { |
Alex Ng | 8e1d260 | 2016-09-08 05:24:14 -0700 | [diff] [blame] | 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 | } |
Haiyang Zhang | 39c4e9c | 2010-05-05 19:23:46 +0000 | [diff] [blame] | 291 | } |
| 292 | |
| 293 | icmsghdrp->icflags = ICMSGHDRFLAG_TRANSACTION |
| 294 | | ICMSGHDRFLAG_RESPONSE; |
| 295 | |
Hank Janssen | 45241e5 | 2010-12-13 16:23:36 -0800 | [diff] [blame] | 296 | vmbus_sendpacket(channel, time_txf_buf, |
Haiyang Zhang | 39c4e9c | 2010-05-05 19:23:46 +0000 | [diff] [blame] | 297 | recvlen, requestid, |
Haiyang Zhang | 415f228 | 2011-01-26 12:12:13 -0800 | [diff] [blame] | 298 | VM_PKT_DATA_INBAND, 0); |
Haiyang Zhang | 39c4e9c | 2010-05-05 19:23:46 +0000 | [diff] [blame] | 299 | } |
Haiyang Zhang | 39c4e9c | 2010-05-05 19:23:46 +0000 | [diff] [blame] | 300 | } |
| 301 | |
Hank Janssen | 9153f7b | 2010-05-15 14:39:58 -0700 | [diff] [blame] | 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; |
Hank Janssen | 45241e5 | 2010-12-13 16:23:36 -0800 | [diff] [blame] | 310 | u32 recvlen; |
Hank Janssen | 9153f7b | 2010-05-15 14:39:58 -0700 | [diff] [blame] | 311 | u64 requestid; |
| 312 | struct icmsg_hdr *icmsghdrp; |
| 313 | struct heartbeat_msg_data *heartbeat_msg; |
K. Y. Srinivasan | a29b643 | 2011-09-18 10:31:33 -0700 | [diff] [blame] | 314 | u8 *hbeat_txf_buf = util_heartbeat.recv_buffer; |
K. Y. Srinivasan | 3a49160 | 2013-09-06 11:49:56 -0700 | [diff] [blame] | 315 | struct icmsg_negotiate *negop = NULL; |
Hank Janssen | 9153f7b | 2010-05-15 14:39:58 -0700 | [diff] [blame] | 316 | |
Long Li | 407a3ae | 2016-10-05 16:57:46 -0700 | [diff] [blame^] | 317 | while (1) { |
Hank Janssen | 9153f7b | 2010-05-15 14:39:58 -0700 | [diff] [blame] | 318 | |
Long Li | 407a3ae | 2016-10-05 16:57:46 -0700 | [diff] [blame^] | 319 | vmbus_recvpacket(channel, hbeat_txf_buf, |
| 320 | PAGE_SIZE, &recvlen, &requestid); |
| 321 | |
| 322 | if (!recvlen) |
| 323 | break; |
| 324 | |
Hank Janssen | 45241e5 | 2010-12-13 16:23:36 -0800 | [diff] [blame] | 325 | icmsghdrp = (struct icmsg_hdr *)&hbeat_txf_buf[ |
Hank Janssen | 9153f7b | 2010-05-15 14:39:58 -0700 | [diff] [blame] | 326 | sizeof(struct vmbuspipe_hdr)]; |
| 327 | |
| 328 | if (icmsghdrp->icmsgtype == ICMSGTYPE_NEGOTIATE) { |
K. Y. Srinivasan | 3a49160 | 2013-09-06 11:49:56 -0700 | [diff] [blame] | 329 | vmbus_prep_negotiate_resp(icmsghdrp, negop, |
| 330 | hbeat_txf_buf, util_fw_version, |
| 331 | hb_srv_version); |
Hank Janssen | 9153f7b | 2010-05-15 14:39:58 -0700 | [diff] [blame] | 332 | } else { |
Hank Janssen | 45241e5 | 2010-12-13 16:23:36 -0800 | [diff] [blame] | 333 | heartbeat_msg = |
| 334 | (struct heartbeat_msg_data *)&hbeat_txf_buf[ |
| 335 | sizeof(struct vmbuspipe_hdr) + |
| 336 | sizeof(struct icmsg_hdr)]; |
Hank Janssen | 9153f7b | 2010-05-15 14:39:58 -0700 | [diff] [blame] | 337 | |
Hank Janssen | 9153f7b | 2010-05-15 14:39:58 -0700 | [diff] [blame] | 338 | heartbeat_msg->seq_num += 1; |
| 339 | } |
| 340 | |
| 341 | icmsghdrp->icflags = ICMSGHDRFLAG_TRANSACTION |
| 342 | | ICMSGHDRFLAG_RESPONSE; |
| 343 | |
Hank Janssen | 45241e5 | 2010-12-13 16:23:36 -0800 | [diff] [blame] | 344 | vmbus_sendpacket(channel, hbeat_txf_buf, |
Hank Janssen | 9153f7b | 2010-05-15 14:39:58 -0700 | [diff] [blame] | 345 | recvlen, requestid, |
Haiyang Zhang | 415f228 | 2011-01-26 12:12:13 -0800 | [diff] [blame] | 346 | VM_PKT_DATA_INBAND, 0); |
Hank Janssen | 9153f7b | 2010-05-15 14:39:58 -0700 | [diff] [blame] | 347 | } |
Hank Janssen | 9153f7b | 2010-05-15 14:39:58 -0700 | [diff] [blame] | 348 | } |
Haiyang Zhang | 39c4e9c | 2010-05-05 19:23:46 +0000 | [diff] [blame] | 349 | |
K. Y. Srinivasan | 8494689 | 2011-09-13 10:59:38 -0700 | [diff] [blame] | 350 | static int util_probe(struct hv_device *dev, |
| 351 | const struct hv_vmbus_device_id *dev_id) |
K. Y. Srinivasan | 283f212 | 2011-08-25 09:48:36 -0700 | [diff] [blame] | 352 | { |
K. Y. Srinivasan | a29b643 | 2011-09-18 10:31:33 -0700 | [diff] [blame] | 353 | struct hv_util_service *srv = |
| 354 | (struct hv_util_service *)dev_id->driver_data; |
| 355 | int ret; |
| 356 | |
K. Y. Srinivasan | 9bd2d0d | 2014-07-07 16:34:25 -0700 | [diff] [blame] | 357 | srv->recv_buffer = kmalloc(PAGE_SIZE * 4, GFP_KERNEL); |
K. Y. Srinivasan | a29b643 | 2011-09-18 10:31:33 -0700 | [diff] [blame] | 358 | if (!srv->recv_buffer) |
| 359 | return -ENOMEM; |
K. Y. Srinivasan | b9830d1 | 2016-02-26 15:13:19 -0800 | [diff] [blame] | 360 | srv->channel = dev->channel; |
K. Y. Srinivasan | a29b643 | 2011-09-18 10:31:33 -0700 | [diff] [blame] | 361 | if (srv->util_init) { |
| 362 | ret = srv->util_init(srv); |
| 363 | if (ret) { |
K. Y. Srinivasan | 4e65f6e | 2011-09-18 10:31:34 -0700 | [diff] [blame] | 364 | ret = -ENODEV; |
| 365 | goto error1; |
K. Y. Srinivasan | a29b643 | 2011-09-18 10:31:33 -0700 | [diff] [blame] | 366 | } |
| 367 | } |
| 368 | |
K. Y. Srinivasan | 7ae3e03 | 2012-12-01 06:46:34 -0800 | [diff] [blame] | 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 | |
K. Y. Srinivasan | a29b643 | 2011-09-18 10:31:33 -0700 | [diff] [blame] | 379 | hv_set_drvdata(dev, srv); |
Dexuan Cui | 1896566 | 2015-02-27 11:25:58 -0800 | [diff] [blame] | 380 | |
K. Y. Srinivasan | 3a49160 | 2013-09-06 11:49:56 -0700 | [diff] [blame] | 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; |
Alex Ng | abeda47 | 2016-09-08 05:24:12 -0700 | [diff] [blame] | 388 | sd_srv_version = SD_VERSION_1; |
| 389 | ts_srv_version = TS_VERSION_1; |
| 390 | hb_srv_version = HB_VERSION_1; |
K. Y. Srinivasan | 3a49160 | 2013-09-06 11:49:56 -0700 | [diff] [blame] | 391 | break; |
Alex Ng | 8e1d260 | 2016-09-08 05:24:14 -0700 | [diff] [blame] | 392 | case(VERSION_WIN10): |
K. Y. Srinivasan | 3a49160 | 2013-09-06 11:49:56 -0700 | [diff] [blame] | 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; |
Alex Ng | 8e1d260 | 2016-09-08 05:24:14 -0700 | [diff] [blame] | 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; |
K. Y. Srinivasan | 3a49160 | 2013-09-06 11:49:56 -0700 | [diff] [blame] | 403 | } |
| 404 | |
Dexuan Cui | 1896566 | 2015-02-27 11:25:58 -0800 | [diff] [blame] | 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 | |
K. Y. Srinivasan | 283f212 | 2011-08-25 09:48:36 -0700 | [diff] [blame] | 410 | return 0; |
K. Y. Srinivasan | 4e65f6e | 2011-09-18 10:31:34 -0700 | [diff] [blame] | 411 | |
| 412 | error: |
| 413 | if (srv->util_deinit) |
| 414 | srv->util_deinit(); |
| 415 | error1: |
| 416 | kfree(srv->recv_buffer); |
| 417 | return ret; |
K. Y. Srinivasan | 283f212 | 2011-08-25 09:48:36 -0700 | [diff] [blame] | 418 | } |
| 419 | |
| 420 | static int util_remove(struct hv_device *dev) |
| 421 | { |
K. Y. Srinivasan | a29b643 | 2011-09-18 10:31:33 -0700 | [diff] [blame] | 422 | struct hv_util_service *srv = hv_get_drvdata(dev); |
| 423 | |
| 424 | if (srv->util_deinit) |
| 425 | srv->util_deinit(); |
K. Y. Srinivasan | 5380b383 | 2015-02-28 11:18:20 -0800 | [diff] [blame] | 426 | vmbus_close(dev->channel); |
K. Y. Srinivasan | a29b643 | 2011-09-18 10:31:33 -0700 | [diff] [blame] | 427 | kfree(srv->recv_buffer); |
| 428 | |
K. Y. Srinivasan | 283f212 | 2011-08-25 09:48:36 -0700 | [diff] [blame] | 429 | return 0; |
| 430 | } |
| 431 | |
| 432 | static const struct hv_vmbus_device_id id_table[] = { |
Greg Kroah-Hartman | c45cf2d | 2011-08-25 11:41:33 -0700 | [diff] [blame] | 433 | /* Shutdown guid */ |
K. Y. Srinivasan | d13984e | 2013-01-23 17:42:41 -0800 | [diff] [blame] | 434 | { HV_SHUTDOWN_GUID, |
| 435 | .driver_data = (unsigned long)&util_shutdown |
| 436 | }, |
Greg Kroah-Hartman | c45cf2d | 2011-08-25 11:41:33 -0700 | [diff] [blame] | 437 | /* Time synch guid */ |
K. Y. Srinivasan | d13984e | 2013-01-23 17:42:41 -0800 | [diff] [blame] | 438 | { HV_TS_GUID, |
| 439 | .driver_data = (unsigned long)&util_timesynch |
| 440 | }, |
Greg Kroah-Hartman | c45cf2d | 2011-08-25 11:41:33 -0700 | [diff] [blame] | 441 | /* Heartbeat guid */ |
K. Y. Srinivasan | d13984e | 2013-01-23 17:42:41 -0800 | [diff] [blame] | 442 | { HV_HEART_BEAT_GUID, |
| 443 | .driver_data = (unsigned long)&util_heartbeat |
| 444 | }, |
Greg Kroah-Hartman | c45cf2d | 2011-08-25 11:41:33 -0700 | [diff] [blame] | 445 | /* KVP guid */ |
K. Y. Srinivasan | d13984e | 2013-01-23 17:42:41 -0800 | [diff] [blame] | 446 | { HV_KVP_GUID, |
| 447 | .driver_data = (unsigned long)&util_kvp |
| 448 | }, |
K. Y. Srinivasan | 96dd86f | 2013-03-15 12:30:06 -0700 | [diff] [blame] | 449 | /* VSS GUID */ |
| 450 | { HV_VSS_GUID, |
| 451 | .driver_data = (unsigned long)&util_vss |
| 452 | }, |
K. Y. Srinivasan | 01325476 | 2014-02-16 11:34:30 -0800 | [diff] [blame] | 453 | /* File copy GUID */ |
| 454 | { HV_FCOPY_GUID, |
| 455 | .driver_data = (unsigned long)&util_fcopy |
| 456 | }, |
Greg Kroah-Hartman | c45cf2d | 2011-08-25 11:41:33 -0700 | [diff] [blame] | 457 | { }, |
K. Y. Srinivasan | 283f212 | 2011-08-25 09:48:36 -0700 | [diff] [blame] | 458 | }; |
| 459 | |
| 460 | MODULE_DEVICE_TABLE(vmbus, id_table); |
| 461 | |
| 462 | /* The one and only one */ |
| 463 | static struct hv_driver util_drv = { |
Greg Kroah-Hartman | 768fa21 | 2011-08-25 15:07:32 -0700 | [diff] [blame] | 464 | .name = "hv_util", |
K. Y. Srinivasan | 283f212 | 2011-08-25 09:48:36 -0700 | [diff] [blame] | 465 | .id_table = id_table, |
| 466 | .probe = util_probe, |
| 467 | .remove = util_remove, |
| 468 | }; |
| 469 | |
Vivek yadav | 3ba1eb1 | 2016-09-09 00:42:30 -0700 | [diff] [blame] | 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 | |
Hank Janssen | c88c4e4 | 2010-05-04 15:55:05 -0700 | [diff] [blame] | 481 | static int __init init_hyperv_utils(void) |
| 482 | { |
Hank Janssen | af7a5b6 | 2011-03-29 13:58:49 -0700 | [diff] [blame] | 483 | pr_info("Registering HyperV Utility Driver\n"); |
Hank Janssen | c88c4e4 | 2010-05-04 15:55:05 -0700 | [diff] [blame] | 484 | |
K. Y. Srinivasan | 4e65f6e | 2011-09-18 10:31:34 -0700 | [diff] [blame] | 485 | return vmbus_driver_register(&util_drv); |
Hank Janssen | c88c4e4 | 2010-05-04 15:55:05 -0700 | [diff] [blame] | 486 | } |
| 487 | |
| 488 | static void exit_hyperv_utils(void) |
| 489 | { |
Hank Janssen | af7a5b6 | 2011-03-29 13:58:49 -0700 | [diff] [blame] | 490 | pr_info("De-Registered HyperV Utility Driver\n"); |
Hank Janssen | c88c4e4 | 2010-05-04 15:55:05 -0700 | [diff] [blame] | 491 | |
Greg Kroah-Hartman | 768fa21 | 2011-08-25 15:07:32 -0700 | [diff] [blame] | 492 | vmbus_driver_unregister(&util_drv); |
Hank Janssen | c88c4e4 | 2010-05-04 15:55:05 -0700 | [diff] [blame] | 493 | } |
| 494 | |
| 495 | module_init(init_hyperv_utils); |
| 496 | module_exit(exit_hyperv_utils); |
| 497 | |
| 498 | MODULE_DESCRIPTION("Hyper-V Utilities"); |
Hank Janssen | c88c4e4 | 2010-05-04 15:55:05 -0700 | [diff] [blame] | 499 | MODULE_LICENSE("GPL"); |