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

[Xen-devel] [PATCH V4] Add libxenlight driver



Add a new xen driver based on libxenlight [1], which is the primary
toolstack starting with Xen 4.1.0.  The driver is stateful, runs
privileged only, and is accessed with libxl:/// URI.

V4:
 - Handle restart of libvirtd, reconnecting to previously
   started domains
 - Rebased to current master
 - Tested against Xen 4.1 RC7-pre (c/s 22961:c5d121fd35c0)

V3:
  - Reserve vnc port within driver when autoport=yes

V2:
  - Update to Xen 4.1 RC6-pre (c/s 22940:5a4710640f81)
  - Rebased to current master
  - Plug memory leaks found by Stefano Stabellini and valgrind
  - Handle SHUTDOWN_crash domain death event

[1] http://lists.xensource.com/archives/html/xen-devel/2009-11/msg00436.html
---
 cfg.mk                      |    1 +
 configure.ac                |   48 ++
 daemon/Makefile.am          |    4 +
 daemon/libvirtd.c           |    6 +
 docs/drivers.html.in        |    3 +-
 docs/drvxen.html.in         |    6 +-
 docs/drvxenlight.html.in    |   53 ++
 docs/sitemap.html.in        |    6 +-
 include/libvirt/virterror.h |    1 +
 po/POTFILES.in              |    2 +
 src/Makefile.am             |   32 +
 src/driver.h                |    3 +-
 src/libvirt.c               |    4 +
 src/libxl/libxl_conf.c      |  896 +++++++++++++++++++++++++++
 src/libxl/libxl_conf.h      |   91 +++
 src/libxl/libxl_driver.c    | 1411 +++++++++++++++++++++++++++++++++++++++++++
 src/libxl/libxl_driver.h    |   27 +
 src/util/virterror.c        |    3 +
 18 files changed, 2593 insertions(+), 4 deletions(-)

diff --git a/cfg.mk b/cfg.mk
index 5cb2ead..ef71cd5 100644
--- a/cfg.mk
+++ b/cfg.mk
@@ -402,6 +402,7 @@ msg_gen_function += virXenStoreError
 msg_gen_function += virXendError
 msg_gen_function += vmwareError
 msg_gen_function += xenapiSessionErrorHandler
+msg_gen_function += libxlError
 msg_gen_function += xenUnifiedError
 msg_gen_function += xenXMError
 msg_gen_function += VIR_ERROR
