cpupools [3/6]: libxen changes

Signed-off-by: Juergen Gross <juergen.gross@ts.fujitsu.com>

11 files changed, 1971 insertions, 4 deletions

diff --git a/tools/libxen/include/xen/api/xen_all.h b/tools/libxen/include/xen/api/xen_all.h
index 4d08226668..52113c7795 100644
--- a/tools/libxen/include/xen/api/xen_all.h
+++ b/tools/libxen/include/xen/api/xen_all.h
@@ -37,4 +37,5 @@
 #include <xen/api/xen_vm_power_state.h>
 #include <xen/api/xen_vtpm.h>
 #include <xen/api/xen_xspolicy.h>
+#include <xen/api/xen_cpu_pool.h>
 #endif
diff --git a/tools/libxen/include/xen/api/xen_cpu_pool.h b/tools/libxen/include/xen/api/xen_cpu_pool.h
new file mode 100644
index 0000000000..423c076cc2
--- /dev/null
+++ b/tools/libxen/include/xen/api/xen_cpu_pool.h
@@ -0,0 +1,424 @@
+/*
+ * Copyright (c) 2006-2007, XenSource Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
+ */
+
+#ifndef XEN_CPU_POOL_H
+#define XEN_CPU_POOL_H
+
+#include <stddef.h>
+#include <stdlib.h>
+
+#include <xen/api/xen_common.h>
+#include <xen/api/xen_string_set.h>
+#include <xen/api/xen_string_string_map.h>
+#include <xen/api/xen_host_cpu_decl.h>
+#include <xen/api/xen_host.h>
+#include <xen/api/xen_vm_decl.h>
+#include <xen/api/xen_vm.h>
+#include <xen/api/xen_cpu_pool_decl.h>
+
+/*
+ * The cpu_pool class.
+ *
+ * Management of CPU pools.
+ */
+
+
+/**
+ * Free the given xen_cpu_pool.  The given handle must have been allocated
+ * by this library.
+ */
+extern void
+xen_cpu_pool_free(xen_cpu_pool cpu_pool);
+
+
+typedef struct xen_cpu_pool_set
+{
+    size_t size;
+    xen_cpu_pool *contents[];
+} xen_cpu_pool_set;
+
+/**
+ * Allocate a xen_cpu_pool_set of the given size.
+ */
+extern xen_cpu_pool_set *
+xen_cpu_pool_set_alloc(size_t size);
+
+/**
+ * Free the given xen_cpu_pool_set.  The given set must have been allocated
+ * by this library.
+ */
+extern void
+xen_cpu_pool_set_free(xen_cpu_pool_set *set);
+
+
+typedef struct xen_cpu_pool_record
+{
+    xen_cpu_pool handle;
+    char *uuid;
+    char *name_label;
+    char *name_description;
+    struct xen_host_record_opt *resident_on;
+    bool auto_power_on;
+    struct xen_vm_record_opt_set *started_vms;
+    int64_t ncpu;
+    char *sched_policy;
+    struct xen_string_set *proposed_cpus;
+    struct xen_host_cpu_record_opt_set *host_cpus;
+    bool activated;
+    xen_string_string_map *other_config;
+} xen_cpu_pool_record;
+
+/**
+ * Allocate a xen_cpu_pool_record.
+ */
+extern xen_cpu_pool_record *
+xen_cpu_pool_record_alloc(void);
+
+/**
+ * Free the given xen_cpu_pool_record, and all referenced values.  The given
+ * record must have been allocated by this library.
+ */
+extern void
+xen_cpu_pool_record_free(xen_cpu_pool_record *record);
+
+
+typedef struct xen_cpu_pool_record_opt
+{
+    bool is_record;
+    union
+    {
+        xen_cpu_pool handle;
+        xen_cpu_pool_record *record;
+    } u;
+} xen_cpu_pool_record_opt;
+
+/**
+ * Allocate a xen_cpu_pool_record_opt.
+ */
+extern xen_cpu_pool_record_opt *
+xen_cpu_pool_record_opt_alloc(void);
+
+/**
+ * Free the given xen_cpu_pool_record_opt, and all referenced values.  The
+ * given record_opt must have been allocated by this library.
+ */
+extern void
+xen_cpu_pool_record_opt_free(xen_cpu_pool_record_opt *record_opt);
+
+
+typedef struct xen_cpu_pool_record_set
+{
+    size_t size;
+    xen_cpu_pool_record *contents[];
+} xen_cpu_pool_record_set;
+
+/**
+ * Allocate a xen_cpu_pool_record_set of the given size.
+ */
+extern xen_cpu_pool_record_set *
+xen_cpu_pool_record_set_alloc(size_t size);
+
+/**
+ * Free the given xen_cpu_pool_record_set, and all referenced values.  The
+ * given set must have been allocated by this library.
+ */
+extern void
+xen_cpu_pool_record_set_free(xen_cpu_pool_record_set *set);
+
+
+
+typedef struct xen_cpu_pool_record_opt_set
+{
+    size_t size;
+    xen_cpu_pool_record_opt *contents[];
+} xen_cpu_pool_record_opt_set;
+
+/**
+ * Allocate a xen_cpu_pool_record_opt_set of the given size.
+ */
+extern xen_cpu_pool_record_opt_set *
+xen_cpu_pool_record_opt_set_alloc(size_t size);
+
+/**
+ * Free the given xen_cpu_pool_record_opt_set, and all referenced values.
+ * The given set must have been allocated by this library.
+ */
+extern void
+xen_cpu_pool_record_opt_set_free(xen_cpu_pool_record_opt_set *set);
+
+
+/**
+ * Get a record containing the current state of the given cpu_pool.
+ */
+extern bool
+xen_cpu_pool_get_record(xen_session *session, xen_cpu_pool_record **result,
+    xen_cpu_pool cpu_pool);
+
+
+/**
+ * Get a reference to the cpu_pool instance with the specified UUID.
+ */
+extern bool
+xen_cpu_pool_get_by_uuid(xen_session *session, xen_cpu_pool *result, char *uuid);
+
+
+/**
+ * Create a new cpu_pool instance, and return its handle.
+ */
+extern bool
+xen_cpu_pool_create(xen_session *session, xen_cpu_pool *result,
+    xen_cpu_pool_record *record);
+
+
+/**
+ * Destroy the specified VBD instance.
+ */
+extern bool
+xen_cpu_pool_destroy(xen_session *session, xen_cpu_pool cpu_pool);
+
+
+/**
+ * Get the uuid field of the given cpu_pool.
+ */
+extern bool
+xen_cpu_pool_get_uuid(xen_session *session, char **result, xen_cpu_pool cpu_pool);
+
+
+/**
+ * Deactivate the given cpu_pool.
+ */
+extern bool
+xen_cpu_pool_deactivate(xen_session *session, xen_cpu_pool cpu_pool);
+
+
+/**
+ * Activate the given cpu_pool.
+ */
+extern bool
+xen_cpu_pool_activate(xen_session *session, xen_cpu_pool cpu_pool);
+
+
+/**
+ * Add a physical cpu to the active pool.
+ */
+extern bool
+xen_cpu_pool_add_host_CPU_live(xen_session *session, xen_cpu_pool cpu_pool,
+    xen_host_cpu host_cpu);
+
+
+/**
+ * Remove a physical cpu from the active pool.
+ */
+extern bool
+xen_cpu_pool_remove_host_CPU_live(xen_session *session, xen_cpu_pool cpu_pool,
+    xen_host_cpu host_cpu);
+
+
+/**
+ * Return a list of all the cpu_pools known to the system.
+ */
+extern bool
+xen_cpu_pool_get_all(xen_session *session, struct xen_cpu_pool_set **result);
+
+
+/**
+ * Get the uuid field of the cpu_pool with given name.
+ */
+extern bool
+xen_cpu_pool_get_by_name_label(xen_session *session,
+    struct xen_cpu_pool_set **result, char *label);
+
+
+/**
+ * Get activation state of given cpu_pool.
+ */
+extern bool
+xen_cpu_pool_get_activated(xen_session *session, bool *result,
+    xen_cpu_pool cpu_pool);
+
+
+/**
+ * Get auto_power_on option of given cpu_pool.
+ */
+extern bool
+xen_cpu_pool_get_auto_power_on(xen_session *session, bool *result,
+    xen_cpu_pool cpu_pool);
+
+
+/**
+ * Get host_cpu refs of all physical cpus of cpu_pool.
+ */
+extern bool
+xen_cpu_pool_get_host_CPUs(xen_session *session, struct xen_host_cpu_set **result,
+    xen_cpu_pool cpu_pool);
+
+
+/**
+ * Get name description field of given cpu_pool.
+ */
+extern bool
+xen_cpu_pool_get_name_description(xen_session *session, char **result,
+    xen_cpu_pool cpu_pool);
+
+
+/**
+ * Get name label field of given cpu_pool.
+ */
+extern bool
+xen_cpu_pool_get_name_label(xen_session *session, char **result,
+    xen_cpu_pool cpu_pool);
+
+
+/**
+ * Get count of physical cpus to attach to cpu_pool on activation.
+ */
+extern bool
+xen_cpu_pool_get_ncpu(xen_session *session, int64_t *result,
+    xen_cpu_pool cpu_pool);
+
+
+/**
+ * Get proposed_CPUs field of given cpu_pool.
+ */
+extern bool
+xen_cpu_pool_get_proposed_CPUs(xen_session *session, struct xen_string_set **result,
+    xen_cpu_pool cpu_pool);
+
+
+/**
+ * Get the other_config field of the given cpu_pool.
+ */
+extern bool
+xen_cpu_pool_get_other_config(xen_session *session, xen_string_string_map **result,
+    xen_cpu_pool cpu_pool);
+
+
+/**
+ * Get host the cpu_pool is resident on.
+ */
+extern bool
+xen_cpu_pool_get_resident_on(xen_session *session, xen_host *result,
+    xen_cpu_pool cpu_pool);
+
+
+/**
+ * Get sched_policy field of given cpu_pool.
+ */
+extern bool
+xen_cpu_pool_get_sched_policy(xen_session *session, char **result,
+    xen_cpu_pool cpu_pool);
+
+
+/**
+ * Get set of started vms in given cpu_pool.
+ */
+extern bool
+xen_cpu_pool_get_started_VMs(xen_session *session, xen_vm_set **result,
+    xen_cpu_pool cpu_pool);
+
+
+/**
+ *  Set auto_power_on field of given cpu_pool.
+ */
+extern bool
+xen_cpu_pool_set_auto_power_on(xen_session *session, xen_cpu_pool cpu_pool,
+    bool auto_power_on);
+
+
+/**
+ * Set proposed_CPUs field of given cpu_pool.
+ */
+extern bool
+xen_cpu_pool_set_proposed_CPUs(xen_session *session, xen_cpu_pool cpu_pool,
+    xen_string_set *proposed_cpus);
+
+
+/**
+ * Add a proposed cpu to proposed_CPUs field of given cpu_pool.
+ */
+extern bool
+xen_cpu_pool_add_to_proposed_CPUs(xen_session *session, xen_cpu_pool cpu_pool,
+    char* proposed_cpu);
+
+
+/**
+ * Remove a proposed cpu from proposed_CPUs field of given cpu_pool.
+ */
+extern bool
+xen_cpu_pool_remove_from_proposed_CPUs(xen_session *session, xen_cpu_pool cpu_pool,
+    char* proposed_cpu);
+
+
+/**
+ * Set name_label field of given cpu_pool.
+ */
+extern bool
+xen_cpu_pool_set_name_label(xen_session *session, xen_cpu_pool cpu_pool,
+    char *label);
+
+
+/**
+ * Set name_description field of given cpu_pool.
+ */
+extern bool
+xen_cpu_pool_set_name_description(xen_session *session, xen_cpu_pool cpu_pool,
+    char *descr);
+
+
+/**
+ * Set ncpu field of given cpu_pool.
+ */
+extern bool
+xen_cpu_pool_set_ncpu(xen_session *session, xen_cpu_pool cpu_pool, int64_t ncpu);
+
+
+/**
+ * Set the other_config field of the given cpu_pool.
+ */
+extern bool
+xen_cpu_pool_set_other_config(xen_session *session, xen_cpu_pool cpu_pool,
+    xen_string_string_map *other_config);
+
+
+/**
+ * Add the given key-value pair to the other_config field of the given
+ * cpu_pool.
+ */
+extern bool
+xen_cpu_pool_add_to_other_config(xen_session *session, xen_cpu_pool cpu_pool,
+    char *key, char *value);
+
+
+/**
+ * Remove the given key and its corresponding value from the
+ * other_config field of the given cpu_pool. If the key is not in that Map, then
+ * do nothing.
+ */
+extern bool
+xen_cpu_pool_remove_from_other_config(xen_session *session, xen_cpu_pool cpu_pool,
+    char *key);
+
+/**
+ * Set sched_policy of given cpu_pool.
+ */
+extern bool
+xen_cpu_pool_set_sched_policy(xen_session *session, xen_cpu_pool cpu_pool,
+    char *sched_policy);
+
+
+#endif
diff --git a/tools/libxen/include/xen/api/xen_cpu_pool_decl.h b/tools/libxen/include/xen/api/xen_cpu_pool_decl.h
new file mode 100644
index 0000000000..62878dd71a
--- /dev/null
+++ b/tools/libxen/include/xen/api/xen_cpu_pool_decl.h
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2006-2007, XenSource Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
+ */
+
+#ifndef XEN_CPU_POOL_DECL_H
+#define XEN_CPU_POOL_DECL_H
+
+typedef void *xen_cpu_pool;
+
+struct xen_cpu_pool_set;
+struct xen_cpu_pool_record;
+struct xen_cpu_pool_record_set;
+struct xen_cpu_pool_record_opt;
+struct xen_cpu_pool_record_opt_set;
+
+#endif
diff --git a/tools/libxen/include/xen/api/xen_host.h b/tools/libxen/include/xen/api/xen_host.h
index 9ca40d700e..f3ca5b9d35 100644
--- a/tools/libxen/include/xen/api/xen_host.h
+++ b/tools/libxen/include/xen/api/xen_host.h
@@ -29,7 +29,7 @@
 #include <xen/api/xen_string_set.h>
 #include <xen/api/xen_string_string_map.h>
 #include <xen/api/xen_vm_decl.h>
