555 lines
13 KiB
C
555 lines
13 KiB
C
/*
|
|
* Copyright (C) 2014 Michael Brown <mbrown@fensystems.co.uk>.
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License as
|
|
* published by the Free Software Foundation; either version 2 of the
|
|
* License, or (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful, but
|
|
* WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
|
|
* 02110-1301, USA.
|
|
*
|
|
* You can also choose to distribute this program under the terms of
|
|
* the Unmodified Binary Distribution Licence (as given in the file
|
|
* COPYING.UBDL), provided that you have satisfied its requirements.
|
|
*/
|
|
|
|
FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
|
|
|
|
#include <stdint.h>
|
|
#include <stdarg.h>
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <ipxe/io.h>
|
|
#include <ipxe/nap.h>
|
|
#include <ipxe/malloc.h>
|
|
#include <ipxe/xen.h>
|
|
#include <ipxe/xenevent.h>
|
|
#include <ipxe/xenstore.h>
|
|
|
|
/*
|
|
* xs_wire.h attempts to define a static error table xsd_errors, which
|
|
* interacts badly with the dynamically generated error numbers used
|
|
* by iPXE. Prevent this table from being constructed by including
|
|
* errno.h only after including xs_wire.h.
|
|
*
|
|
*/
|
|
#include <xen/io/xs_wire.h>
|
|
#include <errno.h>
|
|
|
|
/** @file
|
|
*
|
|
* XenStore interface
|
|
*
|
|
*/
|
|
|
|
/** Request identifier */
|
|
static uint32_t xenstore_req_id;
|
|
|
|
/**
|
|
* Send XenStore request raw data
|
|
*
|
|
* @v xen Xen hypervisor
|
|
* @v data Data buffer
|
|
* @v len Length of data
|
|
*/
|
|
static void xenstore_send ( struct xen_hypervisor *xen, const void *data,
|
|
size_t len ) {
|
|
struct xenstore_domain_interface *intf = xen->store.intf;
|
|
XENSTORE_RING_IDX prod = readl ( &intf->req_prod );
|
|
XENSTORE_RING_IDX cons;
|
|
XENSTORE_RING_IDX idx;
|
|
const char *bytes = data;
|
|
size_t offset = 0;
|
|
size_t fill;
|
|
|
|
DBGCP ( intf, "XENSTORE raw request:\n" );
|
|
DBGCP_HDA ( intf, MASK_XENSTORE_IDX ( prod ), data, len );
|
|
|
|
/* Write one byte at a time */
|
|
while ( offset < len ) {
|
|
|
|
/* Wait for space to become available */
|
|
while ( 1 ) {
|
|
cons = readl ( &intf->req_cons );
|
|
fill = ( prod - cons );
|
|
if ( fill < XENSTORE_RING_SIZE )
|
|
break;
|
|
DBGC2 ( xen, "." );
|
|
cpu_nap();
|
|
rmb();
|
|
}
|
|
|
|
/* Write byte */
|
|
idx = MASK_XENSTORE_IDX ( prod++ );
|
|
writeb ( bytes[offset++], &intf->req[idx] );
|
|
}
|
|
|
|
/* Update producer counter */
|
|
wmb();
|
|
writel ( prod, &intf->req_prod );
|
|
wmb();
|
|
}
|
|
|
|
/**
|
|
* Send XenStore request string (excluding terminating NUL)
|
|
*
|
|
* @v xen Xen hypervisor
|
|
* @v string String
|
|
*/
|
|
static void xenstore_send_string ( struct xen_hypervisor *xen,
|
|
const char *string ) {
|
|
|
|
xenstore_send ( xen, string, strlen ( string ) );
|
|
}
|
|
|
|
/**
|
|
* Receive XenStore response raw data
|
|
*
|
|
* @v xen Xen hypervisor
|
|
* @v data Data buffer, or NULL to discard data
|
|
* @v len Length of data
|
|
*/
|
|
static void xenstore_recv ( struct xen_hypervisor *xen, void *data,
|
|
size_t len ) {
|
|
struct xenstore_domain_interface *intf = xen->store.intf;
|
|
XENSTORE_RING_IDX cons = readl ( &intf->rsp_cons );
|
|
XENSTORE_RING_IDX prod;
|
|
XENSTORE_RING_IDX idx;
|
|
char *bytes = data;
|
|
size_t offset = 0;
|
|
size_t fill;
|
|
|
|
DBGCP ( intf, "XENSTORE raw response:\n" );
|
|
|
|
/* Read one byte at a time */
|
|
while ( offset < len ) {
|
|
|
|
/* Wait for data to be ready */
|
|
while ( 1 ) {
|
|
prod = readl ( &intf->rsp_prod );
|
|
fill = ( prod - cons );
|
|
if ( fill > 0 )
|
|
break;
|
|
DBGC2 ( xen, "." );
|
|
cpu_nap();
|
|
rmb();
|
|
}
|
|
|
|
/* Read byte */
|
|
idx = MASK_XENSTORE_IDX ( cons++ );
|
|
if ( data )
|
|
bytes[offset++] = readb ( &intf->rsp[idx] );
|
|
}
|
|
if ( data )
|
|
DBGCP_HDA ( intf, MASK_XENSTORE_IDX ( cons - len ), data, len );
|
|
|
|
/* Update consumer counter */
|
|
writel ( cons, &intf->rsp_cons );
|
|
wmb();
|
|
}
|
|
|
|
/**
|
|
* Send XenStore request
|
|
*
|
|
* @v xen Xen hypervisor
|
|
* @v type Message type
|
|
* @v req_id Request ID
|
|
* @v value Value, or NULL to omit
|
|
* @v key Key path components
|
|
* @ret rc Return status code
|
|
*/
|
|
static int xenstore_request ( struct xen_hypervisor *xen,
|
|
enum xsd_sockmsg_type type, uint32_t req_id,
|
|
const char *value, va_list key ) {
|
|
struct xsd_sockmsg msg;
|
|
struct evtchn_send event;
|
|
const char *string;
|
|
va_list tmp;
|
|
int xenrc;
|
|
int rc;
|
|
|
|
/* Construct message header */
|
|
msg.type = type;
|
|
msg.req_id = req_id;
|
|
msg.tx_id = 0;
|
|
msg.len = 0;
|
|
DBGC2 ( xen, "XENSTORE request ID %d type %d ", req_id, type );
|
|
|
|
/* Calculate total length */
|
|
va_copy ( tmp, key );
|
|
while ( ( string = va_arg ( tmp, const char * ) ) != NULL ) {
|
|
DBGC2 ( xen, "%s%s", ( msg.len ? "/" : "" ), string );
|
|
msg.len += ( strlen ( string ) + 1 /* '/' or NUL */ );
|
|
}
|
|
va_end ( tmp );
|
|
if ( value ) {
|
|
DBGC2 ( xen, " = \"%s\"", value );
|
|
msg.len += strlen ( value );
|
|
}
|
|
DBGC2 ( xen, "\n" );
|
|
|
|
/* Send message */
|
|
xenstore_send ( xen, &msg, sizeof ( msg ) );
|
|
string = va_arg ( key, const char * );
|
|
assert ( string != NULL );
|
|
xenstore_send_string ( xen, string );
|
|
while ( ( string = va_arg ( key, const char * ) ) != NULL ) {
|
|
xenstore_send_string ( xen, "/" );
|
|
xenstore_send_string ( xen, string );
|
|
}
|
|
xenstore_send ( xen, "", 1 ); /* Separating NUL */
|
|
if ( value )
|
|
xenstore_send_string ( xen, value );
|
|
|
|
/* Notify the back end */
|
|
event.port = xen->store.port;
|
|
if ( ( xenrc = xenevent_send ( xen, &event ) ) != 0 ) {
|
|
rc = -EXEN ( xenrc );
|
|
DBGC ( xen, "XENSTORE could not notify back end: %s\n",
|
|
strerror ( rc ) );
|
|
return rc;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Receive XenStore response
|
|
*
|
|
* @v xen Xen hypervisor
|
|
* @v req_id Request ID
|
|
* @v value Value to fill in
|
|
* @v len Length to fill in
|
|
* @ret rc Return status code
|
|
*
|
|
* The caller is responsible for eventually calling free() on the
|
|
* returned value. Note that the value may comprise multiple
|
|
* NUL-terminated strings concatenated together. A terminating NUL
|
|
* will always be appended to the returned value.
|
|
*/
|
|
static int xenstore_response ( struct xen_hypervisor *xen, uint32_t req_id,
|
|
char **value, size_t *len ) {
|
|
struct xsd_sockmsg msg;
|
|
char *string;
|
|
int rc;
|
|
|
|
/* Wait for response to become available */
|
|
while ( ! xenevent_pending ( xen, xen->store.port ) )
|
|
cpu_nap();
|
|
|
|
/* Receive message header */
|
|
xenstore_recv ( xen, &msg, sizeof ( msg ) );
|
|
*len = msg.len;
|
|
|
|
/* Allocate space for response */
|
|
*value = zalloc ( msg.len + 1 /* terminating NUL */ );
|
|
|
|
/* Receive data. Do this even if allocation failed, or if the
|
|
* request ID was incorrect, to avoid leaving data in the
|
|
* ring.
|
|
*/
|
|
xenstore_recv ( xen, *value, msg.len );
|
|
|
|
/* Validate request ID */
|
|
if ( msg.req_id != req_id ) {
|
|
DBGC ( xen, "XENSTORE response ID mismatch (got %d, expected "
|
|
"%d)\n", msg.req_id, req_id );
|
|
rc = -EPROTO;
|
|
goto err_req_id;
|
|
}
|
|
|
|
/* Check for allocation failure */
|
|
if ( ! *value ) {
|
|
DBGC ( xen, "XENSTORE could not allocate %d bytes for "
|
|
"response\n", msg.len );
|
|
rc = -ENOMEM;
|
|
goto err_alloc;
|
|
}
|
|
|
|
/* Check for explicit errors */
|
|
if ( msg.type == XS_ERROR ) {
|
|
DBGC ( xen, "XENSTORE response error \"%s\"\n", *value );
|
|
rc = -EIO;
|
|
goto err_explicit;
|
|
}
|
|
|
|
DBGC2 ( xen, "XENSTORE response ID %d\n", req_id );
|
|
if ( DBG_EXTRA ) {
|
|
for ( string = *value ; string < ( *value + msg.len ) ;
|
|
string += ( strlen ( string ) + 1 /* NUL */ ) ) {
|
|
DBGC2 ( xen, " - \"%s\"\n", string );
|
|
}
|
|
}
|
|
return 0;
|
|
|
|
err_explicit:
|
|
err_alloc:
|
|
err_req_id:
|
|
free ( *value );
|
|
*value = NULL;
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* Issue a XenStore message
|
|
*
|
|
* @v xen Xen hypervisor
|
|
* @v type Message type
|
|
* @v response Response value to fill in, or NULL to discard
|
|
* @v len Response length to fill in, or NULL to ignore
|
|
* @v request Request value, or NULL to omit
|
|
* @v key Key path components
|
|
* @ret rc Return status code
|
|
*/
|
|
static int xenstore_message ( struct xen_hypervisor *xen,
|
|
enum xsd_sockmsg_type type, char **response,
|
|
size_t *len, const char *request, va_list key ) {
|
|
char *response_value;
|
|
size_t response_len;
|
|
int rc;
|
|
|
|
/* Send request */
|
|
if ( ( rc = xenstore_request ( xen, type, ++xenstore_req_id,
|
|
request, key ) ) != 0 )
|
|
return rc;
|
|
|
|
/* Receive response */
|
|
if ( ( rc = xenstore_response ( xen, xenstore_req_id, &response_value,
|
|
&response_len ) ) != 0 )
|
|
return rc;
|
|
|
|
/* Return response, if applicable */
|
|
if ( response ) {
|
|
*response = response_value;
|
|
} else {
|
|
free ( response_value );
|
|
}
|
|
if ( len )
|
|
*len = response_len;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Read XenStore value
|
|
*
|
|
* @v xen Xen hypervisor
|
|
* @v value Value to fill in
|
|
* @v key Key path components
|
|
* @ret rc Return status code
|
|
*
|
|
* On a successful return, the caller is responsible for calling
|
|
* free() on the returned value.
|
|
*/
|
|
static int xenstore_vread ( struct xen_hypervisor *xen, char **value,
|
|
va_list key ) {
|
|
|
|
return xenstore_message ( xen, XS_READ, value, NULL, NULL, key );
|
|
}
|
|
|
|
/**
|
|
* Read XenStore value
|
|
*
|
|
* @v xen Xen hypervisor
|
|
* @v value Value to fill in
|
|
* @v ... Key path components
|
|
* @ret rc Return status code
|
|
*
|
|
* On a successful return, the caller is responsible for calling
|
|
* free() on the returned value.
|
|
*/
|
|
__attribute__ (( sentinel )) int
|
|
xenstore_read ( struct xen_hypervisor *xen, char **value, ... ) {
|
|
va_list key;
|
|
int rc;
|
|
|
|
va_start ( key, value );
|
|
rc = xenstore_vread ( xen, value, key );
|
|
va_end ( key );
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* Read XenStore numeric value
|
|
*
|
|
* @v xen Xen hypervisor
|
|
* @v num Numeric value to fill in
|
|
* @v ... Key path components
|
|
* @ret rc Return status code
|
|
*/
|
|
__attribute__ (( sentinel )) int
|
|
xenstore_read_num ( struct xen_hypervisor *xen, unsigned long *num, ... ) {
|
|
va_list key;
|
|
char *value;
|
|
char *endp;
|
|
int rc;
|
|
|
|
/* Try to read text value */
|
|
va_start ( key, num );
|
|
rc = xenstore_vread ( xen, &value, key );
|
|
va_end ( key );
|
|
if ( rc != 0 )
|
|
goto err_read;
|
|
|
|
/* Try to parse as numeric value */
|
|
*num = strtoul ( value, &endp, 10 );
|
|
if ( ( *value == '\0' ) || ( *endp != '\0' ) ) {
|
|
DBGC ( xen, "XENSTORE found invalid numeric value \"%s\"\n",
|
|
value );
|
|
rc = -EINVAL;
|
|
goto err_strtoul;
|
|
}
|
|
|
|
err_strtoul:
|
|
free ( value );
|
|
err_read:
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* Write XenStore value
|
|
*
|
|
* @v xen Xen hypervisor
|
|
* @v value Value
|
|
* @v key Key path components
|
|
* @ret rc Return status code
|
|
*/
|
|
static int xenstore_vwrite ( struct xen_hypervisor *xen, const char *value,
|
|
va_list key ) {
|
|
|
|
return xenstore_message ( xen, XS_WRITE, NULL, NULL, value, key );
|
|
}
|
|
|
|
/**
|
|
* Write XenStore value
|
|
*
|
|
* @v xen Xen hypervisor
|
|
* @v value Value
|
|
* @v ... Key path components
|
|
* @ret rc Return status code
|
|
*/
|
|
__attribute__ (( sentinel )) int
|
|
xenstore_write ( struct xen_hypervisor *xen, const char *value, ... ) {
|
|
va_list key;
|
|
int rc;
|
|
|
|
va_start ( key, value );
|
|
rc = xenstore_vwrite ( xen, value, key );
|
|
va_end ( key );
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* Write XenStore numeric value
|
|
*
|
|
* @v xen Xen hypervisor
|
|
* @v num Numeric value
|
|
* @v ... Key path components
|
|
* @ret rc Return status code
|
|
*/
|
|
__attribute__ (( sentinel )) int
|
|
xenstore_write_num ( struct xen_hypervisor *xen, unsigned long num, ... ) {
|
|
char value[ 21 /* "18446744073709551615" + NUL */ ];
|
|
va_list key;
|
|
int rc;
|
|
|
|
/* Construct value */
|
|
snprintf ( value, sizeof ( value ), "%ld", num );
|
|
|
|
/* Write value */
|
|
va_start ( key, num );
|
|
rc = xenstore_vwrite ( xen, value, key );
|
|
va_end ( key );
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* Delete XenStore value
|
|
*
|
|
* @v xen Xen hypervisor
|
|
* @v ... Key path components
|
|
* @ret rc Return status code
|
|
*/
|
|
__attribute__ (( sentinel )) int
|
|
xenstore_rm ( struct xen_hypervisor *xen, ... ) {
|
|
va_list key;
|
|
int rc;
|
|
|
|
va_start ( key, xen );
|
|
rc = xenstore_message ( xen, XS_RM, NULL, NULL, NULL, key );
|
|
va_end ( key );
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* Read XenStore directory
|
|
*
|
|
* @v xen Xen hypervisor
|
|
* @v children Child key names to fill in
|
|
* @v len Length of child key names to fill in
|
|
* @v ... Key path components
|
|
* @ret rc Return status code
|
|
*/
|
|
__attribute__ (( sentinel )) int
|
|
xenstore_directory ( struct xen_hypervisor *xen, char **children, size_t *len,
|
|
... ) {
|
|
va_list key;
|
|
int rc;
|
|
|
|
va_start ( key, len );
|
|
rc = xenstore_message ( xen, XS_DIRECTORY, children, len, NULL, key );
|
|
va_end ( key );
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* Dump XenStore directory contents (for debugging)
|
|
*
|
|
* @v xen Xen hypervisor
|
|
* @v key Key
|
|
*/
|
|
void xenstore_dump ( struct xen_hypervisor *xen, const char *key ) {
|
|
char *value;
|
|
char *children;
|
|
char *child;
|
|
char *child_key;
|
|
size_t len;
|
|
int rc;
|
|
|
|
/* Try to dump current key as a value */
|
|
if ( ( rc = xenstore_read ( xen, &value, key, NULL ) ) == 0 ) {
|
|
DBGC ( xen, "%s = \"%s\"\n", key, value );
|
|
free ( value );
|
|
}
|
|
|
|
/* Try to recurse into each child in turn */
|
|
if ( ( rc = xenstore_directory ( xen, &children, &len, key,
|
|
NULL ) ) == 0 ) {
|
|
for ( child = children ; child < ( children + len ) ;
|
|
child += ( strlen ( child ) + 1 /* NUL */ ) ) {
|
|
|
|
/* Construct child key */
|
|
if ( asprintf ( &child_key, "%s/%s", key, child ) < 0 ){
|
|
DBGC ( xen, "XENSTORE could not allocate child "
|
|
"key \"%s/%s\"\n", key, child );
|
|
rc = -ENOMEM;
|
|
break;
|
|
}
|
|
|
|
/* Recurse into child key, continuing on error */
|
|
xenstore_dump ( xen, child_key );
|
|
free ( child_key );
|
|
}
|
|
free ( children );
|
|
}
|
|
}
|