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
27struct 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};
36EXPORT_SYMBOL_GPL(vmbus_connection);
37
38/*
39 * Negotiated protocol version with the host.
40 */
41__u32 vmbus_proto_version;
42EXPORT_SYMBOL_GPL(vmbus_proto_version);
43
44/*
45 * Table of VMBus versions listed from newest to oldest.
46 */
47static __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 */
63static uint max_version = VERSION_WIN10_V5_2;
64
65module_param(max_version, uint, S_IRUGO);
66MODULE_PARM_DESC(max_version,
67		 "Maximal VMBus protocol version which can be negotiated");
68
69int 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 */
154int 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			ret = -EDOM;
234			goto cleanup;
235		}
236
237		version = vmbus_versions[i];
238		if (version > max_version)
239			continue;
240
241		ret = vmbus_negotiate_version(msginfo, version);
242		if (ret == -ETIMEDOUT)
243			goto cleanup;
244
245		if (vmbus_connection.conn_state == CONNECTED)
246			break;
247	}
248
249	vmbus_proto_version = version;
250	pr_info("Vmbus version:%d.%d\n",
251		version >> 16, version & 0xFFFF);
252
253	vmbus_connection.channels = kcalloc(MAX_CHANNEL_RELIDS,
254					    sizeof(struct vmbus_channel *),
255					    GFP_KERNEL);
256	if (vmbus_connection.channels == NULL) {
257		ret = -ENOMEM;
258		goto cleanup;
259	}
260
261	kfree(msginfo);
262	return 0;
263
264cleanup:
265	pr_err("Unable to connect to host\n");
266
267	vmbus_connection.conn_state = DISCONNECTED;
268	vmbus_disconnect();
269
270	kfree(msginfo);
271
272	return ret;
273}
274
275void vmbus_disconnect(void)
276{
277	/*
278	 * First send the unload request to the host.
279	 */
280	vmbus_initiate_unload(false);
281
282	if (vmbus_connection.handle_sub_chan_wq)
283		destroy_workqueue(vmbus_connection.handle_sub_chan_wq);
284
285	if (vmbus_connection.handle_primary_chan_wq)
286		destroy_workqueue(vmbus_connection.handle_primary_chan_wq);
287
288	if (vmbus_connection.work_queue)
289		destroy_workqueue(vmbus_connection.work_queue);
290
291	if (vmbus_connection.int_page) {
292		hv_free_hyperv_page((unsigned long)vmbus_connection.int_page);
293		vmbus_connection.int_page = NULL;
294	}
295
296	hv_free_hyperv_page((unsigned long)vmbus_connection.monitor_pages[0]);
297	hv_free_hyperv_page((unsigned long)vmbus_connection.monitor_pages[1]);
298	vmbus_connection.monitor_pages[0] = NULL;
299	vmbus_connection.monitor_pages[1] = NULL;
300}
301
302/*
303 * relid2channel - Get the channel object given its
304 * child relative id (ie channel id)
305 */
306struct vmbus_channel *relid2channel(u32 relid)
307{
308	if (vmbus_connection.channels == NULL) {
309		pr_warn_once("relid2channel: relid=%d: No channels mapped!\n", relid);
310		return NULL;
311	}
312	if (WARN_ON(relid >= MAX_CHANNEL_RELIDS))
313		return NULL;
314	return READ_ONCE(vmbus_connection.channels[relid]);
315}
316
317/*
318 * vmbus_on_event - Process a channel event notification
319 *
320 * For batched channels (default) optimize host to guest signaling
321 * by ensuring:
322 * 1. While reading the channel, we disable interrupts from host.
323 * 2. Ensure that we process all posted messages from the host
324 *    before returning from this callback.
325 * 3. Once we return, enable signaling from the host. Once this
326 *    state is set we check to see if additional packets are
327 *    available to read. In this case we repeat the process.
328 *    If this tasklet has been running for a long time
329 *    then reschedule ourselves.
330 */
331void vmbus_on_event(unsigned long data)
332{
333	struct vmbus_channel *channel = (void *) data;
334	unsigned long time_limit = jiffies + 2;
335
336	trace_vmbus_on_event(channel);
337
338	hv_debug_delay_test(channel, INTERRUPT_DELAY);
339	do {
340		void (*callback_fn)(void *);
341
342		/* A channel once created is persistent even when
343		 * there is no driver handling the device. An
344		 * unloading driver sets the onchannel_callback to NULL.
345		 */
346		callback_fn = READ_ONCE(channel->onchannel_callback);
347		if (unlikely(callback_fn == NULL))
348			return;
349
350		(*callback_fn)(channel->channel_callback_context);
351
352		if (channel->callback_mode != HV_CALL_BATCHED)
353			return;
354
355		if (likely(hv_end_read(&channel->inbound) == 0))
356			return;
357
358		hv_begin_read(&channel->inbound);
359	} while (likely(time_before(jiffies, time_limit)));
360
361	/* The time limit (2 jiffies) has been reached */
362	tasklet_schedule(&channel->callback_event);
363}
364
365/*
366 * vmbus_post_msg - Send a msg on the vmbus's message connection
367 */
368int vmbus_post_msg(void *buffer, size_t buflen, bool can_sleep)
369{
370	struct vmbus_channel_message_header *hdr;
371	union hv_connection_id conn_id;
372	int ret = 0;
373	int retries = 0;
374	u32 usec = 1;
375
376	conn_id.asu32 = 0;
377	conn_id.u.id = vmbus_connection.msg_conn_id;
378
379	/*
380	 * hv_post_message() can have transient failures because of
381	 * insufficient resources. Retry the operation a couple of
382	 * times before giving up.
383	 */
384	while (retries < 100) {
385		ret = hv_post_message(conn_id, 1, buffer, buflen);
386
387		switch (ret) {
388		case HV_STATUS_INVALID_CONNECTION_ID:
389			/*
390			 * See vmbus_negotiate_version(): VMBus protocol 5.0
391			 * and higher require that we must use
392			 * VMBUS_MESSAGE_CONNECTION_ID_4 for the Initiate
393			 * Contact message, but on old hosts that only
394			 * support VMBus protocol 4.0 or lower, here we get
395			 * HV_STATUS_INVALID_CONNECTION_ID and we should
396			 * return an error immediately without retrying.
397			 */
398			hdr = buffer;
399			if (hdr->msgtype == CHANNELMSG_INITIATE_CONTACT)
400				return -EINVAL;
401			/*
402			 * We could get this if we send messages too
403			 * frequently.
404			 */
405			ret = -EAGAIN;
406			break;
407		case HV_STATUS_INSUFFICIENT_MEMORY:
408		case HV_STATUS_INSUFFICIENT_BUFFERS:
409			ret = -ENOBUFS;
410			break;
411		case HV_STATUS_SUCCESS:
412			return ret;
413		default:
414			pr_err("hv_post_msg() failed; error code:%d\n", ret);
415			return -EINVAL;
416		}
417
418		retries++;
419		if (can_sleep && usec > 1000)
420			msleep(usec / 1000);
421		else if (usec < MAX_UDELAY_MS * 1000)
422			udelay(usec);
423		else
424			mdelay(usec / 1000);
425
426		if (retries < 22)
427			usec *= 2;
428	}
429	return ret;
430}
431
432/*
433 * vmbus_set_event - Send an event notification to the parent
434 */
435void vmbus_set_event(struct vmbus_channel *channel)
436{
437	u32 child_relid = channel->offermsg.child_relid;
438
439	if (!channel->is_dedicated_interrupt)
440		vmbus_send_interrupt(child_relid);
441
442	++channel->sig_events;
443
444	hv_do_fast_hypercall8(HVCALL_SIGNAL_EVENT, channel->sig_event);
445}
446EXPORT_SYMBOL_GPL(vmbus_set_event);
447