Files
ipxe/src/interface/xen/xenstore.c
T
Michael Brown 211529a7fe [xen] Wait for and clear XenStore event before receiving data
Older, out-of-tree Xen kernel modules (such as those provided with
SuSE Linux Enterprise Server 11) do not clear the leftover "event
pending" bit when opening an event channel.  Consequently, no event is
ever delivered to indicate that there is information in the XenStore
ring buffer, and the system hangs shortly after loading the
xen-platform-pci kernel module.

Work around this problem by always waiting for the XenStore event
channel to be signalled, and clearing the event before processing the
received data.

Signed-off-by: Michael Brown <mcb30@ipxe.org>
2015-06-30 17:18:51 +01:00

556 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 */
asprintf ( &child_key, "%s/%s", key, child );
if ( ! child_key ) {
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 );
}
}