-
+#include <xen/api/xen_cpu_pool_decl.h>
 
 /*
  * The host class.
@@ -91,6 +91,7 @@ typedef struct xen_host_record
     struct xen_pbd_record_opt_set *pbds;
     struct xen_host_cpu_record_opt_set *host_cpus;
     struct xen_host_metrics_record_opt *metrics;
+    struct xen_cpu_pool_record_opt_set *resident_cpu_pools;
 } xen_host_record;
 
 /**
@@ -494,4 +495,11 @@ extern bool
 xen_host_get_all(xen_session *session, struct xen_host_set **result);
 
 
+/**
+ * Get list of resident cpu pools.
+ */
+extern bool
+xen_host_get_resident_cpu_pools(xen_session *session, struct xen_cpu_pool_set **result,
+       xen_host host);
+
 #endif
diff --git a/tools/libxen/include/xen/api/xen_host_cpu.h b/tools/libxen/include/xen/api/xen_host_cpu.h
index f1bdb7134f..761c8f5dd5 100644
--- a/tools/libxen/include/xen/api/xen_host_cpu.h
+++ b/tools/libxen/include/xen/api/xen_host_cpu.h
@@ -22,6 +22,7 @@
 #include <xen/api/xen_common.h>
 #include <xen/api/xen_host_cpu_decl.h>
 #include <xen/api/xen_host_decl.h>
+#include <xen/api/xen_cpu_pool_decl.h>
 
 
 /*
@@ -72,6 +73,7 @@ typedef struct xen_host_cpu_record
     char *flags;
     char *features;
     double utilisation;
+    struct xen_cpu_pool_record_opt_set *cpu_pools;
 } xen_host_cpu_record;
 
 /**
@@ -244,4 +246,18 @@ extern bool
 xen_host_cpu_get_all(xen_session *session, struct xen_host_cpu_set **result);
 
 
+/**
+ * Get the ref of the cpu_pool to which the host_cpu belongs.
+ */
+extern bool
+xen_host_cpu_get_cpu_pool(xen_session *session, struct xen_cpu_pool_set **result, xen_host_cpu host_cpu);
+
+
+/**
+ * Return a list of all the host_cpus not assigned to a cpu_pool.
+ */
+extern bool
+xen_host_cpu_get_unassigned_cpus(xen_session *session, struct xen_host_cpu_set **result);
+
+
 #endif
diff --git a/tools/libxen/include/xen/api/xen_vm.h b/tools/libxen/include/xen/api/xen_vm.h
index 07b5f51a24..de554fc50c 100644
--- a/tools/libxen/include/xen/api/xen_vm.h
+++ b/tools/libxen/include/xen/api/xen_vm.h
@@ -34,6 +34,7 @@
 #include <xen/api/xen_vm_metrics_decl.h>
 #include <xen/api/xen_vm_power_state.h>
 #include <xen/api/xen_vtpm_decl.h>
