src/interface/xen/xenbus.c - ipxe - Git at Google

 /*
  * 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 <stdio.h>
 #include <errno.h>
 #include <ipxe/malloc.h>
 #include <ipxe/device.h>
 #include <ipxe/timer.h>
 #include <ipxe/nap.h>
 #include <ipxe/xen.h>
 #include <ipxe/xenstore.h>
 #include <ipxe/xenbus.h>

 /** @file
  *
  * Xen device bus
  *
  */

 /* Disambiguate the various error causes */
 #define ETIMEDOUT_UNKNOWN						\
 	__einfo_error ( EINFO_ETIMEDOUT_UNKNOWN )
 #define EINFO_ETIMEDOUT_UNKNOWN						\
 	__einfo_uniqify ( EINFO_ETIMEDOUT, XenbusStateUnknown,		\
 			  "Unknown" )
 #define ETIMEDOUT_INITIALISING						\
 	__einfo_error ( EINFO_ETIMEDOUT_INITIALISING )
 #define EINFO_ETIMEDOUT_INITIALISING					\
 	__einfo_uniqify ( EINFO_ETIMEDOUT, XenbusStateInitialising,	\
 			  "Initialising" )
 #define ETIMEDOUT_INITWAIT						\
 	__einfo_error ( EINFO_ETIMEDOUT_INITWAIT )
 #define EINFO_ETIMEDOUT_INITWAIT					\
 	__einfo_uniqify ( EINFO_ETIMEDOUT, XenbusStateInitWait,		\
 			  "InitWait" )
 #define ETIMEDOUT_INITIALISED						\
 	__einfo_error ( EINFO_ETIMEDOUT_INITIALISED )
 #define EINFO_ETIMEDOUT_INITIALISED					\
 	__einfo_uniqify ( EINFO_ETIMEDOUT, XenbusStateInitialised,	\
 			  "Initialised" )
 #define ETIMEDOUT_CONNECTED						\
 	__einfo_error ( EINFO_ETIMEDOUT_CONNECTED )
 #define EINFO_ETIMEDOUT_CONNECTED					\
 	__einfo_uniqify ( EINFO_ETIMEDOUT, XenbusStateConnected,	\
 			  "Connected" )
 #define ETIMEDOUT_CLOSING						\
 	__einfo_error ( EINFO_ETIMEDOUT_CLOSING )
 #define EINFO_ETIMEDOUT_CLOSING						\
 	__einfo_uniqify ( EINFO_ETIMEDOUT, XenbusStateClosing,		\
 			  "Closing" )
 #define ETIMEDOUT_CLOSED						\
 	__einfo_error ( EINFO_ETIMEDOUT_CLOSED )
 #define EINFO_ETIMEDOUT_CLOSED						\
 	__einfo_uniqify ( EINFO_ETIMEDOUT, XenbusStateClosed,		\
 			  "Closed" )
 #define ETIMEDOUT_RECONFIGURING						\
 	__einfo_error ( EINFO_ETIMEDOUT_RECONFIGURING )
 #define EINFO_ETIMEDOUT_RECONFIGURING					\
 	__einfo_uniqify ( EINFO_ETIMEDOUT, XenbusStateReconfiguring,	\
 			  "Reconfiguring" )
 #define ETIMEDOUT_RECONFIGURED						\
 	__einfo_error ( EINFO_ETIMEDOUT_RECONFIGURED )
 #define EINFO_ETIMEDOUT_RECONFIGURED					\
 	__einfo_uniqify ( EINFO_ETIMEDOUT, XenbusStateReconfigured,	\
 			  "Reconfigured" )
 #define ETIMEDOUT_STATE( state )					\
 	EUNIQ ( EINFO_ETIMEDOUT, (state), ETIMEDOUT_UNKNOWN,		\
 		ETIMEDOUT_INITIALISING, ETIMEDOUT_INITWAIT,		\
 		ETIMEDOUT_INITIALISED, ETIMEDOUT_CONNECTED,		\
 		ETIMEDOUT_CLOSING, ETIMEDOUT_CLOSED,			\
 		ETIMEDOUT_RECONFIGURING, ETIMEDOUT_RECONFIGURED )

 /** Maximum time to wait for backend to reach a given state, in ticks */
 #define XENBUS_BACKEND_TIMEOUT ( 5 * TICKS_PER_SEC )

 /**
  * Set device state
  *
  * @v xendev		Xen device
  * @v state		New state
  * @ret rc		Return status code
  */
 int xenbus_set_state ( struct xen_device *xendev, int state ) {
 	int rc;

 	/* Attempt to set state */
 	if ( ( rc = xenstore_write_num ( xendev->xen, state, xendev->key,
 					 "state", NULL ) ) != 0 ) {
 		DBGC ( xendev, "XENBUS %s could not set state=\"%d\": %s\n",
 		       xendev->key, state, strerror ( rc ) );
 		return rc;
 	}

 	return 0;
 }

 /**
  * Get backend state
  *
  * @v xendev		Xen device
  * @ret state		Backend state, or negative error
  */
 int xenbus_backend_state ( struct xen_device *xendev ) {
 	unsigned long state;
 	int rc;

 	/* Attempt to get backend state */
 	if ( ( rc = xenstore_read_num ( xendev->xen, &state, xendev->backend,
 					"state", NULL ) ) != 0 ) {
 		DBGC ( xendev, "XENBUS %s could not read %s/state: %s\n",
 		       xendev->key, xendev->backend, strerror ( rc ) );
 		return rc;
 	}

 	return state;
 }

 /**
  * Wait for backend to reach a given state
  *
  * @v xendev		Xen device
  * @v state		Desired backend state
  * @ret rc		Return status code
  */
 int xenbus_backend_wait ( struct xen_device *xendev, int state ) {
 	unsigned long started = currticks();
 	unsigned long elapsed;
 	unsigned int attempts = 0;
 	int current_state;
 	int rc;

 	/* Wait for backend to reach this state */
 	do {

 		/* Get current backend state */
 		current_state = xenbus_backend_state ( xendev );
 		if ( current_state < 0 ) {
 			rc = current_state;
 			return rc;
 		}
 		if ( current_state == state )
 			return 0;

 		/* Allow time for backend to react */
 		cpu_nap();

 		/* XenStore is a very slow interface; any fixed delay
 		 * time would be dwarfed by the XenStore access time.
 		 * We therefore use wall clock to time out this
 		 * operation.
 		 */
 		elapsed = ( currticks() - started );
 		attempts++;

 	} while ( elapsed < XENBUS_BACKEND_TIMEOUT );

 	/* Construct status code from current backend state */
 	rc = -ETIMEDOUT_STATE ( current_state );
 	DBGC ( xendev, "XENBUS %s timed out after %d attempts waiting for "
 	       "%s/state=\"%d\": %s\n", xendev->key, attempts, xendev->backend,
 	       state, strerror ( rc ) );

 	return rc;
 }

 /**
  * Find driver for Xen device
  *
  * @v type		Device type
  * @ret driver		Driver, or NULL
  */
 static struct xen_driver * xenbus_find_driver ( const char *type ) {
 	struct xen_driver *xendrv;

 	for_each_table_entry ( xendrv, XEN_DRIVERS ) {
 		if ( strcmp ( xendrv->type, type ) == 0 )
 			return xendrv;
 	}
 	return NULL;
 }

 /**
  * Probe Xen device
  *
  * @v xen		Xen hypervisor
  * @v parent		Parent device
  * @v instance		Device instance
  * @v driver		Device driver
  * @ret rc		Return status code
  */
 static int xenbus_probe_device ( struct xen_hypervisor *xen,
 				 struct device *parent, const char *instance,
 				 struct xen_driver *driver ) {
 	const char *type = driver->type;
 	struct xen_device *xendev;
 	size_t key_len;
 	int rc;

 	/* Allocate and initialise structure */
 	key_len = ( 7 /* "device/" */ + strlen ( type ) + 1 /* "/" */ +
 		    strlen ( instance ) + 1 /* NUL */ );
 	xendev = zalloc ( sizeof ( *xendev ) + key_len );
 	if ( ! xendev ) {
 		rc = -ENOMEM;
 		goto err_alloc;
 	}
 	snprintf ( xendev->dev.name, sizeof ( xendev->dev.name ), "%s/%s",
 		   type, instance );
 	xendev->dev.desc.bus_type = BUS_TYPE_XEN;
 	INIT_LIST_HEAD ( &xendev->dev.children );
 	list_add_tail ( &xendev->dev.siblings, &parent->children );
 	xendev->dev.parent = parent;
 	xendev->xen = xen;
 	xendev->key = ( ( void * ) ( xendev + 1 ) );
 	snprintf ( xendev->key, key_len, "device/%s/%s", type, instance );
 	xendev->driver = driver;
 	xendev->dev.driver_name = driver->name;
 	DBGC ( xendev, "XENBUS %s has driver \"%s\"\n", xendev->key,
 	       xendev->driver->name );

 	/* Read backend key */
 	if ( ( rc = xenstore_read ( xen, &xendev->backend, xendev->key,
 				    "backend", NULL ) ) != 0 ) {
 		DBGC ( xendev, "XENBUS %s could not read backend: %s\n",
 		       xendev->key, strerror ( rc ) );
 		goto err_read_backend;
 	}

 	/* Read backend domain ID */
 	if ( ( rc = xenstore_read_num ( xen, &xendev->backend_id, xendev->key,
 					"backend-id", NULL ) ) != 0 ) {
 		DBGC ( xendev, "XENBUS %s could not read backend-id: %s\n",
 		       xendev->key, strerror ( rc ) );
 		goto err_read_backend_id;
 	}
 	DBGC ( xendev, "XENBUS %s backend=\"%s\" in domain %ld\n",
 	       xendev->key, xendev->backend, xendev->backend_id );

 	/* Probe driver */
 	if ( ( rc = xendev->driver->probe ( xendev ) ) != 0 ) {
 		DBGC ( xendev, "XENBUS could not probe %s: %s\n",
 		       xendev->key, strerror ( rc ) );
 		goto err_probe;
 	}

 	return 0;

 	xendev->driver->remove ( xendev );
  err_probe:
  err_read_backend_id:
 	free ( xendev->backend );
  err_read_backend:
 	list_del ( &xendev->dev.siblings );
 	free ( xendev );
  err_alloc:
 	return rc;
 }

 /**
  * Remove Xen device
  *
  * @v xendev		Xen device
  */
 static void xenbus_remove_device ( struct xen_device *xendev ) {

 	/* Remove device */
 	xendev->driver->remove ( xendev );
 	free ( xendev->backend );
 	list_del ( &xendev->dev.siblings );
 	free ( xendev );
 }

 /**
  * Probe Xen devices of a given type
  *
  * @v xen		Xen hypervisor
  * @v parent		Parent device
  * @v type		Device type
  * @ret rc		Return status code
  */
 static int xenbus_probe_type ( struct xen_hypervisor *xen,
 			       struct device *parent, const char *type ) {
 	struct xen_driver *driver;
 	char *children;
 	char *child;
 	size_t len;
 	int rc;

 	/* Look for a driver */
 	driver = xenbus_find_driver ( type );
 	if ( ! driver ) {
 		DBGC ( xen, "XENBUS has no driver for \"%s\" devices\n", type );
 		/* Not a fatal error */
 		rc = 0;
 		goto err_no_driver;
 	}

 	/* Get children of this key */
 	if ( ( rc = xenstore_directory ( xen, &children, &len, "device",
 					 type, NULL ) ) != 0 ) {
 		DBGC ( xen, "XENBUS could not list \"%s\" devices: %s\n",
 		       type, strerror ( rc ) );
 		goto err_directory;
 	}

 	/* Probe each child */
 	for ( child = children ; child < ( children + len ) ;
 	      child += ( strlen ( child ) + 1 /* NUL */ ) ) {
 		if ( ( rc = xenbus_probe_device ( xen, parent, child,
 						  driver ) ) != 0 )
 			goto err_probe_device;
 	}

 	free ( children );
 	return 0;

  err_probe_device:
 	free ( children );
  err_directory:
  err_no_driver:
 	return rc;
 }

 /**
  * Probe Xen bus
  *
  * @v xen		Xen hypervisor
  * @v parent		Parent device
  * @ret rc		Return status code
  */
 int xenbus_probe ( struct xen_hypervisor *xen, struct device *parent ) {
 	char *types;
 	char *type;
 	size_t len;
 	int rc;

 	/* Get children of "device" key */
 	if ( ( rc = xenstore_directory ( xen, &types, &len, "device",
 					 NULL ) ) != 0 ) {
 		DBGC ( xen, "XENBUS could not list device types: %s\n",
 		       strerror ( rc ) );
 		goto err_directory;
 	}

 	/* Probe each child type */
 	for ( type = types ; type < ( types + len ) ;
 	      type += ( strlen ( type ) + 1 /* NUL */ ) ) {
 		if ( ( rc = xenbus_probe_type ( xen, parent, type ) ) != 0 )
 			goto err_probe_type;
 	}

 	free ( types );
 	return 0;

 	xenbus_remove ( xen, parent );
  err_probe_type:
 	free ( types );
  err_directory:
 	return rc;
 }

 /**
  * Remove Xen bus
  *
  * @v xen		Xen hypervisor
  * @v parent		Parent device
  */
 void xenbus_remove ( struct xen_hypervisor *xen __unused,
 		     struct device *parent ) {
 	struct xen_device *xendev;
 	struct xen_device *tmp;

 	/* Remove devices */
 	list_for_each_entry_safe ( xendev, tmp, &parent->children,
 				   dev.siblings ) {
 		xenbus_remove_device ( xendev );
 	}
 }
	/*
	* 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 <stdio.h>
	#include <errno.h>
	#include <ipxe/malloc.h>
	#include <ipxe/device.h>
	#include <ipxe/timer.h>
	#include <ipxe/nap.h>
	#include <ipxe/xen.h>
	#include <ipxe/xenstore.h>
	#include <ipxe/xenbus.h>

	/** @file
	*
	* Xen device bus
	*
	*/

	/* Disambiguate the various error causes */
	#define ETIMEDOUT_UNKNOWN \
	__einfo_error ( EINFO_ETIMEDOUT_UNKNOWN )
	#define EINFO_ETIMEDOUT_UNKNOWN \
	__einfo_uniqify ( EINFO_ETIMEDOUT, XenbusStateUnknown, \
	"Unknown" )
	#define ETIMEDOUT_INITIALISING \
	__einfo_error ( EINFO_ETIMEDOUT_INITIALISING )
	#define EINFO_ETIMEDOUT_INITIALISING \
	__einfo_uniqify ( EINFO_ETIMEDOUT, XenbusStateInitialising, \
	"Initialising" )
	#define ETIMEDOUT_INITWAIT \
	__einfo_error ( EINFO_ETIMEDOUT_INITWAIT )
	#define EINFO_ETIMEDOUT_INITWAIT \
	__einfo_uniqify ( EINFO_ETIMEDOUT, XenbusStateInitWait, \
	"InitWait" )
	#define ETIMEDOUT_INITIALISED \
	__einfo_error ( EINFO_ETIMEDOUT_INITIALISED )
	#define EINFO_ETIMEDOUT_INITIALISED \
	__einfo_uniqify ( EINFO_ETIMEDOUT, XenbusStateInitialised, \
	"Initialised" )
	#define ETIMEDOUT_CONNECTED \
	__einfo_error ( EINFO_ETIMEDOUT_CONNECTED )
	#define EINFO_ETIMEDOUT_CONNECTED \
	__einfo_uniqify ( EINFO_ETIMEDOUT, XenbusStateConnected, \
	"Connected" )
	#define ETIMEDOUT_CLOSING \
	__einfo_error ( EINFO_ETIMEDOUT_CLOSING )
	#define EINFO_ETIMEDOUT_CLOSING \
	__einfo_uniqify ( EINFO_ETIMEDOUT, XenbusStateClosing, \
	"Closing" )
	#define ETIMEDOUT_CLOSED \
	__einfo_error ( EINFO_ETIMEDOUT_CLOSED )
	#define EINFO_ETIMEDOUT_CLOSED \
	__einfo_uniqify ( EINFO_ETIMEDOUT, XenbusStateClosed, \
	"Closed" )
	#define ETIMEDOUT_RECONFIGURING \
	__einfo_error ( EINFO_ETIMEDOUT_RECONFIGURING )
	#define EINFO_ETIMEDOUT_RECONFIGURING \
	__einfo_uniqify ( EINFO_ETIMEDOUT, XenbusStateReconfiguring, \
	"Reconfiguring" )
	#define ETIMEDOUT_RECONFIGURED \
	__einfo_error ( EINFO_ETIMEDOUT_RECONFIGURED )
	#define EINFO_ETIMEDOUT_RECONFIGURED \
	__einfo_uniqify ( EINFO_ETIMEDOUT, XenbusStateReconfigured, \
	"Reconfigured" )
	#define ETIMEDOUT_STATE( state ) \
	EUNIQ ( EINFO_ETIMEDOUT, (state), ETIMEDOUT_UNKNOWN, \
	ETIMEDOUT_INITIALISING, ETIMEDOUT_INITWAIT, \
	ETIMEDOUT_INITIALISED, ETIMEDOUT_CONNECTED, \
	ETIMEDOUT_CLOSING, ETIMEDOUT_CLOSED, \
	ETIMEDOUT_RECONFIGURING, ETIMEDOUT_RECONFIGURED )

	/** Maximum time to wait for backend to reach a given state, in ticks */
	#define XENBUS_BACKEND_TIMEOUT ( 5 * TICKS_PER_SEC )

	/**
	* Set device state
	*
	* @v xendev Xen device
	* @v state New state
	* @ret rc Return status code
	*/
	int xenbus_set_state ( struct xen_device *xendev, int state ) {
	int rc;

	/* Attempt to set state */
	if ( ( rc = xenstore_write_num ( xendev->xen, state, xendev->key,
	"state", NULL ) ) != 0 ) {
	DBGC ( xendev, "XENBUS %s could not set state=\"%d\": %s\n",
	xendev->key, state, strerror ( rc ) );
	return rc;
	}

	return 0;
	}

	/**
	* Get backend state
	*
	* @v xendev Xen device
	* @ret state Backend state, or negative error
	*/
	int xenbus_backend_state ( struct xen_device *xendev ) {
	unsigned long state;
	int rc;

	/* Attempt to get backend state */
	if ( ( rc = xenstore_read_num ( xendev->xen, &state, xendev->backend,
	"state", NULL ) ) != 0 ) {
	DBGC ( xendev, "XENBUS %s could not read %s/state: %s\n",
	xendev->key, xendev->backend, strerror ( rc ) );
	return rc;
	}

	return state;
	}

	/**
	* Wait for backend to reach a given state
	*
	* @v xendev Xen device
	* @v state Desired backend state
	* @ret rc Return status code
	*/
	int xenbus_backend_wait ( struct xen_device *xendev, int state ) {
	unsigned long started = currticks();
	unsigned long elapsed;
	unsigned int attempts = 0;
	int current_state;
	int rc;

	/* Wait for backend to reach this state */
	do {

	/* Get current backend state */
	current_state = xenbus_backend_state ( xendev );
	if ( current_state < 0 ) {
	rc = current_state;
	return rc;
	}
	if ( current_state == state )
	return 0;

	/* Allow time for backend to react */
	cpu_nap();

	/* XenStore is a very slow interface; any fixed delay
	* time would be dwarfed by the XenStore access time.
	* We therefore use wall clock to time out this
	* operation.
	*/
	elapsed = ( currticks() - started );
	attempts++;

	} while ( elapsed < XENBUS_BACKEND_TIMEOUT );

	/* Construct status code from current backend state */
	rc = -ETIMEDOUT_STATE ( current_state );
	DBGC ( xendev, "XENBUS %s timed out after %d attempts waiting for "
	"%s/state=\"%d\": %s\n", xendev->key, attempts, xendev->backend,
	state, strerror ( rc ) );

	return rc;
	}

	/**
	* Find driver for Xen device
	*
	* @v type Device type
	* @ret driver Driver, or NULL
	*/
	static struct xen_driver * xenbus_find_driver ( const char *type ) {
	struct xen_driver *xendrv;

	for_each_table_entry ( xendrv, XEN_DRIVERS ) {
	if ( strcmp ( xendrv->type, type ) == 0 )
	return xendrv;
	}
	return NULL;
	}

	/**
	* Probe Xen device
	*
	* @v xen Xen hypervisor
	* @v parent Parent device
	* @v instance Device instance
	* @v driver Device driver
	* @ret rc Return status code
	*/
	static int xenbus_probe_device ( struct xen_hypervisor *xen,
	struct device parent, const char instance,
	struct xen_driver *driver ) {
	const char *type = driver->type;
	struct xen_device *xendev;
	size_t key_len;
	int rc;

	/* Allocate and initialise structure */
	key_len = ( 7 /* "device/" / + strlen ( type ) + 1 / "/" */ +
	strlen ( instance ) + 1 /* NUL */ );
	xendev = zalloc ( sizeof ( *xendev ) + key_len );
	if ( ! xendev ) {
	rc = -ENOMEM;
	goto err_alloc;
	}
	snprintf ( xendev->dev.name, sizeof ( xendev->dev.name ), "%s/%s",
	type, instance );
	xendev->dev.desc.bus_type = BUS_TYPE_XEN;
	INIT_LIST_HEAD ( &xendev->dev.children );
	list_add_tail ( &xendev->dev.siblings, &parent->children );
	xendev->dev.parent = parent;
	xendev->xen = xen;
	xendev->key = ( ( void * ) ( xendev + 1 ) );
	snprintf ( xendev->key, key_len, "device/%s/%s", type, instance );
	xendev->driver = driver;
	xendev->dev.driver_name = driver->name;
	DBGC ( xendev, "XENBUS %s has driver \"%s\"\n", xendev->key,
	xendev->driver->name );

	/* Read backend key */
	if ( ( rc = xenstore_read ( xen, &xendev->backend, xendev->key,
	"backend", NULL ) ) != 0 ) {
	DBGC ( xendev, "XENBUS %s could not read backend: %s\n",
	xendev->key, strerror ( rc ) );
	goto err_read_backend;
	}

	/* Read backend domain ID */
	if ( ( rc = xenstore_read_num ( xen, &xendev->backend_id, xendev->key,
	"backend-id", NULL ) ) != 0 ) {
	DBGC ( xendev, "XENBUS %s could not read backend-id: %s\n",
	xendev->key, strerror ( rc ) );
	goto err_read_backend_id;
	}
	DBGC ( xendev, "XENBUS %s backend=\"%s\" in domain %ld\n",
	xendev->key, xendev->backend, xendev->backend_id );

	/* Probe driver */
	if ( ( rc = xendev->driver->probe ( xendev ) ) != 0 ) {
	DBGC ( xendev, "XENBUS could not probe %s: %s\n",
	xendev->key, strerror ( rc ) );
	goto err_probe;
	}

	return 0;

	xendev->driver->remove ( xendev );
	err_probe:
	err_read_backend_id:
	free ( xendev->backend );
	err_read_backend:
	list_del ( &xendev->dev.siblings );
	free ( xendev );
	err_alloc:
	return rc;
	}

	/**
	* Remove Xen device
	*
	* @v xendev Xen device
	*/
	static void xenbus_remove_device ( struct xen_device *xendev ) {

	/* Remove device */
	xendev->driver->remove ( xendev );
	free ( xendev->backend );
	list_del ( &xendev->dev.siblings );
	free ( xendev );
	}

	/**
	* Probe Xen devices of a given type
	*
	* @v xen Xen hypervisor
	* @v parent Parent device
	* @v type Device type
	* @ret rc Return status code
	*/
	static int xenbus_probe_type ( struct xen_hypervisor *xen,
	struct device parent, const char type ) {
	struct xen_driver *driver;
	char *children;
	char *child;
	size_t len;
	int rc;

	/* Look for a driver */
	driver = xenbus_find_driver ( type );
	if ( ! driver ) {
	DBGC ( xen, "XENBUS has no driver for \"%s\" devices\n", type );
	/* Not a fatal error */
	rc = 0;
	goto err_no_driver;
	}

	/* Get children of this key */
	if ( ( rc = xenstore_directory ( xen, &children, &len, "device",
	type, NULL ) ) != 0 ) {
	DBGC ( xen, "XENBUS could not list \"%s\" devices: %s\n",
	type, strerror ( rc ) );
	goto err_directory;
	}

	/* Probe each child */
	for ( child = children ; child < ( children + len ) ;
	child += ( strlen ( child ) + 1 /* NUL */ ) ) {
	if ( ( rc = xenbus_probe_device ( xen, parent, child,
	driver ) ) != 0 )
	goto err_probe_device;
	}

	free ( children );
	return 0;

	err_probe_device:
	free ( children );
	err_directory:
	err_no_driver:
	return rc;
	}

	/**
	* Probe Xen bus
	*
	* @v xen Xen hypervisor
	* @v parent Parent device
	* @ret rc Return status code
	*/
	int xenbus_probe ( struct xen_hypervisor xen, struct device parent ) {
	char *types;
	char *type;
	size_t len;
	int rc;

	/* Get children of "device" key */
	if ( ( rc = xenstore_directory ( xen, &types, &len, "device",
	NULL ) ) != 0 ) {
	DBGC ( xen, "XENBUS could not list device types: %s\n",
	strerror ( rc ) );
	goto err_directory;
	}

	/* Probe each child type */
	for ( type = types ; type < ( types + len ) ;
	type += ( strlen ( type ) + 1 /* NUL */ ) ) {
	if ( ( rc = xenbus_probe_type ( xen, parent, type ) ) != 0 )
	goto err_probe_type;
	}

	free ( types );
	return 0;

	xenbus_remove ( xen, parent );
	err_probe_type:
	free ( types );
	err_directory:
	return rc;
	}

	/**
	* Remove Xen bus
	*
	* @v xen Xen hypervisor
	* @v parent Parent device
	*/
	void xenbus_remove ( struct xen_hypervisor *xen __unused,
	struct device *parent ) {
	struct xen_device *xendev;
	struct xen_device *tmp;

	/* Remove devices */
	list_for_each_entry_safe ( xendev, tmp, &parent->children,
	dev.siblings ) {
	xenbus_remove_device ( xendev );
	}
	}