Commit | Line | Data |
---|---|---|
e2be04c7 | 1 | /* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */ |
5267cf02 BIP |
2 | /* |
3 | * | |
4 | * Copyright (c) 2011, Microsoft Corporation. | |
5 | * | |
6 | * This program is free software; you can redistribute it and/or modify it | |
7 | * under the terms and conditions of the GNU General Public License, | |
8 | * version 2, as published by the Free Software Foundation. | |
9 | * | |
10 | * This program is distributed in the hope it will be useful, but WITHOUT | |
11 | * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
12 | * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for | |
13 | * more details. | |
14 | * | |
15 | * You should have received a copy of the GNU General Public License along with | |
16 | * this program; if not, write to the Free Software Foundation, Inc., 59 Temple | |
17 | * Place - Suite 330, Boston, MA 02111-1307 USA. | |
18 | * | |
19 | * Authors: | |
20 | * Haiyang Zhang <haiyangz@microsoft.com> | |
21 | * Hank Janssen <hjanssen@microsoft.com> | |
22 | * K. Y. Srinivasan <kys@microsoft.com> | |
23 | * | |
24 | */ | |
25 | ||
26 | #ifndef _UAPI_HYPERV_H | |
27 | #define _UAPI_HYPERV_H | |
28 | ||
95a13ee8 | 29 | #include <linux/types.h> |
01325476 | 30 | |
5267cf02 BIP |
31 | /* |
32 | * Framework version for util services. | |
33 | */ | |
34 | #define UTIL_FW_MINOR 0 | |
35 | ||
36 | #define UTIL_WS2K8_FW_MAJOR 1 | |
37 | #define UTIL_WS2K8_FW_VERSION (UTIL_WS2K8_FW_MAJOR << 16 | UTIL_FW_MINOR) | |
38 | ||
39 | #define UTIL_FW_MAJOR 3 | |
40 | #define UTIL_FW_VERSION (UTIL_FW_MAJOR << 16 | UTIL_FW_MINOR) | |
41 | ||
42 | ||
43 | /* | |
44 | * Implementation of host controlled snapshot of the guest. | |
45 | */ | |
46 | ||
47 | #define VSS_OP_REGISTER 128 | |
48 | ||
cd8dc054 VK |
49 | /* |
50 | Daemon code with full handshake support. | |
51 | */ | |
52 | #define VSS_OP_REGISTER1 129 | |
53 | ||
5267cf02 BIP |
54 | enum hv_vss_op { |
55 | VSS_OP_CREATE = 0, | |
56 | VSS_OP_DELETE, | |
57 | VSS_OP_HOT_BACKUP, | |
58 | VSS_OP_GET_DM_INFO, | |
59 | VSS_OP_BU_COMPLETE, | |
60 | /* | |
61 | * Following operations are only supported with IC version >= 5.0 | |
62 | */ | |
63 | VSS_OP_FREEZE, /* Freeze the file systems in the VM */ | |
64 | VSS_OP_THAW, /* Unfreeze the file systems */ | |
65 | VSS_OP_AUTO_RECOVER, | |
66 | VSS_OP_COUNT /* Number of operations, must be last */ | |
67 | }; | |
68 | ||
69 | ||
70 | /* | |
71 | * Header for all VSS messages. | |
72 | */ | |
73 | struct hv_vss_hdr { | |
74 | __u8 operation; | |
75 | __u8 reserved[7]; | |
76 | } __attribute__((packed)); | |
77 | ||
78 | ||
79 | /* | |
80 | * Flag values for the hv_vss_check_feature. Linux supports only | |
81 | * one value. | |
82 | */ | |
83 | #define VSS_HBU_NO_AUTO_RECOVERY 0x00000005 | |
84 | ||
85 | struct hv_vss_check_feature { | |
86 | __u32 flags; | |
87 | } __attribute__((packed)); | |
88 | ||
89 | struct hv_vss_check_dm_info { | |
90 | __u32 flags; | |
91 | } __attribute__((packed)); | |
92 | ||
6de74d10 MK |
93 | /* |
94 | * struct hv_vss_msg encodes the fields that the Linux VSS | |
95 | * driver accesses. However, FREEZE messages from Hyper-V contain | |
96 | * additional LUN information that Linux doesn't use and are not | |
97 | * represented in struct hv_vss_msg. A received FREEZE message may | |
98 | * be as large as 6,260 bytes, so the driver must allocate at least | |
99 | * that much space, not sizeof(struct hv_vss_msg). Other messages | |
100 | * such as AUTO_RECOVER may be as large as 12,500 bytes. However, | |
101 | * because the Linux VSS driver responds that it doesn't support | |
102 | * auto-recovery, it should not receive such messages. | |
103 | */ | |
5267cf02 BIP |
104 | struct hv_vss_msg { |
105 | union { | |
106 | struct hv_vss_hdr vss_hdr; | |
107 | int error; | |
108 | }; | |
109 | union { | |
110 | struct hv_vss_check_feature vss_cf; | |
111 | struct hv_vss_check_dm_info dm_info; | |
112 | }; | |
113 | } __attribute__((packed)); | |
114 | ||
01325476 S |
115 | /* |
116 | * Implementation of a host to guest copy facility. | |
117 | */ | |
118 | ||
119 | #define FCOPY_VERSION_0 0 | |
a4d1ee5b VK |
120 | #define FCOPY_VERSION_1 1 |
121 | #define FCOPY_CURRENT_VERSION FCOPY_VERSION_1 | |
01325476 S |
122 | #define W_MAX_PATH 260 |
123 | ||
124 | enum hv_fcopy_op { | |
125 | START_FILE_COPY = 0, | |
126 | WRITE_TO_FILE, | |
127 | COMPLETE_FCOPY, | |
128 | CANCEL_FCOPY, | |
129 | }; | |
130 | ||
131 | struct hv_fcopy_hdr { | |
132 | __u32 operation; | |
f081bbb3 AS |
133 | __u8 service_id0[16]; /* currently unused */ |
134 | __u8 service_id1[16]; /* currently unused */ | |
01325476 S |
135 | } __attribute__((packed)); |
136 | ||
137 | #define OVER_WRITE 0x1 | |
138 | #define CREATE_PATH 0x2 | |
139 | ||
140 | struct hv_start_fcopy { | |
141 | struct hv_fcopy_hdr hdr; | |
142 | __u16 file_name[W_MAX_PATH]; | |
143 | __u16 path_name[W_MAX_PATH]; | |
144 | __u32 copy_flags; | |
145 | __u64 file_size; | |
146 | } __attribute__((packed)); | |
147 | ||
148 | /* | |
149 | * The file is chunked into fragments. | |
150 | */ | |
151 | #define DATA_FRAGMENT (6 * 1024) | |
152 | ||
153 | struct hv_do_fcopy { | |
154 | struct hv_fcopy_hdr hdr; | |
31d4ea1a | 155 | __u32 pad; |
01325476 S |
156 | __u64 offset; |
157 | __u32 size; | |
158 | __u8 data[DATA_FRAGMENT]; | |
bc5a5b02 | 159 | } __attribute__((packed)); |
01325476 | 160 | |
5267cf02 BIP |
161 | /* |
162 | * An implementation of HyperV key value pair (KVP) functionality for Linux. | |
163 | * | |
164 | * | |
165 | * Copyright (C) 2010, Novell, Inc. | |
166 | * Author : K. Y. Srinivasan <ksrinivasan@novell.com> | |
167 | * | |
168 | */ | |
169 | ||
170 | /* | |
171 | * Maximum value size - used for both key names and value data, and includes | |
172 | * any applicable NULL terminators. | |
173 | * | |
174 | * Note: This limit is somewhat arbitrary, but falls easily within what is | |
175 | * supported for all native guests (back to Win 2000) and what is reasonable | |
176 | * for the IC KVP exchange functionality. Note that Windows Me/98/95 are | |
177 | * limited to 255 character key names. | |
178 | * | |
179 | * MSDN recommends not storing data values larger than 2048 bytes in the | |
180 | * registry. | |
181 | * | |
182 | * Note: This value is used in defining the KVP exchange message - this value | |
183 | * cannot be modified without affecting the message size and compatibility. | |
184 | */ | |
185 | ||
186 | /* | |
187 | * bytes, including any null terminators | |
188 | */ | |
189 | #define HV_KVP_EXCHANGE_MAX_VALUE_SIZE (2048) | |
190 | ||
191 | ||
192 | /* | |
193 | * Maximum key size - the registry limit for the length of an entry name | |
194 | * is 256 characters, including the null terminator | |
195 | */ | |
196 | ||
197 | #define HV_KVP_EXCHANGE_MAX_KEY_SIZE (512) | |
198 | ||
199 | /* | |
200 | * In Linux, we implement the KVP functionality in two components: | |
201 | * 1) The kernel component which is packaged as part of the hv_utils driver | |
202 | * is responsible for communicating with the host and responsible for | |
203 | * implementing the host/guest protocol. 2) A user level daemon that is | |
204 | * responsible for data gathering. | |
205 | * | |
206 | * Host/Guest Protocol: The host iterates over an index and expects the guest | |
207 | * to assign a key name to the index and also return the value corresponding to | |
208 | * the key. The host will have atmost one KVP transaction outstanding at any | |
209 | * given point in time. The host side iteration stops when the guest returns | |
210 | * an error. Microsoft has specified the following mapping of key names to | |
211 | * host specified index: | |
212 | * | |
213 | * Index Key Name | |
214 | * 0 FullyQualifiedDomainName | |
215 | * 1 IntegrationServicesVersion | |
216 | * 2 NetworkAddressIPv4 | |
217 | * 3 NetworkAddressIPv6 | |
218 | * 4 OSBuildNumber | |
219 | * 5 OSName | |
220 | * 6 OSMajorVersion | |
221 | * 7 OSMinorVersion | |
222 | * 8 OSVersion | |
223 | * 9 ProcessorArchitecture | |
224 | * | |
225 | * The Windows host expects the Key Name and Key Value to be encoded in utf16. | |
226 | * | |
227 | * Guest Kernel/KVP Daemon Protocol: As noted earlier, we implement all of the | |
228 | * data gathering functionality in a user mode daemon. The user level daemon | |
229 | * is also responsible for binding the key name to the index as well. The | |
230 | * kernel and user-level daemon communicate using a connector channel. | |
231 | * | |
232 | * The user mode component first registers with the | |
7deff7b5 | 233 | * kernel component. Subsequently, the kernel component requests, data |
5267cf02 BIP |
234 | * for the specified keys. In response to this message the user mode component |
235 | * fills in the value corresponding to the specified key. We overload the | |
236 | * sequence field in the cn_msg header to define our KVP message types. | |
237 | * | |
238 | * | |
239 | * The kernel component simply acts as a conduit for communication between the | |
240 | * Windows host and the user-level daemon. The kernel component passes up the | |
241 | * index received from the Host to the user-level daemon. If the index is | |
242 | * valid (supported), the corresponding key as well as its | |
243 | * value (both are strings) is returned. If the index is invalid | |
244 | * (not supported), a NULL key string is returned. | |
245 | */ | |
246 | ||
247 | ||
248 | /* | |
249 | * Registry value types. | |
250 | */ | |
251 | ||
252 | #define REG_SZ 1 | |
253 | #define REG_U32 4 | |
254 | #define REG_U64 8 | |
255 | ||
256 | /* | |
257 | * As we look at expanding the KVP functionality to include | |
258 | * IP injection functionality, we need to maintain binary | |
259 | * compatibility with older daemons. | |
260 | * | |
261 | * The KVP opcodes are defined by the host and it was unfortunate | |
262 | * that I chose to treat the registration operation as part of the | |
263 | * KVP operations defined by the host. | |
264 | * Here is the level of compatibility | |
265 | * (between the user level daemon and the kernel KVP driver) that we | |
266 | * will implement: | |
267 | * | |
268 | * An older daemon will always be supported on a newer driver. | |
269 | * A given user level daemon will require a minimal version of the | |
270 | * kernel driver. | |
271 | * If we cannot handle the version differences, we will fail gracefully | |
272 | * (this can happen when we have a user level daemon that is more | |
273 | * advanced than the KVP driver. | |
274 | * | |
275 | * We will use values used in this handshake for determining if we have | |
276 | * workable user level daemon and the kernel driver. We begin by taking the | |
277 | * registration opcode out of the KVP opcode namespace. We will however, | |
278 | * maintain compatibility with the existing user-level daemon code. | |
279 | */ | |
280 | ||
281 | /* | |
282 | * Daemon code not supporting IP injection (legacy daemon). | |
283 | */ | |
284 | ||
285 | #define KVP_OP_REGISTER 4 | |
286 | ||
287 | /* | |
288 | * Daemon code supporting IP injection. | |
289 | * The KVP opcode field is used to communicate the | |
290 | * registration information; so define a namespace that | |
291 | * will be distinct from the host defined KVP opcode. | |
292 | */ | |
293 | ||
294 | #define KVP_OP_REGISTER1 100 | |
295 | ||
296 | enum hv_kvp_exchg_op { | |
297 | KVP_OP_GET = 0, | |
298 | KVP_OP_SET, | |
299 | KVP_OP_DELETE, | |
300 | KVP_OP_ENUMERATE, | |
301 | KVP_OP_GET_IP_INFO, | |
302 | KVP_OP_SET_IP_INFO, | |
303 | KVP_OP_COUNT /* Number of operations, must be last. */ | |
304 | }; | |
305 | ||
306 | enum hv_kvp_exchg_pool { | |
307 | KVP_POOL_EXTERNAL = 0, | |
308 | KVP_POOL_GUEST, | |
309 | KVP_POOL_AUTO, | |
310 | KVP_POOL_AUTO_EXTERNAL, | |
311 | KVP_POOL_AUTO_INTERNAL, | |
312 | KVP_POOL_COUNT /* Number of pools, must be last. */ | |
313 | }; | |
314 | ||
315 | /* | |
316 | * Some Hyper-V status codes. | |
317 | */ | |
318 | ||
319 | #define HV_S_OK 0x00000000 | |
320 | #define HV_E_FAIL 0x80004005 | |
321 | #define HV_S_CONT 0x80070103 | |
322 | #define HV_ERROR_NOT_SUPPORTED 0x80070032 | |
323 | #define HV_ERROR_MACHINE_LOCKED 0x800704F7 | |
324 | #define HV_ERROR_DEVICE_NOT_CONNECTED 0x8007048F | |
325 | #define HV_INVALIDARG 0x80070057 | |
326 | #define HV_GUID_NOTFOUND 0x80041002 | |
314672a2 | 327 | #define HV_ERROR_ALREADY_EXISTS 0x80070050 |
b4ed5d16 | 328 | #define HV_ERROR_DISK_FULL 0x80070070 |
5267cf02 BIP |
329 | |
330 | #define ADDR_FAMILY_NONE 0x00 | |
331 | #define ADDR_FAMILY_IPV4 0x01 | |
332 | #define ADDR_FAMILY_IPV6 0x02 | |
333 | ||
334 | #define MAX_ADAPTER_ID_SIZE 128 | |
335 | #define MAX_IP_ADDR_SIZE 1024 | |
336 | #define MAX_GATEWAY_SIZE 512 | |
337 | ||
338 | ||
339 | struct hv_kvp_ipaddr_value { | |
340 | __u16 adapter_id[MAX_ADAPTER_ID_SIZE]; | |
341 | __u8 addr_family; | |
342 | __u8 dhcp_enabled; | |
343 | __u16 ip_addr[MAX_IP_ADDR_SIZE]; | |
344 | __u16 sub_net[MAX_IP_ADDR_SIZE]; | |
345 | __u16 gate_way[MAX_GATEWAY_SIZE]; | |
346 | __u16 dns_addr[MAX_IP_ADDR_SIZE]; | |
347 | } __attribute__((packed)); | |
348 | ||
349 | ||
350 | struct hv_kvp_hdr { | |
351 | __u8 operation; | |
352 | __u8 pool; | |
353 | __u16 pad; | |
354 | } __attribute__((packed)); | |
355 | ||
356 | struct hv_kvp_exchg_msg_value { | |
357 | __u32 value_type; | |
358 | __u32 key_size; | |
359 | __u32 value_size; | |
360 | __u8 key[HV_KVP_EXCHANGE_MAX_KEY_SIZE]; | |
361 | union { | |
362 | __u8 value[HV_KVP_EXCHANGE_MAX_VALUE_SIZE]; | |
363 | __u32 value_u32; | |
364 | __u64 value_u64; | |
365 | }; | |
366 | } __attribute__((packed)); | |
367 | ||
368 | struct hv_kvp_msg_enumerate { | |
369 | __u32 index; | |
370 | struct hv_kvp_exchg_msg_value data; | |
371 | } __attribute__((packed)); | |
372 | ||
373 | struct hv_kvp_msg_get { | |
374 | struct hv_kvp_exchg_msg_value data; | |
375 | }; | |
376 | ||
377 | struct hv_kvp_msg_set { | |
378 | struct hv_kvp_exchg_msg_value data; | |
379 | }; | |
380 | ||
381 | struct hv_kvp_msg_delete { | |
382 | __u32 key_size; | |
383 | __u8 key[HV_KVP_EXCHANGE_MAX_KEY_SIZE]; | |
384 | }; | |
385 | ||
386 | struct hv_kvp_register { | |
387 | __u8 version[HV_KVP_EXCHANGE_MAX_KEY_SIZE]; | |
388 | }; | |
389 | ||
390 | struct hv_kvp_msg { | |
391 | union { | |
392 | struct hv_kvp_hdr kvp_hdr; | |
393 | int error; | |
394 | }; | |
395 | union { | |
396 | struct hv_kvp_msg_get kvp_get; | |
397 | struct hv_kvp_msg_set kvp_set; | |
398 | struct hv_kvp_msg_delete kvp_delete; | |
399 | struct hv_kvp_msg_enumerate kvp_enum_data; | |
400 | struct hv_kvp_ipaddr_value kvp_ip_val; | |
401 | struct hv_kvp_register kvp_register; | |
402 | } body; | |
403 | } __attribute__((packed)); | |
404 | ||
405 | struct hv_kvp_ip_msg { | |
406 | __u8 operation; | |
407 | __u8 pool; | |
408 | struct hv_kvp_ipaddr_value kvp_ip_val; | |
409 | } __attribute__((packed)); | |
410 | ||
411 | #endif /* _UAPI_HYPERV_H */ |