[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]

Re: [Libvir] PATCH: 4/7 remote protocol & server impl



This patch defines the remote wire protocol for serializing all the storage API calls.
There are 15 new calls for storage pools, and 9 calls for storage volumes. The style
is following that of the network API calls. The serialization of virStorageVolPtr is
slightly more complicated, because it has to have a nested virStoragePoolPtr serialized
alongside it.


 remote.c                      |  629 ++++++++++++++++++++++++++++++++++++++++++
 remote_dispatch_localvars.h   |   42 ++
 remote_dispatch_proc_switch.h |  201 +++++++++++++
 remote_dispatch_prototypes.h  |   25 +
 remote_protocol.c             |  450 ++++++++++++++++++++++++++++++
 remote_protocol.h             |  367 ++++++++++++++++++++++++
 remote_protocol.x             |  238 +++++++++++++++
 7 files changed, 1951 insertions(+), 1 deletion(-)



diff -r 89d154031d13 qemud/remote.c
--- a/qemud/remote.c	Sat Oct 27 17:52:41 2007 -0400
+++ b/qemud/remote.c	Sat Oct 27 17:52:44 2007 -0400
@@ -57,8 +57,12 @@ static void remoteDispatchError (struct 
                                  const char *fmt, ...);
 static virDomainPtr get_nonnull_domain (virConnectPtr conn, remote_nonnull_domain domain);
 static virNetworkPtr get_nonnull_network (virConnectPtr conn, remote_nonnull_network network);
+static virStoragePoolPtr get_nonnull_storage_pool (virConnectPtr conn, remote_nonnull_storage_pool pool);
+static virStorageVolPtr get_nonnull_storage_vol (virConnectPtr conn, remote_nonnull_storage_vol vol);
 static void make_nonnull_domain (remote_nonnull_domain *dom_dst, virDomainPtr dom_src);
 static void make_nonnull_network (remote_nonnull_network *net_dst, virNetworkPtr net_src);
+static void make_nonnull_storage_pool (remote_nonnull_storage_pool *pool_dst, virStoragePoolPtr pool_src);
+static void make_nonnull_storage_vol (remote_nonnull_storage_vol *vol_dst, virStorageVolPtr vol_src);
 
 #include "remote_dispatch_prototypes.h"
 
@@ -1945,6 +1949,598 @@ remoteDispatchNumOfNetworks (struct qemu
     return 0;
 }
 
+
+/***************************************************************
+ *     STORAGE POOL APIS
+ ***************************************************************/
+
+
+static int
+remoteDispatchListDefinedStoragePools (struct qemud_client *client,
+                                       remote_message_header *req,
+                                       remote_list_defined_storage_pools_args *args,
+                                       remote_list_defined_storage_pools_ret *ret)
+{
+    CHECK_CONN(client);
+
+    if (args->maxnames > REMOTE_NETWORK_NAME_LIST_MAX) {
+        remoteDispatchError (client, req,
+                             "maxnames > REMOTE_NETWORK_NAME_LIST_MAX");
+        return -2;
+    }
+
+    /* Allocate return buffer. */
+    ret->names.names_val = calloc (args->maxnames, sizeof (char *));
+
+    ret->names.names_len =
+        virConnectListDefinedStoragePools (client->conn,
+                                       ret->names.names_val, args->maxnames);
+    if (ret->names.names_len == -1) return -1;
+
+    return 0;
+}
+
+static int
+remoteDispatchListStoragePools (struct qemud_client *client,
+                                remote_message_header *req,
+                                remote_list_storage_pools_args *args,
+                                remote_list_storage_pools_ret *ret)
+{
+    CHECK_CONN(client);
+
+    if (args->maxnames > REMOTE_STORAGE_POOL_NAME_LIST_MAX) {
+        remoteDispatchError (client, req,
+                             "maxnames > REMOTE_STORAGE_POOL_NAME_LIST_MAX");
+        return -2;
+    }
+
+    /* Allocate return buffer. */
+    ret->names.names_val = calloc (args->maxnames, sizeof (char *));
+
+    ret->names.names_len =
+        virConnectListStoragePools (client->conn,
+                                ret->names.names_val, args->maxnames);
+    if (ret->names.names_len == -1) return -1;
+
+    return 0;
+}
+
+static int
+remoteDispatchStoragePoolCreate (struct qemud_client *client,
+                                 remote_message_header *req,
+                                 remote_storage_pool_create_args *args,
+                                 void *ret ATTRIBUTE_UNUSED)
+{
+    virStoragePoolPtr pool;
+    CHECK_CONN(client);
+
+    pool = get_nonnull_storage_pool (client->conn, args->pool);
+    if (pool == NULL) {
+        remoteDispatchError (client, req, "storage_pool not found");
+        return -2;
+    }
+
+    if (virStoragePoolCreate (pool) == -1) {
+        virStoragePoolFree(pool);
+        return -1;
+    }
+    virStoragePoolFree(pool);
+    return 0;
+}
+
+static int
+remoteDispatchStoragePoolCreateXml (struct qemud_client *client,
+                                remote_message_header *req,
+                                remote_storage_pool_create_xml_args *args,
+                                remote_storage_pool_create_xml_ret *ret)
+{
+    virStoragePoolPtr pool;
+    CHECK_CONN(client);
+
+    pool = virStoragePoolCreateXML (client->conn, args->xml);
+    if (pool == NULL) return -1;
+
+    make_nonnull_storage_pool (&ret->pool, pool);
+    virStoragePoolFree(pool);
+    return 0;
+}
+
+static int
+remoteDispatchStoragePoolDefineXml (struct qemud_client *client,
+                                remote_message_header *req,
+                                remote_storage_pool_define_xml_args *args,
+                                remote_storage_pool_define_xml_ret *ret)
+{
+    virStoragePoolPtr pool;
+    CHECK_CONN(client);
+
+    pool = virStoragePoolDefineXML (client->conn, args->xml);
+    if (pool == NULL) return -1;
+
+    make_nonnull_storage_pool (&ret->pool, pool);
+    virStoragePoolFree(pool);
+    return 0;
+}
+
+static int
+remoteDispatchStoragePoolShutdown (struct qemud_client *client,
+                                   remote_message_header *req,
+                                   remote_storage_pool_shutdown_args *args,
+                                   void *ret ATTRIBUTE_UNUSED)
+{
+    virStoragePoolPtr pool;
+    CHECK_CONN(client);
+
+    pool = get_nonnull_storage_pool (client->conn, args->pool);
+    if (pool == NULL) {
+        remoteDispatchError (client, req, "storage_pool not found");
+        return -2;
+    }
+
+    if (virStoragePoolShutdown (pool) == -1) {
+        virStoragePoolFree(pool);
+        return -1;
+    }
+    virStoragePoolFree(pool);
+    return 0;
+}
+
+static int
+remoteDispatchStoragePoolDestroy (struct qemud_client *client,
+                                  remote_message_header *req,
+                                  remote_storage_pool_destroy_args *args,
+                                  void *ret ATTRIBUTE_UNUSED)
+{
+    virStoragePoolPtr pool;
+    CHECK_CONN(client);
+
+    pool = get_nonnull_storage_pool (client->conn, args->pool);
+    if (pool == NULL) {
+        remoteDispatchError (client, req, "storage_pool not found");
+        return -2;
+    }
+
+    if (virStoragePoolDestroy (pool) == -1) {
+        virStoragePoolFree(pool);
+        return -1;
+    }
+    virStoragePoolFree(pool);
+    return 0;
+}
+
+static int
+remoteDispatchStoragePoolGetInfo (struct qemud_client *client,
+                                  remote_message_header *req,
+                                  remote_storage_pool_get_info_args *args,
+                                  remote_storage_pool_get_info_ret *ret)
+{
+    virStoragePoolPtr pool;
+    virStoragePoolInfo info;
+    CHECK_CONN(client);
+
+    pool = get_nonnull_storage_pool (client->conn, args->pool);
+    if (pool == NULL) {
+        remoteDispatchError (client, req, "storage_pool not found");
+        return -2;
+    }
+
+    if (virStoragePoolGetInfo (pool, &info) == -1) {
+        virStoragePoolFree(pool);
+        return -1;
+    }
+
+    ret->state = info.state;
+    ret->allocation = info.allocation;
+    ret->capacity = info.capacity;
+
+    virStoragePoolFree(pool);
+
+    return 0;
+}
+
+static int
+remoteDispatchStoragePoolDumpXml (struct qemud_client *client,
+                              remote_message_header *req,
+                              remote_storage_pool_dump_xml_args *args,
+                              remote_storage_pool_dump_xml_ret *ret)
+{
+    virStoragePoolPtr pool;
+    CHECK_CONN(client);
+
+    pool = get_nonnull_storage_pool (client->conn, args->pool);
+    if (pool == NULL) {
+        remoteDispatchError (client, req, "storage_pool not found");
+        return -2;
+    }
+
+    /* remoteDispatchClientRequest will free this. */
+    ret->xml = virStoragePoolGetXMLDesc (pool, args->flags);
+    if (!ret->xml) {
+        virStoragePoolFree(pool);
+        return -1;
+    }
+    virStoragePoolFree(pool);
+    return 0;
+}
+
+static int
+remoteDispatchStoragePoolGetAutostart (struct qemud_client *client,
+                                   remote_message_header *req,
+                                   remote_storage_pool_get_autostart_args *args,
+                                   remote_storage_pool_get_autostart_ret *ret)
+{
+    virStoragePoolPtr pool;
+    CHECK_CONN(client);
+
+    pool = get_nonnull_storage_pool (client->conn, args->pool);
+    if (pool == NULL) {
+        remoteDispatchError (client, req, "storage_pool not found");
+        return -2;
+    }
+
+    if (virStoragePoolGetAutostart (pool, &ret->autostart) == -1) {
+        virStoragePoolFree(pool);
+        return -1;
+    }
+    virStoragePoolFree(pool);
+    return 0;
+}
+
+
+static int
+remoteDispatchStoragePoolLookupByName (struct qemud_client *client,
+                                       remote_message_header *req,
+                                       remote_storage_pool_lookup_by_name_args *args,
+                                       remote_storage_pool_lookup_by_name_ret *ret)
+{
+    virStoragePoolPtr pool;
+    CHECK_CONN(client);
+
+    pool = virStoragePoolLookupByName (client->conn, args->name);
+    if (pool == NULL) return -1;
+
+    make_nonnull_storage_pool (&ret->pool, pool);
+    virStoragePoolFree(pool);
+    return 0;
+}
+
+static int
+remoteDispatchStoragePoolLookupByUuid (struct qemud_client *client,
+                                   remote_message_header *req,
+                                   remote_storage_pool_lookup_by_uuid_args *args,
+                                   remote_storage_pool_lookup_by_uuid_ret *ret)
+{
+    virStoragePoolPtr pool;
+    CHECK_CONN(client);
+
+    pool = virStoragePoolLookupByUUID (client->conn, (unsigned char *) args->uuid);
+    if (pool == NULL) return -1;
+
+    make_nonnull_storage_pool (&ret->pool, pool);
+    virStoragePoolFree(pool);
+    return 0;
+}
+
+static int
+remoteDispatchStoragePoolSetAutostart (struct qemud_client *client,
+                                   remote_message_header *req,
+                                   remote_storage_pool_set_autostart_args *args,
+                                   void *ret ATTRIBUTE_UNUSED)
+{
+    virStoragePoolPtr pool;
+    CHECK_CONN(client);
+
+    pool = get_nonnull_storage_pool (client->conn, args->pool);
+    if (pool == NULL) {
+        remoteDispatchError (client, req, "storage_pool not found");
+        return -2;
+    }
+
+    if (virStoragePoolSetAutostart (pool, args->autostart) == -1) {
+        virStoragePoolFree(pool);
+        return -1;
+    }
+    virStoragePoolFree(pool);
+    return 0;
+}
+
+static int
+remoteDispatchStoragePoolUndefine (struct qemud_client *client,
+                               remote_message_header *req,
+                               remote_storage_pool_undefine_args *args,
+                               void *ret ATTRIBUTE_UNUSED)
+{
+    virStoragePoolPtr pool;
+    CHECK_CONN(client);
+
+    pool = get_nonnull_storage_pool (client->conn, args->pool);
+    if (pool == NULL) {
+        remoteDispatchError (client, req, "storage_pool not found");
+        return -2;
+    }
+
+    if (virStoragePoolUndefine (pool) == -1) {
+        virStoragePoolFree(pool);
+        return -1;
+    }
+    virStoragePoolFree(pool);
+    return 0;
+}
+
+static int
+remoteDispatchNumOfStoragePools (struct qemud_client *client,
+                                 remote_message_header *req,
+                                 void *args ATTRIBUTE_UNUSED,
+                                 remote_num_of_storage_pools_ret *ret)
+{
+    CHECK_CONN(client);
+
+    ret->num = virConnectNumOfStoragePools (client->conn);
+    if (ret->num == -1) return -1;
+
+    return 0;
+}
+
+static int
+remoteDispatchNumOfDefinedStoragePools (struct qemud_client *client,
+                                        remote_message_header *req,
+                                        void *args ATTRIBUTE_UNUSED,
+                                        remote_num_of_defined_storage_pools_ret *ret)
+{
+    CHECK_CONN(client);
+
+    ret->num = virConnectNumOfDefinedStoragePools (client->conn);
+    if (ret->num == -1) return -1;
+
+    return 0;
+}
+
+
+/***************************************************************
+ *     STORAGE VOL APIS
+ ***************************************************************/
+
+
+static int
+remoteDispatchStoragePoolListVolumes (struct qemud_client *client,
+                                      remote_message_header *req,
+                                      remote_storage_pool_list_volumes_args *args,
+                                      remote_storage_pool_list_volumes_ret *ret)
+{
+    virStoragePoolPtr pool;
+    CHECK_CONN(client);
+
+    if (args->maxnames > REMOTE_STORAGE_VOL_NAME_LIST_MAX) {
+        remoteDispatchError (client, req,
+                             "maxnames > REMOTE_STORAGE_VOL_NAME_LIST_MAX");
+        return -2;
+    }
+
+    pool = get_nonnull_storage_pool (client->conn, args->pool);
+    if (pool == NULL) {
+        remoteDispatchError (client, req, "storage_pool not found");
+        return -2;
+    }
+
+    /* Allocate return buffer. */
+    ret->names.names_val = calloc (args->maxnames, sizeof (char *));
+
+    ret->names.names_len =
+        virStoragePoolListVolumes (pool,
+                                   ret->names.names_val, args->maxnames);
+    virStoragePoolFree(pool);
+    if (ret->names.names_len == -1) return -1;
+
+    return 0;
+}
+
+
+static int
+remoteDispatchStorageVolCreateXml (struct qemud_client *client,
+                                remote_message_header *req,
+                                remote_storage_vol_create_xml_args *args,
+                                remote_storage_vol_create_xml_ret *ret)
+{
+    virStoragePoolPtr pool;
+    virStorageVolPtr vol;
+    CHECK_CONN(client);
+
+    pool = get_nonnull_storage_pool (client->conn, args->pool);
+    if (pool == NULL) {
+        remoteDispatchError (client, req, "storage_pool not found");
+        return -2;
+    }
+
+    vol = virStorageVolCreateXML (pool, args->xml, args->flags);
+    virStoragePoolFree(pool);
+    if (vol == NULL) return -1;
+
+    make_nonnull_storage_vol (&ret->vol, vol);
+    virStorageVolFree(vol);
+    return 0;
+}
+
+
+static int
+remoteDispatchStorageVolDestroy (struct qemud_client *client,
+                                  remote_message_header *req,
+                                  remote_storage_vol_destroy_args *args,
+                                  void *ret ATTRIBUTE_UNUSED)
+{
+    virStorageVolPtr vol;
+    CHECK_CONN(client);
+
+    vol = get_nonnull_storage_vol (client->conn, args->vol);
+    if (vol == NULL) {
+        remoteDispatchError (client, req, "storage_vol not found");
+        return -2;
+    }
+
+    if (virStorageVolDestroy (vol) == -1) {
+        virStorageVolFree(vol);
+        return -1;
+    }
+    virStorageVolFree(vol);
+    return 0;
+}
+
+static int
+remoteDispatchStorageVolGetInfo (struct qemud_client *client,
+                                  remote_message_header *req,
+                                  remote_storage_vol_get_info_args *args,
+                                  remote_storage_vol_get_info_ret *ret)
+{
+    virStorageVolPtr vol;
+    virStorageVolInfo info;
+    CHECK_CONN(client);
+
+    vol = get_nonnull_storage_vol (client->conn, args->vol);
+    if (vol == NULL) {
+        remoteDispatchError (client, req, "storage_vol not found");
+        return -2;
+    }
+
+    if (virStorageVolGetInfo (vol, &info) == -1) {
+        virStorageVolFree(vol);
+        return -1;
+    }
+
+    ret->type = info.type;
+    ret->allocation = info.allocation;
+    ret->capacity = info.capacity;
+
+    virStorageVolFree(vol);
+
+    return 0;
+}
+
+static int
+remoteDispatchStorageVolDumpXml (struct qemud_client *client,
+                              remote_message_header *req,
+                              remote_storage_vol_dump_xml_args *args,
+                              remote_storage_vol_dump_xml_ret *ret)
+{
+    virStorageVolPtr vol;
+    CHECK_CONN(client);
+
+    vol = get_nonnull_storage_vol (client->conn, args->vol);
+    if (vol == NULL) {
+        remoteDispatchError (client, req, "storage_vol not found");
+        return -2;
+    }
+
+    /* remoteDispatchClientRequest will free this. */
+    ret->xml = virStorageVolGetXMLDesc (vol, args->flags);
+    if (!ret->xml) {
+        virStorageVolFree(vol);
+        return -1;
+    }
+    virStorageVolFree(vol);
+    return 0;
+}
+
+
+static int
+remoteDispatchStorageVolGetPath (struct qemud_client *client,
+                                 remote_message_header *req,
+                                 remote_storage_vol_get_path_args *args,
+                                 remote_storage_vol_get_path_ret *ret)
+{
+    virStorageVolPtr vol;
+    CHECK_CONN(client);
+
+    vol = get_nonnull_storage_vol (client->conn, args->vol);
+    if (vol == NULL) {
+        remoteDispatchError (client, req, "storage_vol not found");
+        return -2;
+    }
+
+    /* remoteDispatchClientRequest will free this. */
+    ret->name = virStorageVolGetPath (vol);
+    if (!ret->name) {
+        virStorageVolFree(vol);
+        return -1;
+    }
+    virStorageVolFree(vol);
+    return 0;
+}
+
+
+static int
+remoteDispatchStorageVolLookupByName (struct qemud_client *client,
+                                      remote_message_header *req,
+                                      remote_storage_vol_lookup_by_name_args *args,
+                                      remote_storage_vol_lookup_by_name_ret *ret)
+{
+    virStoragePoolPtr pool;
+    virStorageVolPtr vol;
+    CHECK_CONN(client);
+
+    pool = get_nonnull_storage_pool (client->conn, args->pool);
+    if (pool == NULL) {
+        remoteDispatchError (client, req, "storage_pool not found");
+        return -2;
+    }
+
+
+    vol = virStorageVolLookupByName (pool, args->name);
+    virStoragePoolFree(pool);
+    if (vol == NULL) return -1;
+
+    make_nonnull_storage_vol (&ret->vol, vol);
+    virStorageVolFree(vol);
+    return 0;
+}
+
+static int
+remoteDispatchStorageVolLookupByUuid (struct qemud_client *client,
+                                      remote_message_header *req,
+                                      remote_storage_vol_lookup_by_uuid_args *args,
+                                      remote_storage_vol_lookup_by_uuid_ret *ret)
+{
+    virStoragePoolPtr pool;
+    virStorageVolPtr vol;
+    CHECK_CONN(client);
+
+    pool = get_nonnull_storage_pool (client->conn, args->pool);
+    if (pool == NULL) {
+        remoteDispatchError (client, req, "storage_pool not found");
+        return -2;
+    }
+
+    vol = virStorageVolLookupByUUID (pool, (unsigned char *) args->uuid);
+    virStoragePoolFree(pool);
+    if (vol == NULL) return -1;
+
+    make_nonnull_storage_vol (&ret->vol, vol);
+    virStorageVolFree(vol);
+    return 0;
+}
+
+
+static int
+remoteDispatchStoragePoolNumOfVolumes (struct qemud_client *client,
+                                       remote_message_header *req,
+                                       remote_storage_pool_num_of_volumes_args *args,
+                                       remote_storage_pool_num_of_volumes_ret *ret)
+{
+    virStoragePoolPtr pool;
+    CHECK_CONN(client);
+
+    pool = get_nonnull_storage_pool (client->conn, args->pool);
+    if (pool == NULL) {
+        remoteDispatchError (client, req, "storage_pool not found");
+        return -2;
+    }
+
+    ret->num = virStoragePoolNumOfVolumes (pool);
+    virStoragePoolFree(pool);
+    if (ret->num == -1) return -1;
+
+    return 0;
+}
+
+
 /*----- Helpers. -----*/
 
 /* get_nonnull_domain and get_nonnull_network turn an on-wire
@@ -1971,6 +2567,24 @@ get_nonnull_network (virConnectPtr conn,
     return virGetNetwork (conn, network.name, BAD_CAST network.uuid);
 }
 
+static virStoragePoolPtr
+get_nonnull_storage_pool (virConnectPtr conn, remote_nonnull_storage_pool pool)
+{
+    return virGetStoragePool (conn, pool.name, BAD_CAST pool.uuid);
+}
+
+static virStorageVolPtr
+get_nonnull_storage_vol (virConnectPtr conn, remote_nonnull_storage_vol vol)
+{
+    virStorageVolPtr ret;
+    virStoragePoolPtr pool = get_nonnull_storage_pool(conn, vol.pool);
+    if (pool == NULL)
+        return NULL;
+    ret = virGetStorageVol (pool, vol.name, BAD_CAST vol.uuid);
+    virStoragePoolFree(pool);
+    return ret;
+}
+
 /* Make remote_nonnull_domain and remote_nonnull_network. */
 static void
 make_nonnull_domain (remote_nonnull_domain *dom_dst, virDomainPtr dom_src)