diff --git a/configure.ac b/configure.ac
index a58ee4e..0ef90e1 100644
--- a/configure.ac
+++ b/configure.ac
@@ -263,6 +263,8 @@ AC_ARG_WITH([phyp],
   AC_HELP_STRING([--with-phyp], [add PHYP support 
@<:@default=check@:>@]),[],[with_phyp=check])
 AC_ARG_WITH([xenapi],
   AC_HELP_STRING([--with-xenapi], [add XenAPI support 
@<:@default=check@:>@]),[],[with_xenapi=check])
+AC_ARG_WITH([libxl],
+  AC_HELP_STRING([--with-libxl], [add libxenlight support 
@<:@default=check@:>@]),[],[with_libxl=check])
 AC_ARG_WITH([vbox],
   AC_HELP_STRING([--with-vbox=@<:@PFX@:>@],
                  [VirtualBox XPCOMC location @<:@default=yes@:>@]),[],
@@ -497,6 +499,46 @@ fi
 AC_SUBST([LIBXENSERVER_CFLAGS])
 AC_SUBST([LIBXENSERVER_LIBS])
 
+old_LIBS="$LIBS"
+old_CFLAGS="$CFLAGS"
+LIBXL_LIBS=""
+LIBXL_CFLAGS=""
+dnl search for libxl, aka libxenlight
+fail=0
+if test "$with_libxl" != "no" ; then
+    if test "$with_libxl" != "yes" && test "$with_libxl" != "check" ; then
+        LIBXL_CFLAGS="-I$with_libxl/include"
+        LIBXL_LIBS="-L$with_libxl"
+    fi
+    CFLAGS="$CFLAGS $LIBXL_CFLAGS"
+    LIBS="$LIBS $LIBXL_LIBS"
+    AC_CHECK_LIB([xenlight], [libxl_ctx_init], [
+        with_libxl=yes
+        LIBXL_LIBS="$LIBXL_LIBS -lxenlight -lxenstore -lxenctrl -lxenguest 
-luuid -lutil -lblktapctl"
+    ],[
+        if test "$with_libxl" = "yes"; then
+            fail=1
+        fi
+            with_libxl=no
+    ],[
+         -lxenstore -lxenctrl -lxenguest -luuid -lutil -lblktapctl
+    ])
+fi
+
+LIBS="$old_LIBS"
+CFLAGS="$old_CFLAGS"
+
+if test $fail = 1; then
+    AC_MSG_ERROR([You must install the libxl Library to compile libxenlight 
driver with -lxl])
+fi
+
+if test "$with_libxl" = "yes"; then
+    AC_DEFINE_UNQUOTED([WITH_LIBXL], 1, [whether libxenlight driver is 
enabled])
+fi
+AM_CONDITIONAL([WITH_LIBXL], [test "$with_libxl" = "yes"])
+
+AC_SUBST([LIBXL_CFLAGS])
+AC_SUBST([LIBXL_LIBS])
 
 old_LIBS="$LIBS"
 old_CFLAGS="$CFLAGS"
@@ -2370,6 +2412,7 @@ AC_MSG_NOTICE([  OpenVZ: $with_openvz])
 AC_MSG_NOTICE([  VMware: $with_vmware])
 AC_MSG_NOTICE([    VBox: $with_vbox])
 AC_MSG_NOTICE([  XenAPI: $with_xenapi])
+AC_MSG_NOTICE([libxenlight: $with_libxl])
 AC_MSG_NOTICE([     LXC: $with_lxc])
 AC_MSG_NOTICE([    PHYP: $with_phyp])
 AC_MSG_NOTICE([     ONE: $with_one])
@@ -2479,6 +2522,11 @@ AC_MSG_NOTICE([  xenapi: $LIBXENSERVER_CFLAGS 
$LIBXENSERVER_LIBS])
 else
 AC_MSG_NOTICE([  xenapi: no])
 fi
+if test "$with_libxl" = "yes" ; then
+AC_MSG_NOTICE([  libxenlight: $LIBXL_CFLAGS $LIBXL_LIBS])
+else
+AC_MSG_NOTICE([  libxenlight: no])
+fi
 if test "$with_hal" = "yes" ; then
 AC_MSG_NOTICE([     hal: $HAL_CFLAGS $HAL_LIBS])
 else
diff --git a/daemon/Makefile.am b/daemon/Makefile.am
index 912440c..195b8c8 100644
--- a/daemon/Makefile.am
+++ b/daemon/Makefile.am
@@ -112,6 +112,10 @@ if WITH_LXC
     libvirtd_LDADD += ../src/libvirt_driver_lxc.la
 endif
 
+if WITH_LIBXL
+    libvirtd_LDADD += ../src/libvirt_driver_libxl.la
+endif
+
 if WITH_UML
     libvirtd_LDADD += ../src/libvirt_driver_uml.la
 endif
diff --git a/daemon/libvirtd.c b/daemon/libvirtd.c
index 452566c..57795f8 100644
--- a/daemon/libvirtd.c
+++ b/daemon/libvirtd.c
@@ -81,6 +81,9 @@
 # ifdef WITH_LXC
 #  include "lxc/lxc_driver.h"
 # endif
+# ifdef WITH_LIBXL
+#  include "libxl/libxl_driver.h"
+# endif
 # ifdef WITH_UML
 #  include "uml/uml_driver.h"
 # endif
@@ -948,6 +951,9 @@ static struct qemud_server *qemudInitialize(void) {
 # ifdef WITH_LXC
     lxcRegister();
 # endif
+# ifdef WITH_LIBXL
+    libxlRegister();
+# endif
 # ifdef WITH_UML
     umlRegister();
 # endif
diff --git a/docs/drivers.html.in b/docs/drivers.html.in
index ecad03a..368664e 100644
--- a/docs/drivers.html.in
+++ b/docs/drivers.html.in
@@ -28,7 +28,8 @@
       <li><strong><a href="drvvbox.html">VirtualBox</a></strong></li>
       <li><strong><a href="drvesx.html">VMware ESX</a></strong></li>
       <li><strong><a href="drvvmware.html">VMware 
Workstation/Player</a></strong></li>
-      <li><strong><a href="drvxen.html">Xen</a></strong></li>
+      <li><strong><a href="drvxen.html">Xen 3.0.1 - 4.0.x</a></strong></li>
+      <li><strong><a href="drvxenlight.html">Xen 4.1.0 
onwards</a></strong></li>
     </ul>
 
     <h2><a name="stroage">Storage drivers</a></h2>
diff --git a/docs/drvxen.html.in b/docs/drvxen.html.in
index 4e35afa..4b88a7d 100644
--- a/docs/drvxen.html.in
+++ b/docs/drvxen.html.in
@@ -6,7 +6,11 @@
 
     <p>
       The libvirt Xen driver provides the ability to manage virtual machines
-      on any Xen release from 3.0.1 onwards.
+      on any Xen release from 3.0.1 to 4.0.x.  Starting with Xen 4.1.0,
+      the traditional xm/xend toolstack is replaced with a new toolstack
+      based on libxenlight.  Consult the
+      <a href="drvxenlight.html">libxenlight driver</a> if your Xen host is 
+      configured to use the new toolstack.
     </p>
 
     <h2><a name="prereq">Deployment pre-requisites</a></h2>
diff --git a/docs/drvxenlight.html.in b/docs/drvxenlight.html.in
new file mode 100644
index 0000000..fe60786
--- /dev/null
+++ b/docs/drvxenlight.html.in
@@ -0,0 +1,53 @@
+<html>
+  <body>
+    <h1>libxenlight hypervisor driver</h1>
+
+    <ul id="toc"></ul>
+
+    <p>
+      The libvirt libxenlight driver provides the ability to manage virtual
+      machines on any Xen release from 4.1.0 onwards.
+    </p>
+
+    <h2><a name="prereq">Deployment pre-requisites</a></h2>
+
+    <p>
+      This driver uses Xen's libxenlight toolstack, which is the default
+      toolstack configuration starting with Xen 4.1.0.  The traditional
+      xm/xend toolstack is still provided, but it is no longer maintained
+      and may be removed in a future Xen release.
+    </p>
+
+    <p>
+      The libxenlight toolstack uses xenstored and blktap2.  Ensure
+      xenstored is running, or use the xencommons init script provided.
+      Ensure your kernel supports the blktap2 module and it is loaded.
+    </p>
+
+    <h2><a name="uri">Connections to libxenlight driver</a></h2>
+
+    <p>
+    The libvirt libxenlight driver is a stateful, privileged driver,
+    with a driver name of 'libxl'. Some example conection URIs for
+    the libxenlight driver are:
+    </p>
+
+<pre>
+libxl:///                      (local access, direct)
+libxl://example.com/           (remote access, TLS/x509)
+libxl+tcp://example.com/       (remote access, SASl/Kerberos)
+libxl+ssh://root@xxxxxxxxxxx/  (remote access, SSH tunnelled)
+</pre>
+
+    <h2><a name="xmlconfig">Example domain XML config</a></h2>
+
+    <p>
+      The libxenlight toolstack attempts to be compatible with the
+      legacy xm/xend toolstack, supporting the traditional python
+      configuration files (xen-xm).  Fortunately, the libvirt XML
+      syntax is unchanged with the libxenlight driver.  Consult 
+      the <a href="drvxen.html#xmlconfig">Xen driver examples</a>.
+    </p>
+
+  </body>
+</html>
diff --git a/docs/sitemap.html.in b/docs/sitemap.html.in
index ac0af71..538f227 100644
--- a/docs/sitemap.html.in
+++ b/docs/sitemap.html.in
@@ -156,7 +156,11 @@
             <ul>
               <li>
                 <a href="drvxen.html">Xen</a>
-                <span>Driver the Xen hypervisor</span>
+                <span>Driver the Xen hypervisor, versions 3.0.1 - 4.0.x</span>
+              </li>
+              <li>
+                <a href="drvxenlight.html">libxenlight</a>
+                <span>Driver the Xen hypervisor, version 4.1.0 onwards</span>
               </li>
               <li>
                 <a href="drvqemu.html">QEMU / KVM</a>
diff --git a/include/libvirt/virterror.h b/include/libvirt/virterror.h
index 6b8c789..1d8275b 100644
--- a/include/libvirt/virterror.h
+++ b/include/libvirt/virterror.h
@@ -80,6 +80,7 @@ typedef enum {
     VIR_FROM_STREAMS = 38,     /* Error from I/O streams */
     VIR_FROM_VMWARE = 39,      /* Error from VMware driver */
     VIR_FROM_EVENT = 40,       /* Error from event loop impl */
+    VIR_FROM_LIBXL = 41,       /* Error from libxenlight driver */
 } virErrorDomain;
 
 
diff --git a/po/POTFILES.in b/po/POTFILES.in
index 1ed2765..4bd2b13 100644
--- a/po/POTFILES.in
+++ b/po/POTFILES.in
@@ -34,6 +34,8 @@ src/lxc/lxc_conf.c
 src/lxc/lxc_controller.c
 src/lxc/lxc_driver.c
 src/lxc/veth.c
+src/libxl/libxl_driver.c
+src/libxl/libxl_conf.c
 src/network/bridge_driver.c
 src/node_device/node_device_driver.c
 src/node_device/node_device_hal.c
diff --git a/src/Makefile.am b/src/Makefile.am
index 25f0e48..f9c6066 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -298,6 +298,10 @@ XENAPI_DRIVER_SOURCES =                                    
                        \
                xenapi/xenapi_driver_private.h                                  
\
                xenapi/xenapi_utils.c xenapi/xenapi_utils.h
 
+LIBXL_DRIVER_SOURCES =                                         \
+               libxl/libxl_conf.c libxl/libxl_conf.h           \
+               libxl/libxl_driver.c libxl/libxl_driver.h
+
 UML_DRIVER_SOURCES =                                           \
                uml/uml_conf.c uml/uml_conf.h                   \
                uml/uml_driver.c uml/uml_driver.h
@@ -692,6 +696,25 @@ endif
 libvirt_driver_xenapi_la_SOURCES = $(XENAPI_DRIVER_SOURCES)
 endif
 
+if WITH_LIBXL
+if WITH_DRIVER_MODULES
+mod_LTLIBRARIES += libvirt_driver_libxl.la
+else
+noinst_LTLIBRARIES += libvirt_driver_libxl.la
+# Stateful, so linked to daemon instead
+#libvirt_la_BUILT_LIBADD += libvirt_driver_libxl.la
+endif
+libvirt_driver_libxl_la_CFLAGS = $(LIBXL_CFLAGS) \
+               -I@top_srcdir@/src/conf $(AM_CFLAGS)
+libvirt_driver_libxl_la_LDFLAGS = $(AM_LDFLAGS)
+libvirt_driver_libxl_la_LIBADD = $(LIBXL_LIBS)
+if WITH_DRIVER_MODULES
+libvirt_driver_libxl_la_LIBADD += ../gnulib/lib/libgnu.la
+libvirt_driver_libxl_la_LDFLAGS += -module -avoid-version
+endif
+libvirt_driver_libxl_la_SOURCES = $(LIBXL_DRIVER_SOURCES)
+endif
+
 if WITH_QEMU
 if WITH_DRIVER_MODULES
 mod_LTLIBRARIES += libvirt_driver_qemu.la
@@ -991,6 +1014,7 @@ EXTRA_DIST +=                                              
        \
                $(PHYP_DRIVER_SOURCES)                          \
                $(VBOX_DRIVER_SOURCES)                          \
                $(XENAPI_DRIVER_SOURCES)                        \
+               $(LIBXL_DRIVER_SOURCES)                 \
                $(ESX_DRIVER_SOURCES)                           \
                $(ESX_DRIVER_EXTRA_DIST)                        \
                $(NETWORK_DRIVER_SOURCES)                       \
@@ -1245,6 +1269,10 @@ if WITH_LXC
        $(MKDIR_P) "$(DESTDIR)$(localstatedir)/lib/libvirt/lxc"
        $(MKDIR_P) "$(DESTDIR)$(localstatedir)/run/libvirt/lxc"
 endif
+if WITH_LIBXL
+       $(MKDIR_P) "$(DESTDIR)$(localstatedir)/lib/libvirt/libxl"
+       $(MKDIR_P) "$(DESTDIR)$(localstatedir)/run/libvirt/libxl"
+endif
 if WITH_UML
        $(MKDIR_P) "$(DESTDIR)$(localstatedir)/lib/libvirt/uml"
        $(MKDIR_P) "$(DESTDIR)$(localstatedir)/run/libvirt/uml"
@@ -1282,6 +1310,10 @@ if WITH_LXC
        rmdir "$(DESTDIR)$(localstatedir)/lib/libvirt/lxc" ||:
        rmdir "$(DESTDIR)$(localstatedir)/run/libvirt/lxc" ||:
 endif
+if WITH_LIBXL
+       rmdir "$(DESTDIR)$(localstatedir)/lib/libvirt/libxl" ||:
+       rmdir "$(DESTDIR)$(localstatedir)/run/libvirt/libxl" ||:
+endif
 if WITH_UML
        rmdir "$(DESTDIR)$(localstatedir)/lib/libvirt/uml" ||:
        rmdir "$(DESTDIR)$(localstatedir)/run/libvirt/uml" ||:
diff --git a/src/driver.h b/src/driver.h
index c65a4b9..c8c9624 100644
--- a/src/driver.h
+++ b/src/driver.h
@@ -27,7 +27,8 @@ typedef enum {
     VIR_DRV_ESX = 10,
     VIR_DRV_PHYP = 11,
     VIR_DRV_XENAPI = 12,
-    VIR_DRV_VMWARE = 13
+    VIR_DRV_VMWARE = 13,
+    VIR_DRV_LIBXL = 14,
 } virDrvNo;
 
 
diff --git a/src/libvirt.c b/src/libvirt.c
index e4b451e..5e2876b 100644
--- a/src/libvirt.c
+++ b/src/libvirt.c
@@ -912,6 +912,10 @@ virGetVersion(unsigned long *libVer, const char *type,
         if (STRCASEEQ(type, "LXC"))
             *typeVer = LIBVIR_VERSION_NUMBER;
 # endif
+# if WITH_LIBXL
+        if (STRCASEEQ(type, "libxl"))
+            *typeVer = LIBVIR_VERSION_NUMBER;
+# endif
 # if WITH_PHYP
         if (STRCASEEQ(type, "phyp"))
             *typeVer = LIBVIR_VERSION_NUMBER;
diff --git a/src/libxl/libxl_conf.c b/src/libxl/libxl_conf.c
new file mode 100644
index 0000000..a48eea3
--- /dev/null
+++ b/src/libxl/libxl_conf.c
@@ -0,0 +1,896 @@
+/*---------------------------------------------------------------------------*/
+/*  Copyright (c) 2011 SUSE LINUX Products GmbH, Nuernberg, Germany.
+ *
+ * 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 <config.h>
+
+#include <regex.h>
+#include <libxl.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/utsname.h>
+
+#include "internal.h"
+#include "logging.h"
+#include "virterror_internal.h"
+#include "datatypes.h"
+#include "files.h"
+#include "memory.h"
+#include "uuid.h"
+#include "capabilities.h"
+#include "libxl_driver.h"
+#include "libxl_conf.h"
+
+
+#define VIR_FROM_THIS VIR_FROM_LIBXL
+
+
+struct guest_arch {
+    const char *model;
+    int bits;
+    int hvm;
+    int pae;
+    int nonpae;
+    int ia64_be;
+};
+
+static const char *xen_cap_re = 
"(xen|hvm)-[[:digit:]]+\\.[[:digit:]]+-(x86_32|x86_64|ia64|powerpc64)(p|be)?";
+static regex_t xen_cap_rec;
+
+
+static int
+libxlNextFreeVncPort(libxlDriverPrivatePtr driver, int startPort)
+{
+    int i;
+
+    for (i = startPort ; i < LIBXL_VNC_PORT_MAX; i++) {
+        int fd;
+        int reuse = 1;
+        struct sockaddr_in addr;
+        bool used = false;
+
+        if (virBitmapGetBit(driver->reservedVNCPorts,
+                            i - LIBXL_VNC_PORT_MIN, &used) < 0)
+            VIR_DEBUG("virBitmapGetBit failed on bit %d", i - 
LIBXL_VNC_PORT_MIN);
+
+        if (used)
+            continue;
+
+        addr.sin_family = AF_INET;
+        addr.sin_port = htons(i);
+        addr.sin_addr.s_addr = htonl(INADDR_ANY);
+        fd = socket(PF_INET, SOCK_STREAM, 0);
+        if (fd < 0)
+            return -1;
+
+        if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (void*)&reuse, 
sizeof(reuse)) < 0) {
+            VIR_FORCE_CLOSE(fd);
+            break;
+        }
+
+        if (bind(fd, (struct sockaddr*)&addr, sizeof(addr)) == 0) {
+            /* Not in use, lets grab it */
+            VIR_FORCE_CLOSE(fd);
+            /* Add port to bitmap of reserved ports */
+            if (virBitmapSetBit(driver->reservedVNCPorts,
+                                i - LIBXL_VNC_PORT_MIN) < 0) {
+                VIR_DEBUG("virBitmapSetBit failed on bit %d",
+                          i - LIBXL_VNC_PORT_MIN);
+            }
+            return i;
+        }
+        VIR_FORCE_CLOSE(fd);
+
+        if (errno == EADDRINUSE) {
+            /* In use, try next */
+            continue;
+        }
+        /* Some other bad failure, get out.. */
+        break;
+    }
+    return -1;
+}
+
+static virCapsPtr
+libxlBuildCapabilities(const char *hostmachine,
+                       int host_pae,
+                       struct guest_arch *guest_archs,
+                       int nr_guest_archs)
+{
+    virCapsPtr caps;
+    int i;
+
+    if ((caps = virCapabilitiesNew(hostmachine, 1, 1)) == NULL)
+        goto no_memory;
+
+    virCapabilitiesSetMacPrefix(caps, (unsigned char[]){ 0x00, 0x16, 0x3e });
+
+    if (host_pae &&
+        virCapabilitiesAddHostFeature(caps, "pae") < 0)
+        goto no_memory;
+
+    for (i = 0; i < nr_guest_archs; ++i) {
+        virCapsGuestPtr guest;
+        char const *const xen_machines[] = {guest_archs[i].hvm ? "xenfv" : 
"xenpv"};
+        virCapsGuestMachinePtr *machines;
+
+        if ((machines = virCapabilitiesAllocMachines(xen_machines, 1)) == NULL)
+            goto no_memory;
+
+        if ((guest = virCapabilitiesAddGuest(caps,
+                                             guest_archs[i].hvm ? "hvm" : 
"xen",
+                                             guest_archs[i].model,
+                                             guest_archs[i].bits,
+                                             (STREQ(hostmachine, "x86_64") ?
+                                              "/usr/lib64/xen/bin/qemu-dm" :
+                                              "/usr/lib/xen/bin/qemu-dm"),
+                                             (guest_archs[i].hvm ?
+                                              "/usr/lib/xen/boot/hvmloader" :
+                                              NULL),
+                                             1,
+                                             machines)) == NULL) {
+            virCapabilitiesFreeMachines(machines, 1);
+            goto no_memory;
+        }
+        machines = NULL;
+
+        if (virCapabilitiesAddGuestDomain(guest,
+                                          "xen",
+                                          NULL,
+                                          NULL,
+                                          0,
+                                          NULL) == NULL)
+            goto no_memory;
+
+        if (guest_archs[i].pae &&
+            virCapabilitiesAddGuestFeature(guest,
+                                           "pae",
+                                           1,
+                                           0) == NULL)
+            goto no_memory;
+
+        if (guest_archs[i].nonpae &&
+            virCapabilitiesAddGuestFeature(guest,
+                                           "nonpae",
+                                           1,
+                                           0) == NULL)
+            goto no_memory;
+
+        if (guest_archs[i].ia64_be &&
+            virCapabilitiesAddGuestFeature(guest,
+                                           "ia64_be",
+                                           1,
+                                           0) == NULL)
+            goto no_memory;
+
+        if (guest_archs[i].hvm) {
+            if (virCapabilitiesAddGuestFeature(guest,
+                                               "acpi",
+                                               1,
+                                               1) == NULL)
+                goto no_memory;
+
+            if (virCapabilitiesAddGuestFeature(guest, "apic",
+                                               1,
+                                               0) == NULL)
+                goto no_memory;
+
+            if (virCapabilitiesAddGuestFeature(guest,
+                                               "hap",
+                                               0,
+                                               1) == NULL)
+                goto no_memory;
+        }
+    }
+
+    caps->defaultConsoleTargetType = VIR_DOMAIN_CHR_CONSOLE_TARGET_TYPE_XEN;
+
+    return caps;
+
+ no_memory:
+    virCapabilitiesFree(caps);
+    return NULL;
+}
+
+static virCapsPtr
+libxlMakeCapabilitiesInternal(const char *hostmachine,
+                              libxl_physinfo *phy_info,
+                              char *capabilities)
+{
+    char *str, *token;
+    regmatch_t subs[4];
+    char *saveptr = NULL;
+    int i;
+
+    int host_pae = 0;
+    struct guest_arch guest_archs[32];
+    int nr_guest_archs = 0;
+    virCapsPtr caps = NULL;
+
+    memset(guest_archs, 0, sizeof(guest_archs));
+
+    // TODO: extract pae from phy_info->phys_cap
+    // for now, better default is 1
+    (void)phy_info;
+    host_pae = 1;
+
+    /* Format of capabilities string is documented in the code in
+     * xen-unstable.hg/xen/arch/.../setup.c.
+     *
+     * It is a space-separated list of supported guest architectures.
+     *
+     * For x86:
+     *    TYP-VER-ARCH[p]
+     *    ^   ^   ^    ^
+     *    |   |   |    +-- PAE supported
+     *    |   |   +------- x86_32 or x86_64
+     *    |   +----------- the version of Xen, eg. "3.0"
+     *    +--------------- "xen" or "hvm" for para or full virt respectively
+     *
+     * For IA64:
+     *    TYP-VER-ARCH[be]
+     *    ^   ^   ^    ^
+     *    |   |   |    +-- Big-endian supported
+     *    |   |   +------- always "ia64"
+     *    |   +----------- the version of Xen, eg. "3.0"
+     *    +--------------- "xen" or "hvm" for para or full virt respectively
+     */
+
+    /* Split capabilities string into tokens. strtok_r is OK here because
+     * we "own" the buffer.  Parse out the features from each token.
+     */
+    for (str = capabilities, nr_guest_archs = 0;
+         nr_guest_archs < sizeof guest_archs / sizeof guest_archs[0]
+                 && (token = strtok_r (str, " ", &saveptr)) != NULL;
+         str = NULL) {
+        if (regexec(&xen_cap_rec, token, sizeof subs / sizeof subs[0],
+                    subs, 0) == 0) {
+            int hvm = STRPREFIX(&token[subs[1].rm_so], "hvm");
+            const char *model;
+            int bits, pae = 0, nonpae = 0, ia64_be = 0;
+
+            if (STRPREFIX(&token[subs[2].rm_so], "x86_32")) {
+                model = "i686";
+                bits = 32;
+                if (subs[3].rm_so != -1 &&
+                    STRPREFIX(&token[subs[3].rm_so], "p"))
+                    pae = 1;
+                else
+                    nonpae = 1;
+            }
+            else if (STRPREFIX(&token[subs[2].rm_so], "x86_64")) {
+                model = "x86_64";
+                bits = 64;
+            }
+            else if (STRPREFIX(&token[subs[2].rm_so], "ia64")) {
+                model = "ia64";
+                bits = 64;
+                if (subs[3].rm_so != -1 &&
+                    STRPREFIX(&token[subs[3].rm_so], "be"))
+                    ia64_be = 1;
+            }
+            else if (STRPREFIX(&token[subs[2].rm_so], "powerpc64")) {
+                model = "ppc64";
+                bits = 64;
+            } else {
+                continue;
+            }
+
+            /* Search for existing matching (model,hvm) tuple */
+            for (i = 0 ; i < nr_guest_archs ; i++) {
+                if (STREQ(guest_archs[i].model, model) &&
+                    guest_archs[i].hvm == hvm) {
+                    break;
+                }
+            }
+
+            /* Too many arch flavours - highly unlikely ! */
+            if (i >= ARRAY_CARDINALITY(guest_archs))
+                continue;
+            /* Didn't find a match, so create a new one */
+            if (i == nr_guest_archs)
+                nr_guest_archs++;
+
+            guest_archs[i].model = model;
+            guest_archs[i].bits = bits;
+            guest_archs[i].hvm = hvm;
+
+            /* Careful not to overwrite a previous positive
+               setting with a negative one here - some archs
+               can do both pae & non-pae, but Xen reports
+               separately capabilities so we're merging archs */
+            if (pae)
+                guest_archs[i].pae = pae;
+            if (nonpae)
+                guest_archs[i].nonpae = nonpae;
+            if (ia64_be)
+                guest_archs[i].ia64_be = ia64_be;
+        }
+    }
+
+    if ((caps = libxlBuildCapabilities(hostmachine,
+                                       host_pae,
+                                       guest_archs,
+                                       nr_guest_archs)) == NULL)
+        goto no_memory;
+
+    return caps;
+
+ no_memory:
+    virReportOOMError();
+    virCapabilitiesFree(caps);
+    return NULL;
+}
+
+static int
+libxlMakeDomCreateInfo(virDomainDefPtr def, libxl_domain_create_info *c_info)
+{
+    char uuidstr[VIR_UUID_STRING_BUFLEN];
+
+    libxl_init_create_info(c_info);
+
+    c_info->hvm = STREQ(def->os.type, "hvm");
+    if ((c_info->name = strdup(def->name)) == NULL) {
+        virReportOOMError();
+        goto error;
+    }
+
+    virUUIDFormat(def->uuid, uuidstr);
+    if (libxl_uuid_from_string(&c_info->uuid, uuidstr) ) {
+        libxlError(VIR_ERR_INTERNAL_ERROR,
+                 _("libxenlight failed to parse UUID '%s'"), uuidstr);
+        goto error;
+    }
+
+    return 0;
+
+error:
+    libxl_domain_create_info_destroy(c_info);
+    return -1;
+}
+
+static int
+libxlMakeDomBuildInfo(virDomainDefPtr def, libxl_domain_config *d_config)
+{
+    libxl_domain_build_info *b_info = &d_config->b_info;
+    int hvm = STREQ(def->os.type, "hvm");
+
+    libxl_init_build_info(b_info, &d_config->c_info);
+
+    b_info->hvm = hvm;
+    b_info->max_vcpus = def->maxvcpus;
+    b_info->cur_vcpus = def->vcpus;
+    if (def->clock.ntimers > 0 &&
+        def->clock.timers[0]->name == VIR_DOMAIN_TIMER_NAME_TSC) {
+        switch (def->clock.timers[0]->mode) {
+            case VIR_DOMAIN_TIMER_MODE_NATIVE:
+                b_info->tsc_mode = 2;
+                break;
+            case VIR_DOMAIN_TIMER_MODE_PARAVIRT:
+                b_info->tsc_mode = 3;
+                break;
+            default:
+                b_info->tsc_mode = 1;
+        }
+    }
+    b_info->max_memkb = def->mem.max_balloon;
+    b_info->target_memkb = def->mem.cur_balloon;
+    if (hvm) {
+        b_info->u.hvm.pae = def->features & (1 << VIR_DOMAIN_FEATURE_PAE);
+        b_info->u.hvm.apic = def->features & (1 << VIR_DOMAIN_FEATURE_APIC);
+        b_info->u.hvm.acpi = def->features & (1 << VIR_DOMAIN_FEATURE_ACPI);
+        /*
+         * The following comment and calculation were taken directly from
+         * libxenlight's internal function libxl_get_required_shadow_memory():
+         *
+         * 256 pages (1MB) per vcpu, plus 1 page per MiB of RAM for the P2M 
map,
+         * plus 1 page per MiB of RAM to shadow the resident processes.
+         */
+        b_info->shadow_memkb = 4 * (256 * b_info->cur_vcpus +
+                                    2 * (b_info->max_memkb / 1024));
+    } else {
+        if (def->os.bootloader) {
+            if ((b_info->u.pv.bootloader = strdup(def->os.bootloader)) == 
NULL) {
+                virReportOOMError();
+                goto error;
+            }
+        }
+        if (def->os.bootloaderArgs) {
+            if ((b_info->u.pv.bootloader_args = 
strdup(def->os.bootloaderArgs)) == NULL) {
+                virReportOOMError();
+                goto error;
+            }
+        }
+        if (def->os.cmdline) {
+            if ((b_info->u.pv.cmdline = strdup(def->os.cmdline)) == NULL) {
+                virReportOOMError();
+                goto error;
+            }
+        }
+        if (def->os.kernel) {
+            /* libxl_init_build_info() sets kernel.path = strdup("hvmloader") 
*/
+            free(b_info->kernel.path);
+            if ((b_info->kernel.path = strdup(def->os.kernel)) == NULL) {
+                virReportOOMError();
+                goto error;
+            }
+        }
+        if (def->os.initrd) {
+            if ((b_info->u.pv.ramdisk.path = strdup(def->os.initrd)) == NULL) {
+                virReportOOMError();
+                goto error;
+            }
+        }
+    }
+
+    return 0;
+
+error:
+    libxl_domain_build_info_destroy(b_info);
+    return -1;
+}
+
+static int
+libxlMakeDiskList(virDomainDefPtr def, libxl_domain_config *d_config)
+{
+    virDomainDiskDefPtr *l_disks = def->disks;
+    int ndisks = def->ndisks;
+    libxl_device_disk *x_disks;
+    int i;
+
+    if (VIR_ALLOC_N(x_disks, ndisks) < 0) {
+        virReportOOMError();
+        return -1;
+    }
+
+    for (i = 0; i < ndisks; i++) {
+        if (l_disks[i]->src &&
+             (x_disks[i].pdev_path = strdup(l_disks[i]->src)) == NULL) {
+            virReportOOMError();
+            goto error;
+        }
+
+        if (l_disks[i]->dst &&
+            (x_disks[i].vdev = strdup(l_disks[i]->dst)) == NULL) {
+            virReportOOMError();
+            goto error;
+        }
+
+        if (l_disks[i]->driverName) {
+            if (STREQ(l_disks[i]->driverName, "tap") ||
+                STREQ(l_disks[i]->driverName, "tap2")) {
+                if (l_disks[i]->driverType) {
+                    if (STREQ(l_disks[i]->driverType, "qcow")) {
+                        x_disks[i].format = DISK_FORMAT_QCOW;
+                        x_disks[i].backend = DISK_BACKEND_QDISK;
+                    } else if (STREQ(l_disks[i]->driverType, "qcow2")) {
+                        x_disks[i].format = DISK_FORMAT_QCOW2;
+                        x_disks[i].backend = DISK_BACKEND_QDISK;
+                    } else if (STREQ(l_disks[i]->driverType, "vhd")) {
+                        x_disks[i].format = DISK_FORMAT_VHD;
+                        x_disks[i].backend = DISK_BACKEND_TAP;
+                    } else if (STREQ(l_disks[i]->driverType, "aio") ||
+                               STREQ(l_disks[i]->driverType, "raw")) {
+                        x_disks[i].format = DISK_FORMAT_RAW;
+                        x_disks[i].backend = DISK_BACKEND_TAP;
+                    }
+                } else {
+                    /* No subtype specified, default to raw/tap */
+                        x_disks[i].format = DISK_FORMAT_RAW;
+                        x_disks[i].backend = DISK_BACKEND_TAP;
+                }
+            } else if (STREQ(l_disks[i]->driverName, "file")) {
+                x_disks[i].format = DISK_FORMAT_RAW;
+                x_disks[i].backend = DISK_BACKEND_TAP;
+            } else if (STREQ(l_disks[i]->driverName, "phy")) {
+                x_disks[i].format = DISK_FORMAT_RAW;
+                x_disks[i].backend = DISK_BACKEND_PHY;
+            } else {
+                libxlError(VIR_ERR_INTERNAL_ERROR,
+                           _("libxenlight does not support disk driver %s"),
+                           l_disks[i]->driverName);
+                goto error;
+            }
+        } else {
+            /* No driverName - default to raw/tap?? */
+            x_disks[i].format = DISK_FORMAT_RAW;
+            x_disks[i].backend = DISK_BACKEND_TAP;
+        }
+
+        /* How to set unpluggable? */
+        x_disks[i].unpluggable = 1;
+        x_disks[i].readwrite = !l_disks[i]->readonly;
+        x_disks[i].is_cdrom =
+                l_disks[i]->device == VIR_DOMAIN_DISK_DEVICE_CDROM ? 1 : 0;
+    }
+
+    d_config->disks = x_disks;
+    d_config->num_disks = ndisks;
+
+    return 0;
+
+error:
+    for (i = 0; i < ndisks; i++)
+        libxl_device_disk_destroy(&x_disks[i]);
+    VIR_FREE(x_disks);
+    return -1;
+}
+
+static int
+libxlMakeNicList(virDomainDefPtr def,  libxl_domain_config *d_config)
+{
+    virDomainNetDefPtr *l_nics = def->nets;
+    int nnics = def->nnets;
+    libxl_device_nic *x_nics;
+    int i;
+
+    if (VIR_ALLOC_N(x_nics, nnics) < 0) {
+        virReportOOMError();
+        return -1;
+    }
+
+    for (i = 0; i < nnics; i++) {
+        x_nics[i].devid = i;
+
+        // TODO: Where is mtu stored?
+        x_nics[i].mtu = 1492;
+
+        memcpy(x_nics[i].mac, l_nics[i]->mac, sizeof(libxl_mac));
+
+        if (l_nics[i]->model && !STREQ(l_nics[i]->model, "netfront")) {
+            if ((x_nics[i].model = strdup(l_nics[i]->model)) == NULL) {
+                virReportOOMError();
+                goto error;
+            }
+            x_nics[i].nictype = NICTYPE_IOEMU;
+        } else {
+            x_nics[i].nictype = NICTYPE_VIF;
+        }
+
+        if (l_nics[i]->ifname &&
+            (x_nics[i].ifname = strdup(l_nics[i]->ifname)) == NULL) {
+            virReportOOMError();
+            goto error;
+        }
+
+        if (l_nics[i]->type == VIR_DOMAIN_NET_TYPE_BRIDGE) {
+            if (l_nics[i]->data.bridge.brname &&
+                (x_nics[i].bridge =
+                 strdup(l_nics[i]->data.bridge.brname)) == NULL) {
+                virReportOOMError();
+                goto error;
+            }
+            if (l_nics[i]->data.bridge.script &&
+                (x_nics[i].script =
+                 strdup(l_nics[i]->data.bridge.script)) == NULL) {
+                virReportOOMError();
+                goto error;
+            }
+        }
+
+        //TODO
+        //x_nics[i].ip = ;
+    }
+
+    d_config->vifs = x_nics;
+    d_config->num_vifs = nnics;
+
+    return 0;
+
+error:
+    for (i = 0; i < nnics; i++)
+        libxl_device_nic_destroy(&x_nics[i]);
+    VIR_FREE(x_nics);
+    return -1;
+}
+
+static int
+libxlMakeVfbList(libxlDriverPrivatePtr driver,
+                 virDomainDefPtr def, libxl_domain_config *d_config)
+{
+    virDomainGraphicsDefPtr *l_vfbs = def->graphics;
+    int nvfbs = def->ngraphics;
+    libxl_device_vfb *x_vfbs;
+    libxl_device_vkb *x_vkbs;
+    int i;
+    int port;
+
+    if (nvfbs == 0)
+        return 0;
+
+    if (VIR_ALLOC_N(x_vfbs, nvfbs) < 0) {
+        virReportOOMError();
+        return -1;
+    }
+    if (VIR_ALLOC_N(x_vkbs, nvfbs) < 0) {
+        virReportOOMError();
+        VIR_FREE(x_vfbs);
+        return -1;
+    }
+
+    for (i = 0; i < nvfbs; i++) {
+        libxl_device_vfb_init(&x_vfbs[i], i);
+        libxl_device_vkb_init(&x_vkbs[i], i);
+
+        switch (l_vfbs[i]->type) {
+            case VIR_DOMAIN_GRAPHICS_TYPE_SDL:
+                x_vfbs[i].sdl = 1;
+                if (l_vfbs[i]->data.sdl.display &&
+                    (x_vfbs[i].display =
+                     strdup(l_vfbs[i]->data.sdl.display)) == NULL) {
+                    virReportOOMError();
+                    goto error;
+                }
+                if (l_vfbs[i]->data.sdl.xauth &&
+                    (x_vfbs[i].xauthority =
+                     strdup(l_vfbs[i]->data.sdl.xauth)) == NULL) {
+                    virReportOOMError();
+                    goto error;
+                }
+                break;
+            case  VIR_DOMAIN_GRAPHICS_TYPE_VNC:
+                x_vfbs[i].vnc = 1;
+                /* driver handles selection of free port */
+                x_vfbs[i].vncunused = 0;
+                if (l_vfbs[i]->data.vnc.autoport) {
+                    port = libxlNextFreeVncPort(driver, LIBXL_VNC_PORT_MIN);
+                    if (port < 0) {
+                        libxlError(VIR_ERR_INTERNAL_ERROR,
+                                   "%s", _("Unable to find an unused VNC 
port"));
+                        goto error;
+                    }
+                    l_vfbs[i]->data.vnc.port = port;
+                }
+                x_vfbs[i].vncdisplay = l_vfbs[i]->data.vnc.port -
+                        LIBXL_VNC_PORT_MIN;
+
+                if (l_vfbs[i]->data.vnc.listenAddr) {
+                    /* libxl_device_vfb_init() does strdup("127.0.0.1") */
+                    free(x_vfbs[i].vnclisten);
+                    if ((x_vfbs[i].vnclisten =
+                     strdup(l_vfbs[i]->data.vnc.listenAddr)) == NULL) {
+                        virReportOOMError();
+                        goto error;
+                    }
+                }
+                if (l_vfbs[i]->data.vnc.keymap &&
+                    (x_vfbs[i].keymap =
+                     strdup(l_vfbs[i]->data.vnc.keymap)) == NULL) {
+                    virReportOOMError();
+                    goto error;
+                }
+                break;
+        }
+    }
+
+    d_config->vfbs = x_vfbs;
+    d_config->vkbs = x_vkbs;
+    d_config->num_vfbs = d_config->num_vkbs = nvfbs;
+
+    return 0;
+
+error:
+    for (i = 0; i < nvfbs; i++) {
+        libxl_device_vfb_destroy(&x_vfbs[i]);
+        libxl_device_vkb_destroy(&x_vkbs[i]);
+    }
+    VIR_FREE(x_vfbs);
+    VIR_FREE(x_vkbs);
+    return -1;
+}
+
+static int
+libxlMakeChrdevStr(virDomainChrDefPtr def, char **buf)
+{
+    const char *type = virDomainChrTypeToString(def->source.type);
+
+    if (!type) {
+        libxlError(VIR_ERR_INTERNAL_ERROR,
+                   "%s", _("unexpected chr device type"));
+        return -1;
+    }
+
+    switch (def->source.type) {
+        case VIR_DOMAIN_CHR_TYPE_NULL:
+        case VIR_DOMAIN_CHR_TYPE_STDIO:
+        case VIR_DOMAIN_CHR_TYPE_VC:
+        case VIR_DOMAIN_CHR_TYPE_PTY:
+            if (virAsprintf(buf, "%s", type) < 0) {
+                virReportOOMError();
+                return -1;
+            }
+            break;
+
+        case VIR_DOMAIN_CHR_TYPE_FILE:
+        case VIR_DOMAIN_CHR_TYPE_PIPE:
+            if (virAsprintf(buf, "%s:%s", type,
+                            def->source.data.file.path) < 0) {
+                virReportOOMError();
+                return -1;
+            }
+            break;
+
+        case VIR_DOMAIN_CHR_TYPE_DEV:
+            if (virAsprintf(buf, "%s", def->source.data.file.path) < 0) {
+                virReportOOMError();
+                return -1;
+            }
+            break;
+    }
+
+    return 0;
+}
+
+static int
+libxlMakeDeviceModelInfo(virDomainDefPtr def, libxl_domain_config *d_config)
+{
+    libxl_device_model_info *dm_info = &d_config->dm_info;
+    int i;
+    char b_order[VIR_DOMAIN_BOOT_LAST+1];
+
+    libxl_init_dm_info(dm_info, &d_config->c_info, &d_config->b_info);
+
+    if (d_config->b_info.hvm) {
+        /* HVM-specific device model info */
+        dm_info->type = XENFV;
+        if (def->os.nBootDevs > 0) {
+            free(dm_info->boot);
+            for (i = 0; i < def->os.nBootDevs; i++) {
+                switch (def->os.bootDevs[i]) {
+                    case VIR_DOMAIN_BOOT_FLOPPY:
+                        b_order[i] = 'a';
+                        break;
+                    default:
+                    case VIR_DOMAIN_BOOT_DISK:
+                        b_order[i] = 'c';
+                        break;
+                    case VIR_DOMAIN_BOOT_CDROM:
+                        b_order[i] = 'd';
+                        break;
+                    case VIR_DOMAIN_BOOT_NET:
+                        b_order[i] = 'n';
+                        break;
+                }
+            }
+            b_order[def->os.nBootDevs] = '\0';
+            if ((dm_info->boot = strdup(b_order)) == NULL) {
+                virReportOOMError();
+                goto error;
+            }
+        }
+        if (def->serials &&
+            (libxlMakeChrdevStr(def->serials[0], &dm_info->serial) < 0))
+            goto error;
+    } else {
+        /* PV-specific device model info */
+        dm_info->type = XENPV;
+    }
+
+    /* Build qemu graphics options from previously parsed vfb */
+    if (d_config->num_vfbs > 0) {
+        if (d_config->vfbs[0].vnc) {
+            dm_info->vnc = 1;
+            /* driver handles selection of free port */
+            dm_info->vncunused = 0;
+            if (d_config->vfbs[0].vnclisten) {
+                free(dm_info->vnclisten);
+                if ((dm_info->vnclisten =
+                     strdup(d_config->vfbs[0].vnclisten)) == NULL) {
+                    virReportOOMError();
+                    goto error;
+                }
+            }
+            if (d_config->vfbs[0].keymap &&
+                (dm_info->keymap = strdup(d_config->vfbs[0].keymap)) == NULL) {
+                virReportOOMError();
+                goto error;
+            }
+            dm_info->vncdisplay = d_config->vfbs[0].vncdisplay;
+            if (d_config->vfbs[0].vncpasswd &&
+                (dm_info->vncpasswd =
+                 strdup(d_config->vfbs[0].vncpasswd)) == NULL) {
+                virReportOOMError();
+                goto error;
+            }
+        } else if (d_config->vfbs[0].sdl) {
+            dm_info->sdl = 1;
+            dm_info->vnc = 0;
+        }
+    } else if (d_config->num_vfbs == 0) {
+        dm_info->nographic = 1;
+        dm_info->vnc = 0;
+    }
+
+    // TODO
+    //dm_info->usb = ;
+    //dm_info->usbdevice = ;
+    //dm_info->soundhw = ;
+
+    return 0;
+
+error:
+    libxl_device_model_info_destroy(dm_info);
+    return -1;
+}
+
+virCapsPtr
+libxlMakeCapabilities(libxl_ctx *ctx)
+{
+    libxl_physinfo phy_info;
+    const libxl_version_info *ver_info;
+    struct utsname utsname;
+
+    regcomp (&xen_cap_rec, xen_cap_re, REG_EXTENDED);
+
+    if (libxl_get_physinfo(ctx, &phy_info) != 0) {
+        libxlError(VIR_ERR_INTERNAL_ERROR,
+                   _("Failed to get node physical info from libxenlight"));
+        return NULL;
+    }
+
+    if ((ver_info = libxl_get_version_info(ctx)) == NULL) {
+        libxlError(VIR_ERR_INTERNAL_ERROR,
+                   _("Failed to get version info from libxenlight"));
+        return NULL;
+    }
+
+    uname(&utsname);
+
+    return libxlMakeCapabilitiesInternal(utsname.machine,
+                                         &phy_info,
+                                         ver_info->capabilities);
+}
+
+int
+libxlBuildDomainConfig(libxlDriverPrivatePtr driver,
+                       virDomainDefPtr def, libxl_domain_config *d_config)
+{
+
+    if (libxlMakeDomCreateInfo(def, &d_config->c_info) < 0)
+        return -1;
+
+    if (libxlMakeDomBuildInfo(def, d_config) < 0) {
+        goto error;
+    }
+
+    if (libxlMakeDiskList(def, d_config) < 0) {
+        goto error;
+    }
+
+    if (libxlMakeNicList(def, d_config) < 0) {
+        goto error;
+    }
+
+    if (libxlMakeVfbList(driver, def, d_config) < 0) {
+        goto error;
+    }
+
+    if (libxlMakeDeviceModelInfo(def, d_config) < 0) {
+        goto error;
+    }
+
+    d_config->on_reboot = def->onReboot;
+    d_config->on_poweroff = def->onPoweroff;
+    d_config->on_crash = def->onCrash;
+
+    return 0;
+
+error:
+    libxl_domain_config_destroy(d_config);
+    return -1;
+}
diff --git a/src/libxl/libxl_conf.h b/src/libxl/libxl_conf.h
new file mode 100644
index 0000000..bb49d35
--- /dev/null
+++ b/src/libxl/libxl_conf.h
@@ -0,0 +1,91 @@
+/*---------------------------------------------------------------------------*/
+/*  Copyright (c) 2011 SUSE LINUX Products GmbH, Nuernberg, Germany.
+ *
+ * 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 LIBXL_CONF_H
+# define LIBXL_CONF_H
+
+# include <config.h>
+
+# include <libxl.h>
+
+# include "internal.h"
+# include "domain_conf.h"
+# include "capabilities.h"
+# include "configmake.h"
+# include "bitmap.h"
+
+
+# define LIBXL_VNC_PORT_MIN  5900
+# define LIBXL_VNC_PORT_MAX  65535
+
+# define LIBXL_CONFIG_DIR SYSCONFDIR "/libvirt/libxl"
+# define LIBXL_AUTOSTART_DIR LIBXL_CONFIG_DIR "/autostart"
+# define LIBXL_STATE_DIR LOCALSTATEDIR "/run/libvirt/libxl"
+# define LIBXL_LOG_DIR LOCALSTATEDIR "/log/libvirt/libxl"
+# define LIBXL_LIB_DIR LOCALSTATEDIR "/lib/libvirt/libxl"
+# define LIBXL_SAVE_DIR LIBXL_LIB_DIR "/save"
+
+
+typedef struct _libxlDriverPrivate libxlDriverPrivate;
+typedef libxlDriverPrivate *libxlDriverPrivatePtr;
+struct _libxlDriverPrivate {
+    virMutex lock;
+    virCapsPtr caps;
+    unsigned int version;
+
+    FILE *logger_file;
+    xentoollog_logger *logger;
+    /* libxl ctx for driver wide ops; getVersion, getNodeInfo, ... */
+    libxl_ctx ctx;
+
+    virBitmapPtr reservedVNCPorts;
+    virDomainObjList domains;
+
+    char *configDir;
+    char *autostartDir;
+    char *logDir;
+    char *stateDir;
+    char *libDir;
+    char *saveDir;
+};
+
+typedef struct _libxlDomainObjPrivate libxlDomainObjPrivate;
+typedef libxlDomainObjPrivate *libxlDomainObjPrivatePtr;
+struct _libxlDomainObjPrivate {
+    /* per domain libxl ctx */
+    libxl_ctx ctx;
+    libxl_waiter *dWaiter;
+    int waiterFD;
+    int eventHdl;
+};
+
+
+# define libxlError(code, ...)                                     \
+    virReportErrorHelper(NULL, VIR_FROM_LIBXL, code, __FILE__,     \
+                         __FUNCTION__, __LINE__, __VA_ARGS__)
+
+virCapsPtr
+libxlMakeCapabilities(libxl_ctx *ctx);
+
+int
+libxlBuildDomainConfig(libxlDriverPrivatePtr driver,
+                       virDomainDefPtr def, libxl_domain_config *d_config);
+
+
+#endif /* LIBXL_CONF_H */
diff --git a/src/libxl/libxl_driver.c b/src/libxl/libxl_driver.c
new file mode 100644
index 0000000..d137474
--- /dev/null
+++ b/src/libxl/libxl_driver.c
@@ -0,0 +1,1411 @@
+/*---------------------------------------------------------------------------*/
+/*  Copyright (c) 2011 SUSE LINUX Products GmbH, Nuernberg, Germany.
+ *  Copyright (C) 2011 Univention GmbH.
+ *
+ * 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 <config.h>
+
+#include <sys/utsname.h>
+#include <libxl.h>
+
+#include "internal.h"
+#include "logging.h"
+#include "virterror_internal.h"
+#include "datatypes.h"
+#include "files.h"
+#include "memory.h"
+#include "event.h"
+#include "uuid.h"
+#include "libxl_driver.h"
+#include "libxl_conf.h"
+
+
+#define VIR_FROM_THIS VIR_FROM_LIBXL
+
+#define LIBXL_DOM_REQ_POWEROFF 0
+#define LIBXL_DOM_REQ_REBOOT   1
+#define LIBXL_DOM_REQ_SUSPEND  2
+#define LIBXL_DOM_REQ_CRASH    3
+#define LIBXL_DOM_REQ_HALT     4
+
+static libxlDriverPrivatePtr libxl_driver = NULL;
+
+
+/* Function declarations */
+static int
+libxlVmStart(libxlDriverPrivatePtr driver,
+             virDomainObjPtr vm, bool start_paused);
+
+
+/* Function definitions */
+static void
+libxlDriverLock(libxlDriverPrivatePtr driver)
+{
+    virMutexLock(&driver->lock);
+}
+
+static void
+libxlDriverUnlock(libxlDriverPrivatePtr driver)
+{
+    virMutexUnlock(&driver->lock);
+}
+
+static void *
+libxlDomainObjPrivateAlloc(void)
+{
+    libxlDomainObjPrivatePtr priv;
+
+    if (VIR_ALLOC(priv) < 0)
+        return NULL;
+
+    libxl_ctx_init(&priv->ctx, LIBXL_VERSION, libxl_driver->logger);
+    priv->waiterFD = -1;
+    priv->eventHdl = -1;
+
+    return priv;
+}
+
+static void
+libxlDomainObjPrivateFree(void *data)
+{
+    libxlDomainObjPrivatePtr priv = data;
+
+    if (priv->dWaiter) {
+        libxl_free_waiter(priv->dWaiter);
+        VIR_FREE(priv->dWaiter);
+    }
+    libxl_ctx_free(&priv->ctx);
+    VIR_FREE(priv);
+}
+
+/*
+ * Cleanup function for domain that has reached shutoff state.
+ *
+ * virDomainObjPtr should be locked on invocation
+ */
+static void
+libxlVmCleanup(libxlDriverPrivatePtr driver, virDomainObjPtr vm)
+{
+    libxlDomainObjPrivatePtr priv = vm->privateData;
+    int vnc_port;
+    char *file;
+
+    if (priv->dWaiter) {
+        libxl_free_waiter(priv->dWaiter);
+        VIR_FREE(priv->dWaiter);
+    }
+
+    if (vm->persistent) {
+        vm->def->id = -1;
+        vm->state = VIR_DOMAIN_SHUTOFF;
+    }
+
+    if ((vm->def->ngraphics == 1) &&
+        vm->def->graphics[0]->type == VIR_DOMAIN_GRAPHICS_TYPE_VNC &&
+        vm->def->graphics[0]->data.vnc.autoport) {
+        vnc_port = vm->def->graphics[0]->data.vnc.port;
+        if (vnc_port >= LIBXL_VNC_PORT_MIN) {
+            if (virBitmapClearBit(driver->reservedVNCPorts,
+                                  vnc_port - LIBXL_VNC_PORT_MIN) < 0)
+                VIR_DEBUG("Could not mark port %d as unused", vnc_port);
+        }
+    }
+
+    if (virAsprintf(&file, "%s/%s.xml", driver->stateDir, vm->def->name) > 0) {
+        if (unlink(file) < 0 && errno != ENOENT && errno != ENOTDIR)
+            VIR_DEBUG("Failed to remove domain XML for %s", vm->def->name);
+        VIR_FREE(file);
+    }
+}
+
+/*
+ * Reap a domain from libxenlight.
+ *
+ * virDomainObjPtr should be locked on invocation
+ */
+static int
+libxlVmReap(libxlDriverPrivatePtr driver, virDomainObjPtr vm, int force)
+{
+    libxlDomainObjPrivatePtr priv = vm->privateData;
+
+    if (libxl_domain_destroy(&priv->ctx, vm->def->id, force) < 0) {
+        libxlError(VIR_ERR_INTERNAL_ERROR,
+                   _("Unable to cleanup domain %d"), vm->def->id);
+        return -1;
+    }
+
+    libxlVmCleanup(driver, vm);
+    return 0;
+}
+
+/*
+ * Handle previously registered event notification from libxenlight
+ */
+static void libxlEventHandler(int watch,
+                              int fd,
+                              int events,
+                              void *data)
+{
+    libxlDriverPrivatePtr driver = libxl_driver;
+    virDomainObjPtr vm = data;
+    libxlDomainObjPrivatePtr priv;
+    libxl_event event;
+    libxl_dominfo info;
+
+    libxlDriverLock(driver);
+    virDomainObjLock(vm);
+    libxlDriverUnlock(driver);
+
+    priv = vm->privateData;
+
+    memset(&event, 0, sizeof(event));
+    memset(&info, 0, sizeof(info));
+
+    if (priv->waiterFD != fd || priv->eventHdl != watch) {
+        virEventRemoveHandle(watch);
+        goto cleanup;
+    }
+
+    if (!(events & VIR_EVENT_HANDLE_READABLE))
+        goto cleanup;
+
+    if (libxl_get_event(&priv->ctx, &event))
+        goto cleanup;
+
+    if (event.type == LIBXL_EVENT_DOMAIN_DEATH) {
+        /* libxl_event_get_domain_death_info returns 1 if death
+         * event was for this domid */
+        if (libxl_event_get_domain_death_info(&priv->ctx,
+                                              vm->def->id,
+                                              &event,
+                                              &info) != 1)
+            goto cleanup;
+
+        virEventRemoveHandle(watch);
+        switch (info.shutdown_reason) {
+            case SHUTDOWN_poweroff:
+            case SHUTDOWN_crash:
+                libxlVmReap(driver, vm, 0);
+                if (!vm->persistent) {
+                    virDomainRemoveInactive(&driver->domains, vm);
+                    vm = NULL;
+                }
+                break;
+            case SHUTDOWN_reboot:
+                libxlVmReap(driver, vm, 0);
+                libxlVmStart(driver, vm, 0);
+                break;
+            default:
+                VIR_INFO("Unhandled shutdown_reason %d", info.shutdown_reason);
+                break;
+        }
+    }
+
+cleanup:
+    if (vm)
+        virDomainObjUnlock(vm);
+    libxl_free_event(&event);
+}
+
+/*
+ * Register domain events with libxenlight and insert event handles
+ * in libvirt's event loop.
+ */
+static int
+libxlCreateDomEvents(virDomainObjPtr vm)
+{
+    libxlDomainObjPrivatePtr priv = vm->privateData;
+    int fd;
+
+    /* Do we already have a waiter for this domain? */
+    if (priv->dWaiter == NULL) {
+        if (VIR_ALLOC(priv->dWaiter) < 0) {
+            virReportOOMError();
+            return -1;
+        }
+
+        if (libxl_wait_for_domain_death(&priv->ctx,
+                                        vm->def->id,
+                                        priv->dWaiter))
+            goto error;
+    }
+
+    libxl_get_wait_fd(&priv->ctx, &fd);
+    if (fd < 0)
+        goto error;
+
+    priv->waiterFD = fd;
+    if ((priv->eventHdl = virEventAddHandle(
+             fd,
+             VIR_EVENT_HANDLE_READABLE | VIR_EVENT_HANDLE_ERROR,
+             libxlEventHandler,
+             vm, NULL)) < 0)
+        goto error;
+
+    return 0;
+
+error:
+    libxl_free_waiter(priv->dWaiter);
+    VIR_FREE(priv->dWaiter);
+    return -1;
+}
+
+/*
+ * Start a domain through libxenlight.
+ *
+ * virDomainObjPtr should be locked on invocation
+ */
+static int
+libxlVmStart(libxlDriverPrivatePtr driver,
+             virDomainObjPtr vm, bool start_paused)
+{
+    libxl_domain_config d_config;
+    virDomainDefPtr def = vm->def;
+    int ret;
+    uint32_t domid = 0;
+    char *dom_xml = NULL;
+    pid_t child_console_pid = -1;
+    libxlDomainObjPrivatePtr priv = vm->privateData;
+
+    memset(&d_config, 0, sizeof(d_config));
+
+    if (libxlBuildDomainConfig(driver, def, &d_config) < 0 )
+        return -1;
+
+    //TODO: Balloon dom0 ??
+    //ret = freemem(&d_config->b_info, &d_config->dm_info);
+
+    ret = libxl_domain_create_new(&priv->ctx, &d_config,
+                                  NULL, &child_console_pid, &domid);
+    if (ret) {
+        libxlError(VIR_ERR_INTERNAL_ERROR,
+                   _("libxenlight failed to create new domain '%s'"),
+                   d_config.c_info.name);
+        goto error;
+    }
+
+    def->id = domid;
+    if ((dom_xml = virDomainDefFormat(def, 0)) == NULL)
+        goto error;
+
+    if(libxl_userdata_store(&priv->ctx, domid, "libvirt-xml",
+                            (uint8_t *)dom_xml, strlen(dom_xml) + 1)) {
+        libxlError(VIR_ERR_INTERNAL_ERROR,
+                   _("libxenlight failed to store userdata"));
+        goto error;
+    }
+
+    if (libxlCreateDomEvents(vm) < 0)
+        goto error;
+
+    if (!start_paused) {
+        libxl_domain_unpause(&priv->ctx, domid);
+        vm->state = VIR_DOMAIN_RUNNING;
+    } else {
+        vm->state = VIR_DOMAIN_PAUSED;
+    }
+
+    if (virDomainSaveStatus(driver->caps, driver->stateDir, vm) < 0)
+        goto error;
+    
+    libxl_domain_config_destroy(&d_config);
+    VIR_FREE(dom_xml);
+    return 0;
+
+error:
+    if (domid > 0) {
+        libxl_domain_destroy(&priv->ctx, domid, 0);
+        def->id = -1;
+        vm->state = VIR_DOMAIN_SHUTOFF;
+    }
+    libxl_domain_config_destroy(&d_config);
+    VIR_FREE(dom_xml);
+    return -1;
+}
+
+
+/*
+ * Reconnect to running domains that were previously started/created
+ * with libxenlight driver.
+ */
+static void
+libxlReconnectDomain(void *payload,
+                     const void *name ATTRIBUTE_UNUSED,
+                     void *opaque)
+{
+    virDomainObjPtr vm = payload;
+    libxlDriverPrivatePtr driver = opaque;
+    int rc;
+    libxl_dominfo d_info;
+    int len;
+    uint8_t *data = NULL;
+
+    virDomainObjLock(vm);
+
+    /* Does domain still exist? */
+    rc = libxl_domain_info(&driver->ctx, &d_info, vm->def->id);
+    if (rc == ERROR_INVAL) {
+        goto out;
+    } else if (rc != 0) {
+        VIR_DEBUG("libxl_domain_info failed (code %d), ignoring domain %d",
+                  rc, vm->def->id);
+        goto out;
+    }
+
+    /* Is this a domain that was under libvirt control? */        
+    if (libxl_userdata_retrieve(&driver->ctx, vm->def->id,
+                                "libvirt-xml", &data, &len)) {
+        VIR_DEBUG("libxl_userdata_retrieve failed, ignoring domain %d", 
vm->def->id);
+        goto out;
+    }
+
+    /* Update domid in case it changed (e.g. reboot) while we were gone? */
+    vm->def->id = d_info.domid;
+    vm->state = VIR_DOMAIN_RUNNING;
+
+    /* Recreate domain death et. al. events */
+    libxlCreateDomEvents(vm);
+    virDomainObjUnlock(vm);
+    return;
+
+out:
+    libxlVmCleanup(driver, vm);
+    if (!vm->persistent)
+        virDomainRemoveInactive(&driver->domains, vm);
+    else
+        virDomainObjUnlock(vm);
+}
+
+static void
+libxlReconnectDomains(libxlDriverPrivatePtr driver)
+{
+    virHashForEach(driver->domains.objs, libxlReconnectDomain, driver);
+}
+
+static int
+libxlShutdown(void)
+{
+    if (!libxl_driver)
+        return -1;
+
+    libxlDriverLock(libxl_driver);
+    virCapabilitiesFree(libxl_driver->caps);
+    virDomainObjListDeinit(&libxl_driver->domains);
+    libxl_ctx_free(&libxl_driver->ctx);
+    xtl_logger_destroy(libxl_driver->logger);
+    if (libxl_driver->logger_file)
+        VIR_FORCE_FCLOSE(libxl_driver->logger_file);
+
+    virBitmapFree(libxl_driver->reservedVNCPorts);
+
+    VIR_FREE(libxl_driver->configDir);
+    VIR_FREE(libxl_driver->autostartDir);
+    VIR_FREE(libxl_driver->logDir);
+    VIR_FREE(libxl_driver->stateDir);
+    VIR_FREE(libxl_driver->libDir);
+    VIR_FREE(libxl_driver->saveDir);
+
+    libxlDriverUnlock(libxl_driver);
+    virMutexDestroy(&libxl_driver->lock);
+    VIR_FREE(libxl_driver);
+
+    return 0;
+}
+
+static int
+libxlStartup(int privileged) {
+    const libxl_version_info *ver_info;
+    char *log_file = NULL;
+
+    /* Check that the user is root, silently disable if not */
+    if (!privileged) {
+        VIR_INFO0("Not running privileged, disabling libxenlight driver");
+        return 0;
+    }
+
+    if (VIR_ALLOC(libxl_driver) < 0)
+        return -1;
+
+    if (virMutexInit(&libxl_driver->lock) < 0) {
+        VIR_ERROR0(_("cannot initialize mutex"));
+        VIR_FREE(libxl_driver);
+        return -1;
+    }
+    libxlDriverLock(libxl_driver);
+
+    /* Allocate bitmap for vnc port reservation */
+    if ((libxl_driver->reservedVNCPorts =
+         virBitmapAlloc(LIBXL_VNC_PORT_MAX - LIBXL_VNC_PORT_MIN)) == NULL)
+        goto out_of_memory;
+
+    if (virDomainObjListInit(&libxl_driver->domains) < 0)
+        goto out_of_memory;
+
+    if (virAsprintf(&libxl_driver->configDir,
+                    "%s", LIBXL_CONFIG_DIR) == -1)
+        goto out_of_memory;
+
+    if (virAsprintf(&libxl_driver->autostartDir,
+                    "%s", LIBXL_AUTOSTART_DIR) == -1)
+        goto out_of_memory;
+
+    if (virAsprintf(&libxl_driver->logDir,
+                    "%s", LIBXL_LOG_DIR) == -1)
+        goto out_of_memory;
+
+    if (virAsprintf(&libxl_driver->stateDir,
+                    "%s", LIBXL_STATE_DIR) == -1)
+        goto out_of_memory;
+
+    if (virAsprintf(&libxl_driver->libDir,
+                    "%s", LIBXL_LIB_DIR) == -1)
+        goto out_of_memory;
+
+    if (virAsprintf(&libxl_driver->saveDir,
+                    "%s", LIBXL_SAVE_DIR) == -1)
+        goto out_of_memory;
+
+    if (virFileMakePath(libxl_driver->logDir) != 0) {
+        char ebuf[1024];
+        VIR_ERROR(_("Failed to create log dir '%s': %s"),
+                  libxl_driver->logDir, virStrerror(errno, ebuf, sizeof ebuf));
+        goto error;
+    }
+    if (virFileMakePath(libxl_driver->stateDir) != 0) {
+        char ebuf[1024];
+        VIR_ERROR(_("Failed to create state dir '%s': %s"),
+                  libxl_driver->stateDir, virStrerror(errno, ebuf, sizeof 
ebuf));
+        goto error;
+    }
+    if (virFileMakePath(libxl_driver->libDir) != 0) {
+        char ebuf[1024];
+        VIR_ERROR(_("Failed to create lib dir '%s': %s"),
+                  libxl_driver->libDir, virStrerror(errno, ebuf, sizeof ebuf));
+        goto error;
+    }
+    if (virFileMakePath(libxl_driver->saveDir) != 0) {
+        char ebuf[1024];
+        VIR_ERROR(_("Failed to create save dir '%s': %s"),
+                  libxl_driver->saveDir, virStrerror(errno, ebuf, sizeof 
ebuf));
+        goto error;
+    }
+
+    if (virAsprintf(&log_file, "%s/libxl.log", libxl_driver->logDir) < 0) {
+        goto out_of_memory;
+    }
+
+    if ((libxl_driver->logger_file = fopen(log_file, "a")) == NULL)  {
+        virReportSystemError(errno,
+                             _("failed to create logfile %s"),
+                             log_file);
+        goto error;
+    }
+    VIR_FREE(log_file);
+
+    libxl_driver->logger =
+            (xentoollog_logger 
*)xtl_createlogger_stdiostream(libxl_driver->logger_file, XTL_DEBUG,  0);
+    if (!libxl_driver->logger) {
+        VIR_ERROR0(_("cannot create logger for libxenlight"));
+        goto error;
+    }
+
+    if (libxl_ctx_init(&libxl_driver->ctx,
+                       LIBXL_VERSION,
+                       libxl_driver->logger)) {
+        VIR_ERROR0(_("cannot initialize libxenlight context"));
+        goto error;
+    }
+
+    if ((ver_info = libxl_get_version_info(&libxl_driver->ctx)) == NULL) {
+        VIR_ERROR0(_("cannot version information from libxenlight"));
+        goto error;
+    }
+    libxl_driver->version = (ver_info->xen_version_major * 1000000) +
+            (ver_info->xen_version_minor * 1000);
+
+    if ((libxl_driver->caps =
+         libxlMakeCapabilities(&libxl_driver->ctx)) == NULL) {
+        VIR_ERROR0(_("cannot create capabilities for libxenlight"));
+        goto error;
+    }
+
+    libxl_driver->caps->privateDataAllocFunc = libxlDomainObjPrivateAlloc;
+    libxl_driver->caps->privateDataFreeFunc = libxlDomainObjPrivateFree;
+
+    /* Load running domains first. */
+    if (virDomainLoadAllConfigs(libxl_driver->caps,
+                                &libxl_driver->domains,
+                                libxl_driver->stateDir,
+                                libxl_driver->autostartDir,
+                                1, NULL, NULL) < 0)
+        goto error;
+
+    libxlReconnectDomains(libxl_driver);
+    
+    /* Then inactive persistent configs */
+    if (virDomainLoadAllConfigs(libxl_driver->caps,
+                                &libxl_driver->domains,
+                                libxl_driver->configDir,
+                                libxl_driver->autostartDir,
+                                0, NULL, NULL) < 0)
+        goto error;
+
+    libxlDriverUnlock(libxl_driver);
+
+    // TODO: autostart domains
+    //libxlAutostartConfigs(libxl_driver);
+
+    return 0;
+
+out_of_memory:
+    virReportOOMError();
+error:
+    VIR_FREE(log_file);
+    if (libxl_driver)
+        libxlDriverUnlock(libxl_driver);
+    libxlShutdown();
+    return -1;
+}
+
+static int
+libxlReload(void)
+{
+    if (!libxl_driver)
+        return 0;
+
+    libxlDriverLock(libxl_driver);
+    virDomainLoadAllConfigs(libxl_driver->caps,
+                            &libxl_driver->domains,
+                            libxl_driver->configDir,
+                            libxl_driver->autostartDir,
+                            0, NULL, libxl_driver);
+    libxlDriverUnlock(libxl_driver);
+
+    // TODO
+    //libxlAutostartConfigs(libxl_driver);
+
+    return 0;
+}
+
+static int
+libxlActive(void)
+{
+    if (!libxl_driver)
+        return 0;
+
+    return 1;
+}
+
+static virDrvOpenStatus
+libxlOpen(virConnectPtr conn,
+          virConnectAuthPtr auth ATTRIBUTE_UNUSED,
+          int flags ATTRIBUTE_UNUSED)
+{
+    if (conn->uri == NULL) {
+        if (libxl_driver == NULL)
+            return VIR_DRV_OPEN_DECLINED;
+
+        conn->uri = xmlParseURI("libxl:///");
+        if (!conn->uri) {
+            virReportOOMError();
+            return VIR_DRV_OPEN_ERROR;
+        }
+    } else {
+        if (conn->uri->scheme == NULL || STRNEQ(conn->uri->scheme, "libxl"))
+            return VIR_DRV_OPEN_DECLINED;
+
+        /* If server name is given, its for remote driver */
+        if (conn->uri->server != NULL)
+            return VIR_DRV_OPEN_DECLINED;
+
+        if (libxl_driver == NULL) {
+            libxlError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _("libxenlight state driver is not active"));
+            return VIR_DRV_OPEN_ERROR;
+        }
+
+        /* /session isn't supported in libxenlight */
+        if (conn->uri->path &&
+            STRNEQ(conn->uri->path, "") &&
+            STRNEQ(conn->uri->path, "/") &&
+            STRNEQ(conn->uri->path, "/system")) {
+            libxlError(VIR_ERR_INTERNAL_ERROR,
+                       _("unexpected Xen URI path '%s', try libxl:///"),
+                       NULLSTR(conn->uri->path));
+            return VIR_DRV_OPEN_ERROR;
+        }
+    }
+
+    conn->privateData = libxl_driver;
+
+    return VIR_DRV_OPEN_SUCCESS;
+};
+
+static int
+libxlClose(virConnectPtr conn ATTRIBUTE_UNUSED)
+{
+    conn->privateData = NULL;
+    return 0;
+}
+
+static const char *
+libxlGetType(virConnectPtr conn ATTRIBUTE_UNUSED)
+{
+    return "libxl";
+}
+
+static int
+libxlGetVersion(virConnectPtr conn, unsigned long *version)
+{
+    libxlDriverPrivatePtr driver = conn->privateData;
+
+    libxlDriverLock(driver);
+    *version = driver->version;
+    libxlDriverUnlock(driver);
+    return 0;
+}
+
+static int
+libxlGetMaxVcpus(virConnectPtr conn, const char *type ATTRIBUTE_UNUSED)
+{
+    int ret;
+    libxlDriverPrivatePtr driver = conn->privateData;
+
+    ret = libxl_get_max_cpus(&driver->ctx);
+    /* libxl_get_max_cpus() will return 0 if there were any failures,
+       e.g. xc_physinfo() failing */
+    if (ret == 0)
+        return -1;
+
+    return ret;
+}
+
+static int
+libxlNodeGetInfo(virConnectPtr conn, virNodeInfoPtr info)
+{
+    libxl_physinfo phy_info;
+    const libxl_version_info* ver_info;
+    libxlDriverPrivatePtr driver = conn->privateData;
+    struct utsname utsname;
+
+    if (libxl_get_physinfo(&driver->ctx, &phy_info)) {
+        libxlError(VIR_ERR_INTERNAL_ERROR,
+                   _("libxl_get_physinfo_info failed"));
+        return -1;
+    }
+
+    if ((ver_info = libxl_get_version_info(&driver->ctx)) == NULL) {
+        libxlError(VIR_ERR_INTERNAL_ERROR,
+                   _("libxl_get_version_info failed"));
+        return -1;
+    }
+
+    uname(&utsname);
+    if (virStrncpy(info->model,
+                   utsname.machine,
+                   strlen(utsname.machine),
+                   sizeof(info->model)) == NULL) {
+        libxlError(VIR_ERR_INTERNAL_ERROR,
+                   _("machine type %s too big for destination"),
+                   utsname.machine);
+        return -1;
+    }
+
+    info->memory = phy_info.total_pages * (ver_info->pagesize / 1024);
+    info->cpus = phy_info.nr_cpus;
+    info->nodes = phy_info.nr_nodes;
+    info->cores = phy_info.cores_per_socket;
+    info->threads = phy_info.threads_per_core;
+    info->sockets = 1;
+    info->mhz = phy_info.cpu_khz / 1000;
+    return 0;
+}
+
+static char *
+libxlGetCapabilities(virConnectPtr conn)
+{
+    libxlDriverPrivatePtr driver = conn->privateData;
+    char *xml;
+
+    libxlDriverLock(driver);
+    if ((xml = virCapabilitiesFormatXML(driver->caps)) == NULL)
+        virReportOOMError();
+    libxlDriverUnlock(driver);
+
+    return xml;
+}
+
+static int
+libxlListDomains(virConnectPtr conn, int *ids, int nids)
+{
+    libxlDriverPrivatePtr driver = conn->privateData;
+    int n;
+
+    libxlDriverLock(driver);
+    n = virDomainObjListGetActiveIDs(&driver->domains, ids, nids);
+    libxlDriverUnlock(driver);
+
+    return n;
+}
+
+static int
+libxlNumDomains(virConnectPtr conn)
+{
+    libxlDriverPrivatePtr driver = conn->privateData;
+    int n;
+
+    libxlDriverLock(driver);
+    n = virDomainObjListNumOfDomains(&driver->domains, 1);
+    libxlDriverUnlock(driver);
+
+    return n;
+}
+
+static virDomainPtr
+libxlDomainCreateXML(virConnectPtr conn, const char *xml,
+                     unsigned int flags)
+{
+    libxlDriverPrivatePtr driver = conn->privateData;
+    virDomainDefPtr def;
+    virDomainObjPtr vm = NULL;
+    virDomainPtr dom = NULL;
+
+    virCheckFlags(VIR_DOMAIN_START_PAUSED, NULL);
+
+    libxlDriverLock(driver);
+    if (!(def = virDomainDefParseString(driver->caps, xml,
+                                        VIR_DOMAIN_XML_INACTIVE)))
+        goto cleanup;
+
+    if (virDomainObjIsDuplicate(&driver->domains, def, 1) < 0)
+        goto cleanup;
+
+    if (!(vm = virDomainAssignDef(driver->caps,
+                                  &driver->domains, def, false)))
+        goto cleanup;
+    def = NULL;
+
+    if (libxlVmStart(driver, vm, (flags & VIR_DOMAIN_START_PAUSED) != 0) < 0) {
+        virDomainRemoveInactive(&driver->domains, vm);
+        vm = NULL;
+        goto cleanup;
+    }
+
+    dom = virGetDomain(conn, vm->def->name, vm->def->uuid);
+    if (dom)
+        dom->id = vm->def->id;
+
+cleanup:
+    virDomainDefFree(def);
+    if (vm)
+        virDomainObjUnlock(vm);
+    libxlDriverUnlock(driver);
+    return dom;
+}
+
+static virDomainPtr
+libxlDomainLookupByID(virConnectPtr conn, int id)
+{
+    libxlDriverPrivatePtr driver = conn->privateData;
+    virDomainObjPtr vm;
+    virDomainPtr dom = NULL;
+
+    libxlDriverLock(driver);
+    vm = virDomainFindByID(&driver->domains, id);
+    libxlDriverUnlock(driver);
+
+    if (!vm) {
+        libxlError(VIR_ERR_NO_DOMAIN, NULL);
+        goto cleanup;
+    }
+
+    dom = virGetDomain(conn, vm->def->name, vm->def->uuid);
+    if (dom)
+        dom->id = vm->def->id;
+
+  cleanup:
+    if (vm)
+        virDomainObjUnlock(vm);
+    return dom;
+}
+
+static virDomainPtr
+libxlDomainLookupByUUID(virConnectPtr conn, const unsigned char *uuid)
+{
+    libxlDriverPrivatePtr driver = conn->privateData;
+    virDomainObjPtr vm;
+    virDomainPtr dom = NULL;
+
+    libxlDriverLock(driver);
+    vm = virDomainFindByUUID(&driver->domains, uuid);
+    libxlDriverUnlock(driver);
+
+    if (!vm) {
+        libxlError(VIR_ERR_NO_DOMAIN, NULL);
+        goto cleanup;
+    }
+
+    dom = virGetDomain(conn, vm->def->name, vm->def->uuid);
+    if (dom)
+        dom->id = vm->def->id;
+
+  cleanup:
+    if (vm)
+        virDomainObjUnlock(vm);
+    return dom;
+}
+
+static virDomainPtr
+libxlDomainLookupByName(virConnectPtr conn, const char *name)
+{
+    libxlDriverPrivatePtr driver = conn->privateData;
+    virDomainObjPtr vm;
+    virDomainPtr dom = NULL;
+
+    libxlDriverLock(driver);
+    vm = virDomainFindByName(&driver->domains, name);
+    libxlDriverUnlock(driver);
+
+    if (!vm) {
+        libxlError(VIR_ERR_NO_DOMAIN, NULL);
+        goto cleanup;
+    }
+
+    dom = virGetDomain(conn, vm->def->name, vm->def->uuid);
+    if (dom)
+        dom->id = vm->def->id;
+
+  cleanup:
+    if (vm)
+        virDomainObjUnlock(vm);
+    return dom;
+}
+
+static int
+libxlDomainShutdown(virDomainPtr dom)
+{
+    libxlDriverPrivatePtr driver = dom->conn->privateData;
+    virDomainObjPtr vm;
+    int ret = -1;
+    libxlDomainObjPrivatePtr priv;
+
+    libxlDriverLock(driver);
+    vm = virDomainFindByUUID(&driver->domains, dom->uuid);
+    if (!vm) {
+        char uuidstr[VIR_UUID_STRING_BUFLEN];
+        virUUIDFormat(dom->uuid, uuidstr);
+        libxlError(VIR_ERR_NO_DOMAIN,
+                   _("No domain with matching uuid '%s'"), uuidstr);
+        goto cleanup;
+    }
+
+    if (!virDomainObjIsActive(vm)) {
+        libxlError(VIR_ERR_OPERATION_INVALID,
+                   "%s", _("Domain is not running"));
+        goto cleanup;
+    }
+
+    priv = vm->privateData;
+    if (libxl_domain_shutdown(&priv->ctx, dom->id, LIBXL_DOM_REQ_POWEROFF) != 
0) {
+        libxlError(VIR_ERR_INTERNAL_ERROR,
+                   _("Failed to shutdown domain '%d' with libxenlight"),
+                   dom->id);
+        goto cleanup;
+    }
+
+    /* vm is marked shutoff (or removed from domains list if not persistent)
+     * in shutdown event handler.
+     */
+    ret = 0;
+
+cleanup:
+    if (vm)
+        virDomainObjUnlock(vm);
+    libxlDriverUnlock(driver);
+    return ret;
+}
+
+static int
+libxlDomainReboot(virDomainPtr dom, unsigned int flags ATTRIBUTE_UNUSED)
+{
+    libxlDriverPrivatePtr driver = dom->conn->privateData;
+    virDomainObjPtr vm;
+    int ret = -1;
+    libxlDomainObjPrivatePtr priv;
+
+    libxlDriverLock(driver);
+    vm = virDomainFindByUUID(&driver->domains, dom->uuid);
+    if (!vm) {
+        char uuidstr[VIR_UUID_STRING_BUFLEN];
+        virUUIDFormat(dom->uuid, uuidstr);
+        libxlError(VIR_ERR_NO_DOMAIN,
+                   _("No domain with matching uuid '%s'"), uuidstr);
+        goto cleanup;
+    }
+
+    if (!virDomainObjIsActive(vm)) {
+        libxlError(VIR_ERR_OPERATION_INVALID,
+                   "%s", _("Domain is not running"));
+        goto cleanup;
+    }
+
+    priv = vm->privateData;
+    if (libxl_domain_shutdown(&priv->ctx, dom->id, LIBXL_DOM_REQ_REBOOT) != 0) 
{
+        libxlError(VIR_ERR_INTERNAL_ERROR,
+                   _("Failed to reboot domain '%d' with libxenlight"),
+                   dom->id);
+        goto cleanup;
+    }
+    ret = 0;
+
+cleanup:
+    if (vm)
+        virDomainObjUnlock(vm);
+    libxlDriverUnlock(driver);
+    return ret;
+}
+
+static int
+libxlDomainDestroy(virDomainPtr dom)
+{
+    libxlDriverPrivatePtr driver = dom->conn->privateData;
+    virDomainObjPtr vm;
+    int ret = -1;
+    libxlDomainObjPrivatePtr priv;
+
+    libxlDriverLock(driver);
+    vm = virDomainFindByUUID(&driver->domains, dom->uuid);
+    if (!vm) {
+        char uuidstr[VIR_UUID_STRING_BUFLEN];
+        virUUIDFormat(dom->uuid, uuidstr);
+        libxlError(VIR_ERR_NO_DOMAIN,
+                   _("No domain with matching uuid '%s'"), uuidstr);
+        goto cleanup;
+    }
+
+    if (!virDomainObjIsActive(vm)) {
+        libxlError(VIR_ERR_OPERATION_INVALID,
+                   "%s", _("Domain is not running"));
+        goto cleanup;
+    }
+
+    priv = vm->privateData;
+    if (libxlVmReap(driver, vm, 1) != 0) {
+        libxlError(VIR_ERR_INTERNAL_ERROR,
+                   _("Failed to destroy domain '%d'"), dom->id);
+        goto cleanup;
+    }
+
+    if (!vm->persistent) {
+        virDomainRemoveInactive(&driver->domains, vm);
+        vm = NULL;
+    }
+
+    ret = 0;
+
+cleanup:
+    if (vm)
+        virDomainObjUnlock(vm);
+    libxlDriverUnlock(driver);
+    return ret;
+}
+
+static int
+libxlDomainGetInfo(virDomainPtr dom, virDomainInfoPtr info)
+{
+    libxlDriverPrivatePtr driver = dom->conn->privateData;
+    virDomainObjPtr vm;
+    int ret = -1;
+
+    libxlDriverLock(driver);
+    vm = virDomainFindByUUID(&driver->domains, dom->uuid);
+    libxlDriverUnlock(driver);
+
+    if (!vm) {
+        libxlError(VIR_ERR_NO_DOMAIN, "%s",
+                   _("no domain with matching uuid"));
+        goto cleanup;
+    }
+
+    info->state = vm->state;
+    info->cpuTime = 0;
+    info->maxMem = vm->def->mem.max_balloon;
+    info->memory = vm->def->mem.cur_balloon;
+    info->nrVirtCpu = vm->def->vcpus;
+    ret = 0;
+
+  cleanup:
+    if (vm)
+        virDomainObjUnlock(vm);
+    return ret;
+}
+
+static char *
+libxlDomainDumpXML(virDomainPtr dom, int flags)
+{
+    libxlDriverPrivatePtr driver = dom->conn->privateData;
+    virDomainObjPtr vm;
+    char *ret = NULL;
+
+    libxlDriverLock(driver);
+    vm = virDomainFindByUUID(&driver->domains, dom->uuid);
+    libxlDriverUnlock(driver);
+
+    if (!vm) {
+        libxlError(VIR_ERR_NO_DOMAIN, "%s",
+                   _("no domain with matching uuid"));
+        goto cleanup;
+    }
+
+    ret = virDomainDefFormat(vm->def, flags);
+
+  cleanup:
+    if (vm)
+        virDomainObjUnlock(vm);
+    return ret;
+}
+
+static int
+libxlListDefinedDomains(virConnectPtr conn,
+                        char **const names, int nnames)
+{
+    libxlDriverPrivatePtr driver = conn->privateData;
+    int n;
+
+    libxlDriverLock(driver);
+    n = virDomainObjListGetInactiveNames(&driver->domains, names, nnames);
+    libxlDriverUnlock(driver);
+    return n;
+}
+
+static int
+libxlNumDefinedDomains(virConnectPtr conn)
+{
+    libxlDriverPrivatePtr driver = conn->privateData;
+    int n;
+
+    libxlDriverLock(driver);
+    n = virDomainObjListNumOfDomains(&driver->domains, 0);
+    libxlDriverUnlock(driver);
+
+    return n;
+}
+
+static int
+libxlDomainCreateWithFlags(virDomainPtr dom,
+                           unsigned int flags ATTRIBUTE_UNUSED)
+{
+    libxlDriverPrivatePtr driver = dom->conn->privateData;
+    virDomainObjPtr vm;
+    int ret = -1;
+
+    virCheckFlags(VIR_DOMAIN_START_PAUSED, -1);
+
+    libxlDriverLock(driver);
+    vm = virDomainFindByUUID(&driver->domains, dom->uuid);
+    if (!vm) {
+        char uuidstr[VIR_UUID_STRING_BUFLEN];
+        virUUIDFormat(dom->uuid, uuidstr);
+        libxlError(VIR_ERR_NO_DOMAIN,
+                   _("No domain with matching uuid '%s'"), uuidstr);
+        goto cleanup;
+    }
+
+    if (virDomainObjIsActive(vm)) {
+        libxlError(VIR_ERR_OPERATION_INVALID,
+                   "%s", _("Domain is already running"));
+        goto cleanup;
+    }
+
+    ret = libxlVmStart(driver, vm, (flags & VIR_DOMAIN_START_PAUSED) != 0);
+
+cleanup:
+    if (vm)
+        virDomainObjUnlock(vm);
+    libxlDriverUnlock(driver);
+    return ret;
+}
+
+static int
+libxlDomainCreate(virDomainPtr dom)
+{
+    return libxlDomainCreateWithFlags(dom, 0);
+}
+
+static virDomainPtr
+libxlDomainDefineXML(virConnectPtr conn, const char *xml)
+{
+    libxlDriverPrivatePtr driver = conn->privateData;
+    virDomainDefPtr def = NULL;
+    virDomainObjPtr vm = NULL;
+    virDomainPtr dom = NULL;
+    int dupVM;
+
+    libxlDriverLock(driver);
+    if (!(def = virDomainDefParseString(driver->caps, xml,
+                                        VIR_DOMAIN_XML_INACTIVE)))
+        goto cleanup;
+
+   if ((dupVM = virDomainObjIsDuplicate(&driver->domains, def, 0)) < 0)
+        goto cleanup;
+
+    if (!(vm = virDomainAssignDef(driver->caps,
+                                  &driver->domains, def, false)))
+        goto cleanup;
+    def = NULL;
+    vm->persistent = 1;
+
+    if (virDomainSaveConfig(driver->configDir,
+                            vm->newDef ? vm->newDef : vm->def) < 0) {
+        virDomainRemoveInactive(&driver->domains, vm);
+        vm = NULL;
+        goto cleanup;
+    }
+
+    dom = virGetDomain(conn, vm->def->name, vm->def->uuid);
+    if (dom)
+        dom->id = vm->def->id;
+
+cleanup:
+    virDomainDefFree(def);
+    if (vm)
+        virDomainObjUnlock(vm);
+    libxlDriverUnlock(driver);
+    return dom;
+}
+
+static int
+libxlDomainUndefine(virDomainPtr dom)
+{
+    libxlDriverPrivatePtr driver = dom->conn->privateData;
+    virDomainObjPtr vm;
+    int ret = -1;
+
+    libxlDriverLock(driver);
+    vm = virDomainFindByUUID(&driver->domains, dom->uuid);
+
+    if (!vm) {
+        char uuidstr[VIR_UUID_STRING_BUFLEN];
+
+        virUUIDFormat(dom->uuid, uuidstr);
+        libxlError(VIR_ERR_NO_DOMAIN,
+                   _("no domain with matching uuid '%s'"), uuidstr);
+        goto cleanup;
+    }
+
+    if (virDomainObjIsActive(vm)) {
+        libxlError(VIR_ERR_OPERATION_INVALID,
+                   "%s", _("cannot undefine active domain"));
+        goto cleanup;
+    }
+
+    if (!vm->persistent) {
+        libxlError(VIR_ERR_OPERATION_INVALID,
+                   "%s", _("cannot undefine transient domain"));
+        goto cleanup;
+    }
+
+    if (virDomainDeleteConfig(driver->configDir,
+                              driver->autostartDir,
+                              vm) < 0)
+        goto cleanup;
+
+    virDomainRemoveInactive(&driver->domains, vm);
+    vm = NULL;
+    ret = 0;
+
+  cleanup:
+    if (vm)
+        virDomainObjUnlock(vm);
+    libxlDriverUnlock(driver);
+    return ret;
+}
+
+static int
+libxlDomainIsActive(virDomainPtr dom)
+{
+    libxlDriverPrivatePtr driver = dom->conn->privateData;
+    virDomainObjPtr obj;
+    int ret = -1;
+
+    libxlDriverLock(driver);
+    obj = virDomainFindByUUID(&driver->domains, dom->uuid);
+    libxlDriverUnlock(driver);
+    if (!obj) {
+        libxlError(VIR_ERR_NO_DOMAIN, NULL);
+        goto cleanup;
+    }
+    ret = virDomainObjIsActive(obj);
+
+  cleanup:
+    if (obj)
+        virDomainObjUnlock(obj);
+    return ret;
+}
+
+static int
+libxlDomainIsPersistent(virDomainPtr dom)
+{
+    libxlDriverPrivatePtr driver = dom->conn->privateData;
+    virDomainObjPtr obj;
+    int ret = -1;
+
+    libxlDriverLock(driver);
+    obj = virDomainFindByUUID(&driver->domains, dom->uuid);
+    libxlDriverUnlock(driver);
+    if (!obj) {
+        libxlError(VIR_ERR_NO_DOMAIN, NULL);
+        goto cleanup;
+    }
+    ret = obj->persistent;
+
+  cleanup:
+    if (obj)
+        virDomainObjUnlock(obj);
+    return ret;
+}
+
+
+static virDriver libxlDriver = {
+    VIR_DRV_LIBXL,
+    "libxenlight",
+    libxlOpen,                  /* open */
+    libxlClose,                 /* close */
+    NULL,                       /* supports_feature */
+    libxlGetType,               /* type */
+    libxlGetVersion,            /* version */
+    NULL,                       /* libvirtVersion (impl. in libvirt.c) */
+    virGetHostname,             /* getHostname */
+    NULL,                       /* getSysinfo */
+    libxlGetMaxVcpus,           /* getMaxVcpus */
+    libxlNodeGetInfo,           /* nodeGetInfo */
+    libxlGetCapabilities,       /* getCapabilities */
+    libxlListDomains,           /* listDomains */
+    libxlNumDomains,            /* numOfDomains */
+    libxlDomainCreateXML,       /* domainCreateXML */
+    libxlDomainLookupByID,      /* domainLookupByID */
+    libxlDomainLookupByUUID,    /* domainLookupByUUID */
+    libxlDomainLookupByName,    /* domainLookupByName */
+    NULL,                       /* domainSuspend */
+    NULL,                       /* domainResume */
+    libxlDomainShutdown,        /* domainShutdown */
+    libxlDomainReboot,          /* domainReboot */
+    libxlDomainDestroy,         /* domainDestroy */
+    NULL,                       /* domainGetOSType */
+    NULL,                       /* domainGetMaxMemory */
+    NULL,                       /* domainSetMaxMemory */
+    NULL,                       /* domainSetMemory */
+    libxlDomainGetInfo,         /* domainGetInfo */
+    NULL,                       /* domainSave */
+    NULL,                       /* domainRestore */
+    NULL,                       /* domainCoreDump */
+    NULL,                       /* domainSetVcpus */
+    NULL,                       /* domainSetVcpusFlags */
+    NULL,                       /* domainGetVcpusFlags */
+    NULL,                       /* domainPinVcpu */
+    NULL,                       /* domainGetVcpus */
+    NULL,                       /* domainGetMaxVcpus */
+    NULL,                       /* domainGetSecurityLabel */
+    NULL,                       /* nodeGetSecurityModel */
+    libxlDomainDumpXML,         /* domainDumpXML */
+    NULL,                       /* domainXmlFromNative */
+    NULL,                       /* domainXmlToNative */
+    libxlListDefinedDomains,    /* listDefinedDomains */
+    libxlNumDefinedDomains,     /* numOfDefinedDomains */
+    libxlDomainCreate,          /* domainCreate */
+    libxlDomainCreateWithFlags, /* domainCreateWithFlags */
+    libxlDomainDefineXML,       /* domainDefineXML */
+    libxlDomainUndefine,        /* domainUndefine */
+    NULL,                       /* domainAttachDevice */
+    NULL,                       /* domainAttachDeviceFlags */
+    NULL,                       /* domainDetachDevice */
+    NULL,                       /* domainDetachDeviceFlags */
+    NULL,                       /* domainUpdateDeviceFlags */
+    NULL,                       /* domainGetAutostart */
+    NULL,                       /* domainSetAutostart */
+    NULL,                       /* domainGetSchedulerType */
+    NULL,                       /* domainGetSchedulerParameters */
+    NULL,                       /* domainSetSchedulerParameters */
+    NULL,                       /* domainMigratePrepare */
+    NULL,                       /* domainMigratePerform */
+    NULL,                       /* domainMigrateFinish */
+    NULL,                       /* domainBlockStats */
+    NULL,                       /* domainInterfaceStats */
+    NULL,                       /* domainMemoryStats */
+    NULL,                       /* domainBlockPeek */
+    NULL,                       /* domainMemoryPeek */
+    NULL,                       /* domainGetBlockInfo */
+    NULL,                       /* nodeGetCellsFreeMemory */
+    NULL,                       /* getFreeMemory */
+    NULL,                       /* domainEventRegister */
+    NULL,                       /* domainEventDeregister */
+    NULL,                       /* domainMigratePrepare2 */
+    NULL,                       /* domainMigrateFinish2 */
+    NULL,                       /* nodeDeviceDettach */
+    NULL,                       /* nodeDeviceReAttach */
+    NULL,                       /* nodeDeviceReset */
+    NULL,                       /* domainMigratePrepareTunnel */
+    NULL,                       /* IsEncrypted */
+    NULL,                       /* IsSecure */
+    libxlDomainIsActive,        /* DomainIsActive */
+    libxlDomainIsPersistent,    /* DomainIsPersistent */
+    NULL,                       /* domainIsUpdated */
+    NULL,                       /* cpuCompare */
+    NULL,                       /* cpuBaseline */
+    NULL,                       /* domainGetJobInfo */
+    NULL,                       /* domainAbortJob */
+    NULL,                       /* domainMigrateSetMaxDowntime */
+    NULL,                       /* domainEventRegisterAny */
+    NULL,                       /* domainEventDeregisterAny */
+    NULL,                       /* domainManagedSave */
+    NULL,                       /* domainHasManagedSaveImage */
+    NULL,                       /* domainManagedSaveRemove */
+    NULL,                       /* domainSnapshotCreateXML */
+    NULL,                       /* domainSnapshotDumpXML */
+    NULL,                       /* domainSnapshotNum */
+    NULL,                       /* domainSnapshotListNames */
+    NULL,                       /* domainSnapshotLookupByName */
+    NULL,                       /* domainHasCurrentSnapshot */
+    NULL,                       /* domainSnapshotCurrent */
+    NULL,                       /* domainRevertToSnapshot */
+    NULL,                       /* domainSnapshotDelete */
+    NULL,                       /* qemuDomainMonitorCommand */
+    NULL,                       /* domainSetMemoryParameters */
+    NULL,                       /* domainGetMemoryParameters */
+    NULL,                       /* domainOpenConsole */
+};
+
+static virStateDriver libxlStateDriver = {
+    .name = "LIBXL",
+    .initialize = libxlStartup,
+    .cleanup = libxlShutdown,
+    .reload = libxlReload,
+    .active = libxlActive,
+};
+
+
+int
+libxlRegister(void)
+{
+    if (virRegisterDriver(&libxlDriver) < 0)
+        return -1;
+    if (virRegisterStateDriver(&libxlStateDriver) < 0)
+        return -1;
+
+    return 0;
+}
diff --git a/src/libxl/libxl_driver.h b/src/libxl/libxl_driver.h
new file mode 100644
index 0000000..e047552
--- /dev/null
+++ b/src/libxl/libxl_driver.h
@@ -0,0 +1,27 @@
+/*---------------------------------------------------------------------------*/
+/*  Copyright (c) 2011 SUSE LINUX Products GmbH, Nuernberg, Germany.
+ *
+ * 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 LIBXL_DRIVER_H
+# define LIBXL_DRIVER_H
+
+# include <config.h>
+
+int libxlRegister(void);
+
+#endif /* LIBXL_DRIVER_H */
diff --git a/src/util/virterror.c b/src/util/virterror.c
index aaa3720..3e1c495 100644
--- a/src/util/virterror.c
+++ b/src/util/virterror.c
@@ -89,6 +89,9 @@ static const char *virErrorDomainName(virErrorDomain domain) {
         case VIR_FROM_XENAPI:
             dom = "XenAPI ";
             break;
+        case VIR_FROM_LIBXL:
+            dom = "libxenlight ";
+            break;
         case VIR_FROM_XML:
             dom = "XML ";
             break;
-- 
1.7.3.1


_______________________________________________
Xen-devel mailing list
Xen-devel@xxxxxxxxxxxxxxxxxxx
http://lists.xensource.com/xen-devel


 


Rackspace

Lists.xenproject.org is hosted with RackSpace, monitoring our
servers 24x7x365 and backed by RackSpace's Fanatical Support®.