+#include <xen/api/xen_cpu_pool_decl.h>
 
 
 /*
@@ -113,6 +114,8 @@ typedef struct xen_vm_record
     struct xen_vm_metrics_record_opt *metrics;
     struct xen_vm_guest_metrics_record_opt *guest_metrics;
     char *security_label;
+    char *pool_name;
+    struct xen_cpu_pool_record_opt_set *cpu_pool;
 } xen_vm_record;
 
 /**
@@ -905,4 +908,33 @@ xen_vm_set_security_label(xen_session *session, int64_t *result, xen_vm vm,
 extern bool
 xen_vm_get_security_label(xen_session *session, char **result, xen_vm vm);
 
+
+/**
+ * Get the cpu_pool ref field of a domain.
+ */
+extern bool
+xen_vm_get_cpu_pool(xen_session *session, struct xen_cpu_pool_set **result, xen_vm vm);
+
+
+/**
+ * Get the pool_name field of a domain.
+ */
+extern bool
+xen_vm_get_pool_name(xen_session *session, char **result, xen_vm vm);
+
+
+/**
+ * Set the pool_name field of a domain.
+ */
+extern bool
+xen_vm_set_pool_name(xen_session *session, xen_vm vm, char *pool_name);
+
+
+/**
+ * Migrate the VM to another cpu_pool (on the same host). This can only be
+ * called when the specified VM is in the Running state.
+ */
+extern bool
+xen_vm_cpu_pool_migrate(xen_session *session, xen_vm vm, xen_cpu_pool cpu_pool);
+
 #endif
