1 /*
2  *
3  * Copyright (c) 2011, Microsoft Corporation.
4  *
5  * This program is free software; you can redistribute it and/or modify it
6  * under the terms and conditions of the GNU General Public License,
7  * version 2, as published by the Free Software Foundation.
8  *
9  * This program is distributed in the hope it will be useful, but WITHOUT
10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
12  * more details.
13  *
14  * You should have received a copy of the GNU General Public License along with
15  * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
16  * Place - Suite 330, Boston, MA 02111-1307 USA.
17  *
18  * Authors:
19  *   Haiyang Zhang <haiyangz@microsoft.com>
20  *   Hank Janssen  <hjanssen@microsoft.com>
21  *   K. Y. Srinivasan <kys@microsoft.com>
22  *
23  */
24 
25 #ifndef _HYPERV_VMBUS_H
26 #define _HYPERV_VMBUS_H
27 
28 #include <linux/list.h>
29 #include <asm/sync_bitops.h>
30 #include <asm/hyperv-tlfs.h>
31 #include <linux/atomic.h>
32 #include <linux/hyperv.h>
33 #include <linux/interrupt.h>
34 
35 #include "hv_trace.h"
36 
37 /*
38  * Timeout for services such as KVP and fcopy.
39  */
40 #define HV_UTIL_TIMEOUT 30
41 
42 /*
43  * Timeout for guest-host handshake for services.
44  */
45 #define HV_UTIL_NEGO_TIMEOUT 55
46 
47 /* Define synthetic interrupt controller flag constants. */
48 #define HV_EVENT_FLAGS_COUNT		(256 * 8)
49 #define HV_EVENT_FLAGS_LONG_COUNT	(256 / sizeof(unsigned long))
50 
51 /*
52  * Timer configuration register.
53  */
54 union hv_timer_config {
55 	u64 as_uint64;
56 	struct {
57 		u64 enable:1;
58 		u64 periodic:1;
59 		u64 lazy:1;
60 		u64 auto_enable:1;
61 		u64 apic_vector:8;
62 		u64 direct_mode:1;
63 		u64 reserved_z0:3;
64 		u64 sintx:4;
65 		u64 reserved_z1:44;
66 	};
67 };
68 
69 
70 /* Define the synthetic interrupt controller event flags format. */
71 union hv_synic_event_flags {
72 	unsigned long flags[HV_EVENT_FLAGS_LONG_COUNT];
73 };
74 
75 /* Define SynIC control register. */
76 union hv_synic_scontrol {
77 	u64 as_uint64;
78 	struct {
79 		u64 enable:1;
80 		u64 reserved:63;
81 	};
82 };
83 
84 /* Define synthetic interrupt source. */
85 union hv_synic_sint {
86 	u64 as_uint64;
87 	struct {
88 		u64 vector:8;
89 		u64 reserved1:8;
90 		u64 masked:1;
91 		u64 auto_eoi:1;
92 		u64 reserved2:46;
93 	};
94 };
95 
96 /* Define the format of the SIMP register */
97 union hv_synic_simp {
98 	u64 as_uint64;
99 	struct {
100 		u64 simp_enabled:1;
101 		u64 preserved:11;
102 		u64 base_simp_gpa:52;
103 	};
104 };
105 
106 /* Define the format of the SIEFP register */
107 union hv_synic_siefp {
108 	u64 as_uint64;
109 	struct {
110 		u64 siefp_enabled:1;
111 		u64 preserved:11;
112 		u64 base_siefp_gpa:52;
113 	};
114 };
115 
116 /* Definitions for the monitored notification facility */
117 union hv_monitor_trigger_group {
118 	u64 as_uint64;
119 	struct {
120 		u32 pending;
121 		u32 armed;
122 	};
123 };
124 
125 struct hv_monitor_parameter {
126 	union hv_connection_id connectionid;
127 	u16 flagnumber;
128 	u16 rsvdz;
129 };
130 
131 union hv_monitor_trigger_state {
132 	u32 asu32;
133 
134 	struct {
135 		u32 group_enable:4;
136 		u32 rsvdz:28;
137 	};
138 };
139 
140 /* struct hv_monitor_page Layout */
141 /* ------------------------------------------------------ */
142 /* | 0   | TriggerState (4 bytes) | Rsvd1 (4 bytes)     | */
143 /* | 8   | TriggerGroup[0]                              | */
144 /* | 10  | TriggerGroup[1]                              | */
145 /* | 18  | TriggerGroup[2]                              | */
146 /* | 20  | TriggerGroup[3]                              | */
147 /* | 28  | Rsvd2[0]                                     | */
148 /* | 30  | Rsvd2[1]                                     | */
149 /* | 38  | Rsvd2[2]                                     | */
150 /* | 40  | NextCheckTime[0][0]    | NextCheckTime[0][1] | */
151 /* | ...                                                | */
152 /* | 240 | Latency[0][0..3]                             | */
153 /* | 340 | Rsvz3[0]                                     | */
154 /* | 440 | Parameter[0][0]                              | */
155 /* | 448 | Parameter[0][1]                              | */
156 /* | ...                                                | */
157 /* | 840 | Rsvd4[0]                                     | */
158 /* ------------------------------------------------------ */
159 struct hv_monitor_page {
160 	union hv_monitor_trigger_state trigger_state;
161 	u32 rsvdz1;
162 
163 	union hv_monitor_trigger_group trigger_group[4];
164 	u64 rsvdz2[3];
165 
166 	s32 next_checktime[4][32];
167 
168 	u16 latency[4][32];
169 	u64 rsvdz3[32];
170 
171 	struct hv_monitor_parameter parameter[4][32];
172 
173 	u8 rsvdz4[1984];
174 };
175 
176 #define HV_HYPERCALL_PARAM_ALIGN	sizeof(u64)
177 
178 /* Definition of the hv_post_message hypercall input structure. */
179 struct hv_input_post_message {
180 	union hv_connection_id connectionid;
181 	u32 reserved;
182 	u32 message_type;
183 	u32 payload_size;
184 	u64 payload[HV_MESSAGE_PAYLOAD_QWORD_COUNT];
185 };
186 
187 
188 enum {
189 	VMBUS_MESSAGE_CONNECTION_ID	= 1,
190 	VMBUS_MESSAGE_CONNECTION_ID_4	= 4,
191 	VMBUS_MESSAGE_PORT_ID		= 1,
192 	VMBUS_EVENT_CONNECTION_ID	= 2,
193 	VMBUS_EVENT_PORT_ID		= 2,
194 	VMBUS_MONITOR_CONNECTION_ID	= 3,
195 	VMBUS_MONITOR_PORT_ID		= 3,
196 	VMBUS_MESSAGE_SINT		= 2,
197 };
198 
199 /*
200  * Per cpu state for channel handling
201  */
202 struct hv_per_cpu_context {
203 	void *synic_message_page;
204 	void *synic_event_page;
205 	/*
206 	 * buffer to post messages to the host.
207 	 */
208 	void *post_msg_page;
209 
210 	/*
211 	 * Starting with win8, we can take channel interrupts on any CPU;
212 	 * we will manage the tasklet that handles events messages on a per CPU
213 	 * basis.
214 	 */
215 	struct tasklet_struct msg_dpc;
216 
217 	/*
218 	 * To optimize the mapping of relid to channel, maintain
219 	 * per-cpu list of the channels based on their CPU affinity.
220 	 */
221 	struct list_head chan_list;
222 	struct clock_event_device *clk_evt;
223 };
224 
225 struct hv_context {
226 	/* We only support running on top of Hyper-V
227 	 * So at this point this really can only contain the Hyper-V ID
228 	 */
229 	u64 guestid;
230 
231 	void *tsc_page;
232 
233 	bool synic_initialized;
234 
235 	struct hv_per_cpu_context __percpu *cpu_context;
236 
237 	/*
238 	 * To manage allocations in a NUMA node.
239 	 * Array indexed by numa node ID.
240 	 */
241 	struct cpumask *hv_numa_map;
242 };
243 
244 extern struct hv_context hv_context;
245 
246 /* Hv Interface */
247 
248 extern int hv_init(void);
249 
250 extern int hv_post_message(union hv_connection_id connection_id,
251 			 enum hv_message_type message_type,
252 			 void *payload, size_t payload_size);
253 
254 extern int hv_synic_alloc(void);
255 
256 extern void hv_synic_free(void);
257 
258 extern int hv_synic_init(unsigned int cpu);
259 
260 extern int hv_synic_cleanup(unsigned int cpu);
261 
262 extern void hv_synic_clockevents_cleanup(void);
263 
264 /* Interface */
265 
266 
267 int hv_ringbuffer_init(struct hv_ring_buffer_info *ring_info,
268 		       struct page *pages, u32 pagecnt);
269 
270 void hv_ringbuffer_cleanup(struct hv_ring_buffer_info *ring_info);
271 
272 int hv_ringbuffer_write(struct vmbus_channel *channel,
273 			const struct kvec *kv_list, u32 kv_count);
274 
275 int hv_ringbuffer_read(struct vmbus_channel *channel,
276 		       void *buffer, u32 buflen, u32 *buffer_actual_len,
277 		       u64 *requestid, bool raw);
278 
279 /*
280  * Maximum channels is determined by the size of the interrupt page
281  * which is PAGE_SIZE. 1/2 of PAGE_SIZE is for send endpoint interrupt
282  * and the other is receive endpoint interrupt
283  */
284 #define MAX_NUM_CHANNELS	((PAGE_SIZE >> 1) << 3)	/* 16348 channels */
285 
286 /* The value here must be in multiple of 32 */
287 /* TODO: Need to make this configurable */
288 #define MAX_NUM_CHANNELS_SUPPORTED	256
289 
290 
291 enum vmbus_connect_state {
292 	DISCONNECTED,
293 	CONNECTING,
294 	CONNECTED,
295 	DISCONNECTING
296 };
297 
298 #define MAX_SIZE_CHANNEL_MESSAGE	HV_MESSAGE_PAYLOAD_BYTE_COUNT
299 
300 struct vmbus_connection {
301 	/*
302 	 * CPU on which the initial host contact was made.
303 	 */
304 	int connect_cpu;
305 
306 	u32 msg_conn_id;
307 
308 	atomic_t offer_in_progress;
309 
310 	enum vmbus_connect_state conn_state;
311 
312 	atomic_t next_gpadl_handle;
313 
314 	struct completion  unload_event;
315 	/*
316 	 * Represents channel interrupts. Each bit position represents a
317 	 * channel.  When a channel sends an interrupt via VMBUS, it finds its
318 	 * bit in the sendInterruptPage, set it and calls Hv to generate a port
319 	 * event. The other end receives the port event and parse the
320 	 * recvInterruptPage to see which bit is set
321 	 */
322 	void *int_page;
323 	void *send_int_page;
324 	void *recv_int_page;
325 
326 	/*
327 	 * 2 pages - 1st page for parent->child notification and 2nd
328 	 * is child->parent notification
329 	 */
330 	struct hv_monitor_page *monitor_pages[2];
331 	struct list_head chn_msg_list;
332 	spinlock_t channelmsg_lock;
333 
334 	/* List of channels */
335 	struct list_head chn_list;
336 	struct mutex channel_mutex;
337 
338 	struct workqueue_struct *work_queue;
339 };
340 
341 
342 struct vmbus_msginfo {
343 	/* Bookkeeping stuff */
344 	struct list_head msglist_entry;
345 
346 	/* The message itself */
347 	unsigned char msg[0];
348 };
349 
350 
351 extern struct vmbus_connection vmbus_connection;
352 
vmbus_send_interrupt(u32 relid)353 static inline void vmbus_send_interrupt(u32 relid)
354 {
355 	sync_set_bit(relid, vmbus_connection.send_int_page);
356 }
357 
358 enum vmbus_message_handler_type {
359 	/* The related handler can sleep. */
360 	VMHT_BLOCKING = 0,
361 
362 	/* The related handler must NOT sleep. */
363 	VMHT_NON_BLOCKING = 1,
364 };
365 
366 struct vmbus_channel_message_table_entry {
367 	enum vmbus_channel_message_type message_type;
368 	enum vmbus_message_handler_type handler_type;
369 	void (*message_handler)(struct vmbus_channel_message_header *msg);
370 };
371 
372 extern const struct vmbus_channel_message_table_entry
373 	channel_message_table[CHANNELMSG_COUNT];
374 
375 
376 /* General vmbus interface */
377 
378 struct hv_device *vmbus_device_create(const uuid_le *type,
379 				      const uuid_le *instance,
380 				      struct vmbus_channel *channel);
381 
382 int vmbus_device_register(struct hv_device *child_device_obj);
383 void vmbus_device_unregister(struct hv_device *device_obj);
384 int vmbus_add_channel_kobj(struct hv_device *device_obj,
385 			   struct vmbus_channel *channel);
386 
387 struct vmbus_channel *relid2channel(u32 relid);
388 
389 void vmbus_free_channels(void);
390 
391 /* Connection interface */
392 
393 int vmbus_connect(void);
394 void vmbus_disconnect(void);
395 
396 int vmbus_post_msg(void *buffer, size_t buflen, bool can_sleep);
397 
398 void vmbus_on_event(unsigned long data);
399 void vmbus_on_msg_dpc(unsigned long data);
400 
401 int hv_kvp_init(struct hv_util_service *srv);
402 void hv_kvp_deinit(void);
403 void hv_kvp_onchannelcallback(void *context);
404 
405 int hv_vss_init(struct hv_util_service *srv);
406 void hv_vss_deinit(void);
407 void hv_vss_onchannelcallback(void *context);
408 
409 int hv_fcopy_init(struct hv_util_service *srv);
410 void hv_fcopy_deinit(void);
411 void hv_fcopy_onchannelcallback(void *context);
412 void vmbus_initiate_unload(bool crash);
413 
hv_poll_channel(struct vmbus_channel * channel,void (* cb)(void *))414 static inline void hv_poll_channel(struct vmbus_channel *channel,
415 				   void (*cb)(void *))
416 {
417 	if (!channel)
418 		return;
419 
420 	if (in_interrupt() && (channel->target_cpu == smp_processor_id())) {
421 		cb(channel);
422 		return;
423 	}
424 	smp_call_function_single(channel->target_cpu, cb, channel, true);
425 }
426 
427 enum hvutil_device_state {
428 	HVUTIL_DEVICE_INIT = 0,  /* driver is loaded, waiting for userspace */
429 	HVUTIL_READY,            /* userspace is registered */
430 	HVUTIL_HOSTMSG_RECEIVED, /* message from the host was received */
431 	HVUTIL_USERSPACE_REQ,    /* request to userspace was sent */
432 	HVUTIL_USERSPACE_RECV,   /* reply from userspace was received */
433 	HVUTIL_DEVICE_DYING,     /* driver unload is in progress */
434 };
435 
436 #endif /* _HYPERV_VMBUS_H */
437