Initial Linux containers work

* configure.in include/libvirt/virterror.h src/Makefile.am
  src/driver.h src/lxc_conf.[ch] src/lxc_driver.[ch] src/virterror.c:
  Applied 3 patches from Dave Leskovec for intial support of
  Linux containers, configured off by default, work in progress.
* src/libvirt.c: improve virDomainCreateLinux xmlDesc description
Daniel

ChangeLog

+Fri Mar 21 15:59:53 CET 2008 Daniel Veillard <veillard@redhat.com>
+
+	* configure.in include/libvirt/virterror.h src/Makefile.am
+	  src/driver.h src/lxc_conf.[ch] src/lxc_driver.[ch] src/virterror.c:
+	  Applied 3 patches from Dave Leskovec for intial support of
+	  Linux containers, configured off by default, work in progress.
+	* src/libvirt.c: improve virDomainCreateLinux xmlDesc description
+
 Thu Mar 20 12:23:03 CET 2008 Daniel Veillard <veillard@redhat.com>
 
 	* src/util.c src/util.h src/xml.c: applied patch from Hiroyuki Kaguchi

configure.in

@@ -132,6 +132,8 @@ AC_ARG_WITH(qemu,
 [  --with-qemu             add QEMU/KVM support (on)],[],[with_qemu=yes])
 AC_ARG_WITH(openvz,
 [  --with-openvz           add OpenVZ support (off)],[],[with_openvz=no])