diff --git a/tools/libxen/src/xen_cpu_pool.c b/tools/libxen/src/xen_cpu_pool.c
new file mode 100644
index 0000000000..5186da85b9
--- /dev/null
+++ b/tools/libxen/src/xen_cpu_pool.c
@@ -0,0 +1,671 @@
+/*
+ * Copyright (c) 2006-2007, XenSource Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
+ */
+
+
+#include <stddef.h>
+#include <stdlib.h>
+
+#include "xen_internal.h"
+#include <xen/api/xen_common.h>
+#include <xen/api/xen_cpu_pool.h>
+#include <xen/api/xen_host_cpu.h>
+
+XEN_FREE(xen_cpu_pool)
+XEN_SET_ALLOC_FREE(xen_cpu_pool)
+XEN_ALLOC(xen_cpu_pool_record)
+XEN_SET_ALLOC_FREE(xen_cpu_pool_record)
+XEN_ALLOC(xen_cpu_pool_record_opt)
+XEN_RECORD_OPT_FREE(xen_cpu_pool)
+XEN_SET_ALLOC_FREE(xen_cpu_pool_record_opt)
+
+
+static const struct_member xen_cpu_pool_record_struct_members[] =
+    {
+        { .key = "uuid",
+          .type = &abstract_type_string,
+          .offset = offsetof(xen_cpu_pool_record, uuid) },
+        { .key = "name_label",
+          .type = &abstract_type_string,
+          .offset = offsetof(xen_cpu_pool_record, name_label) },
+        { .key = "name_description",
+          .type = &abstract_type_string,
+          .offset = offsetof(xen_cpu_pool_record, name_description) },
+        { .key = "resident_on",
+          .type = &abstract_type_ref,
+          .offset = offsetof(xen_cpu_pool_record, resident_on) },
+        { .key = "auto_power_on",
+          .type = &abstract_type_bool,
+          .offset = offsetof(xen_cpu_pool_record, auto_power_on) },
+        { .key = "started_VMs",
+          .type = &abstract_type_ref_set,
+          .offset = offsetof(xen_cpu_pool_record, started_vms) },
+        { .key = "ncpu",
+          .type = &abstract_type_int,
+          .offset = offsetof(xen_cpu_pool_record, ncpu) },
+        { .key = "sched_policy",
+          .type = &abstract_type_string,
+          .offset = offsetof(xen_cpu_pool_record, sched_policy) },
+        { .key = "proposed_CPUs",
+          .type = &abstract_type_string_set,
+          .offset = offsetof(xen_cpu_pool_record, proposed_cpus) },
+        { .key = "host_CPUs",
+          .type = &abstract_type_ref_set,
+          .offset = offsetof(xen_cpu_pool_record, host_cpus) },
+        { .key = "activated",
+          .type = &abstract_type_bool,
+          .offset = offsetof(xen_cpu_pool_record, activated) },
+        { .key = "other_config",
+          .type = &abstract_type_string_string_map,
+          .offset = offsetof(xen_cpu_pool_record, other_config) },
+    };
+
+
+const abstract_type xen_cpu_pool_record_abstract_type_ =
+    {
+       .typename = STRUCT,
+       .struct_size = sizeof(xen_cpu_pool_record),
+       .member_count =
+           sizeof(xen_cpu_pool_record_struct_members) / sizeof(struct_member),
+       .members = xen_cpu_pool_record_struct_members
+    };
+
+
+void
+xen_cpu_pool_record_free(xen_cpu_pool_record *record)
+{
+    if (record == NULL)
+    {
+        return;
+    }
+    free(record->handle);
+    free(record->uuid);
+    free(record->name_label);
+    free(record->name_description);
+    xen_host_record_opt_free(record->resident_on);
+    xen_vm_record_opt_set_free(record->started_vms);
+    free(record->sched_policy);
+    xen_string_set_free(record->proposed_cpus);
+    xen_host_cpu_record_opt_set_free(record->host_cpus);
+    xen_string_string_map_free(record->other_config);
+    free(record);
+}
+
+
+bool
+xen_cpu_pool_get_record(xen_session *session, xen_cpu_pool_record **result,
+    xen_cpu_pool cpu_pool)
+{
+    abstract_value param_values[] =
+        {
+            { .type = &abstract_type_string,
+              .u.string_val = cpu_pool }
+        };
+
+    abstract_type result_type = xen_cpu_pool_record_abstract_type_;
+
+    *result = NULL;
+    XEN_CALL_("cpu_pool.get_record");
+
+    if (session->ok)
+    {
+       (*result)->handle = xen_strdup_((*result)->uuid);
+    }
+
+    return session->ok;
+}
+
+
+bool
+xen_cpu_pool_get_by_uuid(xen_session *session, xen_cpu_pool *result, char *uuid)
+{
+    abstract_value param_values[] =
+        {
+            { .type = &abstract_type_string,
+              .u.string_val = uuid }
+        };
+
+    abstract_type result_type = abstract_type_string;
+
+    *result = NULL;
+    XEN_CALL_("cpu_pool.get_by_uuid");
+    return session->ok;
+}
+
+
+bool
+xen_cpu_pool_create(xen_session *session, xen_cpu_pool *result,
+    xen_cpu_pool_record *record)
+{
+    abstract_value param_values[] =
+        {
+            { .type = &xen_cpu_pool_record_abstract_type_,
+              .u.struct_val = record }
+        };
+
+    abstract_type result_type = abstract_type_string;
+
+    *result = NULL;
+    XEN_CALL_("cpu_pool.create");
+    return session->ok;
+}
+
+
+bool
+xen_cpu_pool_destroy(xen_session *session, xen_cpu_pool cpu_pool)
+{
+    abstract_value param_values[] =
+        {
+            { .type = &abstract_type_string,
+              .u.string_val = cpu_pool }
+        };
+
+    xen_call_(session, "cpu_pool.destroy", param_values, 1, NULL, NULL);
+    return session->ok;
+}
+
+
+bool
+xen_cpu_pool_get_uuid(xen_session *session, char **result, xen_cpu_pool cpu_pool)
+{
+    abstract_value param_values[] =
+        {
+            { .type = &abstract_type_string,
+              .u.string_val = cpu_pool }
+        };
+
+    abstract_type result_type = abstract_type_string;
+
+    *result = NULL;
+    XEN_CALL_("cpu_pool.get_uuid");
+    return session->ok;
+}
+
+
+bool
+xen_cpu_pool_deactivate(xen_session *session, xen_cpu_pool cpu_pool)
+{
+    abstract_value param_values[] =
+        {
+            { .type = &abstract_type_string,
+              .u.string_val = cpu_pool },
+        };
+
+    xen_call_(session, "cpu_pool.deactivate", param_values, 1, NULL, NULL);
+    return session->ok;
+}
+
+
+bool
+xen_cpu_pool_activate(xen_session *session, xen_cpu_pool cpu_pool)
+{
+    abstract_value param_values[] =
+        {
+            { .type = &abstract_type_string,
+              .u.string_val = cpu_pool },
+        };
+
+    xen_call_(session, "cpu_pool.activate", param_values, 1, NULL, NULL);
+    return session->ok;
+}
+
+
+bool
+xen_cpu_pool_add_host_CPU_live(xen_session *session, xen_cpu_pool cpu_pool,
+    xen_host_cpu host_cpu)
+{
+    abstract_value param_values[] =
+        {
+            { .type = &abstract_type_string,
+              .u.string_val = cpu_pool },
+            { .type = &abstract_type_string,
+              .u.string_val = host_cpu },
+        };
+
+    xen_call_(session, "cpu_pool.add_host_CPU_live", param_values, 2, NULL, NULL);
+    return session->ok;
+}
+
+
+bool
+xen_cpu_pool_remove_host_CPU_live(xen_session *session, xen_cpu_pool cpu_pool,
+    xen_host_cpu host_cpu)
+{
+    abstract_value param_values[] =
+        {
+            { .type = &abstract_type_string,
+              .u.string_val = cpu_pool },
+            { .type = &abstract_type_string,
+              .u.string_val = host_cpu },
+        };
+
+    xen_call_(session, "cpu_pool.remove_host_CPU_live", param_values, 2, NULL, NULL);
+    return session->ok;
+}
+
+
+bool
+xen_cpu_pool_get_all(xen_session *session, struct xen_cpu_pool_set **result)
+{
+    abstract_type result_type = abstract_type_string_set;
+
+    *result = NULL;
+    xen_call_(session, "cpu_pool.get_all", NULL, 0, &result_type, result);
+    return session->ok;
+}
+
+
+bool
+xen_cpu_pool_get_by_name_label(xen_session *session,
+    struct xen_cpu_pool_set **result, char *label)
+{
+    abstract_value param_values[] =
+        {
+            { .type = &abstract_type_string,
+              .u.string_val = label }
+        };
+
+    abstract_type result_type = abstract_type_string_set;
+
+    *result = NULL;
+    XEN_CALL_("cpu_pool.get_by_name_label");
+    return session->ok;
+}
+
+
+bool
+xen_cpu_pool_get_activated(xen_session *session, bool *result,
+    xen_cpu_pool cpu_pool)
+{
+    abstract_value param_values[] =
+        {
+            { .type = &abstract_type_string,
+              .u.string_val = cpu_pool }
+        };
+
+    abstract_type result_type = abstract_type_bool;
+
+    XEN_CALL_("cpu_pool.get_activated");
+    return session->ok;
+}
+
+
+bool
+xen_cpu_pool_get_auto_power_on(xen_session *session, bool *result,
+    xen_cpu_pool cpu_pool)
+{
+    abstract_value param_values[] =
+        {
+            { .type = &abstract_type_string,
+              .u.string_val = cpu_pool }
+        };
+
+    abstract_type result_type = abstract_type_bool;
+
+    XEN_CALL_("cpu_pool.get_auto_power_on");
+    return session->ok;
+}
+
+
+bool
+xen_cpu_pool_get_host_CPUs(xen_session *session, struct xen_host_cpu_set **result,
+    xen_cpu_pool cpu_pool)
+{
+    abstract_value param_values[] =
+        {
+            { .type = &abstract_type_string,
+              .u.string_val = cpu_pool }
+        };
+
+    abstract_type result_type = abstract_type_string_set;
+
+    *result = NULL;
+    XEN_CALL_("cpu_pool.get_host_CPUs");
+    return session->ok;
+}
+
+
+bool
+xen_cpu_pool_get_name_description(xen_session *session, char **result,
+    xen_cpu_pool cpu_pool)
+{
+    abstract_value param_values[] =
+        {
+            { .type = &abstract_type_string,
+              .u.string_val = cpu_pool }
+        };
+
+    abstract_type result_type = abstract_type_string;
+
+    *result = NULL;
+    XEN_CALL_("cpu_pool.get_name_description");
+    return session->ok;
+}
+
+
+bool
+xen_cpu_pool_get_name_label(xen_session *session, char **result,
+    xen_cpu_pool cpu_pool)
+{
+    abstract_value param_values[] =
+        {
+            { .type = &abstract_type_string,
+              .u.string_val = cpu_pool }
+        };
+
+    abstract_type result_type = abstract_type_string;
+
+    *result = NULL;
+    XEN_CALL_("cpu_pool.get_name_label");
+    return session->ok;
+}
+
+
+bool
+xen_cpu_pool_get_ncpu(xen_session *session, int64_t *result,
+    xen_cpu_pool cpu_pool)
+{
+    abstract_value param_values[] =
+        {
+            { .type = &abstract_type_string,
+              .u.string_val = cpu_pool }
+        };
+
+    abstract_type result_type = abstract_type_int;
+
+    XEN_CALL_("cpu_pool.get_ncpu");
+    return session->ok;
+}
+
+
+bool
+xen_cpu_pool_get_proposed_CPUs(xen_session *session, struct xen_string_set **result,
+    xen_cpu_pool cpu_pool)
+{
+    abstract_value param_values[] =
+        {
+            { .type = &abstract_type_string,
+              .u.string_val = cpu_pool }
+        };
+
+    abstract_type result_type = abstract_type_string_set;
+
+    *result = NULL;
+    XEN_CALL_("cpu_pool.get_proposed_CPUs");
+    return session->ok;
+}
+
+
+bool
+xen_cpu_pool_get_other_config(xen_session *session, xen_string_string_map **result,
+    xen_cpu_pool cpu_pool)
+{
+    abstract_value param_values[] =
+        {
+            { .type = &abstract_type_string,
+              .u.string_val = cpu_pool }
+        };
+
+    abstract_type result_type = abstract_type_string_string_map;
+
+    *result = NULL;
+    XEN_CALL_("cpu_pool.get_other_config");
+    return session->ok;
+}
+
+
+bool
+xen_cpu_pool_get_resident_on(xen_session *session, xen_host *result,
+    xen_cpu_pool cpu_pool)
+{
+    abstract_value param_values[] =
+        {
+            { .type = &abstract_type_string,
+              .u.string_val = cpu_pool }
+        };
+
+    abstract_type result_type = abstract_type_string;
+
+    *result = NULL;
+    XEN_CALL_("cpu_pool.get_resident_on");
+    return session->ok;
+}
+
+
+bool
+xen_cpu_pool_get_sched_policy(xen_session *session, char **result,
+    xen_cpu_pool cpu_pool)
+{
+    abstract_value param_values[] =
+        {
+            { .type = &abstract_type_string,
+              .u.string_val = cpu_pool }
+        };
+
+    abstract_type result_type = abstract_type_string;
+
+    *result = NULL;
+    XEN_CALL_("cpu_pool.get_sched_policy");
+    return session->ok;
+}
+
+
+bool
+xen_cpu_pool_get_started_VMs(xen_session *session, xen_vm_set **result,
+    xen_cpu_pool cpu_pool)
+{
+    abstract_value param_values[] =
+        {
+            { .type = &abstract_type_string,
+              .u.string_val = cpu_pool }
+        };
+
+    abstract_type result_type = abstract_type_string_set;
+
+    *result = NULL;
+    XEN_CALL_("cpu_pool.get_started_VMs");
+    return session->ok;
+}
+
+
+bool
+xen_cpu_pool_set_auto_power_on(xen_session *session, xen_cpu_pool cpu_pool,
+    bool auto_power_on)
+{
+    abstract_value param_values[] =
+        {
+            { .type = &abstract_type_string,
+              .u.string_val = cpu_pool },
+            { .type = &abstract_type_bool,
+              .u.bool_val = auto_power_on }
+        };
+
+    xen_call_(session, "cpu_pool.set_auto_power_on", param_values, 2, NULL, NULL);
+    return session->ok;
+}
+
+
+bool
+xen_cpu_pool_set_proposed_CPUs(xen_session *session, xen_cpu_pool cpu_pool,
+    xen_string_set *proposed_cpus)
+{
+    abstract_value param_values[] =
+        {
+            { .type = &abstract_type_string,
+              .u.string_val = cpu_pool },
+            { .type = &abstract_type_string_set,
+              .u.set_val = (arbitrary_set *)proposed_cpus }
+        };
+
+    xen_call_(session, "cpu_pool.set_proposed_CPUs", param_values, 2, NULL, NULL);
+    return session->ok;
+}
+
+
+bool
+xen_cpu_pool_add_to_proposed_CPUs(xen_session *session, xen_cpu_pool cpu_pool,
+    char* proposed_cpu)
+{
+    abstract_value param_values[] =
+        {
+            { .type = &abstract_type_string,
+              .u.string_val = cpu_pool },
+            { .type = &abstract_type_string,
+              .u.string_val = proposed_cpu }
+        };
+
+    xen_call_(session, "cpu_pool.add_to_proposed_CPUs", param_values, 2, NULL, NULL);
+    return session->ok;
+}
+
+
+bool
+xen_cpu_pool_remove_from_proposed_CPUs(xen_session *session, xen_cpu_pool cpu_pool,
+    char* proposed_cpu)
+{
+    abstract_value param_values[] =
+        {
+            { .type = &abstract_type_string,
+              .u.string_val = cpu_pool },
+            { .type = &abstract_type_string,
+              .u.string_val = proposed_cpu }
+        };
+
+    xen_call_(session, "cpu_pool.remove_from_proposed_CPUs", param_values, 2, NULL, NULL);
+    return session->ok;
+}
+
+
+bool
+xen_cpu_pool_set_name_label(xen_session *session, xen_cpu_pool cpu_pool,
+    char *label)
+{
+    abstract_value param_values[] =
+        {
+            { .type = &abstract_type_string,
+              .u.string_val = cpu_pool },
+            { .type = &abstract_type_string,
+              .u.string_val = label }
+        };
+
+    xen_call_(session, "cpu_pool.set_name_label", param_values, 2, NULL, NULL);
+    return session->ok;
+}
+
+
+bool
+xen_cpu_pool_set_name_description(xen_session *session, xen_cpu_pool cpu_pool,
+    char *descr)
+{
+    abstract_value param_values[] =
+        {
+            { .type = &abstract_type_string,
+              .u.string_val = cpu_pool },
+            { .type = &abstract_type_string,
+              .u.string_val = descr }
+        };
+
+    xen_call_(session, "cpu_pool.set_name_description", param_values, 2, NULL, NULL);
+    return session->ok;
+}
+
+
+bool
+xen_cpu_pool_set_ncpu(xen_session *session, xen_cpu_pool cpu_pool, int64_t ncpu)
+{
+    abstract_value param_values[] =
+        {
+            { .type = &abstract_type_string,
+              .u.string_val = cpu_pool },
+            { .type = &abstract_type_int,
+              .u.int_val = ncpu }
+        };
+
+    xen_call_(session, "cpu_pool.set_ncpu", param_values, 2, NULL, NULL);
+    return session->ok;
+}
+
+
+bool
+xen_cpu_pool_set_other_config(xen_session *session, xen_cpu_pool cpu_pool,
+    xen_string_string_map *other_config)
+{
+    abstract_value param_values[] =
+        {
+            { .type = &abstract_type_string,
+              .u.string_val = cpu_pool },
+            { .type = &abstract_type_string_string_map,
+              .u.set_val = (arbitrary_set *)other_config }
+        };
+
+    xen_call_(session, "cpu_pool.set_other_config", param_values, 2, NULL, NULL);
+    return session->ok;
+}
+
+
+bool
+xen_cpu_pool_add_to_other_config(xen_session *session, xen_cpu_pool cpu_pool,
+    char *key, char *value)
+{
+    abstract_value param_values[] =
+        {
+            { .type = &abstract_type_string,
+              .u.string_val = cpu_pool },
+            { .type = &abstract_type_string,
+              .u.string_val = key },
+            { .type = &abstract_type_string,
+              .u.string_val = value }
+        };
+
+    xen_call_(session, "cpu_pool.add_to_other_config", param_values, 3, NULL, NULL);
+    return session->ok;
+}
+
+
+bool
+xen_cpu_pool_remove_from_other_config(xen_session *session, xen_cpu_pool cpu_pool,
+    char *key)
+{
+    abstract_value param_values[] =
+        {
+            { .type = &abstract_type_string,
+              .u.string_val = cpu_pool },
+            { .type = &abstract_type_string,
+              .u.string_val = key }
+        };
+
+    xen_call_(session, "cpu_pool.remove_from_other_config", param_values, 2, NULL, NULL);
+    return session->ok;
+}
+
+
+bool
+xen_cpu_pool_set_sched_policy(xen_session *session, xen_cpu_pool cpu_pool,
+    char *sched_policy)
+{
+    abstract_value param_values[] =
+        {
+            { .type = &abstract_type_string,
+              .u.string_val = cpu_pool },
+            { .type = &abstract_type_string,
+              .u.string_val = sched_policy }
+        };
+
+    xen_call_(session, "cpu_pool.set_sched_policy", param_values, 2, NULL, NULL);
+    return session->ok;
+}
+
diff --git a/tools/libxen/src/xen_host.c b/tools/libxen/src/xen_host.c
index 0739c4fe4e..b456f5dab6 100644
--- a/tools/libxen/src/xen_host.c
+++ b/tools/libxen/src/xen_host.c
@@ -30,6 +30,7 @@
 #include <xen/api/xen_sr.h>
 #include <xen/api/xen_string_string_map.h>
 #include <xen/api/xen_vm.h>
