1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * 4 * Copyright (c) 2009, Microsoft Corporation. 5 * 6 * Authors: 7 * Haiyang Zhang <haiyangz@microsoft.com> 8 * Hank Janssen <hjanssen@microsoft.com> 9 */ 10 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 11 12 #include <linux/kernel.h> 13 #include <linux/sched.h> 14 #include <linux/wait.h> 15 #include <linux/delay.h> 16 #include <linux/mm.h> 17 #include <linux/module.h> 18 #include <linux/slab.h> 19 #include <linux/vmalloc.h> 20 #include <linux/hyperv.h> 21 #include <linux/export.h> 22 #include <asm/mshyperv.h> 23 24 #include "hyperv_vmbus.h" 25 26 27 struct vmbus_connection vmbus_connection = { 28 .conn_state = DISCONNECTED, 29 .next_gpadl_handle = ATOMIC_INIT(0xE1E10), 30 31 .ready_for_suspend_event= COMPLETION_INITIALIZER( 32 vmbus_connection.ready_for_suspend_event), 33 .ready_for_resume_event = COMPLETION_INITIALIZER( 34 vmbus_connection.ready_for_resume_event), 35 }; 36 EXPORT_SYMBOL_GPL(vmbus_connection); 37 38 /* 39 * Negotiated protocol version with the host. 40 */ 41 __u32 vmbus_proto_version; 42 EXPORT_SYMBOL_GPL(vmbus_proto_version); 43 44 /* 45 * Table of VMBus versions listed from newest to oldest. 46 */ 47 static __u32 vmbus_versions[] = { 48 VERSION_WIN10_V5_2, 49 VERSION_WIN10_V5_1, 50 VERSION_WIN10_V5, 51 VERSION_WIN10_V4_1, 52 VERSION_WIN10, 53 VERSION_WIN8_1, 54 VERSION_WIN8, 55 VERSION_WIN7, 56 VERSION_WS2008 57 }; 58 59 /* 60 * Maximal VMBus protocol version guests can negotiate. Useful to cap the 61 * VMBus version for testing and debugging purpose. 62 */ 63 static uint max_version = VERSION_WIN10_V5_2; 64 65 module_param(max_version, uint, S_IRUGO); 66 MODULE_PARM_DESC(max_version, 67 "Maximal VMBus protocol version which can be negotiated"); 68 69 int vmbus_negotiate_version(struct vmbus_channel_msginfo *msginfo, u32 version) 70 { 71 int ret = 0; 72 struct vmbus_channel_initiate_contact *msg; 73 unsigned long flags; 74 75 init_completion(&msginfo->waitevent); 76 77 msg = (struct vmbus_channel_initiate_contact *)msginfo->msg; 78 79 memset(msg, 0, sizeof(*msg)); 80 msg->header.msgtype = CHANNELMSG_INITIATE_CONTACT; 81 msg->vmbus_version_requested = version; 82 83 /* 84 * VMBus protocol 5.0 (VERSION_WIN10_V5) and higher require that we must 85 * use VMBUS_MESSAGE_CONNECTION_ID_4 for the Initiate Contact Message, 86 * and for subsequent messages, we must use the Message Connection ID 87 * field in the host-returned Version Response Message. And, with 88 * VERSION_WIN10_V5 and higher, we don't use msg->interrupt_page, but we 89 * tell the host explicitly that we still use VMBUS_MESSAGE_SINT(2) for 90 * compatibility. 91 * 92 * On old hosts, we should always use VMBUS_MESSAGE_CONNECTION_ID (1). 93 */ 94 if (version >= VERSION_WIN10_V5) { 95 msg->msg_sint = VMBUS_MESSAGE_SINT; 96 vmbus_connection.msg_conn_id = VMBUS_MESSAGE_CONNECTION_ID_4; 97 } else { 98 msg->interrupt_page = virt_to_phys(vmbus_connection.int_page); 99 vmbus_connection.msg_conn_id = VMBUS_MESSAGE_CONNECTION_ID; 100 } 101 102 msg->monitor_page1 = virt_to_phys(vmbus_connection.monitor_pages[0]); 103 msg->monitor_page2 = virt_to_phys(vmbus_connection.monitor_pages[1]); 104 msg->target_vcpu = hv_cpu_number_to_vp_number(VMBUS_CONNECT_CPU); 105 106 /* 107 * Add to list before we send the request since we may 108 * receive the response before returning from this routine 109 */ 110 spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags); 111 list_add_tail(&msginfo->msglistentry, 112 &vmbus_connection.chn_msg_list); 113 114 spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock, flags); 115 116 ret = vmbus_post_msg(msg, 117 sizeof(struct vmbus_channel_initiate_contact), 118 true); 119 120 trace_vmbus_negotiate_version(msg, ret); 121 122 if (ret != 0) { 123 spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags); 124 list_del(&msginfo->msglistentry); 125 spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock, 126 flags); 127 return ret; 128 } 129 130 /* Wait for the connection response */ 131 wait_for_completion(&msginfo->waitevent); 132 133 spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags); 134 list_del(&msginfo->msglistentry); 135 spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock, flags); 136 137 /* Check if successful */ 138 if (msginfo->response.version_response.version_supported) { 139 vmbus_connection.conn_state = CONNECTED; 140 141 if (version >= VERSION_WIN10_V5) 142 vmbus_connection.msg_conn_id = 143 msginfo->response.version_response.msg_conn_id; 144 } else { 145 return -ECONNREFUSED; 146 } 147 148 return ret; 149 } 150 151 /* 152 * vmbus_connect - Sends a connect request on the partition service connection 153 */ 154 int vmbus_connect(void) 155 { 156 struct vmbus_channel_msginfo *msginfo = NULL; 157 int i, ret = 0; 158 __u32 version; 159 160 /* Initialize the vmbus connection */ 161 vmbus_connection.conn_state = CONNECTING; 162 vmbus_connection.work_queue = create_workqueue("hv_vmbus_con"); 163 if (!vmbus_connection.work_queue) { 164 ret = -ENOMEM; 165 goto cleanup; 166 } 167 168 vmbus_connection.handle_primary_chan_wq = 169 create_workqueue("hv_pri_chan"); 170 if (!vmbus_connection.handle_primary_chan_wq) { 171 ret = -ENOMEM; 172 goto cleanup; 173 } 174 175 vmbus_connection.handle_sub_chan_wq = 176 create_workqueue("hv_sub_chan"); 177 if (!vmbus_connection.handle_sub_chan_wq) { 178 ret = -ENOMEM; 179 goto cleanup; 180 } 181 182 INIT_LIST_HEAD(&vmbus_connection.chn_msg_list); 183 spin_lock_init(&vmbus_connection.channelmsg_lock); 184 185 INIT_LIST_HEAD(&vmbus_connection.chn_list); 186 mutex_init(&vmbus_connection.channel_mutex); 187 188 /* 189 * Setup the vmbus event connection for channel interrupt 190 * abstraction stuff 191 */ 192 vmbus_connection.int_page = 193 (void *)hv_alloc_hyperv_zeroed_page(); 194 if (vmbus_connection.int_page == NULL) { 195 ret = -ENOMEM; 196 goto cleanup; 197 } 198 199 vmbus_connection.recv_int_page = vmbus_connection.int_page; 200 vmbus_connection.send_int_page = 201 (void *)((unsigned long)vmbus_connection.int_page + 202 (HV_HYP_PAGE_SIZE >> 1)); 203 204 /* 205 * Setup the monitor notification facility. The 1st page for 206 * parent->child and the 2nd page for child->parent 207 */ 208 vmbus_connection.monitor_pages[0] = (void *)hv_alloc_hyperv_zeroed_page(); 209 vmbus_connection.monitor_pages[1] = (void *)hv_alloc_hyperv_zeroed_page(); 210 if ((vmbus_connection.monitor_pages[0] == NULL) || 211 (vmbus_connection.monitor_pages[1] == NULL)) { 212 ret = -ENOMEM; 213 goto cleanup; 214 } 215 216 msginfo = kzalloc(sizeof(*msginfo) + 217 sizeof(struct vmbus_channel_initiate_contact), 218 GFP_KERNEL); 219 if (msginfo == NULL) { 220 ret = -ENOMEM; 221 goto cleanup; 222 } 223 224 /* 225 * Negotiate a compatible VMBUS version number with the 226 * host. We start with the highest number we can support 227 * and work our way down until we negotiate a compatible 228 * version. 229 */ 230 231 for (i = 0; ; i++) { 232 if (i == ARRAY_SIZE(vmbus_versions)) 233 goto cleanup; 234 235 version = vmbus_versions[i]; 236 if (version > max_version) 237 continue; 238 239 ret = vmbus_negotiate_version(msginfo, version); 240 if (ret == -ETIMEDOUT) 241 goto cleanup; 242 243 if (vmbus_connection.conn_state == CONNECTED) 244 break; 245 } 246 247 if (hv_is_isolation_supported() && version < VERSION_WIN10_V5_2) { 248 pr_err("Invalid VMBus version %d.%d (expected >= %d.%d) from the host supporting isolation\n", 249 version >> 16, version & 0xFFFF, VERSION_WIN10_V5_2 >> 16, VERSION_WIN10_V5_2 & 0xFFFF); 250 ret = -EINVAL; 251 goto cleanup; 252 } 253 254 vmbus_proto_version = version; 255 pr_info("Vmbus version:%d.%d\n", 256 version >> 16, version & 0xFFFF); 257 258 vmbus_connection.channels = kcalloc(MAX_CHANNEL_RELIDS, 259 sizeof(struct vmbus_channel *), 260 GFP_KERNEL); 261 if (vmbus_connection.channels == NULL) { 262 ret = -ENOMEM; 263 goto cleanup; 264 } 265 266 kfree(msginfo); 267 return 0; 268 269 cleanup: 270 pr_err("Unable to connect to host\n"); 271 272 vmbus_connection.conn_state = DISCONNECTED; 273 vmbus_disconnect(); 274 275 kfree(msginfo); 276 277 return ret; 278 } 279 280 void vmbus_disconnect(void) 281 { 282 /* 283 * First send the unload request to the host. 284 */ 285 vmbus_initiate_unload(false); 286 287 if (vmbus_connection.handle_sub_chan_wq) 288 destroy_workqueue(vmbus_connection.handle_sub_chan_wq); 289 290 if (vmbus_connection.handle_primary_chan_wq) 291 destroy_workqueue(vmbus_connection.handle_primary_chan_wq); 292 293 if (vmbus_connection.work_queue) 294 destroy_workqueue(vmbus_connection.work_queue); 295 296 if (vmbus_connection.int_page) { 297 hv_free_hyperv_page((unsigned long)vmbus_connection.int_page); 298 vmbus_connection.int_page = NULL; 299 } 300 301 hv_free_hyperv_page((unsigned long)vmbus_connection.monitor_pages[0]); 302 hv_free_hyperv_page((unsigned long)vmbus_connection.monitor_pages[1]); 303 vmbus_connection.monitor_pages[0] = NULL; 304 vmbus_connection.monitor_pages[1] = NULL; 305 } 306 307 /* 308 * relid2channel - Get the channel object given its 309 * child relative id (ie channel id) 310 */ 311 struct vmbus_channel *relid2channel(u32 relid) 312 { 313 if (WARN_ON(relid >= MAX_CHANNEL_RELIDS)) 314 return NULL; 315 return READ_ONCE(vmbus_connection.channels[relid]); 316 } 317 318 /* 319 * vmbus_on_event - Process a channel event notification 320 * 321 * For batched channels (default) optimize host to guest signaling 322 * by ensuring: 323 * 1. While reading the channel, we disable interrupts from host. 324 * 2. Ensure that we process all posted messages from the host 325 * before returning from this callback. 326 * 3. Once we return, enable signaling from the host. Once this 327 * state is set we check to see if additional packets are 328 * available to read. In this case we repeat the process. 329 * If this tasklet has been running for a long time 330 * then reschedule ourselves. 331 */ 332 void vmbus_on_event(unsigned long data) 333 { 334 struct vmbus_channel *channel = (void *) data; 335 unsigned long time_limit = jiffies + 2; 336 337 trace_vmbus_on_event(channel); 338 339 hv_debug_delay_test(channel, INTERRUPT_DELAY); 340 do { 341 void (*callback_fn)(void *); 342 343 /* A channel once created is persistent even when 344 * there is no driver handling the device. An 345 * unloading driver sets the onchannel_callback to NULL. 346 */ 347 callback_fn = READ_ONCE(channel->onchannel_callback); 348 if (unlikely(callback_fn == NULL)) 349 return; 350 351 (*callback_fn)(channel->channel_callback_context); 352 353 if (channel->callback_mode != HV_CALL_BATCHED) 354 return; 355 356 if (likely(hv_end_read(&channel->inbound) == 0)) 357 return; 358 359 hv_begin_read(&channel->inbound); 360 } while (likely(time_before(jiffies, time_limit))); 361 362 /* The time limit (2 jiffies) has been reached */ 363 tasklet_schedule(&channel->callback_event); 364 } 365 366 /* 367 * vmbus_post_msg - Send a msg on the vmbus's message connection 368 */ 369 int vmbus_post_msg(void *buffer, size_t buflen, bool can_sleep) 370 { 371 struct vmbus_channel_message_header *hdr; 372 union hv_connection_id conn_id; 373 int ret = 0; 374 int retries = 0; 375 u32 usec = 1; 376 377 conn_id.asu32 = 0; 378 conn_id.u.id = vmbus_connection.msg_conn_id; 379 380 /* 381 * hv_post_message() can have transient failures because of 382 * insufficient resources. Retry the operation a couple of 383 * times before giving up. 384 */ 385 while (retries < 100) { 386 ret = hv_post_message(conn_id, 1, buffer, buflen); 387 388 switch (ret) { 389 case HV_STATUS_INVALID_CONNECTION_ID: 390 /* 391 * See vmbus_negotiate_version(): VMBus protocol 5.0 392 * and higher require that we must use 393 * VMBUS_MESSAGE_CONNECTION_ID_4 for the Initiate 394 * Contact message, but on old hosts that only 395 * support VMBus protocol 4.0 or lower, here we get 396 * HV_STATUS_INVALID_CONNECTION_ID and we should 397 * return an error immediately without retrying. 398 */ 399 hdr = buffer; 400 if (hdr->msgtype == CHANNELMSG_INITIATE_CONTACT) 401 return -EINVAL; 402 /* 403 * We could get this if we send messages too 404 * frequently. 405 */ 406 ret = -EAGAIN; 407 break; 408 case HV_STATUS_INSUFFICIENT_MEMORY: 409 case HV_STATUS_INSUFFICIENT_BUFFERS: 410 ret = -ENOBUFS; 411 break; 412 case HV_STATUS_SUCCESS: 413 return ret; 414 default: 415 pr_err("hv_post_msg() failed; error code:%d\n", ret); 416 return -EINVAL; 417 } 418 419 retries++; 420 if (can_sleep && usec > 1000) 421 msleep(usec / 1000); 422 else if (usec < MAX_UDELAY_MS * 1000) 423 udelay(usec); 424 else 425 mdelay(usec / 1000); 426 427 if (retries < 22) 428 usec *= 2; 429 } 430 return ret; 431 } 432 433 /* 434 * vmbus_set_event - Send an event notification to the parent 435 */ 436 void vmbus_set_event(struct vmbus_channel *channel) 437 { 438 u32 child_relid = channel->offermsg.child_relid; 439 440 if (!channel->is_dedicated_interrupt) 441 vmbus_send_interrupt(child_relid); 442 443 ++channel->sig_events; 444 445 hv_do_fast_hypercall8(HVCALL_SIGNAL_EVENT, channel->sig_event); 446 } 447 EXPORT_SYMBOL_GPL(vmbus_set_event); 448