+AC_ARG_WITH(lxc,
+[  --with-lxc              add Linux Container support (off)],[],[with_lxc=no])
 AC_ARG_WITH(test,
 [  --with-test             add test driver support (on)],[],[with_test=yes])
 AC_ARG_WITH(remote,
@@ -229,6 +231,9 @@ WITH_XEN=0
 if test "$with_openvz" = "yes" ; then
     LIBVIRT_FEATURES="$LIBVIRT_FEATURES -DWITH_OPENVZ"
 fi
+if test "$with_lxc" = "yes" ; then
+    LIBVIRT_FEATURES="$LIBVIRT_FEATURES -DWITH_LXC"
+fi
 if test "$with_qemu" = "yes" ; then
     LIBVIRT_FEATURES="$LIBVIRT_FEATURES -DWITH_QEMU"
 fi
@@ -950,6 +955,7 @@ AC_MSG_NOTICE([     Xen: $with_xen])
 AC_MSG_NOTICE([   Proxy: $with_xen_proxy])
 AC_MSG_NOTICE([    QEMU: $with_qemu])
 AC_MSG_NOTICE([  OpenVZ: $with_openvz])
+AC_MSG_NOTICE([     LXC: $with_lxc])
 AC_MSG_NOTICE([    Test: $with_test])
 AC_MSG_NOTICE([  Remote: $with_remote])
 AC_MSG_NOTICE([Libvirtd: $with_libvirtd])

include/libvirt/virterror.h

@@ -54,6 +54,7 @@ typedef enum {
     VIR_FROM_OPENVZ,    /* Error from OpenVZ driver */
     VIR_FROM_XENXM,	/* Error at Xen XM layer */
     VIR_FROM_STATS_LINUX, /* Error in the Linux Stats code */
+    VIR_FROM_LXC,   /* Error from Linux Container driver */
     VIR_FROM_STORAGE,   /* Error from storage driver */
 } virErrorDomain;
 

src/Makefile.am

@@ -59,6 +59,8 @@ CLIENT_SOURCES =						\
 		qemu_conf.c qemu_conf.h				\
 		openvz_conf.c openvz_conf.h			\
 		openvz_driver.c openvz_driver.h			\
+		lxc_driver.c lxc_driver.h			\
+		lxc_conf.c lxc_conf.h				\
                 nodeinfo.h nodeinfo.c                           \
 		storage_conf.h storage_conf.c			\
 		storage_driver.h storage_driver.c		\

src/driver.h

@@ -24,6 +24,7 @@ typedef enum {
     VIR_DRV_QEMU = 3,
     VIR_DRV_REMOTE = 4,
     VIR_DRV_OPENVZ = 5,
+    VIR_DRV_LXC = 6
 } virDrvNo;
 
 

src/libvirt.c

@@ -45,6 +45,9 @@
 #ifdef WITH_OPENVZ
 #include "openvz_driver.h"
 #endif
+#ifdef WITH_LXC
+#include "lxc_driver.h"
+#endif
 
 /*
  * TODO:
@@ -271,6 +274,9 @@ virInitialize(void)
 #endif
 #ifdef WITH_OPENVZ
     if (openvzRegister() == -1) return -1;
+#endif
+#ifdef WITH_LXC
+    if (lxcRegister() == -1) return -1;
 #endif
     if (storageRegister() == -1) return -1;
 #ifdef WITH_REMOTE
@@ -1183,7 +1189,7 @@ virDomainGetConnect (virDomainPtr dom)
 /**
  * virDomainCreateLinux:
  * @conn: pointer to the hypervisor connection
- * @xmlDesc: an XML description of the domain
+ * @xmlDesc: string containing an XML description of the domain
  * @flags: an optional set of virDomainFlags
  *
  * Launch a new Linux guest domain, based on an XML description similar

src/lxc_conf.h

+/*
+ * Copyright IBM Corp. 2008
+ *
+ * lxc_conf.h: header file for linux container config functions
+ *
+ * Authors:
+ *  David L. Leskovec <dlesko at linux.vnet.ibm.com>
+ *
+ * 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 LXC_CONF_H
+#define LXC_CONF_H
+
+#include <config.h>
+
+#ifdef WITH_LXC
+
+#include "internal.h"
+
+/* Defines */
+#define LXC_MAX_TTY_NAME 32
+#define LXC_MAX_XML_LENGTH 16384
+#define LXC_MAX_ERROR_LEN 1024
+#define LXC_DOMAIN_TYPE "lxc"
+
+typedef struct __lxc_mount lxc_mount_t;
+struct __lxc_mount {
+    char source[PATH_MAX]; /* user's directory */
+    char target[PATH_MAX];
+
+    lxc_mount_t *next;
+};
+
+typedef struct __lxc_vm_def lxc_vm_def_t;
+struct __lxc_vm_def {
+    unsigned char uuid[VIR_UUID_BUFLEN];
+    char* name;
+    int id;
+
+    /* init command string */
+    char init[PATH_MAX];
+
+    int maxMemory;
+
+    /* mounts - list of mount structs */
+    int nmounts;
+    lxc_mount_t *mounts;
+
+    /* tty device */
+    char tty[LXC_MAX_TTY_NAME];
+};
+
+typedef struct __lxc_vm lxc_vm_t;
+struct __lxc_vm {
+    int pid;
+    int state;
+
+    char configFile[PATH_MAX];
+    char configFileBase[PATH_MAX];
+
+    int parentTty;
+
+    lxc_vm_def_t *def;
+
+    lxc_vm_t *next;
+};
+
+typedef struct __lxc_driver lxc_driver_t;
+struct __lxc_driver {
+    lxc_vm_t *vms;
+    int nactivevms;
+    int ninactivevms;
+    char* configDir;
+};
+
+/* Types and structs */
+
+/* Inline Functions */
+static inline int lxcIsActiveVM(lxc_vm_t *vm)
+{
+    return vm->def->id != -1;
+}
+
+/* Function declarations */
+lxc_vm_def_t * lxcParseVMDef(virConnectPtr conn,
+                             const char* xmlString,
+                             const char* fileName);
+int lxcSaveVMDef(virConnectPtr conn,
+                 lxc_driver_t *driver,
+                 lxc_vm_t *vm,
+                 lxc_vm_def_t *def);
+int lxcLoadDriverConfig(virConnectPtr conn);
+int lxcSaveConfig(virConnectPtr conn,
+                  lxc_driver_t *driver,
+                  lxc_vm_t *vm,
+                  lxc_vm_def_t *def);
+int lxcLoadContainerInfo(virConnectPtr conn);
+int lxcLoadContainerConfigFile(lxc_driver_t *driver,
+                               const char *file);
+lxc_vm_t * lxcAssignVMDef(virConnectPtr conn,
+                          lxc_driver_t *driver,
+                          lxc_vm_def_t *def);
+char *lxcGenerateXML(virConnectPtr conn,
+                     lxc_driver_t *driver,
+                     lxc_vm_t *vm,
+                     lxc_vm_def_t *def);
+lxc_vm_t *lxcFindVMByID(const lxc_driver_t *driver, int id);
+lxc_vm_t *lxcFindVMByUUID(const lxc_driver_t *driver,
+                          const unsigned char *uuid);
+lxc_vm_t *lxcFindVMByName(const lxc_driver_t *driver,
+                          const char *name);
+void lxcRemoveInactiveVM(lxc_driver_t *driver,
+                         lxc_vm_t *vm);
+void lxcFreeVMs(lxc_vm_t *vms);
+void lxcFreeVM(lxc_vm_t *vm);
+void lxcFreeVMDef(lxc_vm_def_t *vmdef);
+int lxcDeleteConfig(virConnectPtr conn,
+                    lxc_driver_t *driver,
+                    const char *configFile,
+                    const char *name);
+
+void lxcError(virConnectPtr conn,
+              virDomainPtr dom,
+              int code, const char *fmt, ...)
+    ATTRIBUTE_FORMAT(printf,4,5);
+
+#endif /* WITH_LXC */
+#endif /* LXC_CONF_H */
+

src/lxc_driver.c

+/*
+ * Copyright IBM Corp. 2008
+ *
+ * lxc_driver.c: linux container driver functions
+ *
+ * Authors:
+ *  David L. Leskovec <dlesko at linux.vnet.ibm.com>
+ *
+ * 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>
+
+#ifdef WITH_LXC
+
+#include <sched.h>
+#include <sys/utsname.h>
+#include <string.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <wait.h>
+
+#include "lxc_conf.h"
+#include "lxc_driver.h"
+#include "driver.h"
+#include "internal.h"
+
+/* debug macros */
+#define DEBUG(fmt,...) VIR_DEBUG(__FILE__, fmt, __VA_ARGS__)
+#define DEBUG0(msg) VIR_DEBUG(__FILE__, "%s", msg)
+
+static int lxcStartup(virConnectPtr conn);
+static int lxcShutdown(virConnectPtr conn);
+
+/* Functions */
+static int lxcDummyChild( void *argv ATTRIBUTE_UNUSED )
+{
+    exit(0);
+}
+
+static int lxcCheckContainerSupport( void )
+{
+    int rc = 0;
+    int flags = CLONE_NEWPID|CLONE_NEWNS|CLONE_NEWUTS|CLONE_NEWUSER|
+        CLONE_NEWIPC|SIGCHLD;
+    int cpid;
+    char *childStack;
+    char *stack;
+    int childStatus;
+
+    stack = malloc(getpagesize() * 4);
+    if(!stack) {
+        DEBUG0("Unable to allocate stack");
+        rc = -1;
+        goto check_complete;
+    }
+
+    childStack = stack + (getpagesize() * 4);
+
+    cpid = clone(lxcDummyChild, childStack, flags, NULL);
+    if ((0 > cpid) && (EINVAL == errno)) {
+        DEBUG0("clone call returned EINVAL, container support is not enabled");
+        rc = -1;
+    } else {
+        waitpid(cpid, &childStatus, 0);
+    }
+
+    free(stack);
+
+check_complete:
+    return rc;
+}
+
+static const char *lxcProbe(void)
+{
+#ifdef __linux__
+    if (0 == lxcCheckContainerSupport()) {
+        return("lxc:///");
+    }
+#endif
+    return(NULL);
+}
+
+static virDrvOpenStatus lxcOpen(virConnectPtr conn,
+                                xmlURIPtr uri,
+                                virConnectAuthPtr auth ATTRIBUTE_UNUSED,
+                                int flags ATTRIBUTE_UNUSED)
+{
+    uid_t uid = getuid();
+
+    /* Check that the user is root */
+    if (0 != uid) {
+        goto declineConnection;
+    }
+
+    /* Verify uri was specified */
+    if ((NULL == uri) || (NULL == uri->scheme)) {
+        goto declineConnection;
+    }
+
+    /* Check that the uri scheme is lxc */
+    if (STRNEQ(uri->scheme, "lxc")) {
+        goto declineConnection;
+    }
+
+    /* Check that this is a container enabled kernel */
+    if(0 != lxcCheckContainerSupport()) {
+        goto declineConnection;
+    }
+
+    /* initialize driver data */
+    if (0 > lxcStartup(conn)) {
+        goto declineConnection;
+    }
+
+    return VIR_DRV_OPEN_SUCCESS;
+
+declineConnection:
+    return VIR_DRV_OPEN_DECLINED;
+}
+
+static int lxcClose(virConnectPtr conn)
+{
+    return lxcShutdown(conn);
+}
+
+static virDomainPtr lxcDomainLookupByID(virConnectPtr conn,
+                                        int id)
+{
+    lxc_driver_t *driver = (lxc_driver_t *)conn->privateData;
+    lxc_vm_t *vm = lxcFindVMByID(driver, id);
+    virDomainPtr dom;
+
+    if (!vm) {
+        lxcError(conn, NULL, VIR_ERR_NO_DOMAIN, NULL);
+        return NULL;
+    }
+
+    dom = virGetDomain(conn, vm->def->name, vm->def->uuid);
+    if (dom) {
+        dom->id = vm->def->id;
+    }
+
+    return dom;
+}
+
+static virDomainPtr lxcDomainLookupByUUID(virConnectPtr conn,
+                                          const unsigned char *uuid)
+{
+    lxc_driver_t *driver = (lxc_driver_t *)conn->privateData;
+    lxc_vm_t *vm = lxcFindVMByUUID(driver, uuid);
+    virDomainPtr dom;
+
+    if (!vm) {
+        lxcError(conn, NULL, VIR_ERR_NO_DOMAIN, NULL);
+        return NULL;
+    }
+
+    dom = virGetDomain(conn, vm->def->name, vm->def->uuid);
+    if (dom) {
+        dom->id = vm->def->id;
+    }
+
+    return dom;
+}
+
+static virDomainPtr lxcDomainLookupByName(virConnectPtr conn,
+                                          const char *name)
+{
+    lxc_driver_t *driver = (lxc_driver_t *)conn->privateData;
+    lxc_vm_t *vm = lxcFindVMByName(driver, name);
+    virDomainPtr dom;
+
+    if (!vm) {
+        lxcError(conn, NULL, VIR_ERR_NO_DOMAIN, NULL);
+        return NULL;
+    }
+
+    dom = virGetDomain(conn, vm->def->name, vm->def->uuid);
+    if (dom) {
+        dom->id = vm->def->id;
+    }
+
+    return dom;
+}
+
+static int lxcListDomains(virConnectPtr conn, int *ids, int nids)
+{
+    lxc_driver_t *driver = (lxc_driver_t *)conn->privateData;
+    lxc_vm_t *vm;
+    int numDoms = 0;
+
+    for (vm = driver->vms; vm && (numDoms < nids); vm = vm->next) {
+        if (lxcIsActiveVM(vm)) {
+            ids[numDoms] = vm->def->id;
+            numDoms++;
+        }
+    }
+
+    return numDoms;
+}
+
+static int lxcNumDomains(virConnectPtr conn)
+{
+    lxc_driver_t *driver = (lxc_driver_t *)conn->privateData;
+    return driver->nactivevms;
+}
+
+static int lxcListDefinedDomains(virConnectPtr conn,
+                                 char **const names, int nnames)
+{
+    lxc_driver_t *driver = (lxc_driver_t *)conn->privateData;
+    lxc_vm_t *vm;
+    int numDoms = 0;
+    int i;
+
+    for (vm = driver->vms; vm && (numDoms < nnames); vm = vm->next) {
+        if (!lxcIsActiveVM(vm)) {
+            if (!(names[numDoms] = strdup(vm->def->name))) {
+                lxcError(conn, NULL, VIR_ERR_NO_MEMORY, "names");
+                goto cleanup;
+            }
+
+            numDoms++;
+        }
+
+    }
+
+    return numDoms;
+
+ cleanup:
+    for (i = 0 ; i < numDoms ; i++) {
+        free(names[i]);
+    }
+
+    return -1;
+}
+
+
+static int lxcNumDefinedDomains(virConnectPtr conn)
+{
+    lxc_driver_t *driver = (lxc_driver_t *)conn->privateData;
+    return driver->ninactivevms;
+}
+
+static virDomainPtr lxcDomainDefine(virConnectPtr conn, const char *xml)
+{
+    lxc_driver_t *driver = (lxc_driver_t *)conn->privateData;
+    lxc_vm_def_t *def;
+    lxc_vm_t *vm;
+    virDomainPtr dom;
+
+    if (!(def = lxcParseVMDef(conn, xml, NULL))) {
+        return NULL;
+    }
+
+    if (!(vm = lxcAssignVMDef(conn, driver, def))) {
+        lxcFreeVMDef(def);
+        return NULL;
+    }
+
+    if (lxcSaveVMDef(conn, driver, vm, def) < 0) {
+        lxcRemoveInactiveVM(driver, vm);
+        return NULL;
+    }
+
+    dom = virGetDomain(conn, vm->def->name, vm->def->uuid);
+    if (dom) {
+        dom->id = vm->def->id;
+    }
+
+    return dom;
+}
+
+static int lxcDomainUndefine(virDomainPtr dom)
+{
+    lxc_driver_t *driver = (lxc_driver_t *)dom->conn->privateData;
+    lxc_vm_t *vm = lxcFindVMByUUID(driver, dom->uuid);
+
+    if (!vm) {
+        lxcError(dom->conn, dom, VIR_ERR_INVALID_DOMAIN,
+                 _("no domain with matching uuid"));
+        return -1;
+    }
+
+    if (lxcIsActiveVM(vm)) {
+        lxcError(dom->conn, dom, VIR_ERR_INTERNAL_ERROR,
+                 _("cannot delete active domain"));
+        return -1;
+    }
+
+    if (lxcDeleteConfig(dom->conn, driver, vm->configFile, vm->def->name) < 0) {
+        return -1;
+    }
+
+    vm->configFile[0] = '\0';
+
+    lxcRemoveInactiveVM(driver, vm);
+
+    return 0;
+}
+
+static int lxcDomainGetInfo(virDomainPtr dom,
+                            virDomainInfoPtr info)
+{
+    lxc_driver_t *driver = (lxc_driver_t *)dom->conn->privateData;
+    lxc_vm_t *vm = lxcFindVMByUUID(driver, dom->uuid);
+
+    if (!vm) {
+        lxcError(dom->conn, dom, VIR_ERR_INVALID_DOMAIN,
+                 _("no domain with matching uuid"));
+        return -1;
+    }
+
+    info->state = vm->state;
+
+    if (!lxcIsActiveVM(vm)) {
+        info->cpuTime = 0;
+    } else {
+        info->cpuTime = 0;
+    }
+
+    info->maxMem = vm->def->maxMemory;
+    info->memory = vm->def->maxMemory;
+    info->nrVirtCpu = 1;
+
+    return 0;
+}
+
+static char *lxcGetOSType(virDomainPtr dom ATTRIBUTE_UNUSED)
+{
+    /* Linux containers only run on Linux */
+    return strdup("linux");
+}
+
+static char *lxcDomainDumpXML(virDomainPtr dom,
+                              int flags ATTRIBUTE_UNUSED)
+{
+    lxc_driver_t *driver = (lxc_driver_t *)dom->conn->privateData;
+    lxc_vm_t *vm = lxcFindVMByUUID(driver, dom->uuid);
+
+    if (!vm) {
+        lxcError(dom->conn, dom, VIR_ERR_INVALID_DOMAIN,
+                 _("no domain with matching uuid"));
+        return NULL;
+    }
+
+    return lxcGenerateXML(dom->conn, driver, vm, vm->def);
+}
+
+static int lxcStartup(virConnectPtr conn)
+{
+    lxc_driver_t *driver;
+
+    driver = calloc(1, sizeof(lxc_driver_t));
+    if (NULL == driver) {
+        return -1;
+    }
+
+    conn->privateData = driver;
+
+    /* Call function to load lxc driver configuration information */
+    if (lxcLoadDriverConfig(conn) < 0) {
+        lxcShutdown(conn);
+        return -1;
+    }
+
+    /* Call function to load the container configuration files */
+    if (lxcLoadContainerInfo(conn) < 0) {
+        lxcShutdown(conn);
+        return -1;
+    }
+
+    return 0;
+}
+
+static void lxcFreeDriver(lxc_driver_t *driver)
+{
+    free(driver->configDir);
+    free(driver);
+}
+
+static int lxcShutdown(virConnectPtr conn)
+{
+    lxc_driver_t *driver = (lxc_driver_t *)conn->privateData;
+    lxc_vm_t *vms = driver->vms;
+
+    lxcFreeVMs(vms);
+    driver->vms = NULL;
+    lxcFreeDriver(driver);
+    conn->privateData = NULL;
+
+    return 0;
+}
+
+/* Function Tables */
+static virDriver lxcDriver = {
+    VIR_DRV_LXC, /* the number virDrvNo */
+    "LXC", /* the name of the driver */
+    LIBVIR_VERSION_NUMBER, /* the version of the backend */
+    lxcProbe, /* probe */
+    lxcOpen, /* open */
+    lxcClose, /* close */
+    NULL, /* supports_feature */
+    NULL, /* type */
+    NULL, /* version */
+    NULL, /* getHostname */
+    NULL, /* getURI */
+    NULL, /* getMaxVcpus */
+    NULL, /* nodeGetInfo */
+    NULL, /* getCapabilities */
+    lxcListDomains, /* listDomains */
+    lxcNumDomains, /* numOfDomains */
+    NULL/*lxcDomainCreateLinux*/, /* domainCreateLinux */
+    lxcDomainLookupByID, /* domainLookupByID */
+    lxcDomainLookupByUUID, /* domainLookupByUUID */
+    lxcDomainLookupByName, /* domainLookupByName */
+    NULL, /* domainSuspend */
+    NULL, /* domainResume */
+    NULL, /* domainShutdown */
+    NULL, /* domainReboot */
+    NULL, /* domainDestroy */
+    lxcGetOSType, /* domainGetOSType */
+    NULL, /* domainGetMaxMemory */
+    NULL, /* domainSetMaxMemory */
+    NULL, /* domainSetMemory */
+    lxcDomainGetInfo, /* domainGetInfo */
+    NULL, /* domainSave */
+    NULL, /* domainRestore */
+    NULL, /* domainCoreDump */
+    NULL, /* domainSetVcpus */
+    NULL, /* domainPinVcpu */
+    NULL, /* domainGetVcpus */
+    NULL, /* domainGetMaxVcpus */
+    lxcDomainDumpXML, /* domainDumpXML */
+    lxcListDefinedDomains, /* listDefinedDomains */
+    lxcNumDefinedDomains, /* numOfDefinedDomains */
+    NULL, /* domainCreate */
+    lxcDomainDefine, /* domainDefineXML */
+    lxcDomainUndefine, /* domainUndefine */
+    NULL, /* domainAttachDevice */
+    NULL, /* domainDetachDevice */
+    NULL, /* domainGetAutostart */
+    NULL, /* domainSetAutostart */
+    NULL, /* domainGetSchedulerType */
+    NULL, /* domainGetSchedulerParameters */
+    NULL, /* domainSetSchedulerParameters */
+    NULL, /* domainMigratePrepare */
+    NULL, /* domainMigratePerform */
+    NULL, /* domainMigrateFinish */
+    NULL, /* domainBlockStats */
+    NULL, /* domainInterfaceStats */
+    NULL, /* nodeGetCellsFreeMemory */
+    NULL, /* getFreeMemory */
+};
+
+int lxcRegister(void)
+{
+    virRegisterDriver(&lxcDriver);
+    return 0;
+}
+
+#endif /* WITH_LXC */
+
+/*
+ * Local variables:
+ *  indent-tabs-mode: nil
+ *  c-indent-level: 4
+ *  c-basic-offset: 4
+ *  tab-width: 4
+ * End:
+ */

src/lxc_driver.h

+/*
+ * Copyright IBM Corp. 2008
+ *
+ * lxc_driver.h: header file for linux container driver functions
+ *
+ * Authors:
+ *  David L. Leskovec <dlesko at linux.vnet.ibm.com>
+ *
+ * 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 LXC_DRIVER_H
+#define LXC_DRIVER_H
+
+#include <config.h>
+
+#ifdef WITH_LXC
+
+/* Function declarations */
+int lxcRegister(void);
+
+#endif /* WITH_LXC */
+
+#endif /* LXC_DRIVER_H */
+
+/*
+ * Local variables:
+ *  indent-tabs-mode: nil
+ *  c-indent-level: 4
+ *  c-basic-offset: 4
+ *  tab-width: 4
+ * End:
+ */

src/virterror.c

@@ -296,6 +296,9 @@ virDefaultErrorFunc(virErrorPtr err)
         case VIR_FROM_STATS_LINUX:
             dom = "Linux Stats ";
             break;
+        case VIR_FROM_LXC:
+            dom = "Linux Container ";
+            break;
         case VIR_FROM_STORAGE:
             dom = "Storage ";
             break;