+#include <xen/api/xen_cpu_pool.h>
 
 
 XEN_FREE(xen_host)
@@ -108,7 +109,10 @@ static const struct_member xen_host_record_struct_members[] =
           .offset = offsetof(xen_host_record, host_cpus) },
         { .key = "metrics",
           .type = &abstract_type_ref,
-          .offset = offsetof(xen_host_record, metrics) }
+          .offset = offsetof(xen_host_record, metrics) },
+        { .key = "resident_cpu_pools",
+          .type = &abstract_type_ref_set,
+          .offset = offsetof(xen_host_record, resident_cpu_pools) }
     };
 
 const abstract_type xen_host_record_abstract_type_ =
@@ -148,6 +152,7 @@ xen_host_record_free(xen_host_record *record)
     xen_pbd_record_opt_set_free(record->pbds);
     xen_host_cpu_record_opt_set_free(record->host_cpus);
     xen_host_metrics_record_opt_free(record->metrics);
+    xen_cpu_pool_record_opt_set_free(record->resident_cpu_pools);
     free(record);
 }
 
@@ -889,3 +894,22 @@ xen_host_get_uuid(xen_session *session, char **result, xen_host host)
     XEN_CALL_("host.get_uuid");
     return session->ok;
 }
+
+
+bool
+xen_host_get_resident_cpu_pools(xen_session *session, struct xen_cpu_pool_set **result,
+        xen_host host)
+{
+    abstract_value param_values[] =
+        {
+            { .type = &abstract_type_string,
+              .u.string_val = host }
+        };
+
+    abstract_type result_type = abstract_type_string_set;
+
+    *result = NULL;
+    XEN_CALL_("host.get_resident_cpu_pools");
+    return session->ok;
+}
+
diff --git a/tools/libxen/src/xen_host_cpu.c b/tools/libxen/src/xen_host_cpu.c
index 6e84b49f63..85d88f6336 100644
--- a/tools/libxen/src/xen_host_cpu.c
+++ b/tools/libxen/src/xen_host_cpu.c
@@ -24,6 +24,7 @@
 #include <xen/api/xen_common.h>
 #include <xen/api/xen_host.h>
 #include <xen/api/xen_host_cpu.h>
+#include <xen/api/xen_cpu_pool.h>
 
 
 XEN_FREE(xen_host_cpu)
@@ -66,7 +67,10 @@ static const struct_member xen_host_cpu_record_struct_members[] =
           .offset = offsetof(xen_host_cpu_record, features) },
         { .key = "utilisation",
           .type = &abstract_type_float,
-          .offset = offsetof(xen_host_cpu_record, utilisation) }
+          .offset = offsetof(xen_host_cpu_record, utilisation) },
+        { .key = "cpu_pool",
+          .type = &abstract_type_ref_set,
+          .offset = offsetof(xen_host_cpu_record, cpu_pools) },
     };
 
 const abstract_type xen_host_cpu_record_abstract_type_ =
@@ -94,6 +98,7 @@ xen_host_cpu_record_free(xen_host_cpu_record *record)
     free(record->stepping);
     free(record->flags);
     free(record->features);
+    xen_cpu_pool_record_opt_set_free(record->cpu_pools);
     free(record);
 }
 
@@ -315,3 +320,34 @@ xen_host_cpu_get_uuid(xen_session *session, char **result, xen_host_cpu host_cpu
     XEN_CALL_("host_cpu.get_uuid");
     return session->ok;
 }
+
+
+bool
+xen_host_cpu_get_cpu_pool(xen_session *session, struct xen_cpu_pool_set **result, xen_host_cpu host_cpu)
+{
+    abstract_value param_values[] =
+        {
+            { .type = &abstract_type_string,
+              .u.string_val = host_cpu }
+        };
+
+    abstract_type result_type = abstract_type_string_set;
+
+    *result = NULL;
+    XEN_CALL_("host_cpu.get_cpu_pool");
+    return session->ok;
+}
+
+
+bool
+xen_host_cpu_get_unassigned_cpus(xen_session *session, struct xen_host_cpu_set **result)
+{
+    abstract_type result_type = abstract_type_string_set;
+
+    *result = NULL;
+    xen_call_(session, "host_cpu.get_unassigned_cpus", NULL, 0, &result_type, result);
+    return session->ok;
+}
+
+
+
diff --git a/tools/libxen/src/xen_vm.c b/tools/libxen/src/xen_vm.c
index 2b501e56e3..b762fbea29 100644
--- a/tools/libxen/src/xen_vm.c
+++ b/tools/libxen/src/xen_vm.c
@@ -36,6 +36,7 @@
 #include <xen/api/xen_vm_guest_metrics.h>
 #include <xen/api/xen_vm_metrics.h>
 #include <xen/api/xen_vtpm.h>
+#include <xen/api/xen_cpu_pool.h>
 
 
 XEN_FREE(xen_vm)
