xengrant.h File Reference

Xen grant tables. More...

#include <stdint.h>
#include <stdlib.h>
#include <ipxe/io.h>
#include <ipxe/xen.h>
#include <xen/grant_table.h>

Go to the source code of this file.

Macros
#define	XENGRANT_FAIL_RATE   0
	Induced failure rate (for testing)

Functions
	FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)
	FILE_SECBOOT (PERMITTED)
static	__attribute__ ((always_inline)) int xengrant_query_size(struct xen_hypervisor *xen
	Query grant table size.
	return (container_of(&v1->flags, struct grant_entry_header, flags))
static void	xengrant_zero (struct xen_hypervisor *xen, struct grant_entry_header *hdr)
	Zero grant table entry.
	assert ((readw(&hdr->flags) &(GTF_reading|GTF_writing))==0)
	writew (0, &hdr->flags)
	writew (DOMID_SELF, &hdr->domid)
	if ((XENGRANT_FAIL_RATE > 0) &&(random() % XENGRANT_FAIL_RATE)==0)
	if (sizeof(physaddr_t)==sizeof(uint64_t))
	wmb ()
	writew ((GTF_permit_access|subflags), &hdr->flags)
int	xengrant_init (struct xen_hypervisor *xen)
	Initialise grant table.
int	xengrant_alloc (struct xen_hypervisor *xen, grant_ref_t *refs, unsigned int count)
	Allocate grant references.
void	xengrant_free (struct xen_hypervisor *xen, grant_ref_t *refs, unsigned int count)
	Free grant references.

Variables
static struct gnttab_query_size *	size
static struct gnttab_set_version *	version
static grant_ref_t	ref
	v1 = &xen->grant.table[ ref << xen->grant.shift ]
static grant_ref_t domid_t	domid
static grant_ref_t domid_t unsigned int	subflags
static grant_ref_t domid_t unsigned int physaddr_t	addr
union grant_entry_v2 *	v2 = xengrant_v2 ( hdr )
unsigned long	frame = ( addr / PAGE_SIZE )
	else
	return

Detailed Description

Xen grant tables.

Definition in file xengrant.h.

Macro Definition Documentation

XENGRANT_FAIL_RATE

#define XENGRANT_FAIL_RATE   0

Induced failure rate (for testing)

Definition at line 20 of file xengrant.h.

Referenced by if().

Function Documentation

FILE_LICENCE()

FILE_LICENCE

(

GPL2_OR_LATER_OR_UBDL

)

FILE_SECBOOT()

FILE_SECBOOT

(

PERMITTED

)

__attribute__()

__attribute__ ( (always_inline) )

inlinestatic

Query grant table size.

Permit access to a page.

Invalidate access to a page.

Get version 2 grant table entry.

Get version 1 grant table entry.

Get grant table entry header.

Get number of grant table entries.

Get grant table version.

Set grant table version.

Parameters

xen	Xen hypervisor
size	Table size

Return values

xenrc

Xen status code

Parameters

xen	Xen hypervisor
version	Version

Return values

xenrc

Xen status code

Parameters

xen	Xen hypervisor

Return values

entries

Number of grant table entries

Parameters

xen	Xen hypervisor
ref	Grant reference

Return values

hdr	Grant table entry header

Parameters

hdr	Grant table entry header

Return values

v1	Version 1 grant table entry

Parameters

hdr	Grant table entry header

Return values

v2	Version 2 grant table entry

Parameters

xen	Xen hypervisor
ref	Grant reference
xen	Xen hypervisor
ref	Grant reference
domid	Domain ID
subflags	Additional flags
addr	Physical address within page

Return values

rc	Return status code

Definition at line 76 of file xengrant.h.

                                                {
 
        return ( ( xen->grant.len / sizeof ( xen->grant.table[0] ) )
                 >> xen->grant.shift );
}

References xen_hypervisor::grant, xen_grant::len, xen_grant::shift, and xen_grant::table.

return()

return

(

container_of &->,,

flags

)

References container_of, flags, and v1.

xengrant_zero()

void xengrant_zero ( struct xen_hypervisor * xen, struct grant_entry_header * hdr )

inlinestatic

Zero grant table entry.

Parameters

xen	Xen hypervisor
hdr	Grant table entry header

Definition at line 128 of file xengrant.h.

                                                                    {
        uint32_t *dword = ( ( uint32_t * ) hdr );
        unsigned int i = ( ( sizeof ( xen->grant.table[0] ) / sizeof ( *dword ))
                           << xen->grant.shift );
 
        while ( i-- )
                writel ( 0, dword++ );
}

References xen_hypervisor::grant, hdr, xen_grant::shift, xen_grant::table, and writel.

Referenced by xengrant_alloc(), and xengrant_free().

assert()

assert

(

(readw(&hdr->flags) &(GTF_reading|GTF_writing))

= =0

)

References GTF_reading, GTF_writing, hdr, and readw.

writew() [1/3]

writew	(	0	,
		&hdr->	flags )

References hdr.

writew() [2/3]

writew	(	DOMID_SELF	,
		&hdr->	domid )

References DOMID_SELF, and hdr.

if() [1/2]

if

(

(XENGRANT_FAIL_RATE > 0) &&(random() % XENGRANT_FAIL_RATE)

= = 0

)

Definition at line 183 of file xengrant.h.

                                                      {
                return -EAGAIN;
        }

References EAGAIN, and XENGRANT_FAIL_RATE.

if() [2/2]

if

(

sizeof(physaddr_t)

= = sizeof ( uint64_t )

)

Definition at line 194 of file xengrant.h.

                                                            {
 
                /* 64-bit system */
                if ( xen->grant.shift ) {
                        /* Version 2 table: no possible failure */
                        writeq ( frame, &v2->full_page.frame );
                } else {
                        /* Version 1 table: may fail if address above 16TB */
                        if ( frame > 0xffffffffUL )
                                return -ERANGE;
                        writel ( frame, &v1->frame );
                }
 
        } else {

References ERANGE, frame, xen_hypervisor::grant, xen_grant::shift, v1, v2, writel, and writeq.

wmb()

wmb

(

)

writew() [3/3]

writew	(	(GTF_permit_access|subflags)	,
		&hdr->	flags )

References GTF_permit_access, hdr, and subflags.

xengrant_init()

int xengrant_init ( struct xen_hypervisor * xen )

extern

Initialise grant table.

Parameters

xen	Xen hypervisor

Return values

rc	Return status code

Definition at line 71 of file xengrant.c.

                                                 {
        struct gnttab_query_size size;
        struct gnttab_set_version set_version;
        struct gnttab_get_version get_version;
        struct grant_entry_v1 *v1;
        union grant_entry_v2 *v2;
        unsigned int version;
        int xenrc;
        int rc;
 
        /* Get grant table size */
        size.dom = DOMID_SELF;
        if ( ( xenrc = xengrant_query_size ( xen, &size ) ) != 0 ) {
                rc = -EXEN ( xenrc );
                DBGC ( xen, "XENGRANT could not get table size: %s\n",
                       strerror ( rc ) );
                return rc;
        }
        xen->grant.len = ( size.nr_frames * PAGE_SIZE );
 
        /* Set grant table version, if applicable */
        set_version.version = XENGRANT_TRY_VERSION;
        if ( ( xenrc = xengrant_set_version ( xen, &set_version ) ) != 0 ) {
                rc = -EXEN ( xenrc );
                DBGC ( xen, "XENGRANT could not set version %d: %s\n",
                       XENGRANT_TRY_VERSION, strerror ( rc ) );
                /* Continue; use whatever version is current */
        }
 
        /* Get grant table version */
        get_version.dom = DOMID_SELF;
        get_version.pad = 0;
        if ( ( xenrc = xengrant_get_version ( xen, &get_version ) ) == 0 ) {
                version = get_version.version;
                switch ( version ) {
 
                case 0:
                        /* Version not yet specified: will be version 1 */
                        version = 1;
                        break;
 
                case 1 :
                        /* Version 1 table: nothing special to do */
                        break;
 
                case 2:
                        /* Version 2 table: configure shift appropriately */
                        xen->grant.shift = ( fls ( sizeof ( *v2 ) /
                                                   sizeof ( *v1 ) ) - 1 );
                        break;
 
                default:
                        /* Unsupported version */
                        DBGC ( xen, "XENGRANT detected unsupported version "
                               "%d\n", version );
                        return -ENOTSUP;
 
                }
        } else {
                rc = -EXEN ( xenrc );
                DBGC ( xen, "XENGRANT could not get version (assuming v1): "
                       "%s\n", strerror ( rc ) );
                version = 1;
        }
 
        DBGC ( xen, "XENGRANT using v%d table with %d entries\n",
               version, xengrant_entries ( xen ) );
        return 0;
}

References DBGC, DOMID_SELF, ENOTSUP, EXEN, fls, xen_hypervisor::grant, grant_entry_v1, xen_grant::len, PAGE_SIZE, rc, xen_grant::shift, size, strerror(), v1, v2, version, and XENGRANT_TRY_VERSION.

Referenced by hvm_map_grant().

xengrant_alloc()

int xengrant_alloc ( struct xen_hypervisor * xen, grant_ref_t * refs, unsigned int count )

extern

Allocate grant references.

Parameters

xen	Xen hypervisor
refs	Grant references to fill in
count	Number of references

Return values

rc	Return status code

Definition at line 149 of file xengrant.c.

                                          {
        struct grant_entry_header *hdr;
        unsigned int entries = xengrant_entries ( xen );
        unsigned int mask = ( entries - 1 );
        unsigned int check = 0;
        unsigned int avail;
        unsigned int ref;
 
        /* Fail unless we have enough references available */
        avail = ( entries - xen->grant.used - GNTTAB_NR_RESERVED_ENTRIES );
        if ( avail < count ) {
                DBGC ( xen, "XENGRANT cannot allocate %d references (only %d "
                       "of %d available)\n", count, avail, entries );
                return -ENOBUFS;
        }
        DBGC ( xen, "XENGRANT allocating %d references (from %d of %d "
               "available)\n", count, avail, entries );
 
        /* Update number of references used */
        xen->grant.used += count;
 
        /* Find unused references */
        for ( ref = xen->grant.ref ; count ; ref = ( ( ref + 1 ) & mask ) ) {
 
                /* Sanity check */
                assert ( check++ < entries );
 
                /* Skip reserved references */
                if ( ref < GNTTAB_NR_RESERVED_ENTRIES )
                        continue;
 
                /* Skip in-use references */
                hdr = xengrant_header ( xen, ref );
                if ( readw ( &hdr->flags ) & GTF_type_mask )
                        continue;
                if ( readw ( &hdr->domid ) == DOMID_SELF )
                        continue;
 
                /* Zero reference */
                xengrant_zero ( xen, hdr );
 
                /* Mark reference as in-use.  We leave the flags as
                 * empty (to avoid creating a valid grant table entry)
                 * and set the domid to DOMID_SELF.
                 */
                writew ( DOMID_SELF, &hdr->domid );
                DBGC2 ( xen, "XENGRANT allocated ref %d\n", ref );
 
                /* Record reference */
                refs[--count] = ref;
        }
 
        /* Update cursor */
        xen->grant.ref = ref;
 
        return 0;
}

References assert, count, DBGC, DBGC2, DOMID_SELF, ENOBUFS, GNTTAB_NR_RESERVED_ENTRIES, xen_hypervisor::grant, GTF_type_mask, hdr, readw, ref, xen_grant::ref, refs, xen_grant::used, writew, and xengrant_zero().

Referenced by netfront_probe().

xengrant_free()

void xengrant_free ( struct xen_hypervisor * xen, grant_ref_t * refs, unsigned int count )

extern

Free grant references.

Parameters

xen	Xen hypervisor
refs	Grant references
count	Number of references

Definition at line 215 of file xengrant.c.

                                          {
        struct grant_entry_header *hdr;
        unsigned int ref;
        unsigned int i;
 
        /* Free references */
        for ( i = 0 ; i < count ; i++ ) {
 
                /* Sanity check */
                ref = refs[i];
                assert ( ref < xengrant_entries ( xen ) );
 
                /* Zero reference */
                hdr = xengrant_header ( xen, ref );
                xengrant_zero ( xen, hdr );
                DBGC2 ( xen, "XENGRANT freed ref %d\n", ref );
        }
}

References assert, count, DBGC2, hdr, ref, refs, and xengrant_zero().

Referenced by netfront_probe(), and netfront_remove().

Variable Documentation

size

struct gnttab_query_size* size

Initial value:

{
 
        return xen_hypercall_3 ( xen, __HYPERVISOR_grant_table_op,
                                 GNTTABOP_query_size,
                                 virt_to_phys ( size ), 1 )

Definition at line 31 of file xengrant.h.

version

struct gnttab_get_version* version

Initial value:

{
 
        return xen_hypercall_3 ( xen, __HYPERVISOR_grant_table_op,
                                 GNTTABOP_set_version,
                                 virt_to_phys ( version ), 1 )

Definition at line 47 of file xengrant.h.

ref

grant_ref_t ref

Initial value:

{
        struct grant_entry_v1 *v1

Definition at line 91 of file xengrant.h.

v1

struct grant_entry_v1 * v1 = &xen->grant.table[ ref << xen->grant.shift ]

Definition at line 94 of file xengrant.h.

Referenced by if(), return(), and xengrant_init().

domid

grant_ref_t domid_t domid

Definition at line 175 of file xengrant.h.

Referenced by DEFINE_XEN_GUEST_HANDLE().

subflags

grant_ref_t domid_t unsigned int subflags

Definition at line 175 of file xengrant.h.

Referenced by writew().

addr

grant_ref_t domid_t unsigned int physaddr_t addr

Initial value:

{
        struct grant_entry_header *hdr = xengrant_header ( xen, ref )

Definition at line 176 of file xengrant.h.

v2

union grant_entry_v2* v2 = xengrant_v2 ( hdr )

Definition at line 179 of file xengrant.h.

Referenced by if(), and xengrant_init().

frame

unsigned long frame = ( addr / PAGE_SIZE )

Definition at line 180 of file xengrant.h.

Referenced by amd8111e_transmit(), bnx2_transmit(), fc_els_detect(), fc_els_prli_detect(), fc_els_prli_rx(), fc_els_prli_tx(), fc_els_rx(), fcoe_fip_rx_els_response(), and if().

else

else

Initial value:

{
 
                
                if ( xen->grant.shift ) {
                        
                        writel ( frame, &v2->full_page.frame );
                } else {
                        
                        writel ( frame, &v1->frame );
                }
        }
 
        
        writew ( domid, &hdr->domid )

Definition at line 207 of file xengrant.h.

               {
 
                /* 32-bit system */
                if ( xen->grant.shift ) {
                        /* Version 2 table: no possible failure */
                        writel ( frame, &v2->full_page.frame );
                } else {
                        /* Version 1 table: no possible failure */
                        writel ( frame, &v1->frame );
                }
        }

return

return

Definition at line 225 of file xengrant.h.