Grant Tables

group grant_table

Xen’s grant tables provide a generic mechanism to memory sharing between domains. This shared memory interface underpins the split device drivers for block and network IO.

Each domain has its own grant table. This is a data structure that is shared with Xen; it allows the domain to tell Xen what kind of permissions other domains have on its pages. Entries in the grant table are identified by grant references. A grant reference is an integer, which indexes into the grant table. It acts as a capability which the grantee can use to perform operations on the granter’s memory.

This capability-based system allows shared-memory communications between unprivileged domains. A grant reference also encapsulates the details of a shared page, removing the need for a domain to know the real machine address of a page it is sharing. This makes it possible to share memory correctly with domains running in fully virtualised memory.

GRANT TABLE REPRESENTATION

A grant table comprises a packed array of grant entries in one or more page frames shared between Xen and a guest.

Some rough guidelines on accessing and updating grant-table entries in a concurrency-safe manner. For more information, Linux contains a reference implementation for guest OSes (drivers/xen/grant_table.c, see http://git.kernel.org/?p=linux/kernel/git/torvalds/linux.git;a=blob;f=drivers/xen/grant-table.c;hb=HEAD

NB. WMB is a no-op on current-generation x86 processors. However, a compiler barrier will still be required.

Introducing a valid entry into the grant table:

1. Write ent->domid.
2. Write ent->frame:
    GTF_permit_access:   Frame to which access is permitted.
    GTF_accept_transfer: Pseudo-phys frame slot being filled by new
                         frame, or zero if none.
3. Write memory barrier (WMB).
4. Write ent->flags, inc. valid type.

Invalidating an unused GTF_permit_access entry:

1. flags = ent->flags.
2. Observe that !(flags & (GTF_reading|GTF_writing)).
3. Check result of SMP-safe CMPXCHG(&ent->flags, flags, 0).
NB. No need for WMB as reuse of entry is control-dependent on success of
    step 3, and all architectures guarantee ordering of ctrl-dep writes.

Invalidating an in-use GTF_permit_access entry:

This cannot be done directly. Request assistance from the domain controller which can set a timeout on the use of a grant entry and take necessary action. (NB. This is not yet implemented!).

Invalidating an unused GTF_accept_transfer entry:

1. flags = ent->flags.
2. Observe that !(flags & GTF_transfer_committed). [*]
3. Check result of SMP-safe CMPXCHG(&ent->flags, flags, 0).
NB. No need for WMB as reuse of entry is control-dependent on success of
    step 3, and all architectures guarantee ordering of ctrl-dep writes.
[*] If GTF_transfer_committed is set then the grant entry is 'committed'.
    The guest must /not/ modify the grant entry until the address of the
    transferred frame is written. It is safe for the guest to spin waiting
    for this to occur (detect by observing GTF_transfer_completed in
    ent->flags).

Invalidating a committed GTF_accept_transfer entry:

  1. Wait for (ent->flags & GTF_transfer_completed).

Changing a GTF_permit_access from writable to read-only:

Use SMP-safe CMPXCHG to set GTF_readonly, while checking !GTF_writing.

Changing a GTF_permit_access from read-only to writable:

Use SMP-safe bit-setting instruction.

Data structure fields or defines described below have the following tags:

  • [XEN]: This field is written by Xen and read by the sharing guest.
  • [GST]: This field is written by the guest and read by Xen.

GRANT TABLE QUERIES AND USES

enum grant_table_op { // GNTTABOP_* => struct gnttab_*
    GNTTABOP_map_grant_ref      = 0,
    GNTTABOP_unmap_grant_ref    = 1,
    GNTTABOP_setup_table        = 2,
    GNTTABOP_dump_table         = 3,
    GNTTABOP_transfer           = 4,
    GNTTABOP_copy               = 5,
    GNTTABOP_query_size         = 6,
    GNTTABOP_unmap_and_replace  = 7,
#if __XEN_INTERFACE_VERSION__ >= 0x0003020a
    GNTTABOP_set_version        = 8,
    GNTTABOP_get_status_frames  = 9,
    GNTTABOP_get_version        = 10,
    GNTTABOP_swap_grant_ref     = 11,
    GNTTABOP_cache_flush        = 12
#endif
};

enum neg_errnoval
HYPERVISOR_grant_table_op(enum grant_table_op cmd,
                          void *args,
                          unsigned int count)

@args points to an array of a per-command data structure. The array has @count members

Defines

GNTTAB_NR_RESERVED_ENTRIES 8
GNTTAB_RESERVED_CONSOLE 0
GNTTAB_RESERVED_XENSTORE 1
GTF_invalid (0U<<0)

This type of grant entry grants no privileges.

GTF_permit_access (1U<<0)

This type of grant entry allow @domid to map/access @frame.

GTF_accept_transfer (2U<<0)

This type of grant entry allow @domid to transfer ownership of one pageframe to this guest. Xen writes the page number to @frame.

GTF_transitive (3U<<0)

This type of grant entry allow @domid to transitively access a subrange of @trans_grant in @trans_domid. No mappings are allowed.

GTF_type_mask (3U<<0)
GTF_readonly (1U<<_GTF_readonly)

Subflag for GTF_permit_access and GTF_transitive: Restrict @domid to read-only mappings and accesses. [GST]

_GTF_readonly (2)
GTF_reading (1U<<_GTF_reading)

Subflag for GTF_permit_access and GTF_transitive: Grant entry is currently mapped for reading by @domid. [XEN]

_GTF_reading (3)
GTF_writing (1U<<_GTF_writing)

Subflag for GTF_permit_access and GTF_transitive: Grant entry is currently mapped for writing by @domid. [XEN]

_GTF_writing (4)
GTF_PWT (1U<<_GTF_PWT)

Subflag for GTF_permit_access only: (x86) cache attribute flags to be used for mappings of the grant [GST]

_GTF_PWT (5)
GTF_PCD (1U<<_GTF_PCD)

Subflag for GTF_permit_access only: (x86) cache attribute flags to be used for mappings of the grant [GST]

_GTF_PCD (6)
GTF_PAT (1U<<_GTF_PAT)

Subflag for GTF_permit_access only: (x86) cache attribute flags to be used for mappings of the grant [GST]

_GTF_PAT (7)
GTF_sub_page (1U<<_GTF_sub_page)

Subflag for GTF_permit_access only: Grant access to only a subrange of the page. @domid will only be allowed to copy from the grant, and not map it. [GST]

_GTF_sub_page (8)
GTF_transfer_committed (1U<<_GTF_transfer_committed)

Subflag for GTF_accept_transfer: Xen sets this flag to indicate that it is committed to transferring ownership of a page frame. When a guest sees this flag it must /not/ modify the grant entry until GTF_transfer_completed is set by Xen.

_GTF_transfer_committed (2)
GTF_transfer_completed (1U<<_GTF_transfer_completed)

Subflag for GTF_accept_transfer: It is safe for the guest to spin-wait on this flag after reading GTF_transfer_committed. Xen will always write the frame address, followed by ORing this flag, in a timely manner.

_GTF_transfer_completed (3)
GNTTABOP_map_grant_ref 0

struct gnttab_map_grant_ref

GNTTABOP_unmap_grant_ref 1

struct gnttab_unmap_grant_ref

GNTTABOP_setup_table 2

struct gnttab_setup_table

GNTTABOP_dump_table 3

struct gnttab_dump_table

GNTTABOP_transfer 4

struct gnttab_transfer

GNTTABOP_copy 5

struct gnttab_copy

GNTTABOP_query_size 6

struct gnttab_query_size

GNTTABOP_unmap_and_replace 7

struct gnttab_unmap_and_replace

GNTTABOP_set_version 8

struct gnttab_set_version

GNTTABOP_get_status_frames 9

struct gnttab_get_status_frames

GNTTABOP_get_version 10

struct gnttab_get_version

GNTTABOP_swap_grant_ref 11

struct gnttab_swap_grant_ref

GNTTABOP_cache_flush 12

struct gnttab_cache_flush

GNTMAP_device_map (1<<_GNTMAP_device_map)

Bitfield value for gnttab_map_grant_ref.flags: Map the grant entry for access by I/O devices.

_GNTMAP_device_map (0)
GNTMAP_host_map (1<<_GNTMAP_host_map)

Bitfield value for gnttab_map_grant_ref.flags: Map the grant entry for access by host CPUs.

_GNTMAP_host_map (1)
GNTMAP_readonly (1<<_GNTMAP_readonly)

Bitfield value for gnttab_map_grant_ref.flags: Accesses to the granted frame will be restricted to read-only access.

_GNTMAP_readonly (2)
GNTMAP_application_map (1<<_GNTMAP_application_map)

Bitfield value for gnttab_map_grant_ref.flags.

GNTMAP_host_map subflag:

  • 0 => The host mapping is usable only by the guest OS.
  • 1 => The host mapping is usable by guest OS + current application.

_GNTMAP_application_map (3)
GNTMAP_contains_pte (1<<_GNTMAP_contains_pte)

Bitfield value for gnttab_map_grant_ref.flags.

GNTMAP_contains_pte subflag:

  • 0 => This map request contains a host virtual address.
  • 1 => This map request contains the machine addess of the PTE to update.

_GNTMAP_contains_pte (4)
_GNTMAP_can_fail (5)
GNTMAP_can_fail (1<<_GNTMAP_can_fail)
GNTMAP_guest_avail_mask ((uint32_t)~0 << _GNTMAP_guest_avail0)

Bitfield value for gnttab_map_grant_ref.flags: Bits to be placed in guest kernel available PTE bits (architecture dependent; only supported when XENFEAT_gnttab_map_avail_bits is set).

_GNTMAP_guest_avail0 (16)
GNTST_okay (0)

Normal return.

GNTST_general_error (-1)

General undefined error.

GNTST_bad_domain (-2)

Unrecognsed domain id.

GNTST_bad_gntref (-3)

Unrecognised or inappropriate gntref.

GNTST_bad_handle (-4)

Unrecognised or inappropriate handle.

GNTST_bad_virt_addr (-5)

Inappropriate virtual address to map.

GNTST_bad_dev_addr (-6)

Inappropriate device address to unmap.

GNTST_no_device_space (-7)

Out of space in I/O MMU.

GNTST_permission_denied (-8)

Not enough privilege for operation.

GNTST_bad_page (-9)

Specified page was invalid for op.

GNTST_bad_copy_arg (-10)

copy arguments cross page boundary.

GNTST_address_too_big (-11)

transfer page address too large.

GNTST_eagain (-12)

Operation not done; try again.

GNTTABOP_error_msgs { \ “okay”, \ “undefined error”, \ “unrecognised domain id”, \ “invalid grant reference”, \ “invalid mapping handle”, \ “invalid virtual address”, \ “invalid device address”, \ “no spare translation slot in the I/O MMU”, \ “permission denied”, \ “bad page”, \ “copy arguments cross page boundary”, \ “page address size too large”, \ “operation not done; try again” \ }

Typedefs

typedef uint32_t grant_ref_t

Reference to a grant entry in a specified domain’s grant table.

typedef struct grant_entry_v1 grant_entry_v1_t
typedef struct grant_entry_header grant_entry_header_t
typedef union grant_entry_v2 grant_entry_v2_t
typedef uint16_t grant_status_t
typedef uint32_t grant_handle_t

Handle to track a mapping created via a grant reference.

typedef struct gnttab_map_grant_ref gnttab_map_grant_ref_t
typedef struct gnttab_unmap_grant_ref gnttab_unmap_grant_ref_t
typedef struct gnttab_setup_table gnttab_setup_table_t
typedef struct gnttab_dump_table gnttab_dump_table_t
typedef struct gnttab_transfer gnttab_transfer_t
typedef struct gnttab_copy gnttab_copy_t
typedef struct gnttab_query_size gnttab_query_size_t
typedef struct gnttab_unmap_and_replace gnttab_unmap_and_replace_t
typedef struct gnttab_set_version gnttab_set_version_t
typedef struct gnttab_get_status_frames gnttab_get_status_frames_t
typedef struct gnttab_get_version gnttab_get_version_t
typedef struct gnttab_swap_grant_ref gnttab_swap_grant_ref_t
typedef struct gnttab_cache_flush gnttab_cache_flush_t
struct grant_entry_v1
#include <grant_table.h>

Public Members

uint16_t flags

GTF_xxx: various type and flag information. [XEN,GST]

domid_t domid

The domain being granted foreign privileges. [GST]

uint32_t frame

GTF_permit_access: GFN that @domid is allowed to map and access. [GST]
GTF_accept_transfer: GFN that @domid is allowed to transfer into. [GST]
GTF_transfer_completed: MFN whose ownership transferred by @domid
                        (non-translated guests only). [XEN]

struct grant_entry_header
#include <grant_table.h>

Public Members

uint16_t flags
domid_t domid
union grant_entry_v2
#include <grant_table.h>

Version 2 of the grant entry structure.

Public Members

grant_entry_header_t hdr
struct grant_entry_v2::anonymous_struct_0 full_page
struct grant_entry_v2::anonymous_struct_1 sub_page
struct grant_entry_v2::anonymous_struct_2 transitive
uint32_t grant_entry_v2::__spacer[4]

Pad to a power of two

struct anonymous_struct_0
#include <grant_table.h>

This member is used for V1-style full page grants, where either:

  • hdr.type is GTF_accept_transfer, or
  • hdr.type is GTF_permit_access and GTF_sub_page is not set.

In that case, the frame field has the same semantics as the field of the same name in the V1 entry structure.

Public Members

grant_entry_header_t anonymous_struct_0::hdr
uint32_t anonymous_struct_0::pad0
uint64_t anonymous_struct_0::frame
struct anonymous_struct_1
#include <grant_table.h>

If the grant type is GTF_grant_access and GTF_sub_page is set, @domid is allowed to access bytes [@page_off,@page_off+@length) in frame @frame.

Public Members

grant_entry_header_t anonymous_struct_1::hdr
uint16_t anonymous_struct_1::page_off
uint16_t anonymous_struct_1::length
uint64_t anonymous_struct_1::frame
struct anonymous_struct_2
#include <grant_table.h>

If the grant is GTF_transitive, @domid is allowed to use the grant @gref in domain @trans_domid, as if it was the local domain. Obviously, the transitive access must be compatible with the original grant.

The current version of Xen does not allow transitive grants to be mapped.

Public Members

grant_entry_header_t anonymous_struct_2::hdr
domid_t anonymous_struct_2::trans_domid
uint16_t anonymous_struct_2::pad0
grant_ref_t anonymous_struct_2::gref
struct gnttab_map_grant_ref
#include <grant_table.h>

GNTTABOP_map_grant_ref: Map the grant entry (@dom,@ref) for access by devices and/or host CPUs. If successful, @handle is a tracking number that must be presented later to destroy the mapping(s). On error, @status is a negative status code.

NOTES:

  1. If GNTMAP_device_map is specified then @dev_bus_addr is the address via which I/O devices may access the granted frame.
  2. If GNTMAP_host_map is specified then a mapping will be added at either a host virtual address in the current address space, or at a PTE at the specified machine address. The type of mapping to perform is selected through the GNTMAP_contains_pte flag, and the address is specified in @host_addr.
  3. Mappings should only be destroyed via GNTTABOP_unmap_grant_ref. If a host mapping is destroyed by other means then it is NOT guaranteed to be accounted to the correct grant reference!

Public Members

uint64_t host_addr
uint32_t flags

GNTMAP_*

grant_ref_t ref
domid_t dom
int16_t status

GNTST_* status code

grant_handle_t handle
uint64_t dev_bus_addr
union __guest_handle_gnttab_map_grant_ref_t
#include <grant_table.h>

Public Members

gnttab_map_grant_ref_t* p
unsigned long q
union __guest_handle_64_gnttab_map_grant_ref_t
#include <grant_table.h>

Public Members

gnttab_map_grant_ref_t* p
uint64_t q
union __guest_handle_const_gnttab_map_grant_ref_t
#include <grant_table.h>

Public Members

const gnttab_map_grant_ref_t* p
unsigned long q
union __guest_handle_64_const_gnttab_map_grant_ref_t
#include <grant_table.h>

Public Members

const gnttab_map_grant_ref_t* p
uint64_t q
struct gnttab_unmap_grant_ref
#include <grant_table.h>

GNTTABOP_unmap_grant_ref: Destroy one or more grant-reference mappings tracked by @handle. If @host_addr or @dev_bus_addr is zero, that field is ignored. If non-zero, they must refer to a device/host mapping that is tracked by @handle

NOTES:

  1. The call may fail in an undefined manner if either mapping is not tracked by @handle.
  2. After executing a batch of unmaps, it is guaranteed that no stale mappings will remain in the device or host TLBs.

Public Members

uint64_t host_addr
uint64_t dev_bus_addr
grant_handle_t handle
int16_t status

GNTST_* status code

union __guest_handle_gnttab_unmap_grant_ref_t
#include <grant_table.h>

Public Members

gnttab_unmap_grant_ref_t* p
unsigned long q
union __guest_handle_64_gnttab_unmap_grant_ref_t
#include <grant_table.h>

Public Members

gnttab_unmap_grant_ref_t* p
uint64_t q
union __guest_handle_const_gnttab_unmap_grant_ref_t
#include <grant_table.h>

Public Members

const gnttab_unmap_grant_ref_t* p
unsigned long q
union __guest_handle_64_const_gnttab_unmap_grant_ref_t
#include <grant_table.h>

Public Members

const gnttab_unmap_grant_ref_t* p
uint64_t q
struct gnttab_setup_table
#include <grant_table.h>

GNTTABOP_setup_table: Set up a grant table for @dom comprising at least @nr_frames pages. The frame addresses are written to the @frame_list. Only @nr_frames addresses are written, even if the table is larger.

NOTES:

  1. @dom may be specified as DOMID_SELF.
  2. Only a sufficiently-privileged domain may specify @dom != DOMID_SELF.
  3. Xen may not support more than a single grant-table page per domain.

Public Members

domid_t dom
uint32_t nr_frames
int16_t status

GNTST_* status code

__guest_handle_64_xen_pfn_t frame_list
union __guest_handle_gnttab_setup_table_t
#include <grant_table.h>

Public Members

gnttab_setup_table_t* p
unsigned long q
union __guest_handle_64_gnttab_setup_table_t
#include <grant_table.h>

Public Members

gnttab_setup_table_t* p
uint64_t q
union __guest_handle_const_gnttab_setup_table_t
#include <grant_table.h>

Public Members

const gnttab_setup_table_t* p
unsigned long q
union __guest_handle_64_const_gnttab_setup_table_t
#include <grant_table.h>

Public Members

const gnttab_setup_table_t* p
uint64_t q
struct gnttab_dump_table
#include <grant_table.h>

GNTTABOP_dump_table: Dump the contents of the grant table to the xen console. Debugging use only.

Public Members

domid_t dom
int16_t status

GNTST_* status code

union __guest_handle_gnttab_dump_table_t
#include <grant_table.h>

Public Members

gnttab_dump_table_t* p
unsigned long q
union __guest_handle_64_gnttab_dump_table_t
#include <grant_table.h>

Public Members

gnttab_dump_table_t* p
uint64_t q
union __guest_handle_const_gnttab_dump_table_t
#include <grant_table.h>

Public Members

const gnttab_dump_table_t* p
unsigned long q
union __guest_handle_64_const_gnttab_dump_table_t
#include <grant_table.h>

Public Members

const gnttab_dump_table_t* p
uint64_t q
struct gnttab_transfer
#include <grant_table.h>

GNTTABOP_transfer: Transfer @frame to a foreign domain. The foreign domain has previously registered its interest in the transfer via @domid, @ref.

Note that, even if the transfer fails, the specified page no longer belongs to the calling domain unless the error is GNTST_bad_page.

Note further that only PV guests can use this operation.

Public Members

xen_pfn_t mfn
domid_t domid
grant_ref_t ref
int16_t status

GNTST_* status code

union __guest_handle_gnttab_transfer_t
#include <grant_table.h>

Public Members

gnttab_transfer_t* p
unsigned long q
union __guest_handle_64_gnttab_transfer_t
#include <grant_table.h>

Public Members

gnttab_transfer_t* p
uint64_t q
union __guest_handle_const_gnttab_transfer_t
#include <grant_table.h>

Public Members

const gnttab_transfer_t* p
unsigned long q
union __guest_handle_64_const_gnttab_transfer_t
#include <grant_table.h>

Public Members

const gnttab_transfer_t* p
uint64_t q
struct gnttab_copy
#include <grant_table.h>

GNTTABOP_copy: Hypervisor based copy source and destinations can be eithers MFNs or, for foreign domains, grant references. the foreign domain has to grant read/write access in its grant table.

The flags specify what type source and destinations are (either MFN or grant reference).

Note that this can also be used to copy data between two domains via a third party if the source and destination domains had previously grant appropriate access to their pages to the third party.

source_offset specifies an offset in the source frame, dest_offset the offset in the target frame and len specifies the number of bytes to be copied.

Public Members

struct gnttab_copy::gnttab_copy_ptr source
struct gnttab_copy::gnttab_copy_ptr dest
uint16_t len
uint16_t flags

GNTCOPY_*

int16_t status
struct gnttab_copy_ptr
#include <grant_table.h>

Public Members

union gnttab_copy::gnttab_copy_ptr::anonymous_union_0 gnttab_copy_ptr::u
domid_t gnttab_copy_ptr::domid
uint16_t gnttab_copy_ptr::offset
union gnttab_copy_ptr::anonymous_union_0
#include <grant_table.h>

Public Members

grant_ref_t gnttab_copy_ptr::anonymous_union_0::ref
xen_pfn_t gnttab_copy_ptr::anonymous_union_0::gmfn
union __guest_handle_gnttab_copy_t
#include <grant_table.h>

Public Members

gnttab_copy_t* p
unsigned long q
union __guest_handle_64_gnttab_copy_t
#include <grant_table.h>

Public Members

gnttab_copy_t* p
uint64_t q
union __guest_handle_const_gnttab_copy_t
#include <grant_table.h>

Public Members

const gnttab_copy_t* p
unsigned long q
union __guest_handle_64_const_gnttab_copy_t
#include <grant_table.h>

Public Members

const gnttab_copy_t* p
uint64_t q
struct gnttab_query_size
#include <grant_table.h>

GNTTABOP_query_size: Query the current and maximum sizes of the shared grant table.

NOTES:

  1. @dom may be specified as DOMID_SELF.
  2. Only a sufficiently-privileged domain may specify @dom != DOMID_SELF.

Public Members

domid_t dom
uint32_t nr_frames
uint32_t max_nr_frames
int16_t status

GNTST_* status code

union __guest_handle_gnttab_query_size_t
#include <grant_table.h>

Public Members

gnttab_query_size_t* p
unsigned long q
union __guest_handle_64_gnttab_query_size_t
#include <grant_table.h>

Public Members

gnttab_query_size_t* p
uint64_t q
union __guest_handle_const_gnttab_query_size_t
#include <grant_table.h>

Public Members

const gnttab_query_size_t* p
unsigned long q
union __guest_handle_64_const_gnttab_query_size_t
#include <grant_table.h>

Public Members

const gnttab_query_size_t* p
uint64_t q
struct gnttab_unmap_and_replace
#include <grant_table.h>

GNTTABOP_unmap_and_replace: Destroy one or more grant-reference mappings tracked by @handle but atomically replace the page table entry with one pointing to the machine address under @new_addr. @new_addr will be redirected to the null entry.

NOTES:

  1. The call may fail in an undefined manner if either mapping is not tracked by @handle.
  2. After executing a batch of unmaps, it is guaranteed that no stale mappings will remain in the device or host TLBs.

Public Members

uint64_t host_addr
uint64_t new_addr
grant_handle_t handle
int16_t status

GNTST_* status code

union __guest_handle_gnttab_unmap_and_replace_t
#include <grant_table.h>

Public Members

gnttab_unmap_and_replace_t* p
unsigned long q
union __guest_handle_64_gnttab_unmap_and_replace_t
#include <grant_table.h>

Public Members

gnttab_unmap_and_replace_t* p
uint64_t q
union __guest_handle_const_gnttab_unmap_and_replace_t
#include <grant_table.h>

Public Members

const gnttab_unmap_and_replace_t* p
unsigned long q
union __guest_handle_64_const_gnttab_unmap_and_replace_t
#include <grant_table.h>

Public Members

const gnttab_unmap_and_replace_t* p
uint64_t q
struct gnttab_set_version
#include <grant_table.h>

GNTTABOP_set_version: Request a particular version of the grant table shared table structure. This operation may be used to toggle between different versions, but must be performed while no grants are active. The only defined versions are 1 and 2.

Public Members

uint32_t version
union __guest_handle_gnttab_set_version_t
#include <grant_table.h>

Public Members

gnttab_set_version_t* p
unsigned long q
union __guest_handle_64_gnttab_set_version_t
#include <grant_table.h>

Public Members

gnttab_set_version_t* p
uint64_t q
union __guest_handle_const_gnttab_set_version_t
#include <grant_table.h>

Public Members

const gnttab_set_version_t* p
unsigned long q
union __guest_handle_64_const_gnttab_set_version_t
#include <grant_table.h>

Public Members

const gnttab_set_version_t* p
uint64_t q
struct gnttab_get_status_frames
#include <grant_table.h>

GNTTABOP_get_status_frames: Get the list of frames used to store grant status for @dom. In grant format version 2, the status is separated from the other shared grant fields to allow more efficient synchronization using barriers instead of atomic cmpexch operations. @nr_frames specify the size of vector @frame_list. The frame addresses are returned in the @frame_list. Only @nr_frames addresses are returned, even if the table is larger.

NOTES:

  1. @dom may be specified as DOMID_SELF.
  2. Only a sufficiently-privileged domain may specify @dom != DOMID_SELF.

Public Members

uint32_t nr_frames
domid_t dom
int16_t status

GNTST_* status code

__guest_handle_64_uint64_t frame_list
union __guest_handle_gnttab_get_status_frames_t
#include <grant_table.h>

Public Members

gnttab_get_status_frames_t* p
unsigned long q
union __guest_handle_64_gnttab_get_status_frames_t
#include <grant_table.h>

Public Members

gnttab_get_status_frames_t* p
uint64_t q
union __guest_handle_const_gnttab_get_status_frames_t
#include <grant_table.h>

Public Members

const gnttab_get_status_frames_t* p
unsigned long q
union __guest_handle_64_const_gnttab_get_status_frames_t
#include <grant_table.h>

Public Members

const gnttab_get_status_frames_t* p
uint64_t q
struct gnttab_get_version
#include <grant_table.h>

GNTTABOP_get_version: Get the grant table version which is in effect for domain @dom.

Public Members

domid_t dom
uint16_t pad
uint32_t version
union __guest_handle_gnttab_get_version_t
#include <grant_table.h>

Public Members

gnttab_get_version_t* p
unsigned long q
union __guest_handle_64_gnttab_get_version_t
#include <grant_table.h>

Public Members

gnttab_get_version_t* p
uint64_t q
union __guest_handle_const_gnttab_get_version_t
#include <grant_table.h>

Public Members

const gnttab_get_version_t* p
unsigned long q
union __guest_handle_64_const_gnttab_get_version_t
#include <grant_table.h>

Public Members

const gnttab_get_version_t* p
uint64_t q
struct gnttab_swap_grant_ref
#include <grant_table.h>

GNTTABOP_swap_grant_ref: Swap the contents of two grant entries.

Public Members

grant_ref_t ref_a
grant_ref_t ref_b
int16_t status

GNTST_* status code

union __guest_handle_gnttab_swap_grant_ref_t
#include <grant_table.h>

Public Members

gnttab_swap_grant_ref_t* p
unsigned long q
union __guest_handle_64_gnttab_swap_grant_ref_t
#include <grant_table.h>

Public Members

gnttab_swap_grant_ref_t* p
uint64_t q
union __guest_handle_const_gnttab_swap_grant_ref_t
#include <grant_table.h>

Public Members

const gnttab_swap_grant_ref_t* p
unsigned long q
union __guest_handle_64_const_gnttab_swap_grant_ref_t
#include <grant_table.h>

Public Members

const gnttab_swap_grant_ref_t* p
uint64_t q
struct gnttab_cache_flush
#include <grant_table.h>

Issue one or more cache maintenance operations on a portion of a page granted to the calling domain by a foreign domain.

Public Members

union gnttab_cache_flush::anonymous_union_1 a
uint16_t offset

offset from start of grant

uint16_t length

size within the grant

uint32_t op
union anonymous_union_1
#include <grant_table.h>

Public Members

uint64_t anonymous_union_1::dev_bus_addr
grant_ref_t anonymous_union_1::ref
union __guest_handle_gnttab_cache_flush_t
#include <grant_table.h>

Public Members

gnttab_cache_flush_t* p
unsigned long q
union __guest_handle_64_gnttab_cache_flush_t
#include <grant_table.h>

Public Members

gnttab_cache_flush_t* p
uint64_t q
union __guest_handle_const_gnttab_cache_flush_t
#include <grant_table.h>

Public Members

const gnttab_cache_flush_t* p
unsigned long q
union __guest_handle_64_const_gnttab_cache_flush_t
#include <grant_table.h>

Public Members

const gnttab_cache_flush_t* p
uint64_t q