@@ -1985,6 +2599,21 @@ make_nonnull_network (remote_nonnull_net
 {
     net_dst->name = strdup (net_src->name);
     memcpy (net_dst->uuid, net_src->uuid, VIR_UUID_BUFLEN);
+}
+
+static void
+make_nonnull_storage_pool (remote_nonnull_storage_pool *pool_dst, virStoragePoolPtr pool_src)
+{
+    pool_dst->name = strdup (pool_src->name);
+    memcpy (pool_dst->uuid, pool_src->uuid, VIR_UUID_BUFLEN);
+}
+
+static void
+make_nonnull_storage_vol (remote_nonnull_storage_vol *vol_dst, virStorageVolPtr vol_src)
+{
+    make_nonnull_storage_pool (&vol_dst->pool, vol_src->pool);
+    vol_dst->name = strdup (vol_src->name);
+    memcpy (vol_dst->uuid, vol_src->uuid, VIR_UUID_BUFLEN);
 }
 
 /*
diff -r 89d154031d13 qemud/remote_dispatch_localvars.h
--- a/qemud/remote_dispatch_localvars.h	Sat Oct 27 17:52:41 2007 -0400
+++ b/qemud/remote_dispatch_localvars.h	Sat Oct 27 17:55:07 2007 -0400
@@ -4,10 +4,14 @@
 
 remote_domain_lookup_by_uuid_args lv_remote_domain_lookup_by_uuid_args;
 remote_domain_lookup_by_uuid_ret lv_remote_domain_lookup_by_uuid_ret;
+remote_storage_pool_list_volumes_args lv_remote_storage_pool_list_volumes_args;
+remote_storage_pool_list_volumes_ret lv_remote_storage_pool_list_volumes_ret;
 remote_domain_shutdown_args lv_remote_domain_shutdown_args;
 remote_list_defined_domains_args lv_remote_list_defined_domains_args;
 remote_list_defined_domains_ret lv_remote_list_defined_domains_ret;
 remote_get_capabilities_ret lv_remote_get_capabilities_ret;
+remote_storage_vol_create_xml_args lv_remote_storage_vol_create_xml_args;
+remote_storage_vol_create_xml_ret lv_remote_storage_vol_create_xml_ret;
 remote_domain_set_max_memory_args lv_remote_domain_set_max_memory_args;
 remote_domain_get_os_type_args lv_remote_domain_get_os_type_args;
 remote_domain_get_os_type_ret lv_remote_domain_get_os_type_ret;
@@ -15,9 +19,13 @@ remote_domain_get_autostart_ret lv_remot
 remote_domain_get_autostart_ret lv_remote_domain_get_autostart_ret;
 remote_domain_set_vcpus_args lv_remote_domain_set_vcpus_args;
 remote_get_hostname_ret lv_remote_get_hostname_ret;
+remote_storage_vol_lookup_by_uuid_args lv_remote_storage_vol_lookup_by_uuid_args;
+remote_storage_vol_lookup_by_uuid_ret lv_remote_storage_vol_lookup_by_uuid_ret;
 remote_network_undefine_args lv_remote_network_undefine_args;
 remote_domain_create_args lv_remote_domain_create_args;
 remote_network_destroy_args lv_remote_network_destroy_args;
+remote_storage_pool_lookup_by_uuid_args lv_remote_storage_pool_lookup_by_uuid_args;
+remote_storage_pool_lookup_by_uuid_ret lv_remote_storage_pool_lookup_by_uuid_ret;
 remote_domain_pin_vcpu_args lv_remote_domain_pin_vcpu_args;
 remote_list_defined_networks_args lv_remote_list_defined_networks_args;
 remote_list_defined_networks_ret lv_remote_list_defined_networks_ret;
@@ -33,19 +41,27 @@ remote_network_dump_xml_ret lv_remote_ne
 remote_network_dump_xml_ret lv_remote_network_dump_xml_ret;
 remote_domain_reboot_args lv_remote_domain_reboot_args;
 remote_domain_set_memory_args lv_remote_domain_set_memory_args;
+remote_storage_pool_destroy_args lv_remote_storage_pool_destroy_args;
 remote_domain_create_linux_args lv_remote_domain_create_linux_args;
 remote_domain_create_linux_ret lv_remote_domain_create_linux_ret;
 remote_domain_set_scheduler_parameters_args lv_remote_domain_set_scheduler_parameters_args;
 remote_domain_interface_stats_args lv_remote_domain_interface_stats_args;
 remote_domain_interface_stats_ret lv_remote_domain_interface_stats_ret;
+remote_storage_pool_dump_xml_args lv_remote_storage_pool_dump_xml_args;
+remote_storage_pool_dump_xml_ret lv_remote_storage_pool_dump_xml_ret;
+remote_storage_pool_create_xml_args lv_remote_storage_pool_create_xml_args;
+remote_storage_pool_create_xml_ret lv_remote_storage_pool_create_xml_ret;
 remote_domain_get_max_vcpus_args lv_remote_domain_get_max_vcpus_args;
 remote_domain_get_max_vcpus_ret lv_remote_domain_get_max_vcpus_ret;
 remote_domain_get_info_args lv_remote_domain_get_info_args;
 remote_domain_get_info_ret lv_remote_domain_get_info_ret;
+remote_storage_pool_num_of_volumes_args lv_remote_storage_pool_num_of_volumes_args;
+remote_storage_pool_num_of_volumes_ret lv_remote_storage_pool_num_of_volumes_ret;
 remote_supports_feature_args lv_remote_supports_feature_args;
 remote_supports_feature_ret lv_remote_supports_feature_ret;
 remote_domain_lookup_by_name_args lv_remote_domain_lookup_by_name_args;
 remote_domain_lookup_by_name_ret lv_remote_domain_lookup_by_name_ret;
+remote_storage_pool_set_autostart_args lv_remote_storage_pool_set_autostart_args;
 remote_domain_resume_args lv_remote_domain_resume_args;
 remote_network_get_bridge_name_args lv_remote_network_get_bridge_name_args;
 remote_network_get_bridge_name_ret lv_remote_network_get_bridge_name_ret;
@@ -56,6 +72,7 @@ remote_domain_get_vcpus_ret lv_remote_do
 remote_domain_get_vcpus_ret lv_remote_domain_get_vcpus_ret;
 remote_domain_get_scheduler_parameters_args lv_remote_domain_get_scheduler_parameters_args;
 remote_domain_get_scheduler_parameters_ret lv_remote_domain_get_scheduler_parameters_ret;
+remote_storage_vol_destroy_args lv_remote_storage_vol_destroy_args;
 remote_node_get_info_ret lv_remote_node_get_info_ret;
 remote_network_lookup_by_name_args lv_remote_network_lookup_by_name_args;
 remote_network_lookup_by_name_ret lv_remote_network_lookup_by_name_ret;
@@ -64,6 +81,7 @@ remote_domain_block_stats_ret lv_remote_
 remote_domain_block_stats_ret lv_remote_domain_block_stats_ret;
 remote_domain_detach_device_args lv_remote_domain_detach_device_args;
 remote_domain_save_args lv_remote_domain_save_args;
+remote_num_of_storage_pools_ret lv_remote_num_of_storage_pools_ret;
 remote_domain_migrate_prepare_args lv_remote_domain_migrate_prepare_args;
 remote_domain_migrate_prepare_ret lv_remote_domain_migrate_prepare_ret;
 remote_domain_undefine_args lv_remote_domain_undefine_args;
@@ -71,27 +89,51 @@ remote_domain_get_scheduler_type_ret lv_
 remote_domain_get_scheduler_type_ret lv_remote_domain_get_scheduler_type_ret;
 remote_get_version_ret lv_remote_get_version_ret;
 remote_domain_suspend_args lv_remote_domain_suspend_args;
+remote_storage_pool_lookup_by_name_args lv_remote_storage_pool_lookup_by_name_args;
+remote_storage_pool_lookup_by_name_ret lv_remote_storage_pool_lookup_by_name_ret;
 remote_network_set_autostart_args lv_remote_network_set_autostart_args;
 remote_network_get_autostart_args lv_remote_network_get_autostart_args;
 remote_network_get_autostart_ret lv_remote_network_get_autostart_ret;
+remote_storage_pool_create_args lv_remote_storage_pool_create_args;
+remote_num_of_defined_storage_pools_ret lv_remote_num_of_defined_storage_pools_ret;
 remote_domain_core_dump_args lv_remote_domain_core_dump_args;
+remote_list_defined_storage_pools_args lv_remote_list_defined_storage_pools_args;
+remote_list_defined_storage_pools_ret lv_remote_list_defined_storage_pools_ret;
 remote_domain_get_max_memory_args lv_remote_domain_get_max_memory_args;
 remote_domain_get_max_memory_ret lv_remote_domain_get_max_memory_ret;
 remote_num_of_domains_ret lv_remote_num_of_domains_ret;
 remote_list_networks_args lv_remote_list_networks_args;
 remote_list_networks_ret lv_remote_list_networks_ret;
+remote_storage_pool_undefine_args lv_remote_storage_pool_undefine_args;
 remote_domain_set_autostart_args lv_remote_domain_set_autostart_args;
+remote_storage_pool_get_autostart_args lv_remote_storage_pool_get_autostart_args;
+remote_storage_pool_get_autostart_ret lv_remote_storage_pool_get_autostart_ret;
+remote_storage_vol_get_path_args lv_remote_storage_vol_get_path_args;
+remote_storage_vol_get_path_ret lv_remote_storage_vol_get_path_ret;
 remote_domain_lookup_by_id_args lv_remote_domain_lookup_by_id_args;
 remote_domain_lookup_by_id_ret lv_remote_domain_lookup_by_id_ret;
 remote_domain_attach_device_args lv_remote_domain_attach_device_args;
 remote_num_of_networks_ret lv_remote_num_of_networks_ret;
+remote_storage_pool_get_info_args lv_remote_storage_pool_get_info_args;
+remote_storage_pool_get_info_ret lv_remote_storage_pool_get_info_ret;
+remote_list_storage_pools_args lv_remote_list_storage_pools_args;
+remote_list_storage_pools_ret lv_remote_list_storage_pools_ret;
 remote_domain_restore_args lv_remote_domain_restore_args;
+remote_storage_pool_shutdown_args lv_remote_storage_pool_shutdown_args;
 remote_network_create_args lv_remote_network_create_args;
 remote_num_of_defined_networks_ret lv_remote_num_of_defined_networks_ret;
+remote_storage_vol_lookup_by_name_args lv_remote_storage_vol_lookup_by_name_args;
+remote_storage_vol_lookup_by_name_ret lv_remote_storage_vol_lookup_by_name_ret;
+remote_storage_pool_define_xml_args lv_remote_storage_pool_define_xml_args;
+remote_storage_pool_define_xml_ret lv_remote_storage_pool_define_xml_ret;
 remote_network_lookup_by_uuid_args lv_remote_network_lookup_by_uuid_args;
 remote_network_lookup_by_uuid_ret lv_remote_network_lookup_by_uuid_ret;
+remote_storage_vol_get_info_args lv_remote_storage_vol_get_info_args;
+remote_storage_vol_get_info_ret lv_remote_storage_vol_get_info_ret;
 remote_domain_define_xml_args lv_remote_domain_define_xml_args;
 remote_domain_define_xml_ret lv_remote_domain_define_xml_ret;
+remote_storage_vol_dump_xml_args lv_remote_storage_vol_dump_xml_args;
+remote_storage_vol_dump_xml_ret lv_remote_storage_vol_dump_xml_ret;
 remote_domain_dump_xml_args lv_remote_domain_dump_xml_args;
 remote_domain_dump_xml_ret lv_remote_domain_dump_xml_ret;
 remote_get_max_vcpus_args lv_remote_get_max_vcpus_args;
diff -r 89d154031d13 qemud/remote_dispatch_proc_switch.h
--- a/qemud/remote_dispatch_proc_switch.h	Sat Oct 27 17:52:41 2007 -0400
+++ b/qemud/remote_dispatch_proc_switch.h	Sat Oct 27 17:55:07 2007 -0400
@@ -332,6 +332,15 @@ case REMOTE_PROC_LIST_DEFINED_NETWORKS:
 	ret = (char *) &lv_remote_list_defined_networks_ret;
 	memset (&lv_remote_list_defined_networks_ret, 0, sizeof lv_remote_list_defined_networks_ret);
 	break;
+case REMOTE_PROC_LIST_DEFINED_STORAGE_POOLS:
+	fn = (dispatch_fn) remoteDispatchListDefinedStoragePools;
+	args_filter = (xdrproc_t) xdr_remote_list_defined_storage_pools_args;
+	args = (char *) &lv_remote_list_defined_storage_pools_args;
+	memset (&lv_remote_list_defined_storage_pools_args, 0, sizeof lv_remote_list_defined_storage_pools_args);
+	ret_filter = (xdrproc_t) xdr_remote_list_defined_storage_pools_ret;
+	ret = (char *) &lv_remote_list_defined_storage_pools_ret;
+	memset (&lv_remote_list_defined_storage_pools_ret, 0, sizeof lv_remote_list_defined_storage_pools_ret);
+	break;
 case REMOTE_PROC_LIST_DOMAINS:
 	fn = (dispatch_fn) remoteDispatchListDomains;
 	args_filter = (xdrproc_t) xdr_remote_list_domains_args;
@@ -350,6 +359,15 @@ case REMOTE_PROC_LIST_NETWORKS:
 	ret = (char *) &lv_remote_list_networks_ret;
 	memset (&lv_remote_list_networks_ret, 0, sizeof lv_remote_list_networks_ret);
 	break;
+case REMOTE_PROC_LIST_STORAGE_POOLS:
+	fn = (dispatch_fn) remoteDispatchListStoragePools;
+	args_filter = (xdrproc_t) xdr_remote_list_storage_pools_args;
+	args = (char *) &lv_remote_list_storage_pools_args;
+	memset (&lv_remote_list_storage_pools_args, 0, sizeof lv_remote_list_storage_pools_args);
+	ret_filter = (xdrproc_t) xdr_remote_list_storage_pools_ret;
+	ret = (char *) &lv_remote_list_storage_pools_ret;
+	memset (&lv_remote_list_storage_pools_ret, 0, sizeof lv_remote_list_storage_pools_ret);
+	break;
 case REMOTE_PROC_NETWORK_CREATE:
 	fn = (dispatch_fn) remoteDispatchNetworkCreate;
 	args_filter = (xdrproc_t) xdr_remote_network_create_args;
@@ -455,6 +473,12 @@ case REMOTE_PROC_NUM_OF_DEFINED_NETWORKS
 	ret = (char *) &lv_remote_num_of_defined_networks_ret;
 	memset (&lv_remote_num_of_defined_networks_ret, 0, sizeof lv_remote_num_of_defined_networks_ret);
 	break;
+case REMOTE_PROC_NUM_OF_DEFINED_STORAGE_POOLS:
+	fn = (dispatch_fn) remoteDispatchNumOfDefinedStoragePools;
+	ret_filter = (xdrproc_t) xdr_remote_num_of_defined_storage_pools_ret;
+	ret = (char *) &lv_remote_num_of_defined_storage_pools_ret;
+	memset (&lv_remote_num_of_defined_storage_pools_ret, 0, sizeof lv_remote_num_of_defined_storage_pools_ret);
+	break;
 case REMOTE_PROC_NUM_OF_DOMAINS:
 	fn = (dispatch_fn) remoteDispatchNumOfDomains;
 	ret_filter = (xdrproc_t) xdr_remote_num_of_domains_ret;
@@ -467,11 +491,188 @@ case REMOTE_PROC_NUM_OF_NETWORKS:
 	ret = (char *) &lv_remote_num_of_networks_ret;
 	memset (&lv_remote_num_of_networks_ret, 0, sizeof lv_remote_num_of_networks_ret);
 	break;
+case REMOTE_PROC_NUM_OF_STORAGE_POOLS:
+	fn = (dispatch_fn) remoteDispatchNumOfStoragePools;
+	ret_filter = (xdrproc_t) xdr_remote_num_of_storage_pools_ret;
+	ret = (char *) &lv_remote_num_of_storage_pools_ret;
+	memset (&lv_remote_num_of_storage_pools_ret, 0, sizeof lv_remote_num_of_storage_pools_ret);
+	break;
 case REMOTE_PROC_OPEN:
 	fn = (dispatch_fn) remoteDispatchOpen;
 	args_filter = (xdrproc_t) xdr_remote_open_args;
 	args = (char *) &lv_remote_open_args;
 	memset (&lv_remote_open_args, 0, sizeof lv_remote_open_args);
+	break;
+case REMOTE_PROC_STORAGE_POOL_CREATE:
+	fn = (dispatch_fn) remoteDispatchStoragePoolCreate;
+	args_filter = (xdrproc_t) xdr_remote_storage_pool_create_args;
+	args = (char *) &lv_remote_storage_pool_create_args;
+	memset (&lv_remote_storage_pool_create_args, 0, sizeof lv_remote_storage_pool_create_args);
+	break;
+case REMOTE_PROC_STORAGE_POOL_CREATE_XML:
+	fn = (dispatch_fn) remoteDispatchStoragePoolCreateXml;
+	args_filter = (xdrproc_t) xdr_remote_storage_pool_create_xml_args;
+	args = (char *) &lv_remote_storage_pool_create_xml_args;
+	memset (&lv_remote_storage_pool_create_xml_args, 0, sizeof lv_remote_storage_pool_create_xml_args);
+	ret_filter = (xdrproc_t) xdr_remote_storage_pool_create_xml_ret;
+	ret = (char *) &lv_remote_storage_pool_create_xml_ret;
+	memset (&lv_remote_storage_pool_create_xml_ret, 0, sizeof lv_remote_storage_pool_create_xml_ret);
+	break;
+case REMOTE_PROC_STORAGE_POOL_DEFINE_XML:
+	fn = (dispatch_fn) remoteDispatchStoragePoolDefineXml;
+	args_filter = (xdrproc_t) xdr_remote_storage_pool_define_xml_args;
+	args = (char *) &lv_remote_storage_pool_define_xml_args;
+	memset (&lv_remote_storage_pool_define_xml_args, 0, sizeof lv_remote_storage_pool_define_xml_args);
+	ret_filter = (xdrproc_t) xdr_remote_storage_pool_define_xml_ret;
+	ret = (char *) &lv_remote_storage_pool_define_xml_ret;
+	memset (&lv_remote_storage_pool_define_xml_ret, 0, sizeof lv_remote_storage_pool_define_xml_ret);
+	break;
+case REMOTE_PROC_STORAGE_POOL_DESTROY:
+	fn = (dispatch_fn) remoteDispatchStoragePoolDestroy;
+	args_filter = (xdrproc_t) xdr_remote_storage_pool_destroy_args;
+	args = (char *) &lv_remote_storage_pool_destroy_args;
+	memset (&lv_remote_storage_pool_destroy_args, 0, sizeof lv_remote_storage_pool_destroy_args);
+	break;
+case REMOTE_PROC_STORAGE_POOL_DUMP_XML:
+	fn = (dispatch_fn) remoteDispatchStoragePoolDumpXml;
+	args_filter = (xdrproc_t) xdr_remote_storage_pool_dump_xml_args;
+	args = (char *) &lv_remote_storage_pool_dump_xml_args;
+	memset (&lv_remote_storage_pool_dump_xml_args, 0, sizeof lv_remote_storage_pool_dump_xml_args);
+	ret_filter = (xdrproc_t) xdr_remote_storage_pool_dump_xml_ret;
+	ret = (char *) &lv_remote_storage_pool_dump_xml_ret;
+	memset (&lv_remote_storage_pool_dump_xml_ret, 0, sizeof lv_remote_storage_pool_dump_xml_ret);
+	break;
+case REMOTE_PROC_STORAGE_POOL_GET_AUTOSTART:
+	fn = (dispatch_fn) remoteDispatchStoragePoolGetAutostart;
+	args_filter = (xdrproc_t) xdr_remote_storage_pool_get_autostart_args;
+	args = (char *) &lv_remote_storage_pool_get_autostart_args;
+	memset (&lv_remote_storage_pool_get_autostart_args, 0, sizeof lv_remote_storage_pool_get_autostart_args);
+	ret_filter = (xdrproc_t) xdr_remote_storage_pool_get_autostart_ret;
+	ret = (char *) &lv_remote_storage_pool_get_autostart_ret;
+	memset (&lv_remote_storage_pool_get_autostart_ret, 0, sizeof lv_remote_storage_pool_get_autostart_ret);
+	break;
+case REMOTE_PROC_STORAGE_POOL_GET_INFO:
+	fn = (dispatch_fn) remoteDispatchStoragePoolGetInfo;
+	args_filter = (xdrproc_t) xdr_remote_storage_pool_get_info_args;
+	args = (char *) &lv_remote_storage_pool_get_info_args;
+	memset (&lv_remote_storage_pool_get_info_args, 0, sizeof lv_remote_storage_pool_get_info_args);
+	ret_filter = (xdrproc_t) xdr_remote_storage_pool_get_info_ret;
+	ret = (char *) &lv_remote_storage_pool_get_info_ret;
+	memset (&lv_remote_storage_pool_get_info_ret, 0, sizeof lv_remote_storage_pool_get_info_ret);
+	break;
+case REMOTE_PROC_STORAGE_POOL_LIST_VOLUMES:
+	fn = (dispatch_fn) remoteDispatchStoragePoolListVolumes;
+	args_filter = (xdrproc_t) xdr_remote_storage_pool_list_volumes_args;
+	args = (char *) &lv_remote_storage_pool_list_volumes_args;
+	memset (&lv_remote_storage_pool_list_volumes_args, 0, sizeof lv_remote_storage_pool_list_volumes_args);
+	ret_filter = (xdrproc_t) xdr_remote_storage_pool_list_volumes_ret;
+	ret = (char *) &lv_remote_storage_pool_list_volumes_ret;
+	memset (&lv_remote_storage_pool_list_volumes_ret, 0, sizeof lv_remote_storage_pool_list_volumes_ret);
+	break;
+case REMOTE_PROC_STORAGE_POOL_LOOKUP_BY_NAME:
+	fn = (dispatch_fn) remoteDispatchStoragePoolLookupByName;
+	args_filter = (xdrproc_t) xdr_remote_storage_pool_lookup_by_name_args;
+	args = (char *) &lv_remote_storage_pool_lookup_by_name_args;
+	memset (&lv_remote_storage_pool_lookup_by_name_args, 0, sizeof lv_remote_storage_pool_lookup_by_name_args);
+	ret_filter = (xdrproc_t) xdr_remote_storage_pool_lookup_by_name_ret;
+	ret = (char *) &lv_remote_storage_pool_lookup_by_name_ret;
+	memset (&lv_remote_storage_pool_lookup_by_name_ret, 0, sizeof lv_remote_storage_pool_lookup_by_name_ret);
+	break;
+case REMOTE_PROC_STORAGE_POOL_LOOKUP_BY_UUID:
+	fn = (dispatch_fn) remoteDispatchStoragePoolLookupByUuid;
+	args_filter = (xdrproc_t) xdr_remote_storage_pool_lookup_by_uuid_args;
+	args = (char *) &lv_remote_storage_pool_lookup_by_uuid_args;
+	memset (&lv_remote_storage_pool_lookup_by_uuid_args, 0, sizeof lv_remote_storage_pool_lookup_by_uuid_args);
+	ret_filter = (xdrproc_t) xdr_remote_storage_pool_lookup_by_uuid_ret;
+	ret = (char *) &lv_remote_storage_pool_lookup_by_uuid_ret;
+	memset (&lv_remote_storage_pool_lookup_by_uuid_ret, 0, sizeof lv_remote_storage_pool_lookup_by_uuid_ret);
+	break;
+case REMOTE_PROC_STORAGE_POOL_NUM_OF_VOLUMES:
+	fn = (dispatch_fn) remoteDispatchStoragePoolNumOfVolumes;
+	args_filter = (xdrproc_t) xdr_remote_storage_pool_num_of_volumes_args;
+	args = (char *) &lv_remote_storage_pool_num_of_volumes_args;
+	memset (&lv_remote_storage_pool_num_of_volumes_args, 0, sizeof lv_remote_storage_pool_num_of_volumes_args);
+	ret_filter = (xdrproc_t) xdr_remote_storage_pool_num_of_volumes_ret;
+	ret = (char *) &lv_remote_storage_pool_num_of_volumes_ret;
+	memset (&lv_remote_storage_pool_num_of_volumes_ret, 0, sizeof lv_remote_storage_pool_num_of_volumes_ret);
+	break;
+case REMOTE_PROC_STORAGE_POOL_SET_AUTOSTART:
+	fn = (dispatch_fn) remoteDispatchStoragePoolSetAutostart;
+	args_filter = (xdrproc_t) xdr_remote_storage_pool_set_autostart_args;
+	args = (char *) &lv_remote_storage_pool_set_autostart_args;
+	memset (&lv_remote_storage_pool_set_autostart_args, 0, sizeof lv_remote_storage_pool_set_autostart_args);
+	break;
+case REMOTE_PROC_STORAGE_POOL_SHUTDOWN:
+	fn = (dispatch_fn) remoteDispatchStoragePoolShutdown;
+	args_filter = (xdrproc_t) xdr_remote_storage_pool_shutdown_args;
+	args = (char *) &lv_remote_storage_pool_shutdown_args;
+	memset (&lv_remote_storage_pool_shutdown_args, 0, sizeof lv_remote_storage_pool_shutdown_args);
+	break;
+case REMOTE_PROC_STORAGE_POOL_UNDEFINE:
+	fn = (dispatch_fn) remoteDispatchStoragePoolUndefine;
+	args_filter = (xdrproc_t) xdr_remote_storage_pool_undefine_args;
+	args = (char *) &lv_remote_storage_pool_undefine_args;
+	memset (&lv_remote_storage_pool_undefine_args, 0, sizeof lv_remote_storage_pool_undefine_args);
+	break;
+case REMOTE_PROC_STORAGE_VOL_CREATE_XML:
+	fn = (dispatch_fn) remoteDispatchStorageVolCreateXml;
+	args_filter = (xdrproc_t) xdr_remote_storage_vol_create_xml_args;
+	args = (char *) &lv_remote_storage_vol_create_xml_args;
+	memset (&lv_remote_storage_vol_create_xml_args, 0, sizeof lv_remote_storage_vol_create_xml_args);
+	ret_filter = (xdrproc_t) xdr_remote_storage_vol_create_xml_ret;
+	ret = (char *) &lv_remote_storage_vol_create_xml_ret;
+	memset (&lv_remote_storage_vol_create_xml_ret, 0, sizeof lv_remote_storage_vol_create_xml_ret);
+	break;
+case REMOTE_PROC_STORAGE_VOL_DESTROY:
+	fn = (dispatch_fn) remoteDispatchStorageVolDestroy;
+	args_filter = (xdrproc_t) xdr_remote_storage_vol_destroy_args;
+	args = (char *) &lv_remote_storage_vol_destroy_args;
+	memset (&lv_remote_storage_vol_destroy_args, 0, sizeof lv_remote_storage_vol_destroy_args);
+	break;
+case REMOTE_PROC_STORAGE_VOL_DUMP_XML:
+	fn = (dispatch_fn) remoteDispatchStorageVolDumpXml;
+	args_filter = (xdrproc_t) xdr_remote_storage_vol_dump_xml_args;
+	args = (char *) &lv_remote_storage_vol_dump_xml_args;
+	memset (&lv_remote_storage_vol_dump_xml_args, 0, sizeof lv_remote_storage_vol_dump_xml_args);
+	ret_filter = (xdrproc_t) xdr_remote_storage_vol_dump_xml_ret;
+	ret = (char *) &lv_remote_storage_vol_dump_xml_ret;
+	memset (&lv_remote_storage_vol_dump_xml_ret, 0, sizeof lv_remote_storage_vol_dump_xml_ret);
+	break;
+case REMOTE_PROC_STORAGE_VOL_GET_INFO:
+	fn = (dispatch_fn) remoteDispatchStorageVolGetInfo;
+	args_filter = (xdrproc_t) xdr_remote_storage_vol_get_info_args;
+	args = (char *) &lv_remote_storage_vol_get_info_args;
+	memset (&lv_remote_storage_vol_get_info_args, 0, sizeof lv_remote_storage_vol_get_info_args);
+	ret_filter = (xdrproc_t) xdr_remote_storage_vol_get_info_ret;
+	ret = (char *) &lv_remote_storage_vol_get_info_ret;
+	memset (&lv_remote_storage_vol_get_info_ret, 0, sizeof lv_remote_storage_vol_get_info_ret);
+	break;
+case REMOTE_PROC_STORAGE_VOL_GET_PATH:
+	fn = (dispatch_fn) remoteDispatchStorageVolGetPath;
+	args_filter = (xdrproc_t) xdr_remote_storage_vol_get_path_args;
+	args = (char *) &lv_remote_storage_vol_get_path_args;
+	memset (&lv_remote_storage_vol_get_path_args, 0, sizeof lv_remote_storage_vol_get_path_args);
+	ret_filter = (xdrproc_t) xdr_remote_storage_vol_get_path_ret;
+	ret = (char *) &lv_remote_storage_vol_get_path_ret;
+	memset (&lv_remote_storage_vol_get_path_ret, 0, sizeof lv_remote_storage_vol_get_path_ret);
+	break;
+case REMOTE_PROC_STORAGE_VOL_LOOKUP_BY_NAME:
+	fn = (dispatch_fn) remoteDispatchStorageVolLookupByName;
+	args_filter = (xdrproc_t) xdr_remote_storage_vol_lookup_by_name_args;
+	args = (char *) &lv_remote_storage_vol_lookup_by_name_args;
+	memset (&lv_remote_storage_vol_lookup_by_name_args, 0, sizeof lv_remote_storage_vol_lookup_by_name_args);
+	ret_filter = (xdrproc_t) xdr_remote_storage_vol_lookup_by_name_ret;
+	ret = (char *) &lv_remote_storage_vol_lookup_by_name_ret;
+	memset (&lv_remote_storage_vol_lookup_by_name_ret, 0, sizeof lv_remote_storage_vol_lookup_by_name_ret);
+	break;
+case REMOTE_PROC_STORAGE_VOL_LOOKUP_BY_UUID:
+	fn = (dispatch_fn) remoteDispatchStorageVolLookupByUuid;
+	args_filter = (xdrproc_t) xdr_remote_storage_vol_lookup_by_uuid_args;
+	args = (char *) &lv_remote_storage_vol_lookup_by_uuid_args;
+	memset (&lv_remote_storage_vol_lookup_by_uuid_args, 0, sizeof lv_remote_storage_vol_lookup_by_uuid_args);
+	ret_filter = (xdrproc_t) xdr_remote_storage_vol_lookup_by_uuid_ret;
+	ret = (char *) &lv_remote_storage_vol_lookup_by_uuid_ret;
+	memset (&lv_remote_storage_vol_lookup_by_uuid_ret, 0, sizeof lv_remote_storage_vol_lookup_by_uuid_ret);
 	break;
 case REMOTE_PROC_SUPPORTS_FEATURE:
 	fn = (dispatch_fn) remoteDispatchSupportsFeature;
diff -r 89d154031d13 qemud/remote_dispatch_prototypes.h
--- a/qemud/remote_dispatch_prototypes.h	Sat Oct 27 17:52:41 2007 -0400
+++ b/qemud/remote_dispatch_prototypes.h	Sat Oct 27 17:55:07 2007 -0400
@@ -47,8 +47,10 @@ static int remoteDispatchGetVersion (str
 static int remoteDispatchGetVersion (struct qemud_client *client, remote_message_header *req, void *args, remote_get_version_ret *ret);
 static int remoteDispatchListDefinedDomains (struct qemud_client *client, remote_message_header *req, remote_list_defined_domains_args *args, remote_list_defined_domains_ret *ret);
 static int remoteDispatchListDefinedNetworks (struct qemud_client *client, remote_message_header *req, remote_list_defined_networks_args *args, remote_list_defined_networks_ret *ret);
+static int remoteDispatchListDefinedStoragePools (struct qemud_client *client, remote_message_header *req, remote_list_defined_storage_pools_args *args, remote_list_defined_storage_pools_ret *ret);
 static int remoteDispatchListDomains (struct qemud_client *client, remote_message_header *req, remote_list_domains_args *args, remote_list_domains_ret *ret);
 static int remoteDispatchListNetworks (struct qemud_client *client, remote_message_header *req, remote_list_networks_args *args, remote_list_networks_ret *ret);
+static int remoteDispatchListStoragePools (struct qemud_client *client, remote_message_header *req, remote_list_storage_pools_args *args, remote_list_storage_pools_ret *ret);
 static int remoteDispatchNetworkCreate (struct qemud_client *client, remote_message_header *req, remote_network_create_args *args, void *ret);
 static int remoteDispatchNetworkCreateXml (struct qemud_client *client, remote_message_header *req, remote_network_create_xml_args *args, remote_network_create_xml_ret *ret);
 static int remoteDispatchNetworkDefineXml (struct qemud_client *client, remote_message_header *req, remote_network_define_xml_args *args, remote_network_define_xml_ret *ret);
@@ -63,7 +65,30 @@ static int remoteDispatchNodeGetInfo (st
 static int remoteDispatchNodeGetInfo (struct qemud_client *client, remote_message_header *req, void *args, remote_node_get_info_ret *ret);
 static int remoteDispatchNumOfDefinedDomains (struct qemud_client *client, remote_message_header *req, void *args, remote_num_of_defined_domains_ret *ret);
 static int remoteDispatchNumOfDefinedNetworks (struct qemud_client *client, remote_message_header *req, void *args, remote_num_of_defined_networks_ret *ret);
+static int remoteDispatchNumOfDefinedStoragePools (struct qemud_client *client, remote_message_header *req, void *args, remote_num_of_defined_storage_pools_ret *ret);
 static int remoteDispatchNumOfDomains (struct qemud_client *client, remote_message_header *req, void *args, remote_num_of_domains_ret *ret);
 static int remoteDispatchNumOfNetworks (struct qemud_client *client, remote_message_header *req, void *args, remote_num_of_networks_ret *ret);
+static int remoteDispatchNumOfStoragePools (struct qemud_client *client, remote_message_header *req, void *args, remote_num_of_storage_pools_ret *ret);
 static int remoteDispatchOpen (struct qemud_client *client, remote_message_header *req, remote_open_args *args, void *ret);
+static int remoteDispatchStoragePoolCreate (struct qemud_client *client, remote_message_header *req, remote_storage_pool_create_args *args, void *ret);
+static int remoteDispatchStoragePoolCreateXml (struct qemud_client *client, remote_message_header *req, remote_storage_pool_create_xml_args *args, remote_storage_pool_create_xml_ret *ret);
+static int remoteDispatchStoragePoolDefineXml (struct qemud_client *client, remote_message_header *req, remote_storage_pool_define_xml_args *args, remote_storage_pool_define_xml_ret *ret);
+static int remoteDispatchStoragePoolDestroy (struct qemud_client *client, remote_message_header *req, remote_storage_pool_destroy_args *args, void *ret);
+static int remoteDispatchStoragePoolDumpXml (struct qemud_client *client, remote_message_header *req, remote_storage_pool_dump_xml_args *args, remote_storage_pool_dump_xml_ret *ret);
+static int remoteDispatchStoragePoolGetAutostart (struct qemud_client *client, remote_message_header *req, remote_storage_pool_get_autostart_args *args, remote_storage_pool_get_autostart_ret *ret);
+static int remoteDispatchStoragePoolGetInfo (struct qemud_client *client, remote_message_header *req, remote_storage_pool_get_info_args *args, remote_storage_pool_get_info_ret *ret);
+static int remoteDispatchStoragePoolListVolumes (struct qemud_client *client, remote_message_header *req, remote_storage_pool_list_volumes_args *args, remote_storage_pool_list_volumes_ret *ret);
+static int remoteDispatchStoragePoolLookupByName (struct qemud_client *client, remote_message_header *req, remote_storage_pool_lookup_by_name_args *args, remote_storage_pool_lookup_by_name_ret *ret);
+static int remoteDispatchStoragePoolLookupByUuid (struct qemud_client *client, remote_message_header *req, remote_storage_pool_lookup_by_uuid_args *args, remote_storage_pool_lookup_by_uuid_ret *ret);
+static int remoteDispatchStoragePoolNumOfVolumes (struct qemud_client *client, remote_message_header *req, remote_storage_pool_num_of_volumes_args *args, remote_storage_pool_num_of_volumes_ret *ret);
+static int remoteDispatchStoragePoolSetAutostart (struct qemud_client *client, remote_message_header *req, remote_storage_pool_set_autostart_args *args, void *ret);
+static int remoteDispatchStoragePoolShutdown (struct qemud_client *client, remote_message_header *req, remote_storage_pool_shutdown_args *args, void *ret);
+static int remoteDispatchStoragePoolUndefine (struct qemud_client *client, remote_message_header *req, remote_storage_pool_undefine_args *args, void *ret);
+static int remoteDispatchStorageVolCreateXml (struct qemud_client *client, remote_message_header *req, remote_storage_vol_create_xml_args *args, remote_storage_vol_create_xml_ret *ret);
+static int remoteDispatchStorageVolDestroy (struct qemud_client *client, remote_message_header *req, remote_storage_vol_destroy_args *args, void *ret);
+static int remoteDispatchStorageVolDumpXml (struct qemud_client *client, remote_message_header *req, remote_storage_vol_dump_xml_args *args, remote_storage_vol_dump_xml_ret *ret);
+static int remoteDispatchStorageVolGetInfo (struct qemud_client *client, remote_message_header *req, remote_storage_vol_get_info_args *args, remote_storage_vol_get_info_ret *ret);
+static int remoteDispatchStorageVolGetPath (struct qemud_client *client, remote_message_header *req, remote_storage_vol_get_path_args *args, remote_storage_vol_get_path_ret *ret);
+static int remoteDispatchStorageVolLookupByName (struct qemud_client *client, remote_message_header *req, remote_storage_vol_lookup_by_name_args *args, remote_storage_vol_lookup_by_name_ret *ret);
+static int remoteDispatchStorageVolLookupByUuid (struct qemud_client *client, remote_message_header *req, remote_storage_vol_lookup_by_uuid_args *args, remote_storage_vol_lookup_by_uuid_ret *ret);
 static int remoteDispatchSupportsFeature (struct qemud_client *client, remote_message_header *req, remote_supports_feature_args *args, remote_supports_feature_ret *ret);
diff -r 89d154031d13 qemud/remote_protocol.c
--- a/qemud/remote_protocol.c	Sat Oct 27 17:52:41 2007 -0400
+++ b/qemud/remote_protocol.c	Sat Oct 27 17:55:07 2007 -0400
@@ -58,6 +58,30 @@ xdr_remote_nonnull_network (XDR *xdrs, r
 }
 
 bool_t
+xdr_remote_nonnull_storage_pool (XDR *xdrs, remote_nonnull_storage_pool *objp)
+{
+
+	 if (!xdr_remote_nonnull_string (xdrs, &objp->name))
+		 return FALSE;
+	 if (!xdr_remote_uuid (xdrs, objp->uuid))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_remote_nonnull_storage_vol (XDR *xdrs, remote_nonnull_storage_vol *objp)
+{
+
+	 if (!xdr_remote_nonnull_storage_pool (xdrs, &objp->pool))
+		 return FALSE;
+	 if (!xdr_remote_nonnull_string (xdrs, &objp->name))
+		 return FALSE;
+	 if (!xdr_remote_uuid (xdrs, objp->uuid))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
 xdr_remote_domain (XDR *xdrs, remote_domain *objp)
 {
 
@@ -71,6 +95,24 @@ xdr_remote_network (XDR *xdrs, remote_ne
 {
 
 	 if (!xdr_pointer (xdrs, (char **)objp, sizeof (remote_nonnull_network), (xdrproc_t) xdr_remote_nonnull_network))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_remote_storage_pool (XDR *xdrs, remote_storage_pool *objp)
+{
+
+	 if (!xdr_pointer (xdrs, (char **)objp, sizeof (remote_nonnull_storage_pool), (xdrproc_t) xdr_remote_nonnull_storage_pool))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_remote_storage_vol (XDR *xdrs, remote_storage_vol *objp)
+{
+
+	 if (!xdr_pointer (xdrs, (char **)objp, sizeof (remote_nonnull_storage_vol), (xdrproc_t) xdr_remote_nonnull_storage_vol))
 		 return FALSE;
 	return TRUE;
 }
@@ -1222,6 +1264,414 @@ xdr_remote_network_set_autostart_args (X
 }
 
 bool_t
+xdr_remote_num_of_storage_pools_ret (XDR *xdrs, remote_num_of_storage_pools_ret *objp)
+{
+
+	 if (!xdr_int (xdrs, &objp->num))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_remote_list_storage_pools_args (XDR *xdrs, remote_list_storage_pools_args *objp)
+{
+
+	 if (!xdr_int (xdrs, &objp->maxnames))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_remote_list_storage_pools_ret (XDR *xdrs, remote_list_storage_pools_ret *objp)
+{
+	char **objp_cpp0 = (char **) (void *) &objp->names.names_val;
+
+	 if (!xdr_array (xdrs, objp_cpp0, (u_int *) &objp->names.names_len, REMOTE_STORAGE_POOL_NAME_LIST_MAX,
+		sizeof (remote_nonnull_string), (xdrproc_t) xdr_remote_nonnull_string))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_remote_num_of_defined_storage_pools_ret (XDR *xdrs, remote_num_of_defined_storage_pools_ret *objp)
+{
+
+	 if (!xdr_int (xdrs, &objp->num))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_remote_list_defined_storage_pools_args (XDR *xdrs, remote_list_defined_storage_pools_args *objp)
+{
+
+	 if (!xdr_int (xdrs, &objp->maxnames))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_remote_list_defined_storage_pools_ret (XDR *xdrs, remote_list_defined_storage_pools_ret *objp)
+{
+	char **objp_cpp0 = (char **) (void *) &objp->names.names_val;
+
+	 if (!xdr_array (xdrs, objp_cpp0, (u_int *) &objp->names.names_len, REMOTE_STORAGE_POOL_NAME_LIST_MAX,
+		sizeof (remote_nonnull_string), (xdrproc_t) xdr_remote_nonnull_string))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_remote_storage_pool_lookup_by_uuid_args (XDR *xdrs, remote_storage_pool_lookup_by_uuid_args *objp)
+{
+
+	 if (!xdr_remote_uuid (xdrs, objp->uuid))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_remote_storage_pool_lookup_by_uuid_ret (XDR *xdrs, remote_storage_pool_lookup_by_uuid_ret *objp)
+{
+
+	 if (!xdr_remote_nonnull_storage_pool (xdrs, &objp->pool))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_remote_storage_pool_lookup_by_name_args (XDR *xdrs, remote_storage_pool_lookup_by_name_args *objp)
+{
+
+	 if (!xdr_remote_nonnull_string (xdrs, &objp->name))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_remote_storage_pool_lookup_by_name_ret (XDR *xdrs, remote_storage_pool_lookup_by_name_ret *objp)
+{
+
+	 if (!xdr_remote_nonnull_storage_pool (xdrs, &objp->pool))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_remote_storage_pool_create_xml_args (XDR *xdrs, remote_storage_pool_create_xml_args *objp)
+{
+
+	 if (!xdr_remote_nonnull_string (xdrs, &objp->xml))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_remote_storage_pool_create_xml_ret (XDR *xdrs, remote_storage_pool_create_xml_ret *objp)
+{
+
+	 if (!xdr_remote_nonnull_storage_pool (xdrs, &objp->pool))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_remote_storage_pool_define_xml_args (XDR *xdrs, remote_storage_pool_define_xml_args *objp)
+{
+
+	 if (!xdr_remote_nonnull_string (xdrs, &objp->xml))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_remote_storage_pool_define_xml_ret (XDR *xdrs, remote_storage_pool_define_xml_ret *objp)
+{
+
+	 if (!xdr_remote_nonnull_storage_pool (xdrs, &objp->pool))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_remote_storage_pool_undefine_args (XDR *xdrs, remote_storage_pool_undefine_args *objp)
+{
+
+	 if (!xdr_remote_nonnull_storage_pool (xdrs, &objp->pool))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_remote_storage_pool_create_args (XDR *xdrs, remote_storage_pool_create_args *objp)
+{
+
+	 if (!xdr_remote_nonnull_storage_pool (xdrs, &objp->pool))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_remote_storage_pool_shutdown_args (XDR *xdrs, remote_storage_pool_shutdown_args *objp)
+{
+
+	 if (!xdr_remote_nonnull_storage_pool (xdrs, &objp->pool))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_remote_storage_pool_destroy_args (XDR *xdrs, remote_storage_pool_destroy_args *objp)
+{
+
+	 if (!xdr_remote_nonnull_storage_pool (xdrs, &objp->pool))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_remote_storage_pool_dump_xml_args (XDR *xdrs, remote_storage_pool_dump_xml_args *objp)
+{
+
+	 if (!xdr_remote_nonnull_storage_pool (xdrs, &objp->pool))
+		 return FALSE;
+	 if (!xdr_int (xdrs, &objp->flags))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_remote_storage_pool_dump_xml_ret (XDR *xdrs, remote_storage_pool_dump_xml_ret *objp)
+{
+
+	 if (!xdr_remote_nonnull_string (xdrs, &objp->xml))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_remote_storage_pool_get_info_args (XDR *xdrs, remote_storage_pool_get_info_args *objp)
+{
+
+	 if (!xdr_remote_nonnull_storage_pool (xdrs, &objp->pool))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_remote_storage_pool_get_info_ret (XDR *xdrs, remote_storage_pool_get_info_ret *objp)
+{
+
+	 if (!xdr_u_char (xdrs, &objp->state))
+		 return FALSE;
+	 if (!xdr_u_quad_t (xdrs, &objp->capacity))
+		 return FALSE;
+	 if (!xdr_u_quad_t (xdrs, &objp->allocation))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_remote_storage_pool_get_autostart_args (XDR *xdrs, remote_storage_pool_get_autostart_args *objp)
+{
+
+	 if (!xdr_remote_nonnull_storage_pool (xdrs, &objp->pool))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_remote_storage_pool_get_autostart_ret (XDR *xdrs, remote_storage_pool_get_autostart_ret *objp)
+{
+
+	 if (!xdr_int (xdrs, &objp->autostart))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_remote_storage_pool_set_autostart_args (XDR *xdrs, remote_storage_pool_set_autostart_args *objp)
+{
+
+	 if (!xdr_remote_nonnull_storage_pool (xdrs, &objp->pool))
+		 return FALSE;
+	 if (!xdr_int (xdrs, &objp->autostart))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_remote_storage_pool_num_of_volumes_args (XDR *xdrs, remote_storage_pool_num_of_volumes_args *objp)
+{
+
+	 if (!xdr_remote_nonnull_storage_pool (xdrs, &objp->pool))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_remote_storage_pool_num_of_volumes_ret (XDR *xdrs, remote_storage_pool_num_of_volumes_ret *objp)
+{
+
+	 if (!xdr_int (xdrs, &objp->num))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_remote_storage_pool_list_volumes_args (XDR *xdrs, remote_storage_pool_list_volumes_args *objp)
+{
+
+	 if (!xdr_remote_nonnull_storage_pool (xdrs, &objp->pool))
+		 return FALSE;
+	 if (!xdr_int (xdrs, &objp->maxnames))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_remote_storage_pool_list_volumes_ret (XDR *xdrs, remote_storage_pool_list_volumes_ret *objp)
+{
+	char **objp_cpp0 = (char **) (void *) &objp->names.names_val;
+
+	 if (!xdr_array (xdrs, objp_cpp0, (u_int *) &objp->names.names_len, REMOTE_STORAGE_VOL_NAME_LIST_MAX,
+		sizeof (remote_nonnull_string), (xdrproc_t) xdr_remote_nonnull_string))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_remote_storage_vol_lookup_by_uuid_args (XDR *xdrs, remote_storage_vol_lookup_by_uuid_args *objp)
+{
+
+	 if (!xdr_remote_nonnull_storage_pool (xdrs, &objp->pool))
+		 return FALSE;
+	 if (!xdr_remote_uuid (xdrs, objp->uuid))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_remote_storage_vol_lookup_by_uuid_ret (XDR *xdrs, remote_storage_vol_lookup_by_uuid_ret *objp)
+{
+
+	 if (!xdr_remote_nonnull_storage_vol (xdrs, &objp->vol))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_remote_storage_vol_lookup_by_name_args (XDR *xdrs, remote_storage_vol_lookup_by_name_args *objp)
+{
+
+	 if (!xdr_remote_nonnull_storage_pool (xdrs, &objp->pool))
+		 return FALSE;
+	 if (!xdr_remote_nonnull_string (xdrs, &objp->name))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_remote_storage_vol_lookup_by_name_ret (XDR *xdrs, remote_storage_vol_lookup_by_name_ret *objp)
+{
+
+	 if (!xdr_remote_nonnull_storage_vol (xdrs, &objp->vol))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_remote_storage_vol_create_xml_args (XDR *xdrs, remote_storage_vol_create_xml_args *objp)
+{
+
+	 if (!xdr_remote_nonnull_storage_pool (xdrs, &objp->pool))
+		 return FALSE;
+	 if (!xdr_remote_nonnull_string (xdrs, &objp->xml))
+		 return FALSE;
+	 if (!xdr_int (xdrs, &objp->flags))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_remote_storage_vol_create_xml_ret (XDR *xdrs, remote_storage_vol_create_xml_ret *objp)
+{
+
+	 if (!xdr_remote_nonnull_storage_vol (xdrs, &objp->vol))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_remote_storage_vol_destroy_args (XDR *xdrs, remote_storage_vol_destroy_args *objp)
+{
+
+	 if (!xdr_remote_nonnull_storage_vol (xdrs, &objp->vol))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_remote_storage_vol_dump_xml_args (XDR *xdrs, remote_storage_vol_dump_xml_args *objp)
+{
+
+	 if (!xdr_remote_nonnull_storage_vol (xdrs, &objp->vol))
+		 return FALSE;
+	 if (!xdr_int (xdrs, &objp->flags))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_remote_storage_vol_dump_xml_ret (XDR *xdrs, remote_storage_vol_dump_xml_ret *objp)
+{
+
+	 if (!xdr_remote_nonnull_string (xdrs, &objp->xml))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_remote_storage_vol_get_info_args (XDR *xdrs, remote_storage_vol_get_info_args *objp)
+{
+
+	 if (!xdr_remote_nonnull_storage_vol (xdrs, &objp->vol))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_remote_storage_vol_get_info_ret (XDR *xdrs, remote_storage_vol_get_info_ret *objp)
+{
+
+	 if (!xdr_char (xdrs, &objp->type))
+		 return FALSE;
+	 if (!xdr_u_quad_t (xdrs, &objp->capacity))
+		 return FALSE;
+	 if (!xdr_u_quad_t (xdrs, &objp->allocation))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_remote_storage_vol_get_path_args (XDR *xdrs, remote_storage_vol_get_path_args *objp)
+{
+
+	 if (!xdr_remote_nonnull_storage_vol (xdrs, &objp->vol))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_remote_storage_vol_get_path_ret (XDR *xdrs, remote_storage_vol_get_path_ret *objp)
+{
+
+	 if (!xdr_remote_nonnull_string (xdrs, &objp->name))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
 xdr_remote_procedure (XDR *xdrs, remote_procedure *objp)
 {
 
diff -r 89d154031d13 qemud/remote_protocol.h
--- a/qemud/remote_protocol.h	Sat Oct 27 17:52:41 2007 -0400
+++ b/qemud/remote_protocol.h	Sat Oct 27 17:55:06 2007 -0400
@@ -27,6 +27,8 @@ typedef remote_nonnull_string *remote_st
 #define REMOTE_CPUMAPS_MAX 16384
 #define REMOTE_MIGRATE_COOKIE_MAX 256
 #define REMOTE_NETWORK_NAME_LIST_MAX 256
+#define REMOTE_STORAGE_POOL_NAME_LIST_MAX 256
+#define REMOTE_STORAGE_VOL_NAME_LIST_MAX 1024
 #define REMOTE_DOMAIN_SCHEDULER_PARAMETERS_MAX 16
 
 typedef char remote_uuid[VIR_UUID_BUFLEN];
@@ -44,9 +46,26 @@ struct remote_nonnull_network {
 };
 typedef struct remote_nonnull_network remote_nonnull_network;
 
+struct remote_nonnull_storage_pool {
+	remote_nonnull_string name;
+	remote_uuid uuid;
+};
+typedef struct remote_nonnull_storage_pool remote_nonnull_storage_pool;
+
+struct remote_nonnull_storage_vol {
+	remote_nonnull_storage_pool pool;
+	remote_nonnull_string name;
+	remote_uuid uuid;
+};
+typedef struct remote_nonnull_storage_vol remote_nonnull_storage_vol;
+
 typedef remote_nonnull_domain *remote_domain;
 
 typedef remote_nonnull_network *remote_network;
+
+typedef remote_nonnull_storage_pool *remote_storage_pool;
+
+typedef remote_nonnull_storage_vol *remote_storage_vol;
 
 struct remote_error {
 	int code;
@@ -659,6 +678,237 @@ struct remote_network_set_autostart_args
 	int autostart;
 };
 typedef struct remote_network_set_autostart_args remote_network_set_autostart_args;
+
+struct remote_num_of_storage_pools_ret {
+	int num;
+};
+typedef struct remote_num_of_storage_pools_ret remote_num_of_storage_pools_ret;
+
+struct remote_list_storage_pools_args {
+	int maxnames;
+};
+typedef struct remote_list_storage_pools_args remote_list_storage_pools_args;
+
+struct remote_list_storage_pools_ret {
+	struct {
+		u_int names_len;
+		remote_nonnull_string *names_val;
+	} names;
+};
+typedef struct remote_list_storage_pools_ret remote_list_storage_pools_ret;
+
+struct remote_num_of_defined_storage_pools_ret {
+	int num;
+};
+typedef struct remote_num_of_defined_storage_pools_ret remote_num_of_defined_storage_pools_ret;
+
+struct remote_list_defined_storage_pools_args {
+	int maxnames;
+};
+typedef struct remote_list_defined_storage_pools_args remote_list_defined_storage_pools_args;
+
+struct remote_list_defined_storage_pools_ret {
+	struct {
+		u_int names_len;
+		remote_nonnull_string *names_val;
+	} names;
+};
+typedef struct remote_list_defined_storage_pools_ret remote_list_defined_storage_pools_ret;
+
+struct remote_storage_pool_lookup_by_uuid_args {
+	remote_uuid uuid;
+};
+typedef struct remote_storage_pool_lookup_by_uuid_args remote_storage_pool_lookup_by_uuid_args;
+
+struct remote_storage_pool_lookup_by_uuid_ret {
+	remote_nonnull_storage_pool pool;
+};
+typedef struct remote_storage_pool_lookup_by_uuid_ret remote_storage_pool_lookup_by_uuid_ret;
+
+struct remote_storage_pool_lookup_by_name_args {
+	remote_nonnull_string name;
+};
+typedef struct remote_storage_pool_lookup_by_name_args remote_storage_pool_lookup_by_name_args;
+
+struct remote_storage_pool_lookup_by_name_ret {
+	remote_nonnull_storage_pool pool;
+};
+typedef struct remote_storage_pool_lookup_by_name_ret remote_storage_pool_lookup_by_name_ret;
+
+struct remote_storage_pool_create_xml_args {
+	remote_nonnull_string xml;
+};
+typedef struct remote_storage_pool_create_xml_args remote_storage_pool_create_xml_args;
+
+struct remote_storage_pool_create_xml_ret {
+	remote_nonnull_storage_pool pool;
+};
+typedef struct remote_storage_pool_create_xml_ret remote_storage_pool_create_xml_ret;
+
+struct remote_storage_pool_define_xml_args {
+	remote_nonnull_string xml;
+};
+typedef struct remote_storage_pool_define_xml_args remote_storage_pool_define_xml_args;
+
+struct remote_storage_pool_define_xml_ret {
+	remote_nonnull_storage_pool pool;
+};
+typedef struct remote_storage_pool_define_xml_ret remote_storage_pool_define_xml_ret;
+
+struct remote_storage_pool_undefine_args {
+	remote_nonnull_storage_pool pool;
+};
+typedef struct remote_storage_pool_undefine_args remote_storage_pool_undefine_args;
+
+struct remote_storage_pool_create_args {
+	remote_nonnull_storage_pool pool;
+};
+typedef struct remote_storage_pool_create_args remote_storage_pool_create_args;
+
+struct remote_storage_pool_shutdown_args {
+	remote_nonnull_storage_pool pool;
+};
+typedef struct remote_storage_pool_shutdown_args remote_storage_pool_shutdown_args;
+
+struct remote_storage_pool_destroy_args {
+	remote_nonnull_storage_pool pool;
+};
+typedef struct remote_storage_pool_destroy_args remote_storage_pool_destroy_args;
+
+struct remote_storage_pool_dump_xml_args {
+	remote_nonnull_storage_pool pool;
+	int flags;
+};
+typedef struct remote_storage_pool_dump_xml_args remote_storage_pool_dump_xml_args;
+
+struct remote_storage_pool_dump_xml_ret {
+	remote_nonnull_string xml;
+};
+typedef struct remote_storage_pool_dump_xml_ret remote_storage_pool_dump_xml_ret;
+
+struct remote_storage_pool_get_info_args {
+	remote_nonnull_storage_pool pool;
+};
+typedef struct remote_storage_pool_get_info_args remote_storage_pool_get_info_args;
+
+struct remote_storage_pool_get_info_ret {
+	u_char state;
+	u_quad_t capacity;
+	u_quad_t allocation;
+};
+typedef struct remote_storage_pool_get_info_ret remote_storage_pool_get_info_ret;
+
+struct remote_storage_pool_get_autostart_args {
+	remote_nonnull_storage_pool pool;
+};
+typedef struct remote_storage_pool_get_autostart_args remote_storage_pool_get_autostart_args;
+
+struct remote_storage_pool_get_autostart_ret {
+	int autostart;
+};
+typedef struct remote_storage_pool_get_autostart_ret remote_storage_pool_get_autostart_ret;
+
+struct remote_storage_pool_set_autostart_args {
+	remote_nonnull_storage_pool pool;
+	int autostart;
+};
+typedef struct remote_storage_pool_set_autostart_args remote_storage_pool_set_autostart_args;
+
+struct remote_storage_pool_num_of_volumes_args {
+	remote_nonnull_storage_pool pool;
+};
+typedef struct remote_storage_pool_num_of_volumes_args remote_storage_pool_num_of_volumes_args;
+
+struct remote_storage_pool_num_of_volumes_ret {
+	int num;
+};
+typedef struct remote_storage_pool_num_of_volumes_ret remote_storage_pool_num_of_volumes_ret;
+
+struct remote_storage_pool_list_volumes_args {
+	remote_nonnull_storage_pool pool;
+	int maxnames;
+};
+typedef struct remote_storage_pool_list_volumes_args remote_storage_pool_list_volumes_args;
+
+struct remote_storage_pool_list_volumes_ret {
+	struct {
+		u_int names_len;
+		remote_nonnull_string *names_val;
+	} names;
+};
+typedef struct remote_storage_pool_list_volumes_ret remote_storage_pool_list_volumes_ret;
+
+struct remote_storage_vol_lookup_by_uuid_args {
+	remote_nonnull_storage_pool pool;
+	remote_uuid uuid;
+};
+typedef struct remote_storage_vol_lookup_by_uuid_args remote_storage_vol_lookup_by_uuid_args;
+
+struct remote_storage_vol_lookup_by_uuid_ret {
+	remote_nonnull_storage_vol vol;
+};
+typedef struct remote_storage_vol_lookup_by_uuid_ret remote_storage_vol_lookup_by_uuid_ret;
+
+struct remote_storage_vol_lookup_by_name_args {
+	remote_nonnull_storage_pool pool;
+	remote_nonnull_string name;
+};
+typedef struct remote_storage_vol_lookup_by_name_args remote_storage_vol_lookup_by_name_args;
+
+struct remote_storage_vol_lookup_by_name_ret {
+	remote_nonnull_storage_vol vol;
+};
+typedef struct remote_storage_vol_lookup_by_name_ret remote_storage_vol_lookup_by_name_ret;
+
+struct remote_storage_vol_create_xml_args {
+	remote_nonnull_storage_pool pool;
+	remote_nonnull_string xml;
+	int flags;
+};
+typedef struct remote_storage_vol_create_xml_args remote_storage_vol_create_xml_args;
+
+struct remote_storage_vol_create_xml_ret {
+	remote_nonnull_storage_vol vol;
+};
+typedef struct remote_storage_vol_create_xml_ret remote_storage_vol_create_xml_ret;
+
+struct remote_storage_vol_destroy_args {
+	remote_nonnull_storage_vol vol;
+};
+typedef struct remote_storage_vol_destroy_args remote_storage_vol_destroy_args;
+
+struct remote_storage_vol_dump_xml_args {
+	remote_nonnull_storage_vol vol;
+	int flags;
+};
+typedef struct remote_storage_vol_dump_xml_args remote_storage_vol_dump_xml_args;
+
+struct remote_storage_vol_dump_xml_ret {
+	remote_nonnull_string xml;
+};
+typedef struct remote_storage_vol_dump_xml_ret remote_storage_vol_dump_xml_ret;
+
+struct remote_storage_vol_get_info_args {
+	remote_nonnull_storage_vol vol;
+};
+typedef struct remote_storage_vol_get_info_args remote_storage_vol_get_info_args;
+
+struct remote_storage_vol_get_info_ret {
+	char type;
+	u_quad_t capacity;
+	u_quad_t allocation;
+};
+typedef struct remote_storage_vol_get_info_ret remote_storage_vol_get_info_ret;
+
+struct remote_storage_vol_get_path_args {
+	remote_nonnull_storage_vol vol;
+};
+typedef struct remote_storage_vol_get_path_args remote_storage_vol_get_path_args;
+
+struct remote_storage_vol_get_path_ret {
+	remote_nonnull_string name;
+};
+typedef struct remote_storage_vol_get_path_ret remote_storage_vol_get_path_ret;
 #define REMOTE_PROGRAM 0x20008086
 #define REMOTE_PROTOCOL_VERSION 1
 
@@ -728,6 +978,31 @@ enum remote_procedure {
 	REMOTE_PROC_DOMAIN_MIGRATE_FINISH = 63,
 	REMOTE_PROC_DOMAIN_BLOCK_STATS = 64,
 	REMOTE_PROC_DOMAIN_INTERFACE_STATS = 65,
+	REMOTE_PROC_NUM_OF_STORAGE_POOLS = 66,
+	REMOTE_PROC_LIST_STORAGE_POOLS = 67,
+	REMOTE_PROC_NUM_OF_DEFINED_STORAGE_POOLS = 68,
+	REMOTE_PROC_LIST_DEFINED_STORAGE_POOLS = 69,
+	REMOTE_PROC_STORAGE_POOL_CREATE_XML = 70,
+	REMOTE_PROC_STORAGE_POOL_DEFINE_XML = 71,
+	REMOTE_PROC_STORAGE_POOL_CREATE = 72,
+	REMOTE_PROC_STORAGE_POOL_SHUTDOWN = 73,
+	REMOTE_PROC_STORAGE_POOL_DESTROY = 74,
+	REMOTE_PROC_STORAGE_POOL_UNDEFINE = 75,
+	REMOTE_PROC_STORAGE_POOL_LOOKUP_BY_NAME = 76,
+	REMOTE_PROC_STORAGE_POOL_LOOKUP_BY_UUID = 77,
+	REMOTE_PROC_STORAGE_POOL_GET_INFO = 78,
+	REMOTE_PROC_STORAGE_POOL_DUMP_XML = 79,
+	REMOTE_PROC_STORAGE_POOL_GET_AUTOSTART = 80,
+	REMOTE_PROC_STORAGE_POOL_SET_AUTOSTART = 81,
+	REMOTE_PROC_STORAGE_POOL_NUM_OF_VOLUMES = 82,
+	REMOTE_PROC_STORAGE_POOL_LIST_VOLUMES = 83,
+	REMOTE_PROC_STORAGE_VOL_CREATE_XML = 84,
+	REMOTE_PROC_STORAGE_VOL_DESTROY = 85,
+	REMOTE_PROC_STORAGE_VOL_LOOKUP_BY_NAME = 86,
+	REMOTE_PROC_STORAGE_VOL_LOOKUP_BY_UUID = 87,
+	REMOTE_PROC_STORAGE_VOL_GET_INFO = 88,
+	REMOTE_PROC_STORAGE_VOL_DUMP_XML = 89,
+	REMOTE_PROC_STORAGE_VOL_GET_PATH = 90,
 };
 typedef enum remote_procedure remote_procedure;
 
@@ -762,8 +1037,12 @@ extern  bool_t xdr_remote_uuid (XDR *, r
 extern  bool_t xdr_remote_uuid (XDR *, remote_uuid);
 extern  bool_t xdr_remote_nonnull_domain (XDR *, remote_nonnull_domain*);
 extern  bool_t xdr_remote_nonnull_network (XDR *, remote_nonnull_network*);
+extern  bool_t xdr_remote_nonnull_storage_pool (XDR *, remote_nonnull_storage_pool*);
+extern  bool_t xdr_remote_nonnull_storage_vol (XDR *, remote_nonnull_storage_vol*);
 extern  bool_t xdr_remote_domain (XDR *, remote_domain*);
 extern  bool_t xdr_remote_network (XDR *, remote_network*);
+extern  bool_t xdr_remote_storage_pool (XDR *, remote_storage_pool*);
+extern  bool_t xdr_remote_storage_vol (XDR *, remote_storage_vol*);
 extern  bool_t xdr_remote_error (XDR *, remote_error*);
 extern  bool_t xdr_remote_vcpu_info (XDR *, remote_vcpu_info*);
 extern  bool_t xdr_remote_sched_param_value (XDR *, remote_sched_param_value*);
@@ -863,6 +1142,48 @@ extern  bool_t xdr_remote_network_get_au
 extern  bool_t xdr_remote_network_get_autostart_args (XDR *, remote_network_get_autostart_args*);
 extern  bool_t xdr_remote_network_get_autostart_ret (XDR *, remote_network_get_autostart_ret*);
 extern  bool_t xdr_remote_network_set_autostart_args (XDR *, remote_network_set_autostart_args*);
+extern  bool_t xdr_remote_num_of_storage_pools_ret (XDR *, remote_num_of_storage_pools_ret*);
+extern  bool_t xdr_remote_list_storage_pools_args (XDR *, remote_list_storage_pools_args*);
+extern  bool_t xdr_remote_list_storage_pools_ret (XDR *, remote_list_storage_pools_ret*);
+extern  bool_t xdr_remote_num_of_defined_storage_pools_ret (XDR *, remote_num_of_defined_storage_pools_ret*);
+extern  bool_t xdr_remote_list_defined_storage_pools_args (XDR *, remote_list_defined_storage_pools_args*);
+extern  bool_t xdr_remote_list_defined_storage_pools_ret (XDR *, remote_list_defined_storage_pools_ret*);
+extern  bool_t xdr_remote_storage_pool_lookup_by_uuid_args (XDR *, remote_storage_pool_lookup_by_uuid_args*);
+extern  bool_t xdr_remote_storage_pool_lookup_by_uuid_ret (XDR *, remote_storage_pool_lookup_by_uuid_ret*);
+extern  bool_t xdr_remote_storage_pool_lookup_by_name_args (XDR *, remote_storage_pool_lookup_by_name_args*);
+extern  bool_t xdr_remote_storage_pool_lookup_by_name_ret (XDR *, remote_storage_pool_lookup_by_name_ret*);
+extern  bool_t xdr_remote_storage_pool_create_xml_args (XDR *, remote_storage_pool_create_xml_args*);
+extern  bool_t xdr_remote_storage_pool_create_xml_ret (XDR *, remote_storage_pool_create_xml_ret*);
+extern  bool_t xdr_remote_storage_pool_define_xml_args (XDR *, remote_storage_pool_define_xml_args*);
+extern  bool_t xdr_remote_storage_pool_define_xml_ret (XDR *, remote_storage_pool_define_xml_ret*);
+extern  bool_t xdr_remote_storage_pool_undefine_args (XDR *, remote_storage_pool_undefine_args*);
+extern  bool_t xdr_remote_storage_pool_create_args (XDR *, remote_storage_pool_create_args*);
+extern  bool_t xdr_remote_storage_pool_shutdown_args (XDR *, remote_storage_pool_shutdown_args*);
+extern  bool_t xdr_remote_storage_pool_destroy_args (XDR *, remote_storage_pool_destroy_args*);
+extern  bool_t xdr_remote_storage_pool_dump_xml_args (XDR *, remote_storage_pool_dump_xml_args*);
+extern  bool_t xdr_remote_storage_pool_dump_xml_ret (XDR *, remote_storage_pool_dump_xml_ret*);
+extern  bool_t xdr_remote_storage_pool_get_info_args (XDR *, remote_storage_pool_get_info_args*);
+extern  bool_t xdr_remote_storage_pool_get_info_ret (XDR *, remote_storage_pool_get_info_ret*);
+extern  bool_t xdr_remote_storage_pool_get_autostart_args (XDR *, remote_storage_pool_get_autostart_args*);
+extern  bool_t xdr_remote_storage_pool_get_autostart_ret (XDR *, remote_storage_pool_get_autostart_ret*);
+extern  bool_t xdr_remote_storage_pool_set_autostart_args (XDR *, remote_storage_pool_set_autostart_args*);
+extern  bool_t xdr_remote_storage_pool_num_of_volumes_args (XDR *, remote_storage_pool_num_of_volumes_args*);
+extern  bool_t xdr_remote_storage_pool_num_of_volumes_ret (XDR *, remote_storage_pool_num_of_volumes_ret*);
+extern  bool_t xdr_remote_storage_pool_list_volumes_args (XDR *, remote_storage_pool_list_volumes_args*);
+extern  bool_t xdr_remote_storage_pool_list_volumes_ret (XDR *, remote_storage_pool_list_volumes_ret*);
+extern  bool_t xdr_remote_storage_vol_lookup_by_uuid_args (XDR *, remote_storage_vol_lookup_by_uuid_args*);
+extern  bool_t xdr_remote_storage_vol_lookup_by_uuid_ret (XDR *, remote_storage_vol_lookup_by_uuid_ret*);
+extern  bool_t xdr_remote_storage_vol_lookup_by_name_args (XDR *, remote_storage_vol_lookup_by_name_args*);
+extern  bool_t xdr_remote_storage_vol_lookup_by_name_ret (XDR *, remote_storage_vol_lookup_by_name_ret*);
+extern  bool_t xdr_remote_storage_vol_create_xml_args (XDR *, remote_storage_vol_create_xml_args*);
+extern  bool_t xdr_remote_storage_vol_create_xml_ret (XDR *, remote_storage_vol_create_xml_ret*);
+extern  bool_t xdr_remote_storage_vol_destroy_args (XDR *, remote_storage_vol_destroy_args*);
+extern  bool_t xdr_remote_storage_vol_dump_xml_args (XDR *, remote_storage_vol_dump_xml_args*);
+extern  bool_t xdr_remote_storage_vol_dump_xml_ret (XDR *, remote_storage_vol_dump_xml_ret*);
+extern  bool_t xdr_remote_storage_vol_get_info_args (XDR *, remote_storage_vol_get_info_args*);
+extern  bool_t xdr_remote_storage_vol_get_info_ret (XDR *, remote_storage_vol_get_info_ret*);
+extern  bool_t xdr_remote_storage_vol_get_path_args (XDR *, remote_storage_vol_get_path_args*);
+extern  bool_t xdr_remote_storage_vol_get_path_ret (XDR *, remote_storage_vol_get_path_ret*);
 extern  bool_t xdr_remote_procedure (XDR *, remote_procedure*);
 extern  bool_t xdr_remote_message_direction (XDR *, remote_message_direction*);
 extern  bool_t xdr_remote_message_status (XDR *, remote_message_status*);
@@ -874,8 +1195,12 @@ extern bool_t xdr_remote_uuid ();
 extern bool_t xdr_remote_uuid ();
 extern bool_t xdr_remote_nonnull_domain ();
 extern bool_t xdr_remote_nonnull_network ();
+extern bool_t xdr_remote_nonnull_storage_pool ();
+extern bool_t xdr_remote_nonnull_storage_vol ();
 extern bool_t xdr_remote_domain ();
 extern bool_t xdr_remote_network ();
+extern bool_t xdr_remote_storage_pool ();
+extern bool_t xdr_remote_storage_vol ();
 extern bool_t xdr_remote_error ();
 extern bool_t xdr_remote_vcpu_info ();
 extern bool_t xdr_remote_sched_param_value ();
@@ -975,6 +1300,48 @@ extern bool_t xdr_remote_network_get_aut
 extern bool_t xdr_remote_network_get_autostart_args ();
 extern bool_t xdr_remote_network_get_autostart_ret ();
 extern bool_t xdr_remote_network_set_autostart_args ();
+extern bool_t xdr_remote_num_of_storage_pools_ret ();
+extern bool_t xdr_remote_list_storage_pools_args ();
+extern bool_t xdr_remote_list_storage_pools_ret ();
+extern bool_t xdr_remote_num_of_defined_storage_pools_ret ();
+extern bool_t xdr_remote_list_defined_storage_pools_args ();
+extern bool_t xdr_remote_list_defined_storage_pools_ret ();
+extern bool_t xdr_remote_storage_pool_lookup_by_uuid_args ();
+extern bool_t xdr_remote_storage_pool_lookup_by_uuid_ret ();
+extern bool_t xdr_remote_storage_pool_lookup_by_name_args ();
+extern bool_t xdr_remote_storage_pool_lookup_by_name_ret ();
+extern bool_t xdr_remote_storage_pool_create_xml_args ();
+extern bool_t xdr_remote_storage_pool_create_xml_ret ();
+extern bool_t xdr_remote_storage_pool_define_xml_args ();
+extern bool_t xdr_remote_storage_pool_define_xml_ret ();
+extern bool_t xdr_remote_storage_pool_undefine_args ();
+extern bool_t xdr_remote_storage_pool_create_args ();
+extern bool_t xdr_remote_storage_pool_shutdown_args ();
+extern bool_t xdr_remote_storage_pool_destroy_args ();
+extern bool_t xdr_remote_storage_pool_dump_xml_args ();
+extern bool_t xdr_remote_storage_pool_dump_xml_ret ();
+extern bool_t xdr_remote_storage_pool_get_info_args ();
+extern bool_t xdr_remote_storage_pool_get_info_ret ();
+extern bool_t xdr_remote_storage_pool_get_autostart_args ();
+extern bool_t xdr_remote_storage_pool_get_autostart_ret ();
+extern bool_t xdr_remote_storage_pool_set_autostart_args ();
+extern bool_t xdr_remote_storage_pool_num_of_volumes_args ();
+extern bool_t xdr_remote_storage_pool_num_of_volumes_ret ();
+extern bool_t xdr_remote_storage_pool_list_volumes_args ();
+extern bool_t xdr_remote_storage_pool_list_volumes_ret ();
+extern bool_t xdr_remote_storage_vol_lookup_by_uuid_args ();
+extern bool_t xdr_remote_storage_vol_lookup_by_uuid_ret ();
+extern bool_t xdr_remote_storage_vol_lookup_by_name_args ();
+extern bool_t xdr_remote_storage_vol_lookup_by_name_ret ();
+extern bool_t xdr_remote_storage_vol_create_xml_args ();
+extern bool_t xdr_remote_storage_vol_create_xml_ret ();
+extern bool_t xdr_remote_storage_vol_destroy_args ();
+extern bool_t xdr_remote_storage_vol_dump_xml_args ();
+extern bool_t xdr_remote_storage_vol_dump_xml_ret ();
+extern bool_t xdr_remote_storage_vol_get_info_args ();
+extern bool_t xdr_remote_storage_vol_get_info_ret ();
+extern bool_t xdr_remote_storage_vol_get_path_args ();
+extern bool_t xdr_remote_storage_vol_get_path_ret ();
 extern bool_t xdr_remote_procedure ();
 extern bool_t xdr_remote_message_direction ();
 extern bool_t xdr_remote_message_status ();
diff -r 89d154031d13 qemud/remote_protocol.x
--- a/qemud/remote_protocol.x	Sat Oct 27 17:52:41 2007 -0400
+++ b/qemud/remote_protocol.x	Sat Oct 27 17:55:05 2007 -0400
@@ -78,6 +78,12 @@ const REMOTE_MIGRATE_COOKIE_MAX = 256;
 /* Upper limit on lists of network names. */
 const REMOTE_NETWORK_NAME_LIST_MAX = 256;
 
+/* Upper limit on lists of storage pool names. */
+const REMOTE_STORAGE_POOL_NAME_LIST_MAX = 256;
+
+/* Upper limit on lists of storage vol names. */
+const REMOTE_STORAGE_VOL_NAME_LIST_MAX = 1024;
+
 /* Upper limit on list of scheduler parameters. */
 const REMOTE_DOMAIN_SCHEDULER_PARAMETERS_MAX = 16;
 
@@ -93,6 +99,19 @@ struct remote_nonnull_domain {
 
 /* A network which may not be NULL. */
 struct remote_nonnull_network {
+    remote_nonnull_string name;
+    remote_uuid uuid;
+};
+
+/* A storage pool which may not be NULL. */
+struct remote_nonnull_storage_pool {
+    remote_nonnull_string name;
+    remote_uuid uuid;
+};
+
+/* A storage vol which may not be NULL. */
+struct remote_nonnull_storage_vol {
+    remote_nonnull_storage_pool pool;
     remote_nonnull_string name;
     remote_uuid uuid;
 };
@@ -100,6 +119,8 @@ struct remote_nonnull_network {
 /* A domain or network which may be NULL. */
 typedef remote_nonnull_domain *remote_domain;
 typedef remote_nonnull_network *remote_network;
+typedef remote_nonnull_storage_pool *remote_storage_pool;
+typedef remote_nonnull_storage_vol *remote_storage_vol;
 
 /* Error message. See <virterror.h> for explanation of fields. */
 
@@ -610,6 +631,195 @@ struct remote_network_set_autostart_args
 struct remote_network_set_autostart_args {
     remote_nonnull_network net;
     int autostart;
+};
+
+
+
+
+/* Storage pool calls: */
+
+struct remote_num_of_storage_pools_ret {
+    int num;
+};
+
+struct remote_list_storage_pools_args {
+    int maxnames;
+};
+
+struct remote_list_storage_pools_ret {
+    remote_nonnull_string names<REMOTE_STORAGE_POOL_NAME_LIST_MAX>;
+};
+
+struct remote_num_of_defined_storage_pools_ret {
+    int num;
+};
+
+struct remote_list_defined_storage_pools_args {
+    int maxnames;
+};
+
+struct remote_list_defined_storage_pools_ret {
+    remote_nonnull_string names<REMOTE_STORAGE_POOL_NAME_LIST_MAX>;
+};
+
+struct remote_storage_pool_lookup_by_uuid_args {
+    remote_uuid uuid;
+};
+
+struct remote_storage_pool_lookup_by_uuid_ret {
+    remote_nonnull_storage_pool pool;
+};
+
+struct remote_storage_pool_lookup_by_name_args {
+    remote_nonnull_string name;
+};
+
+struct remote_storage_pool_lookup_by_name_ret {
+    remote_nonnull_storage_pool pool;
+};
+
+struct remote_storage_pool_create_xml_args {
+    remote_nonnull_string xml;
+};
+
+struct remote_storage_pool_create_xml_ret {
+    remote_nonnull_storage_pool pool;
+};
+
+struct remote_storage_pool_define_xml_args {
+    remote_nonnull_string xml;
+};
+
+struct remote_storage_pool_define_xml_ret {
+    remote_nonnull_storage_pool pool;
+};
+
+struct remote_storage_pool_undefine_args {
+    remote_nonnull_storage_pool pool;
+};
+
+struct remote_storage_pool_create_args {
+    remote_nonnull_storage_pool pool;
+};
+
+struct remote_storage_pool_shutdown_args {
+    remote_nonnull_storage_pool pool;
+};
+
+struct remote_storage_pool_destroy_args {
+    remote_nonnull_storage_pool pool;
+};
+
+struct remote_storage_pool_dump_xml_args {
+    remote_nonnull_storage_pool pool;
+    int flags;
+};
+
+struct remote_storage_pool_dump_xml_ret {
+    remote_nonnull_string xml;
+};
+
+struct remote_storage_pool_get_info_args {
+    remote_nonnull_storage_pool pool;
+};
+
+struct remote_storage_pool_get_info_ret {
+    unsigned char state;
+    unsigned hyper capacity;
+    unsigned hyper allocation;
+};
+
+struct remote_storage_pool_get_autostart_args {
+    remote_nonnull_storage_pool pool;
+};
+
+struct remote_storage_pool_get_autostart_ret {
+    int autostart;
+};
+
+struct remote_storage_pool_set_autostart_args {
+    remote_nonnull_storage_pool pool;
+    int autostart;
+};
+
+
+
+/* Storage vol calls: */
+
+struct remote_storage_pool_num_of_volumes_args {
+    remote_nonnull_storage_pool pool;
+};
+
+struct remote_storage_pool_num_of_volumes_ret {
+    int num;
+};
+
+struct remote_storage_pool_list_volumes_args {
+    remote_nonnull_storage_pool pool;
+    int maxnames;
+};
+
+struct remote_storage_pool_list_volumes_ret {
+    remote_nonnull_string names<REMOTE_STORAGE_VOL_NAME_LIST_MAX>;
+};
+
+struct remote_storage_vol_lookup_by_uuid_args {
+    remote_nonnull_storage_pool pool;
+    remote_uuid uuid;
+};
+
+struct remote_storage_vol_lookup_by_uuid_ret {
+    remote_nonnull_storage_vol vol;
+};
+
+struct remote_storage_vol_lookup_by_name_args {
+    remote_nonnull_storage_pool pool;
+    remote_nonnull_string name;
+};
+
+struct remote_storage_vol_lookup_by_name_ret {
+    remote_nonnull_storage_vol vol;
+};
+
+struct remote_storage_vol_create_xml_args {
+    remote_nonnull_storage_pool pool;
+    remote_nonnull_string xml;
+    int flags;
+};
+
+struct remote_storage_vol_create_xml_ret {
+    remote_nonnull_storage_vol vol;
+};
+
+struct remote_storage_vol_destroy_args {
+    remote_nonnull_storage_vol vol;
+};
+
+struct remote_storage_vol_dump_xml_args {
+    remote_nonnull_storage_vol vol;
+    int flags;
+};
+
+struct remote_storage_vol_dump_xml_ret {
+    remote_nonnull_string xml;
+};
+
+struct remote_storage_vol_get_info_args {
+    remote_nonnull_storage_vol vol;
+};
+
+struct remote_storage_vol_get_info_ret {
+    char type;
+    unsigned hyper capacity;
+    unsigned hyper allocation;
+};
+
+struct remote_storage_vol_get_path_args {
+    remote_nonnull_storage_vol vol;
+};
+
+struct remote_storage_vol_get_path_ret {
+    remote_nonnull_string name;
 };
 
 /*----- Protocol. -----*/
@@ -683,7 +893,33 @@ enum remote_procedure {
     REMOTE_PROC_DOMAIN_MIGRATE_PERFORM = 62,
     REMOTE_PROC_DOMAIN_MIGRATE_FINISH = 63,
     REMOTE_PROC_DOMAIN_BLOCK_STATS = 64,
-    REMOTE_PROC_DOMAIN_INTERFACE_STATS = 65
+    REMOTE_PROC_DOMAIN_INTERFACE_STATS = 65,
+    REMOTE_PROC_NUM_OF_STORAGE_POOLS = 66,
+    REMOTE_PROC_LIST_STORAGE_POOLS = 67,
+    REMOTE_PROC_NUM_OF_DEFINED_STORAGE_POOLS = 68,
+    REMOTE_PROC_LIST_DEFINED_STORAGE_POOLS = 69,
+    REMOTE_PROC_STORAGE_POOL_CREATE_XML = 70,
+    REMOTE_PROC_STORAGE_POOL_DEFINE_XML = 71,
+    REMOTE_PROC_STORAGE_POOL_CREATE = 72,
+    REMOTE_PROC_STORAGE_POOL_SHUTDOWN = 73,
+    REMOTE_PROC_STORAGE_POOL_DESTROY = 74,
+    REMOTE_PROC_STORAGE_POOL_UNDEFINE = 75,
+    REMOTE_PROC_STORAGE_POOL_LOOKUP_BY_NAME = 76,
+    REMOTE_PROC_STORAGE_POOL_LOOKUP_BY_UUID = 77,
+    REMOTE_PROC_STORAGE_POOL_GET_INFO = 78,
+    REMOTE_PROC_STORAGE_POOL_DUMP_XML = 79,
+    REMOTE_PROC_STORAGE_POOL_GET_AUTOSTART = 80,
+    REMOTE_PROC_STORAGE_POOL_SET_AUTOSTART = 81,
+
+    REMOTE_PROC_STORAGE_POOL_NUM_OF_VOLUMES = 82,
+    REMOTE_PROC_STORAGE_POOL_LIST_VOLUMES = 83,
+    REMOTE_PROC_STORAGE_VOL_CREATE_XML = 84,
+    REMOTE_PROC_STORAGE_VOL_DESTROY = 85,
+    REMOTE_PROC_STORAGE_VOL_LOOKUP_BY_NAME = 86,
+    REMOTE_PROC_STORAGE_VOL_LOOKUP_BY_UUID = 87,
+    REMOTE_PROC_STORAGE_VOL_GET_INFO = 88,
+    REMOTE_PROC_STORAGE_VOL_DUMP_XML = 89,
+    REMOTE_PROC_STORAGE_VOL_GET_PATH = 90
 };
 
 /* Custom RPC structure. */

-- 
|=- Red Hat, Engineering, Emerging Technologies, Boston.  +1 978 392 2496 -=|
|=-           Perl modules: http://search.cpan.org/~danberr/              -=|
|=-               Projects: http://freshmeat.net/~danielpb/               -=|
|=-  GnuPG: 7D3B9505   F3C9 553F A1DA 4AC2 5648 23C1 B3DF F742 7D3B 9505  -=| 


[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]