@@ -165,7 +166,13 @@ static const struct_member xen_vm_record_struct_members[] =
           .offset = offsetof(xen_vm_record, guest_metrics) },
         { .key = "security_label",
           .type = &abstract_type_string,
-          .offset = offsetof(xen_vm_record, security_label) }
+          .offset = offsetof(xen_vm_record, security_label) },
+        { .key = "pool_name",
+          .type = &abstract_type_string,
+          .offset = offsetof(xen_vm_record, pool_name) },
+        { .key = "cpu_pool",
+          .type = &abstract_type_ref_set,
+          .offset = offsetof(xen_vm_record, cpu_pool) },
     };
 
 const abstract_type xen_vm_record_abstract_type_ =
@@ -209,6 +216,7 @@ xen_vm_record_free(xen_vm_record *record)
     xen_string_string_map_free(record->other_config);
     xen_vm_metrics_record_opt_free(record->metrics);
     xen_vm_guest_metrics_record_opt_free(record->guest_metrics);
+    xen_cpu_pool_record_opt_set_free(record->cpu_pool);
     free(record->security_label);
     free(record);
 }
@@ -1781,3 +1789,71 @@ xen_vm_get_security_label(xen_session *session, char **result, xen_vm vm)
     XEN_CALL_("VM.get_security_label");
     return session->ok;
 }
+
+
+bool
+xen_vm_get_cpu_pool(xen_session *session, struct xen_cpu_pool_set **result, xen_vm vm)
+{
+    abstract_value param_values[] =
+        {
+            { .type = &abstract_type_string,
+              .u.string_val = vm },
+        };
+
+    abstract_type result_type = abstract_type_string_set;
+
+    *result = NULL;
+    XEN_CALL_("VM.get_cpu_pool");
+    return session->ok;
+}
+
+
+bool
+xen_vm_get_pool_name(xen_session *session, char **result, xen_vm vm)
+{
+    abstract_value param_values[] =
+        {
+            { .type = &abstract_type_string,
+              .u.string_val = vm },
+        };
+
+    abstract_type result_type = abstract_type_string;
+
+    *result = NULL;
+    XEN_CALL_("VM.get_pool_name");
+    return session->ok;
+}
+
+
+bool
+xen_vm_set_pool_name(xen_session *session, xen_vm vm, char *pool_name)
+{
+    abstract_value param_values[] =
+        {
+            { .type = &abstract_type_string,
+              .u.string_val = vm },
+            { .type = &abstract_type_string,
+              .u.string_val = pool_name }
+        };
+
+    xen_call_(session, "VM.set_pool_name", param_values, 2, NULL, NULL);
+    return session->ok;
+}
+
+
+bool
+xen_vm_cpu_pool_migrate(xen_session *session, xen_vm vm, xen_cpu_pool cpu_pool)
+{
+    abstract_value param_values[] =
+        {
+            { .type = &abstract_type_string,
+              .u.string_val = vm },
+            { .type = &abstract_type_string,
+              .u.string_val = cpu_pool }
+        };
+
+    xen_call_(session, "VM.cpu_pool_migrate", param_values, 2, NULL, NULL);
+    return session->ok;
+}
+
+
diff --git a/tools/libxen/test/test_bindings.c b/tools/libxen/test/test_bindings.c
index 566a0388fa..27ae57240a 100644
--- a/tools/libxen/test/test_bindings.c
+++ b/tools/libxen/test/test_bindings.c
@@ -28,6 +28,7 @@
 #include <xen/api/xen_all.h>
 
 //#define PRINT_XML
+//////////////#define POOL_TESTS
 
 static void usage()
 {
@@ -125,6 +126,649 @@ static void print_error(xen_session *session)
 }
 
 
