LXR linux/include/uapi/linux/vboxguest.h

   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 */
  27struct 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};
  44VMMDEV_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 */
  64struct 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};
  95VMMDEV_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. */
 110struct 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};
 121VMMDEV_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. */
 128struct vbg_ioctl_hgcm_disconnect {
 129        struct vbg_ioctl_hdr hdr;
 130        union {
 131                struct {
 132                        __u32 client_id;
 133                } in;
 134        } u;
 135};
 136VMMDEV_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. */
 143struct 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};
 174VMMDEV_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. */
 186struct 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. */
 205struct 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};
 221VMMDEV_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. */
 241struct 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};
 253VMMDEV_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. */
 261struct 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};
 275VMMDEV_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. */
 285struct 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};
 303VMMDEV_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. */
 310struct 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};
 327VMMDEV_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. */
 341struct 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};
 349VMMDEV_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
 355