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