vboxguest.h (9367B) - Raw
1 /* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR CDDL-1.0) */ 2 /* 3 * VBoxGuest - VirtualBox Guest Additions Driver Interface. 4 * 5 * Copyright (C) 2006-2016 Oracle Corporation 6 */ 7 8 #ifndef __UAPI_VBOXGUEST_H__ 9 #define __UAPI_VBOXGUEST_H__ 10 11 #include <asm/bitsperlong.h> 12 #include <linux/ioctl.h> 13 #include <linux/vbox_err.h> 14 #include <linux/vbox_vmmdev_types.h> 15 16 /* Version of vbg_ioctl_hdr structure. */ 17 #define VBG_IOCTL_HDR_VERSION 0x10001 18 /* Default request type. Use this for non-VMMDev requests. */ 19 #define VBG_IOCTL_HDR_TYPE_DEFAULT 0 20 21 /** 22 * Common ioctl header. 23 * 24 * This is a mirror of vmmdev_request_header to prevent duplicating data and 25 * needing to verify things multiple times. 26 */ 27 struct vbg_ioctl_hdr { 28 /** IN: The request input size, and output size if size_out is zero. */ 29 __u32 size_in; 30 /** IN: Structure version (VBG_IOCTL_HDR_VERSION) */ 31 __u32 version; 32 /** IN: The VMMDev request type or VBG_IOCTL_HDR_TYPE_DEFAULT. */ 33 __u32 type; 34 /** 35 * OUT: The VBox status code of the operation, out direction only. 36 * This is a VINF_ or VERR_ value as defined in vbox_err.h. 37 */ 38 __s32 rc; 39 /** IN: Output size. Set to zero to use size_in as output size. */ 40 __u32 size_out; 41 /** Reserved, MBZ. */ 42 __u32 reserved; 43 }; 44 VMMDEV_ASSERT_SIZE(vbg_ioctl_hdr, 24); 45 46 47 /* 48 * The VBoxGuest I/O control version. 49 * 50 * As usual, the high word contains the major version and changes to it 51 * signifies incompatible changes. 52 * 53 * The lower word is the minor version number, it is increased when new 54 * functions are added or existing changed in a backwards compatible manner. 55 */ 56 #define VBG_IOC_VERSION 0x00010000u 57 58 /** 59 * VBG_IOCTL_DRIVER_VERSION_INFO data structure 60 * 61 * Note VBG_IOCTL_DRIVER_VERSION_INFO may switch the session to a backwards 62 * compatible interface version if uClientVersion indicates older client code. 63 */ 64 struct vbg_ioctl_driver_version_info { 65 /** The header. */ 66 struct vbg_ioctl_hdr hdr; 67 union { 68 struct { 69 /** Requested interface version (VBG_IOC_VERSION). */ 70 __u32 req_version; 71 /** 72 * Minimum interface version number (typically the 73 * major version part of VBG_IOC_VERSION). 74 */ 75 __u32 min_version; 76 /** Reserved, MBZ. */ 77 __u32 reserved1; 78 /** Reserved, MBZ. */ 79 __u32 reserved2; 80 } in; 81 struct { 82 /** Version for this session (typ. VBG_IOC_VERSION). */ 83 __u32 session_version; 84 /** Version of the IDC interface (VBG_IOC_VERSION). */ 85 __u32 driver_version; 86 /** The SVN revision of the driver, or 0. */ 87 __u32 driver_revision; 88 /** Reserved \#1 (zero until defined). */ 89 __u32 reserved1; 90 /** Reserved \#2 (zero until defined). */ 91 __u32 reserved2; 92 } out; 93 } u; 94 }; 95 VMMDEV_ASSERT_SIZE(vbg_ioctl_driver_version_info, 24 + 20); 96 97 #define VBG_IOCTL_DRIVER_VERSION_INFO \ 98 _IOWR('V', 0, struct vbg_ioctl_driver_version_info) 99 100 101 /* IOCTL to perform a VMM Device request less than 1KB in size. */ 102 #define VBG_IOCTL_VMMDEV_REQUEST(s) _IOC(_IOC_READ | _IOC_WRITE, 'V', 2, s) 103 104 105 /* IOCTL to perform a VMM Device request larger then 1KB. */ 106 #define VBG_IOCTL_VMMDEV_REQUEST_BIG _IO('V', 3) 107 108 109 /** VBG_IOCTL_HGCM_CONNECT data structure. */ 110 struct vbg_ioctl_hgcm_connect { 111 struct vbg_ioctl_hdr hdr; 112 union { 113 struct { 114 struct vmmdev_hgcm_service_location loc; 115 } in; 116 struct { 117 __u32 client_id; 118 } out; 119 } u; 120 }; 121 VMMDEV_ASSERT_SIZE(vbg_ioctl_hgcm_connect, 24 + 132); 122 123 #define VBG_IOCTL_HGCM_CONNECT \ 124 _IOWR('V', 4, struct vbg_ioctl_hgcm_connect) 125 126 127 /** VBG_IOCTL_HGCM_DISCONNECT data structure. */ 128 struct vbg_ioctl_hgcm_disconnect { 129 struct vbg_ioctl_hdr hdr; 130 union { 131 struct { 132 __u32 client_id; 133 } in; 134 } u; 135 }; 136 VMMDEV_ASSERT_SIZE(vbg_ioctl_hgcm_disconnect, 24 + 4); 137 138 #define VBG_IOCTL_HGCM_DISCONNECT \ 139 _IOWR('V', 5, struct vbg_ioctl_hgcm_disconnect) 140 141 142 /** VBG_IOCTL_HGCM_CALL data structure. */ 143 struct vbg_ioctl_hgcm_call { 144 /** The header. */ 145 struct vbg_ioctl_hdr hdr; 146 /** Input: The id of the caller. */ 147 __u32 client_id; 148 /** Input: Function number. */ 149 __u32 function; 150 /** 151 * Input: How long to wait (milliseconds) for completion before 152 * cancelling the call. Set to -1 to wait indefinitely. 153 */ 154 __u32 timeout_ms; 155 /** Interruptable flag, ignored for userspace calls. */ 156 __u8 interruptible; 157 /** Explicit padding, MBZ. */ 158 __u8 reserved; 159 /** 160 * Input: How many parameters following this structure. 161 * 162 * The parameters are either HGCMFunctionParameter64 or 32, 163 * depending on whether we're receiving a 64-bit or 32-bit request. 164 * 165 * The current maximum is 61 parameters (given a 1KB max request size, 166 * and a 64-bit parameter size of 16 bytes). 167 */ 168 __u16 parm_count; 169 /* 170 * Parameters follow in form: 171 * struct hgcm_function_parameter<32|64> parms[parm_count] 172 */ 173 }; 174 VMMDEV_ASSERT_SIZE(vbg_ioctl_hgcm_call, 24 + 16); 175 176 #define VBG_IOCTL_HGCM_CALL_32(s) _IOC(_IOC_READ | _IOC_WRITE, 'V', 6, s) 177 #define VBG_IOCTL_HGCM_CALL_64(s) _IOC(_IOC_READ | _IOC_WRITE, 'V', 7, s) 178 #if __BITS_PER_LONG == 64 179 #define VBG_IOCTL_HGCM_CALL(s) VBG_IOCTL_HGCM_CALL_64(s) 180 #else 181 #define VBG_IOCTL_HGCM_CALL(s) VBG_IOCTL_HGCM_CALL_32(s) 182 #endif 183 184 185 /** VBG_IOCTL_LOG data structure. */ 186 struct vbg_ioctl_log { 187 /** The header. */ 188 struct vbg_ioctl_hdr hdr; 189 union { 190 struct { 191 /** 192 * The log message, this may be zero terminated. If it 193 * is not zero terminated then the length is determined 194 * from the input size. 195 */ 196 char msg[1]; 197 } in; 198 } u; 199 }; 200 201 #define VBG_IOCTL_LOG(s) _IO('V', 9) 202 203 204 /** VBG_IOCTL_WAIT_FOR_EVENTS data structure. */ 205 struct vbg_ioctl_wait_for_events { 206 /** The header. */ 207 struct vbg_ioctl_hdr hdr; 208 union { 209 struct { 210 /** Timeout in milliseconds. */ 211 __u32 timeout_ms; 212 /** Events to wait for. */ 213 __u32 events; 214 } in; 215 struct { 216 /** Events that occurred. */ 217 __u32 events; 218 } out; 219 } u; 220 }; 221 VMMDEV_ASSERT_SIZE(vbg_ioctl_wait_for_events, 24 + 8); 222 223 #define VBG_IOCTL_WAIT_FOR_EVENTS \ 224 _IOWR('V', 10, struct vbg_ioctl_wait_for_events) 225 226 227 /* 228 * IOCTL to VBoxGuest to interrupt (cancel) any pending 229 * VBG_IOCTL_WAIT_FOR_EVENTS and return. 230 * 231 * Handled inside the vboxguest driver and not seen by the host at all. 232 * After calling this, VBG_IOCTL_WAIT_FOR_EVENTS should no longer be called in 233 * the same session. Any VBOXGUEST_IOCTL_WAITEVENT calls in the same session 234 * done after calling this will directly exit with -EINTR. 235 */ 236 #define VBG_IOCTL_INTERRUPT_ALL_WAIT_FOR_EVENTS \ 237 _IOWR('V', 11, struct vbg_ioctl_hdr) 238 239 240 /** VBG_IOCTL_CHANGE_FILTER_MASK data structure. */ 241 struct vbg_ioctl_change_filter { 242 /** The header. */ 243 struct vbg_ioctl_hdr hdr; 244 union { 245 struct { 246 /** Flags to set. */ 247 __u32 or_mask; 248 /** Flags to remove. */ 249 __u32 not_mask; 250 } in; 251 } u; 252 }; 253 VMMDEV_ASSERT_SIZE(vbg_ioctl_change_filter, 24 + 8); 254 255 /* IOCTL to VBoxGuest to control the event filter mask. */ 256 #define VBG_IOCTL_CHANGE_FILTER_MASK \ 257 _IOWR('V', 12, struct vbg_ioctl_change_filter) 258 259 260 /** VBG_IOCTL_ACQUIRE_GUEST_CAPABILITIES data structure. */ 261 struct vbg_ioctl_acquire_guest_caps { 262 /** The header. */ 263 struct vbg_ioctl_hdr hdr; 264 union { 265 struct { 266 /** Flags (VBGL_IOC_AGC_FLAGS_XXX). */ 267 __u32 flags; 268 /** Capabilities to set (VMMDEV_GUEST_SUPPORTS_XXX). */ 269 __u32 or_mask; 270 /** Capabilities to drop (VMMDEV_GUEST_SUPPORTS_XXX). */ 271 __u32 not_mask; 272 } in; 273 } u; 274 }; 275 VMMDEV_ASSERT_SIZE(vbg_ioctl_acquire_guest_caps, 24 + 12); 276 277 #define VBGL_IOC_AGC_FLAGS_CONFIG_ACQUIRE_MODE 0x00000001 278 #define VBGL_IOC_AGC_FLAGS_VALID_MASK 0x00000001 279 280 #define VBG_IOCTL_ACQUIRE_GUEST_CAPABILITIES \ 281 _IOWR('V', 13, struct vbg_ioctl_acquire_guest_caps) 282 283 284 /** VBG_IOCTL_CHANGE_GUEST_CAPABILITIES data structure. */ 285 struct vbg_ioctl_set_guest_caps { 286 /** The header. */ 287 struct vbg_ioctl_hdr hdr; 288 union { 289 struct { 290 /** Capabilities to set (VMMDEV_GUEST_SUPPORTS_XXX). */ 291 __u32 or_mask; 292 /** Capabilities to drop (VMMDEV_GUEST_SUPPORTS_XXX). */ 293 __u32 not_mask; 294 } in; 295 struct { 296 /** Capabilities held by the session after the call. */ 297 __u32 session_caps; 298 /** Capabilities for all the sessions after the call. */ 299 __u32 global_caps; 300 } out; 301 } u; 302 }; 303 VMMDEV_ASSERT_SIZE(vbg_ioctl_set_guest_caps, 24 + 8); 304 305 #define VBG_IOCTL_CHANGE_GUEST_CAPABILITIES \ 306 _IOWR('V', 14, struct vbg_ioctl_set_guest_caps) 307 308 309 /** VBG_IOCTL_CHECK_BALLOON data structure. */ 310 struct vbg_ioctl_check_balloon { 311 /** The header. */ 312 struct vbg_ioctl_hdr hdr; 313 union { 314 struct { 315 /** The size of the balloon in chunks of 1MB. */ 316 __u32 balloon_chunks; 317 /** 318 * false = handled in R0, no further action required. 319 * true = allocate balloon memory in R3. 320 */ 321 __u8 handle_in_r3; 322 /** Explicit padding, MBZ. */ 323 __u8 padding[3]; 324 } out; 325 } u; 326 }; 327 VMMDEV_ASSERT_SIZE(vbg_ioctl_check_balloon, 24 + 8); 328 329 /* 330 * IOCTL to check memory ballooning. 331 * 332 * The guest kernel module will ask the host for the current size of the 333 * balloon and adjust the size. Or it will set handle_in_r3 = true and R3 is 334 * responsible for allocating memory and calling VBG_IOCTL_CHANGE_BALLOON. 335 */ 336 #define VBG_IOCTL_CHECK_BALLOON \ 337 _IOWR('V', 17, struct vbg_ioctl_check_balloon) 338 339 340 /** VBG_IOCTL_WRITE_CORE_DUMP data structure. */ 341 struct vbg_ioctl_write_coredump { 342 struct vbg_ioctl_hdr hdr; 343 union { 344 struct { 345 __u32 flags; /** Flags (reserved, MBZ). */ 346 } in; 347 } u; 348 }; 349 VMMDEV_ASSERT_SIZE(vbg_ioctl_write_coredump, 24 + 4); 350 351 #define VBG_IOCTL_WRITE_CORE_DUMP \ 352 _IOWR('V', 19, struct vbg_ioctl_write_coredump) 353 354 #endif