+#ifdef POOL_TESTS
+#define NAME_DESCRIPTION "TestPool"
+#define NAME_DESCRIPTION_2 "TestPool-2"
+#define NAME_LABEL "Pool-1"
+#define NAME_LABEL_2 "Pool-2"
+#define SCHED_NAME "credit"
+#define NCPU_VAL   2
+#define NCPU_VAL_2   1
+
+
+static int pool_tests(xen_session *session, xen_host host)
+{
+    int rc = 1;
+    xen_cpu_pool_set            *pools = NULL;
+    xen_host_record             *host_record = NULL;
+    xen_cpu_pool_record_opt     *cpu_pool_opt = NULL;
+    xen_cpu_pool_record         *cpu_pool_rec = NULL;
+    xen_host_cpu_set            *host_cpu_set = NULL;
+    xen_host_cpu_record         *host_cpu_record = NULL;
+    xen_vm_set                  *vm_set = NULL;
+    xen_cpu_pool                pool = NULL;
+    xen_cpu_pool                pool_out = NULL;
+    xen_string_string_map       *pool_other_config = NULL;
+    xen_vm_record               *vm_record = NULL;
+    xen_string_set              *proposed_cpus = NULL;
+    xen_host                    res_host = NULL;
+    char                        *name_description = NULL;
+    char                        *name_label = NULL;
+    char                        *sched_policy = NULL;
+    char                        *pool_uuid = NULL;
+    int64_t                     ncpu;
+
+    for (int loop= 0; loop < 1; loop++)
+    {
+        // Test extensions of class host
+        printf("Test cpu_pool extension of host class -----------------------------------------\n");
+
+        printf("host.get_resident_cpu_pools\n");
+        if (!xen_host_get_resident_cpu_pools(session, &pools, host))
+        {
+            break;
+        }
+        if (pools->size != 1)
+        {
+            printf("Wrong pool count; only one pool expected\n");
+            break;
+        }
+        printf("Pool UUID %s\n", (char*)pools->contents[0]);
+        xen_cpu_pool_set_free(pools);
+        pools = NULL;
+
+        printf("host.get_record\n");
+        if (!xen_host_get_record(session, &host_record, host))
+        {
+            break;
+        }
+        printf("Pool count %d\n", (int)host_record->resident_cpu_pools->size);
+        if (host_record->resident_cpu_pools->size != 1)
+        {
+            break;
+        }
+        cpu_pool_opt = host_record->resident_cpu_pools->contents[0];
+        printf("Pool UUID %s\n", (char*)cpu_pool_opt->u.handle);
+        xen_host_record_free(host_record);
+        host_record = NULL;
+        cpu_pool_opt = NULL;
+
+
+        // Test extensions of class host_cpu
+        printf("host_cpu.get_all\n");
+        if (!xen_host_cpu_get_all(session, &host_cpu_set))
+        {
+            break;
+        }
+
+        printf("host_cpu.get_cpu_pool & host_cpu.get_record\n");
+        for (int i= 0; i < host_cpu_set->size; i++)
+        {
+            if (!xen_host_cpu_get_cpu_pool(session, &pools, host_cpu_set->contents[i]))
+            {
+                break;
+            }
+            if (pools->size > 1)
+            {
+                printf("Wrong pool count (xen_host_cpu_get_cpu_pool)\n");
+                break;
+            }
+
+            printf("host_cpu (get_cpu_pool) %s, cpu_pool %s\n", (char*)host_cpu_set->contents[i],
+                pools->size != 0 ? (char*)pools->contents[0] : "(None)");
+
+            if (!xen_host_cpu_get_record(session, &host_cpu_record, host_cpu_set->contents[i]))
+            {
+                break;
+            }
+            if (host_cpu_record->cpu_pools->size > 1)
+            {
+                printf("Wrong pool count (xen_host_cpu_get_record)\n");
+                break;
+            }
+
+            printf("host_cpu (get_record) %s, cpu_pool %s\n", (char*)host_cpu_set->contents[i],
+                host_cpu_record->cpu_pools->size != 0
+                ? (char*)((xen_cpu_pool_record_opt*)(host_cpu_record->cpu_pools->contents[0])->u.handle)
+                : "(None)");
+
+        }
+        xen_host_cpu_record_free(host_cpu_record);
+        host_cpu_record = NULL;
+        xen_host_cpu_set_free(host_cpu_set);
+        host_cpu_set = NULL;
+        xen_cpu_pool_set_free(pools);
+        pools = NULL;
+
+        printf("host_cpu.get_unassigned_cpus\n");
+        if (!xen_host_cpu_get_unassigned_cpus(session, &host_cpu_set))
+        {
+            break;
+        }
+        printf("Free cpus (not bound to a pool)\n");
+        for (int i= 0; i < host_cpu_set->size; i++)
+        {
+            printf("  cpu UUID %s\n", (char*)host_cpu_set->contents[i]);
+        }
+        xen_host_cpu_set_free(host_cpu_set);
+        host_cpu_set = NULL;
+
+
+        printf("vm.get_record\n");
+        if (!xen_vm_get_all(session, &vm_set))
+        {
+            break;
+        }
+
+        if (!xen_vm_get_record(session, &vm_record, vm_set->contents[0]))
+        {
+            break;
+        }
+        printf("VM %s, pool_name %s, cpu_pool %s\n", (char*)vm_set->contents[0],
+            vm_record->pool_name, (char*)vm_record->cpu_pool->contents[0]);
+
+        xen_vm_record_free(vm_record);
+        vm_record = NULL;
+
+        printf("vm.get_cpu_pool\n");
+        if (!xen_vm_get_cpu_pool(session, &pools, vm_set->contents[0]))
+        {
+            break;
+        }
+        printf("vm_get_cpu_pool %s\n", (char*)pools->contents[0]);
+
+        xen_vm_set_free(vm_set);
+        xen_cpu_pool_set_free(pools);
+        vm_set = NULL;
+        pools = NULL;
+
+
+        // Class cpu_pool
+
+        // create
+        pool_other_config = xen_string_string_map_alloc(1);
+        pool_other_config->contents[0].key = strdup("type");
+        pool_other_config->contents[0].val = strdup("bs2000");
+        xen_string_set *proposed_CPUs_set = xen_string_set_alloc(1);
+        proposed_CPUs_set->contents[0] = strdup("3");
+
+        xen_cpu_pool_record new_cpu_pool_record =
+        {
+            .name_label = NAME_LABEL,
+            .name_description = NAME_DESCRIPTION,
+            .auto_power_on = false,
+            .ncpu = NCPU_VAL,
+            .sched_policy = SCHED_NAME,
+            .proposed_cpus = proposed_CPUs_set,
+            .other_config = pool_other_config,
+        };
+
+        printf("cpu_pool.create\n");
+        if (!xen_cpu_pool_create(session, &pool, &new_cpu_pool_record))
+        {
+            break;
+        }
+        printf("New Pool UUID %s\n", (char*)pool);
+        xen_string_set_free(proposed_CPUs_set);
+        proposed_CPUs_set = NULL;
+        xen_string_string_map_free(pool_other_config);
+        pool_other_config = NULL;
+
+        // get_by_name_label
+        printf("cpu_pool.get_by_name_label\n");
+        if (!xen_cpu_pool_get_by_name_label(session, &pools, "Pool-1"))
+        {
+            break;
+        }
+        if (strcmp((char*)pools->contents[0], (char*)pool) != 0)
+        {
+            break;
+        }
+        xen_cpu_pool_set_free(pools);
+        pools = NULL;
+
+
+        // get_by_uuid
+        printf("cpu_pool.get_by_uuid\n");
+        if (!xen_cpu_pool_get_by_uuid(session, &pool_out, pool))
+        {
+            break;
+        }
+        if (strcmp((char*)pool_out, (char*)pool) != 0)
+        {
+            printf("Wrong pool returned\n");
+            break;
+        }
+        xen_cpu_pool_free(pool_out);
+        pool_out = NULL;
+
+        // get_all
+        printf("cpu_pool.get_all\n");
+        if (!xen_cpu_pool_get_all(session, &pools))
+        {
+            break;
+        }
+        if (pools->size != 2)
+        {
+            printf("Wrong pool count (%d)\n", (int)pools->size);
+            break;
+        }
+        xen_cpu_pool_set_free(pools);
+        pools = NULL;
+
+
+        // get_activated
+        printf("cpu_pool.get_activated\n");
+        bool activated_state = true;
+        if (!xen_cpu_pool_get_activated(session, &activated_state, pool))
+        {
+            break;
+        }
+        if (activated_state)
+        {
+            printf("Pool must not be activated\n");
+            break;
+        }
+
+
+        // get_auto_power_on
+        printf("cpu_pool.get_auto_power_on\n");
+        bool power_state = true;
+        if (!xen_cpu_pool_get_auto_power_on(session, &power_state, pool))
+        {
+            break;
+        }
+        if (power_state)
+        {
+            printf("Pool must not have attibute 'auto_power_on'\n");
+            break;
+        }
+
+        // get_host_CPUs
+        printf("cpu_pool.get_host_CPUs\n");
+        if (!xen_cpu_pool_get_host_CPUs(session, &host_cpu_set, pool))
+        {
+            break;
+        }
+        if (host_cpu_set->size != 0)
+        {
+            printf("Pool must not have any attached cpus\n");
+            break;
+        }
+        xen_host_cpu_set_free(host_cpu_set);
+        host_cpu_set = NULL;
+
+
+        // get_name_description
+        printf("cpu_pool.get_name_description\n");
+        if (!xen_cpu_pool_get_name_description(session, &name_description, pool))
+        {
+            break;
+        }
+        if (strcmp(NAME_DESCRIPTION, name_description) != 0)
+        {
+            printf("Pool has wrong name_description\n");
+            break;
+        }
+        free(name_description);
+        name_description = NULL;
+
+
+        // get_name_label
+        printf("cpu_pool.get_name_label\n");
+        if (!xen_cpu_pool_get_name_label(session, &name_label, pool))
+        {
+            break;
+        }
+        if (strcmp(NAME_LABEL, name_label) != 0)
+        {
+            printf("Pool has wrong name_label\n");
+            break;
+        }
+        free(name_label);
+        name_label = NULL;
+
+        // get_ncpu
+        printf("cpu_pool.get_ncpu\n");
+        if (!xen_cpu_pool_get_ncpu(session, &ncpu, pool))
+        {
+            break;
+        }
+        if (NCPU_VAL != ncpu)
+        {
+            printf("Pool has wrong ncpu\n");
+            break;
+        }
+
+        // get_proposed_CPUs
+        printf("cpu_pool.get_proposed_CPUs\n");
+        if (!xen_cpu_pool_get_proposed_CPUs(session, &proposed_cpus, pool))
+        {
+            break;
+        }
+        if (proposed_cpus->size != 1)
+        {
+            printf("Pool has wrong proposed_cpus count\n");
+            break;
+        }
+        xen_string_set_free(proposed_cpus);
+        proposed_cpus = NULL;
+
+
+        // get_other_config
+        printf("cpu_pool.get_other_config\n");
+        if (!xen_cpu_pool_get_other_config(session, &pool_other_config, pool))
+        {
+            break;
+        }
+        if (pool_other_config->size != 1)
+        {
+            printf("Pool has wrong other_config element count\n");
+            break;
+        }
+        if ((strcmp(pool_other_config->contents[0].key, "type") != 0) ||
+            (strcmp(pool_other_config->contents[0].val, "bs2000") != 0))
+        {
+            printf("Pool has wrong other_config attributes\n");
+            break;
+        }
+        xen_string_string_map_free(pool_other_config);
+        pool_other_config = NULL;
+
+
+        // get_record
+        printf("cpu_pool.get_record\n");
+        if (!xen_cpu_pool_get_record(session, &cpu_pool_rec, pool))
+        {
+            break;
+        }
+        if ( (strcmp(cpu_pool_rec->name_label, NAME_LABEL) != 0) ||
+             (strcmp(cpu_pool_rec->name_description, NAME_DESCRIPTION) != 0) ||
+             (cpu_pool_rec->auto_power_on) ||
+             (cpu_pool_rec->ncpu != NCPU_VAL) ||
+             (cpu_pool_rec->started_vms->size != 0) ||
+             (strcmp(cpu_pool_rec->sched_policy, SCHED_NAME) != 0) ||
+             (cpu_pool_rec->proposed_cpus->size != 1) ||
+             (cpu_pool_rec->host_cpus->size != 0) ||
+             (cpu_pool_rec->activated) ||
+             (strcmp(cpu_pool_rec->resident_on->u.handle, host) != 0) ||
+             (strcmp(cpu_pool_rec->uuid, pool) != 0) ||
+             (cpu_pool_rec->other_config->size != 1))
+        {
+            printf("Wrong record output\n");
+            break;
+        }
+        xen_cpu_pool_record_free(cpu_pool_rec);
+        cpu_pool_rec = NULL;
+
+
+        // get_resident_on
+        printf("cpu_pool.get_resident_on\n");
+        if (!xen_cpu_pool_get_resident_on(session, &res_host, pool))
+        {
+            break;
+        }
+        if (strcmp(res_host, host) != 0)
+        {
+            printf("Wrong resident host returned\n");
+            break;
+        }
+        xen_host_free(res_host);
+        res_host = NULL;
+
+
+        // get_sched_policy
+        printf("cpu_pool.get_sched_policy\n");
+        if (!xen_cpu_pool_get_sched_policy(session, &sched_policy, pool))
+        {
+            break;
+        }
+        if (strcmp(sched_policy, SCHED_NAME) != 0)
+        {
+            printf("Wrong sched_policy returned\n");
+            break;
+        }
+        free(sched_policy);
+        sched_policy = NULL;
+
+
+        // get_started_VMs
+        printf("cpu_pool.get_started_VMs\n");
+        if (!xen_cpu_pool_get_started_VMs(session, &vm_set, pool))
+        {
+            break;
+        }
+        if (vm_set->size != 0)
+        {
+            printf("Wrong count of started VMs\n");
+            break;
+        }
+        xen_vm_set_free(vm_set);
+        vm_set = NULL;
+
+
+        // get_uuid
+        printf("cpu_pool.get_uuid\n");
+        if (!xen_cpu_pool_get_uuid(session, &pool_uuid, pool))
+        {
+            break;
+        }
+        if (strcmp(pool_uuid, pool) != 0)
+        {
+            printf("Wrong Pool UUID returnd\n");
+            break;
+        }
+        free(pool_uuid);
+        pool_uuid = NULL;
+
+
+        // set_auto_power_on
+        printf("cpu_pool.set_auto_power_on\n");
+        if (!xen_cpu_pool_set_auto_power_on(session, pool, true))
+            break;
+
+
+        // set_proposed_CPUs
+        printf("cpu_pool.set_proposed_CPUs\n");
+        proposed_CPUs_set = xen_string_set_alloc(2);
+        proposed_CPUs_set->contents[0] = strdup("2");
+        proposed_CPUs_set->contents[1] = strdup("4");
+        if (!xen_cpu_pool_set_proposed_CPUs(session, pool, proposed_CPUs_set))
+            break;
+        xen_string_set_free(proposed_CPUs_set);
+        proposed_CPUs_set = NULL;
+
+
+        // add_to_proposed_CPUs
+        printf("cpu_pool.add_to_proposed_CPUs\n");
+        if (!xen_cpu_pool_add_to_proposed_CPUs(session, pool, "3"))
+            break;
+
+
+        // remove_from_proposed_CPUs
+        printf("cpu_pool.remove_from_proposed_CPUs\n");
+        if (!xen_cpu_pool_remove_from_proposed_CPUs(session, pool, "4"))
+            break;
+
+
+        // set_name_label
+        printf("cpu_pool.set_name_label\n");
+        if (!xen_cpu_pool_set_name_label(session, pool, NAME_LABEL_2))
+            break;
+
+
+        // set_name_description
+        printf("cpu_pool.set_name_description\n");
+        if (!xen_cpu_pool_set_name_description(session, pool, NAME_DESCRIPTION_2))
+            break;
+
+
+        // set_ncpu
+        printf("cpu_pool.set_ncpu\n");
+        if (!xen_cpu_pool_set_ncpu(session, pool, NCPU_VAL_2))
+            break;
+
+
+        // set_other_config
+        printf("cpu_pool.set_other_config\n");
+        pool_other_config = xen_string_string_map_alloc(2);
+        pool_other_config->contents[0].key = strdup("test1");
+        pool_other_config->contents[0].val = strdup("field1");
+        pool_other_config->contents[1].key = strdup("test2");
+        pool_other_config->contents[1].val = strdup("field2");
+        if (!xen_cpu_pool_set_other_config(session, pool, pool_other_config))
+            break;
+        xen_string_string_map_free(pool_other_config);
+        pool_other_config = NULL;
+
+
+        // add_to_other_config
+        printf("cpu_pool.add_to_other_config\n");
+        if (!xen_cpu_pool_add_to_other_config(session, pool, "test3", "field3"))
+            break;
+
+
+        // remove_from_other_config
+        printf("cpu_pool.remove_from_other_config\n");
+        if (!xen_cpu_pool_remove_from_other_config(session, pool, "test2"))
+            break;
+
+
+        // set_sched_policy
+        printf("cpu_pool.set_sched_policy\n");
+        if (!xen_cpu_pool_set_sched_policy(session, pool, SCHED_NAME))
+            break;
+
+
+        // check get_record again
+        printf("check cpu_pool record\n");
+        if (!xen_cpu_pool_get_record(session, &cpu_pool_rec, pool))
+        {
+            break;
+        }
+        if ( (strcmp(cpu_pool_rec->name_label, NAME_LABEL_2) != 0) ||
+             (strcmp(cpu_pool_rec->name_description, NAME_DESCRIPTION_2) != 0) ||
+             (!cpu_pool_rec->auto_power_on) ||
+             (cpu_pool_rec->ncpu != NCPU_VAL_2) ||
+             (cpu_pool_rec->started_vms->size != 0) ||
+             (strcmp(cpu_pool_rec->sched_policy, SCHED_NAME) != 0) ||
+             (cpu_pool_rec->proposed_cpus->size != 2) ||
+             (cpu_pool_rec->host_cpus->size != 0) ||
+             (cpu_pool_rec->activated) ||
+             (strcmp(cpu_pool_rec->resident_on->u.handle, host) != 0) ||
+             (strcmp(cpu_pool_rec->uuid, pool) != 0) ||
+             (cpu_pool_rec->other_config->size != 2))
+        {
+            printf("Wrong record output\n");
+            break;
+        }
+        xen_cpu_pool_record_free(cpu_pool_rec);
+        cpu_pool_rec = NULL;
+
+
+        // activate pool
+        printf("cpu_pool.activate\n");
+        if (!xen_cpu_pool_activate(session, pool))
+            break;
+
+
+        // add_host_CPU_live
+        printf("cpu_pool.add_host_CPU_live\n");
+        if (!xen_host_cpu_get_unassigned_cpus(session, &host_cpu_set))
+        {
+            break;
+        }
+        if (host_cpu_set->size < 1)
+        {
+            printf("No free CPU found\n");
+            break;
+        }
+        if (!xen_cpu_pool_add_host_CPU_live(session, pool, host_cpu_set->contents[0]))
+            break;
+
+
+        // remove_host_CPU_live
+        printf("cpu_pool.remove_host_CPU_live\n");
+        if (!xen_cpu_pool_remove_host_CPU_live(session, pool, host_cpu_set->contents[0]))
+            break;
+
+        xen_host_cpu_set_free(host_cpu_set);
+        host_cpu_set = NULL;
+
+
+        // check get_record again
+        printf("check cpu_pool record\n");
+        if (!xen_cpu_pool_get_record(session, &cpu_pool_rec, pool))
+        {
+            break;
+        }
+        if ( (strcmp(cpu_pool_rec->name_label, NAME_LABEL_2) != 0) ||
+             (strcmp(cpu_pool_rec->name_description, NAME_DESCRIPTION_2) != 0) ||
+             (!cpu_pool_rec->auto_power_on) ||
+             (cpu_pool_rec->ncpu != NCPU_VAL_2) ||
+             (cpu_pool_rec->started_vms->size != 0) ||
+             (strcmp(cpu_pool_rec->sched_policy, SCHED_NAME) != 0) ||
+             (cpu_pool_rec->proposed_cpus->size != 2) ||
+             (cpu_pool_rec->host_cpus->size != 1) ||
+             (!cpu_pool_rec->activated) ||
+             (strcmp(cpu_pool_rec->resident_on->u.handle, host) != 0) ||
+             (strcmp(cpu_pool_rec->uuid, pool) != 0) ||
+             (cpu_pool_rec->other_config->size != 2))
+        {
+            printf("Wrong record output\n");
+            break;
+        }
+        xen_cpu_pool_record_free(cpu_pool_rec);
+        cpu_pool_rec = NULL;
+
+
+        // deactivate pool
+        printf("cpu_pool.deactivate\n");
+        if (!xen_cpu_pool_deactivate(session, pool))
+            break;
+
+
+        // Pool delete
+        if (!xen_cpu_pool_destroy(session, pool))
+        {
+            break;
+        }
+        xen_cpu_pool_free(pool);
+        pool = NULL;
+
+        // Tests OK
+        printf("Pool Tests OK\n");
+        rc= 0;
+    }
+
+    if (rc != 0)
+    {
+        print_error(session);
+    }
+
+    xen_cpu_pool_set_free(pools);
+    xen_host_record_free(host_record);
+    xen_cpu_pool_record_opt_free(cpu_pool_opt);
+    xen_host_cpu_set_free(host_cpu_set);
+    xen_host_cpu_record_free(host_cpu_record);
+    xen_vm_set_free(vm_set);
+    xen_cpu_pool_free(pool);
+    xen_cpu_pool_free(pool_out);
+    xen_string_string_map_free(pool_other_config);
+    xen_vm_record_free(vm_record);
+    xen_string_set_free(proposed_cpus);
+    free(name_description);
+    free(name_label);
+    free(sched_policy);
+    free(pool_uuid);
+    xen_cpu_pool_record_free(cpu_pool_rec);
+    xen_host_free(res_host);
+
+    return rc;
+}
+#endif
+
+
 int main(int argc, char **argv)
 {
     if (argc != 4)
@@ -365,6 +1009,11 @@ int main(int argc, char **argv)
 
     xen_vm_record_free(vm_record);
 
+#ifdef POOL_TESTS
+    if (pool_tests(session, host) != 0)
+        return 1;
+#endif
+
     xen_host_free(host);
     xen_string_string_map_free(versions);
     free(dmesg);